Remove unnecessary casts and general code clean-up

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 201 matching lines @@
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     resolveMetadata(node);
     return null;
   }
 
   @override
   Object visitCommentReference(CommentReference node) {
     Identifier identifier = node.identifier;
     if (identifier is SimpleIdentifier) {
-      SimpleIdentifier simpleIdentifier = identifier;
-      Element element = _resolveSimpleIdentifier(simpleIdentifier);
+      Element element = _resolveSimpleIdentifier(identifier);
       if (element == null) {
         //
         // This might be a reference to an imported name that is missing the
         // prefix.
         //
-        element = _findImportWithoutPrefix(simpleIdentifier);
+        element = _findImportWithoutPrefix(identifier);
         if (element is MultiplyDefinedElement) {
           // TODO(brianwilkerson) Report this error?
           element = null;
         }
       }
       if (element == null) {
         // TODO(brianwilkerson) Report this error?
         //        resolver.reportError(
         //            StaticWarningCode.UNDEFINED_IDENTIFIER,
         //            simpleIdentifier,
         //            simpleIdentifier.getName());
       } else {
         if (element.library == null || element.library != _definingLibrary) {
           // TODO(brianwilkerson) Report this error?
         }
-        simpleIdentifier.staticElement = element;
+        identifier.staticElement = element;
         if (node.newKeyword != null) {
           if (element is ClassElement) {
             ConstructorElement constructor = element.unnamedConstructor;
             if (constructor == null) {
               // TODO(brianwilkerson) Report this error.
             } else {
-              simpleIdentifier.staticElement = constructor;
+              identifier.staticElement = constructor;
             }
           } else {
             // TODO(brianwilkerson) Report this error.
           }
         }
       }
     } else if (identifier is PrefixedIdentifier) {
-      PrefixedIdentifier prefixedIdentifier = identifier;
-      SimpleIdentifier prefix = prefixedIdentifier.prefix;
-      SimpleIdentifier name = prefixedIdentifier.identifier;
+      SimpleIdentifier prefix = identifier.prefix;
+      SimpleIdentifier name = identifier.identifier;
       Element element = _resolveSimpleIdentifier(prefix);
       if (element == null) {
 //        resolver.reportError(StaticWarningCode.UNDEFINED_IDENTIFIER, prefix, prefix.getName());
       } else {
         prefix.staticElement = element;
         if (element is PrefixElement) {
           // TODO(brianwilkerson) Report this error?
           element = _resolver.nameScope.lookup(identifier, _definingLibrary);
           name.staticElement = element;
           return null;
@@ skipping 11 matching lines @@
           if (element is ClassElement) {
             Element memberElement =
                 _lookupGetterOrMethod(element.type, name.name);
             if (memberElement == null) {
               memberElement = element.getNamedConstructor(name.name);
               if (memberElement == null) {
                 memberElement = _lookUpSetter(prefix, element.type, name.name);
               }
             }
             if (memberElement == null) {
-//              reportGetterOrSetterNotFound(prefixedIdentifier, name, element.getDisplayName());
+//              reportGetterOrSetterNotFound(identifier, name, element.getDisplayName());
             } else {
               name.staticElement = memberElement;
             }
           } else {
             // TODO(brianwilkerson) Report this error.
           }
         } else {
           if (element is ClassElement) {
             ConstructorElement constructor =
                 element.getNamedConstructor(name.name);
             if (constructor == null) {
               // TODO(brianwilkerson) Report this error.
             } else {
               name.staticElement = constructor;
             }
           } else {
             // TODO(brianwilkerson) Report this error.
           }
         }
       }
     }
     return null;
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     super.visitConstructorDeclaration(node);
     ConstructorElement element = node.element;
     if (element is ConstructorElementImpl) {
-      ConstructorElementImpl constructorElement = element;
       ConstructorName redirectedNode = node.redirectedConstructor;
       if (redirectedNode != null) {
         // set redirected factory constructor
         ConstructorElement redirectedElement = redirectedNode.staticElement;
-        constructorElement.redirectedConstructor = redirectedElement;
+        element.redirectedConstructor = redirectedElement;
       } else {
         // set redirected generative constructor
         for (ConstructorInitializer initializer in node.initializers) {
           if (initializer is RedirectingConstructorInvocation) {
             ConstructorElement redirectedElement = initializer.staticElement;
-            constructorElement.redirectedConstructor = redirectedElement;
+            element.redirectedConstructor = redirectedElement;
           }
         }
       }
       resolveMetadata(node);
     }
     return null;
   }
 
   @override
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
@@ skipping 369 matching lines @@
       // The method lookup may have failed because there were multiple
       // incompatible choices. In this case we don't want to generate a hint.
       errorCode = _checkForInvocationError(target, false, propagatedElement);
       if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_METHOD)) {
         ClassElement classElementContext = null;
         if (target == null) {
           classElementContext = _resolver.enclosingClass;
         } else {
           DartType type = _getBestType(target);
           if (type != null) {
-            if (type.element is ClassElement) {
-              classElementContext = type.element as ClassElement;
+            Element element = type.element;
+            if (element is ClassElement) {
+              classElementContext = element;
             }
           }
         }
         if (classElementContext != null) {
           _subtypeManager.ensureLibraryVisited(_definingLibrary);
           HashSet<ClassElement> subtypeElements =
               _subtypeManager.computeAllSubtypes(classElementContext);
           for (ClassElement subtypeElement in subtypeElements) {
             if (subtypeElement.getMethod(methodName.name) != null) {
               errorCode = null;
@@ skipping 64 matching lines @@
         ErrorCode proxyErrorCode = (generatedWithTypePropagation
             ? HintCode.UNDEFINED_METHOD
             : StaticTypeWarningCode.UNDEFINED_METHOD);
         _recordUndefinedNode(targetType.element, proxyErrorCode, methodName,
             [methodName.name, targetTypeName]);
       }
     } else if (identical(
         errorCode, StaticTypeWarningCode.UNDEFINED_SUPER_METHOD)) {
       // Generate the type name.
       // The error code will never be generated via type propagation
-      DartType targetType = _getStaticType(target);
-      if (targetType is InterfaceType && !targetType.isObject) {
-        targetType = (targetType as InterfaceType).superclass;
+      DartType getSuperType(DartType type) {
+        if (type is InterfaceType && !type.isObject) {
+          return type.superclass;
+        }
+        return type;
       }
-      String targetTypeName = targetType == null ? null : targetType.name;
+      DartType targetType = getSuperType(_getStaticType(target));
+      String targetTypeName = targetType?.name;
       _resolver.reportErrorForNode(StaticTypeWarningCode.UNDEFINED_SUPER_METHOD,
           methodName, [methodName.name, targetTypeName]);
     }
     return null;
   }
 
   @override
   Object visitPartDirective(PartDirective node) {
     resolveMetadata(node);
     return null;
@@ skipping 54 matching lines @@
     if (prefixElement is PrefixElement) {
       Element element = _resolver.nameScope.lookup(node, _definingLibrary);
       if (element == null && identifier.inSetterContext()) {
         element = _resolver.nameScope.lookup(
             new SyntheticIdentifier("${node.name}=", node), _definingLibrary);
       }
       if (element == null) {
         if (identifier.inSetterContext()) {
           _resolver.reportErrorForNode(StaticWarningCode.UNDEFINED_SETTER,
               identifier, [identifier.name, prefixElement.name]);
-        } else if (node.parent is Annotation) {
-          Annotation annotation = node.parent as Annotation;
+          return null;
+        }
+        AstNode parent = node.parent;
+        if (parent is Annotation) {
           _resolver.reportErrorForNode(
-              CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
-          return null;
+              CompileTimeErrorCode.INVALID_ANNOTATION, parent);
         } else {
           _resolver.reportErrorForNode(StaticWarningCode.UNDEFINED_GETTER,
               identifier, [identifier.name, prefixElement.name]);
         }
         return null;
       }
-      if (element is PropertyAccessorElement && identifier.inSetterContext()) {
-        PropertyInducingElement variable =
-            (element as PropertyAccessorElement).variable;
+      Element accessor = element;
+      if (accessor is PropertyAccessorElement && identifier.inSetterContext()) {
+        PropertyInducingElement variable = accessor.variable;
         if (variable != null) {
           PropertyAccessorElement setter = variable.setter;
           if (setter != null) {
             element = setter;
           }
         }
       }
       // TODO(brianwilkerson) The prefix needs to be resolved to the element for
       // the import that defines the prefix, not the prefix's element.
       identifier.staticElement = element;
       // Validate annotation element.
-      if (node.parent is Annotation) {
-        Annotation annotation = node.parent as Annotation;
-        _resolveAnnotationElement(annotation);
-        return null;
+      AstNode parent = node.parent;
+      if (parent is Annotation) {
+        _resolveAnnotationElement(parent);
       }
       return null;
     }
     // May be annotation, resolve invocation of "const" constructor.
-    if (node.parent is Annotation) {
-      Annotation annotation = node.parent as Annotation;
-      _resolveAnnotationElement(annotation);
+    AstNode parent = node.parent;
+    if (parent is Annotation) {
+      _resolveAnnotationElement(parent);
     }
     //
     // Otherwise, the prefix is really an expression that happens to be a simple
     // identifier and this is really equivalent to a property access node.
     //
     _resolvePropertyAccess(prefix, identifier, false);
     return null;
   }
 
   @override
@@ skipping 140 matching lines @@
         !identical(element, enclosingClass)) {
       _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 if (node.parent is Annotation) {
-        Annotation annotation = node.parent as Annotation;
-        _resolver.reportErrorForNode(
-            CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
-      } else if (element is PrefixElement) {
-        _resolver.reportErrorForNode(
-            CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT,
-            node,
-            [element.name]);
       } else {
-        _recordUndefinedNode(_resolver.enclosingClass,
-            StaticWarningCode.UNDEFINED_IDENTIFIER, node, [node.name]);
+        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;
@@ skipping 85 matching lines @@
    * error code that should be reported, or `null` if no error should be
    * reported. The [target] is the target of the invocation, or `null` if there
    * was no target. The flag [useStaticContext] should be `true` if the
    * invocation is in a static constant (does not have access to instance state.
    */
   ErrorCode _checkForInvocationError(
       Expression target, bool useStaticContext, Element element) {
     // Prefix is not declared, instead "prefix.id" are declared.
     if (element is PrefixElement) {
       return CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT;
-    }
-    if (element is PropertyAccessorElement) {
+    } else if (element is PropertyAccessorElement) {
       //
       // This is really a function expression invocation.
       //
       // TODO(brianwilkerson) Consider the possibility of re-writing the AST.
       FunctionType getterType = element.type;
       if (getterType != null) {
         DartType returnType = getterType.returnType;
         if (!_isExecutableType(returnType)) {
           return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
         }
@@ skipping 293 matching lines @@
     return staticType;
   }
 
   /**
    * Check for a generic method & apply type arguments if any were passed.
    */
   DartType _instantiateGenericMethod(
       DartType invokeType, TypeArgumentList typeArguments, AstNode node) {
     // TODO(jmesserly): support generic "call" methods on InterfaceType.
     if (invokeType is FunctionType) {
-      FunctionType type = invokeType;
-      List<TypeParameterElement> parameters = type.typeFormals;
+      List<TypeParameterElement> parameters = invokeType.typeFormals;
 
       NodeList<TypeName> arguments = typeArguments?.arguments;
       if (arguments != null && arguments.length != parameters.length) {
         _resolver.reportErrorForNode(
             StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS,
             node,
-            [type, parameters.length, arguments?.length ?? 0]);
+            [invokeType, parameters.length, arguments?.length ?? 0]);
 
         // Wrong number of type arguments. Ignore them.
         arguments = null;
       }
       if (parameters.isNotEmpty) {
         if (arguments == null) {
-          invokeType = _resolver.typeSystem.instantiateToBounds(type);
+          return _resolver.typeSystem.instantiateToBounds(invokeType);
         } else {
-          invokeType = type.instantiate(arguments.map((n) => n.type).toList());
+          return invokeType.instantiate(arguments.map((n) => n.type).toList());
         }
       }
     }
     return invokeType;
   }
 
   /**
    * Return `true` if the given [expression] is a prefix for a deferred import.
    */
   bool _isDeferredPrefix(Expression expression) {
@@ skipping 338 matching lines @@
     //
     if (nameNode1 != null && nameNode2 == null && nameNode3 == null) {
       Element element1 = nameNode1.staticElement;
       // CONST
       if (element1 is PropertyAccessorElement) {
         _resolveAnnotationElementGetter(annotation, element1);
         return;
       }
       // Class(args)
       if (element1 is ClassElement) {
-        ClassElement classElement = element1;
-        constructor = new InterfaceTypeImpl(classElement)
+        constructor = new InterfaceTypeImpl(element1)
             .lookUpConstructor(null, _definingLibrary);
       }
     }
     //
     // prefix.CONST or prefix.Class() or Class.CONST or Class.constructor(args)
     //
     if (nameNode1 != null && nameNode2 != null && nameNode3 == null) {
       Element element1 = nameNode1.staticElement;
       Element element2 = nameNode2.staticElement;
       // Class.CONST - not resolved yet
       if (element1 is ClassElement) {
-        ClassElement classElement = element1;
-        element2 = classElement.lookUpGetter(nameNode2.name, _definingLibrary);
+        element2 = element1.lookUpGetter(nameNode2.name, _definingLibrary);
       }
       // prefix.CONST or Class.CONST
       if (element2 is PropertyAccessorElement) {
         nameNode2.staticElement = element2;
         annotation.element = element2;
         _resolveAnnotationElementGetter(annotation, element2);
         return;
       }
       // prefix.Class()
       if (element2 is ClassElement) {
         constructor = element2.unnamedConstructor;
       }
       // Class.constructor(args)
       if (element1 is ClassElement) {
-        ClassElement classElement = element1;
-        constructor = new InterfaceTypeImpl(classElement)
+        constructor = new InterfaceTypeImpl(element1)
             .lookUpConstructor(nameNode2.name, _definingLibrary);
         nameNode2.staticElement = constructor;
       }
     }
     //
     // prefix.Class.CONST or prefix.Class.constructor(args)
     //
     if (nameNode1 != null && nameNode2 != null && nameNode3 != null) {
       Element element2 = nameNode2.staticElement;
       // element2 should be ClassElement
       if (element2 is ClassElement) {
-        ClassElement classElement = element2;
         String name3 = nameNode3.name;
         // prefix.Class.CONST
         PropertyAccessorElement getter =
-            classElement.lookUpGetter(name3, _definingLibrary);
+            element2.lookUpGetter(name3, _definingLibrary);
         if (getter != null) {
           nameNode3.staticElement = getter;
           annotation.element = element2;
           _resolveAnnotationElementGetter(annotation, getter);
           return;
         }
         // prefix.Class.constructor(args)
-        constructor = new InterfaceTypeImpl(classElement)
+        constructor = new InterfaceTypeImpl(element2)
             .lookUpConstructor(name3, _definingLibrary);
         nameNode3.staticElement = constructor;
       }
     }
     // we need constructor
     if (constructor == null) {
       _resolver.reportErrorForNode(
           CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
       return;
     }
@@ skipping 118 matching lines @@
         new NamespaceBuilder().createExportNamespaceForLibrary(library);
     for (Combinator combinator in combinators) {
       NodeList<SimpleIdentifier> names;
       if (combinator is HideCombinator) {
         names = combinator.hiddenNames;
       } else {
         names = (combinator as ShowCombinator).shownNames;
       }
       for (SimpleIdentifier name in names) {
         String nameStr = name.name;
-        Element element = namespace.get(nameStr);
-        if (element == null) {
-          element = namespace.get("$nameStr=");
-        }
+        Element element = namespace.get(nameStr) ?? namespace.get("$nameStr=");
         if (element != null) {
           // Ensure that the name always resolves to a top-level variable
           // rather than a getter or setter
           if (element is PropertyAccessorElement) {
-            element = (element as PropertyAccessorElement).variable;
+            name.staticElement = element.variable;
+          } else {
+            name.staticElement = element;
           }
-          name.staticElement = element;
         }
       }
     }
   }
 
   /**
    * Given that we are accessing a property of the given [classElement] with the
    * given [propertyName], return the element that represents the property.
    */
   Element _resolveElement(
@@ skipping 183 matching lines @@
           shouldReportMissingMember_static ? staticType : propagatedType;
       Element staticOrPropagatedEnclosingElt = staticOrPropagatedType.element;
       bool isStaticProperty = _isStatic(staticOrPropagatedEnclosingElt);
       DartType displayType = staticOrPropagatedType != null
           ? staticOrPropagatedType
           : propagatedType != null ? propagatedType : staticType;
       // Special getter cases.
       if (propertyName.inGetterContext()) {
         if (!isStaticProperty &&
             staticOrPropagatedEnclosingElt is ClassElement) {
-          ClassElement classElement = staticOrPropagatedEnclosingElt;
-          InterfaceType targetType = classElement.type;
+          InterfaceType targetType = staticOrPropagatedEnclosingElt.type;
           if (!_enableStrictCallChecks &&
               targetType != null &&
               targetType.isDartCoreFunction &&
               propertyName.name == FunctionElement.CALL_METHOD_NAME) {
             // TODO(brianwilkerson) Can we ever resolve the function being
             // invoked?
 //            resolveArgumentsToParameters(node.getArgumentList(), invokedFunction);
             return;
-          } else if (classElement.isEnum && propertyName.name == "_name") {
+          } else if (staticOrPropagatedEnclosingElt.isEnum &&
+              propertyName.name == "_name") {
             _resolver.reportErrorForNode(
                 CompileTimeErrorCode.ACCESS_PRIVATE_ENUM_FIELD,
                 propertyName,
                 [propertyName.name]);
             return;
           }
         }
       }
       Element declaringElement =
           staticType.isVoid ? null : staticOrPropagatedEnclosingElt;
@@ skipping 129 matching lines @@
     }
     return null;
   }
 
   /**
    * Given a [node] that can have annotations associated with it, resolve the
    * annotations in the element model representing the annotations on the node.
    */
   static void resolveMetadata(AnnotatedNode node) {
     _resolveAnnotations(node.metadata);
-    if (node is VariableDeclaration && node.parent is VariableDeclarationList) {
-      VariableDeclarationList list = node.parent as VariableDeclarationList;
-      _resolveAnnotations(list.metadata);
-      if (list.parent is FieldDeclaration) {
-        FieldDeclaration fieldDeclaration = list.parent as FieldDeclaration;
-        _resolveAnnotations(fieldDeclaration.metadata);
-      } else if (list.parent is TopLevelVariableDeclaration) {
-        TopLevelVariableDeclaration variableDeclaration =
-            list.parent as TopLevelVariableDeclaration;
-        _resolveAnnotations(variableDeclaration.metadata);
+    if (node is VariableDeclaration) {
+      AstNode parent = node.parent;
+      if (parent is VariableDeclarationList) {
+        _resolveAnnotations(parent.metadata);
+        AstNode grandParent = parent.parent;
+        if (grandParent is FieldDeclaration) {
+          _resolveAnnotations(grandParent.metadata);
+        } else if (grandParent is TopLevelVariableDeclaration) {
+          _resolveAnnotations(grandParent.metadata);
+        }
       }
     }
   }
 
   /**
    * Return `true` if the given [identifier] is the return type of a constructor
    * declaration.
    */
   static bool _isConstructorReturnType(SimpleIdentifier identifier) {
     AstNode parent = identifier.parent;
     if (parent is ConstructorDeclaration) {
       return identical(parent.returnType, identifier);
     }
     return false;
   }
 
   /**
    * Return `true` if the given [identifier] is the return type of a factory
    * constructor.
    */
   static bool _isFactoryConstructorReturnType(SimpleIdentifier identifier) {
     AstNode parent = identifier.parent;
     if (parent is ConstructorDeclaration) {
-      ConstructorDeclaration constructor = parent;
-      return identical(constructor.returnType, identifier) &&
-          constructor.factoryKeyword != null;
+      return identical(parent.returnType, identifier) &&
+          parent.factoryKeyword != null;
     }
     return false;
   }
 
   /**
    * Return `true` if the given 'super' [expression] is used in a valid context.
    */
   static bool _isSuperInValidContext(SuperExpression expression) {
     for (AstNode node = expression; node != null; node = node.parent) {
       if (node is CompilationUnit) {
         return false;
-      }
-      if (node is ConstructorDeclaration) {
+      } else if (node is ConstructorDeclaration) {
         return node.factoryKeyword == null;
-      }
-      if (node is ConstructorFieldInitializer) {
+      } else if (node is ConstructorFieldInitializer) {
         return false;
-      }
-      if (node is MethodDeclaration) {
+      } else if (node is MethodDeclaration) {
         return !node.isStatic;
       }
     }
     return false;
   }
 
   /**
    * Resolve each of the annotations in the given list of [annotations].
    */
   static void _resolveAnnotations(NodeList<Annotation> annotations) {
@@ skipping 59 matching lines @@
 
   @override
   Element get staticElement => null;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {}
 }