Remove unnecessary casts and general code clean-up

pkg/analyzer/lib/src/dart/resolver/inheritance_manager.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 35 matching lines @@
       new HashMap<ClassElement, Set<AnalysisError>>();
 
   /**
    * Initialize a newly created inheritance manager.
    *
    * @param library the library element context that the inheritance mappings are being generated
    */
   InheritanceManager(LibraryElement library) {
     this._library = library;
     _classLookup = new HashMap<ClassElement, Map<String, ExecutableElement>>();
-    _interfaceLookup = new HashMap<ClassElement, Map<String, ExecutableElement>>();
+    _interfaceLookup =
+        new HashMap<ClassElement, Map<String, ExecutableElement>>();
   }
 
   /**
    * Set the new library element context.
    *
    * @param library the new library element
    */
   void set libraryElement(LibraryElement library) {
     this._library = library;
   }
@@ skipping 12 matching lines @@
   /**
    * Get and return a mapping between the set of all string names of the members inherited from the
    * passed [ClassElement] superclass hierarchy, and the associated [ExecutableElement].
    *
    * @param classElt the class element to query
    * @return a mapping between the set of all members inherited from the passed [ClassElement]
    *         superclass hierarchy, and the associated [ExecutableElement]
    */
   @deprecated
   MemberMap getMapOfMembersInheritedFromClasses(ClassElement classElt) =>
-      new MemberMap.fromMap(_computeClassChainLookupMap(classElt, new HashSet<ClassElement>()));
+      new MemberMap.fromMap(
+          _computeClassChainLookupMap(classElt, new HashSet<ClassElement>()));
 
   /**
    * Get and return a mapping between the set of all string names of the members inherited from the
    * passed [ClassElement] interface hierarchy, and the associated [ExecutableElement].
    *
    * @param classElt the class element to query
    * @return a mapping between the set of all string names of the members inherited from the passed
    *         [ClassElement] interface hierarchy, and the associated [ExecutableElement].
    */
   @deprecated
   MemberMap getMapOfMembersInheritedFromInterfaces(ClassElement classElt) =>
-      new MemberMap.fromMap(_computeInterfaceLookupMap(classElt, new HashSet<ClassElement>()));
+      new MemberMap.fromMap(
+          _computeInterfaceLookupMap(classElt, new HashSet<ClassElement>()));
 
   /**
    * Return a table mapping the string names of the members inherited from the
    * passed [ClassElement]'s superclass hierarchy, and the associated executable
    * element.
    */
-  Map<String, ExecutableElement> getMembersInheritedFromClasses(ClassElement classElt) =>
+  Map<String, ExecutableElement> getMembersInheritedFromClasses(
+          ClassElement classElt) =>
       _computeClassChainLookupMap(classElt, new HashSet<ClassElement>());
 
   /**
    * Return a table mapping the string names of the members inherited from the
    * passed [ClassElement]'s interface hierarchy, and the associated executable
    * element.
    */
-  Map<String, ExecutableElement> getMembersInheritedFromInterfaces(ClassElement classElt) =>
+  Map<String, ExecutableElement> getMembersInheritedFromInterfaces(
+          ClassElement classElt) =>
       _computeInterfaceLookupMap(classElt, new HashSet<ClassElement>());
 
   /**
    * Given some [ClassElement] and some member name, this returns the
    * [ExecutableElement] that the class inherits from the mixins,
    * superclasses or interfaces, that has the member name, if no member is inherited `null` is
    * returned.
    *
    * @param classElt the class element to query
    * @param memberName the name of the executable element to find and return
    * @return the inherited executable element with the member name, or `null` if no such
    *         member exists
    */
   ExecutableElement lookupInheritance(
       ClassElement classElt, String memberName) {
     if (memberName == null || memberName.isEmpty) {
       return null;
     }
-    ExecutableElement executable =
-        _computeClassChainLookupMap(classElt, new HashSet<ClassElement>())
-            [memberName];
+    ExecutableElement executable = _computeClassChainLookupMap(
+        classElt, new HashSet<ClassElement>())[memberName];
     if (executable == null) {
-      return _computeInterfaceLookupMap(classElt, new HashSet<ClassElement>())
-          [memberName];
+      return _computeInterfaceLookupMap(classElt, new HashSet<ClassElement>())[
+          memberName];
     }
     return executable;
   }
 
   /**
    * Given some [ClassElement] and some member name, this returns the
    * [ExecutableElement] that the class either declares itself, or
    * inherits, that has the member name, if no member is inherited `null` is returned.
    *
    * @param classElt the class element to query
@@ skipping 25 matching lines @@
     if (memberName == null || memberName.isEmpty) {
       return result;
     }
     List<Map<String, ExecutableElement>> interfaceMaps =
         _gatherInterfaceLookupMaps(classElt, new HashSet<ClassElement>());
     if (interfaceMaps != null) {
       for (Map<String, ExecutableElement> interfaceMap in interfaceMaps) {
         ExecutableElement overriddenElement = interfaceMap[memberName];
         if (overriddenElement != null) {
           if (overriddenElement is MultiplyInheritedExecutableElement) {
-            MultiplyInheritedExecutableElement multiplyInheritedElement =
-                overriddenElement;
             for (ExecutableElement element
-                in multiplyInheritedElement.inheritedElements) {
+                in overriddenElement.inheritedElements) {
               result.add(element);
             }
           } else {
             result.add(overriddenElement);
           }
         }
       }
     }
     return result;
   }
@@ skipping 98 matching lines @@
     // multiple mixins, visit them in the order listed so that methods in later
     // mixins will overwrite identically-named methods in earlier mixins.
     //
     List<InterfaceType> mixins = classElt.mixins;
     for (InterfaceType mixin in mixins) {
       ClassElement mixinElement = mixin.element;
       if (mixinElement != null) {
         if (!visitedClasses.contains(mixinElement)) {
           visitedClasses.add(mixinElement);
           try {
-            Map<String, ExecutableElement> map = new Map<String, ExecutableElement>.from(
-                _computeClassChainLookupMap(mixinElement, visitedClasses));
+            Map<String, ExecutableElement> map =
+                new Map<String, ExecutableElement>.from(
+                    _computeClassChainLookupMap(mixinElement, visitedClasses));
             //
             // Substitute the super types down the hierarchy.
             //
             _substituteTypeParametersDownHierarchy(mixin, map);
             //
             // Include the members from the superclass in the resultMap.
             //
             _recordMapWithClassMembers(map, mixin, false);
             //
             // Add the members from map into result map.
@@ skipping 135 matching lines @@
    *         lookup maps.
    */
   List<Map<String, ExecutableElement>> _gatherInterfaceLookupMaps(
       ClassElement classElt, HashSet<ClassElement> visitedInterfaces) {
     InterfaceType supertype = classElt.supertype;
     ClassElement superclassElement =
         supertype != null ? supertype.element : null;
     List<InterfaceType> mixins = classElt.mixins;
     List<InterfaceType> interfaces = classElt.interfaces;
     // Recursively collect the list of mappings from all of the interface types
-    List<Map<String, ExecutableElement>> lookupMaps = new List<Map<String, ExecutableElement>>();
+    List<Map<String, ExecutableElement>> lookupMaps =
+        new List<Map<String, ExecutableElement>>();
     //
     // Superclass element
     //
     if (superclassElement != null) {
       if (!visitedInterfaces.contains(superclassElement)) {
         try {
           visitedInterfaces.add(superclassElement);
           //
           // Recursively compute the map for the super type.
           //
@@ skipping 119 matching lines @@
 
   /**
    * Record the passed map with the set of all members (methods, getters and setters) in the type
    * into the passed map.
    *
    * @param map some non-`null` map to put the methods and accessors from the passed
    *          [ClassElement] into
    * @param type the type that will be recorded into the passed map
    * @param doIncludeAbstract `true` if abstract members will be put into the map
    */
-  void _recordMapWithClassMembers(
-      Map<String, ExecutableElement> map, InterfaceType type, bool doIncludeAbstract) {
+  void _recordMapWithClassMembers(Map<String, ExecutableElement> map,
+      InterfaceType type, bool doIncludeAbstract) {
     List<MethodElement> methods = type.methods;
     for (MethodElement method in methods) {
       if (method.isAccessibleIn(_library) &&
           !method.isStatic &&
           (doIncludeAbstract || !method.isAbstract)) {
         map[method.name] = method;
       }
     }
     List<PropertyAccessorElement> accessors = type.accessors;
     for (PropertyAccessorElement accessor in accessors) {
@@ skipping 32 matching lines @@
    * apply the appropriate inheritance rules to determine those methods inherited by or overridden
    * by [classElt]. Also report static warnings
    * [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE] and
    * [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD] if appropriate.
    *
    * @param classElt the class element to query.
    * @param unionMap a mapping from method name to the set of unique (in terms of signature) methods
    *          defined in superclasses of [classElt].
    * @return the inheritance lookup map for [classElt].
    */
-  Map<String, ExecutableElement> _resolveInheritanceLookup(ClassElement classElt,
-      Map<String, List<ExecutableElement>> unionMap) {
-    Map<String, ExecutableElement> resultMap = new Map<String, ExecutableElement>();
+  Map<String, ExecutableElement> _resolveInheritanceLookup(
+      ClassElement classElt, Map<String, List<ExecutableElement>> unionMap) {
+    Map<String, ExecutableElement> resultMap =
+        new Map<String, ExecutableElement>();
     unionMap.forEach((String key, List<ExecutableElement> list) {
       int numOfEltsWithMatchingNames = list.length;
       if (numOfEltsWithMatchingNames == 1) {
         //
         // Example: class A inherits only 1 method named 'm'.
         // Since it is the only such method, it is inherited.
         // Another example: class A inherits 2 methods named 'm' from 2
         // different interfaces, but they both have the same signature, so it is
         // the method inherited.
         //
@@ skipping 266 matching lines @@
   static ExecutableElement _createSyntheticExecutableElement(
       List<ExecutableElement> elementArrayToMerge,
       String name,
       int numOfRequiredParameters,
       int numOfPositionalParameters,
       List<String> namedParameters) {
     DynamicTypeImpl dynamicType = DynamicTypeImpl.instance;
     SimpleIdentifier nameIdentifier =
         new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, name, 0));
     ExecutableElementImpl executable;
-    if (elementArrayToMerge[0] is MethodElement) {
+    ExecutableElement elementToMerge = elementArrayToMerge[0];
+    if (elementToMerge is MethodElement) {
       MultiplyInheritedMethodElementImpl unionedMethod =
           new MultiplyInheritedMethodElementImpl(nameIdentifier);
       unionedMethod.inheritedElements = elementArrayToMerge;
       executable = unionedMethod;
     } else {
       MultiplyInheritedPropertyAccessorElementImpl unionedPropertyAccessor =
           new MultiplyInheritedPropertyAccessorElementImpl(nameIdentifier);
       unionedPropertyAccessor.getter =
-          (elementArrayToMerge[0] as PropertyAccessorElement).isGetter;
+          (elementToMerge as PropertyAccessorElement).isGetter;
       unionedPropertyAccessor.setter =
-          (elementArrayToMerge[0] as PropertyAccessorElement).isSetter;
+          (elementToMerge as PropertyAccessorElement).isSetter;
       unionedPropertyAccessor.inheritedElements = elementArrayToMerge;
       executable = unionedPropertyAccessor;
     }
     int numOfParameters = numOfRequiredParameters +
         numOfPositionalParameters +
         namedParameters.length;
     List<ParameterElement> parameters =
         new List<ParameterElement>(numOfParameters);
     int i = 0;
     for (int j = 0; j < numOfRequiredParameters; j++, i++) {
@@ skipping 255 matching lines @@
   }
 
   /**
    * Initializes [keys] and [values].
    */
   void _initArrays(int initialCapacity) {
     _keys = new List<String>(initialCapacity);
     _values = new List<ExecutableElement>(initialCapacity);
   }
 }