All strong mode cleaning of dart2js.

pkg/compiler/lib/src/inferrer/type_graph_nodes.dart

 // Copyright (c) 2013, 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 compiler.src.inferrer.type_graph_nodes;
 
 import 'dart:collection' show IterableBase;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 292 matching lines @@
       int other = assignments[replacement];
       if (other != null) existing += other;
       assignments[replacement] = existing;
       assignments.remove(old);
     }
   }
 
   Iterator<TypeInformation> get iterator => assignments.keys.iterator;
   Iterable<TypeInformation> where(Function f) => assignments.keys.where(f);
 
-  bool contains(TypeInformation info) => assignments.containsKey(info);
+  bool contains(Object info) => assignments.containsKey(info);
 
   String toString() => assignments.keys.toList().toString();
 }
 
 /**
  * A node representing a resolved element of the program. The kind of
  * elements that need an [ElementTypeInformation] are:
  *
  * - Functions (including getters and setters)
  * - Constructors (factory or generative)
@@ skipping 77 matching lines @@
    * The global information is summarized in [cleanup], after which [_callers]
    * is set to `null`.
    */
   Map<Element, Setlet<Spannable>> _callers;
 
   MemberTypeInformation._internal(Element element)
       : super._internal(null, element);
 
   void addCall(Element caller, Spannable node) {
     assert(node is ast.Node || node is Element);
-    _callers ??= <Element, Setlet>{};
+    _callers ??= <Element, Setlet<Spannable>>{};
     _callers.putIfAbsent(caller, () => new Setlet()).add(node);
   }
 
   void removeCall(Element caller, node) {
     if (_callers == null) return;
     Setlet calls = _callers[caller];
     if (calls == null) return;
     calls.remove(node);
     if (calls.isEmpty) {
       _callers.remove(caller);
@@ skipping 408 matching lines @@
     for (MemberElement element in targets) {
       MemberTypeInformation callee = inferrer.types.getInferredTypeOf(element);
       callee.addCall(caller, call);
       callee.addUser(this);
       inferrer.updateParameterAssignments(
           this, element, arguments, selector, typeMask,
           remove: false, addToQueue: false);
     }
   }
 
-  Iterable<Element> get callees =>
-      targets.map((MemberElement e) => e.implementation);
+  Iterable<Element> get callees => targets.map((_e) {
+        MemberElement e = _e;
+        return e.implementation;
+      });
 
   TypeMask computeTypedSelector(InferrerEngine inferrer) {
     TypeMask receiverType = receiver.type;
 
     if (mask != receiverType) {
       return receiverType == inferrer.commonMasks.dynamicType
           ? null
           : receiverType;
     } else {
       return mask;
     }
   }
 
   bool targetsIncludeComplexNoSuchMethod(InferrerEngine inferrer) {
-    return targets.any((MemberElement e) {
+    return targets.any((_e) {
+      MemberElement e = _e;
       return e is MethodElement &&
           e.isInstanceMember &&
           e.name == Identifiers.noSuchMethod_ &&
           inferrer.backend.noSuchMethodRegistry.isComplex(e);
     });
   }
 
   /**
    * We optimize certain operations on the [int] class because we know more
    * about their return type than the actual Dart code. For example, we know int
@@ skipping 148 matching lines @@
         callee.removeCall(caller, call);
         callee.removeUser(this);
         inferrer.updateParameterAssignments(
             this, element, arguments, selector, typeMask,
             remove: true, addToQueue: true);
       });
     }
 
     // Walk over the found targets, and compute the joined union type mask
     // for all these targets.
-    TypeMask result =
-        inferrer.types.joinTypeMasks(targets.map((MemberElement element) {
+    TypeMask result = inferrer.types.joinTypeMasks(targets.map((_element) {
+      MemberElement element = _element;
       // If [canReachAll] is true, then we are iterating over all
       // targets that satisfy the untyped selector. We skip the return
       // type of the targets that can only be reached through
       // `Invocation.delegate`. Note that the `noSuchMethod` targets
       // are included in [typedTargets].
       if (canReachAll && !typedTargets.contains(element)) {
         return const TypeMask.nonNullEmpty();
       }
       if (inferrer.returnsListElementType(selector, typeMask)) {
         ContainerTypeMask containerTypeMask = receiver.type;
@@ skipping 74 matching lines @@
   }
 
   String toString() => 'Call site $call on ${receiver.type} $type';
 
   accept(TypeInformationVisitor visitor) {
     return visitor.visitDynamicCallSiteTypeInformation(this);
   }
 
   bool hasStableType(InferrerEngine inferrer) {
     return receiver.isStable &&
-        targets.every((MemberElement element) =>
-            inferrer.types.getInferredTypeOf(element).isStable) &&
+        targets.every((_element) {
+          MemberElement element = _element;
+          return inferrer.types.getInferredTypeOf(element).isStable;
+        }) &&
         (arguments == null || arguments.every((info) => info.isStable)) &&
         super.hasStableType(inferrer);
   }
 }
 
 class ClosureCallSiteTypeInformation extends CallSiteTypeInformation {
   final TypeInformation closure;
 
   ClosureCallSiteTypeInformation(
       MemberTypeInformation context,
@@ skipping 625 matching lines @@
     // TODO(ngeoffray): Narrow to bound.
     return type;
   } else {
     ResolutionInterfaceType interfaceType = annotation;
     otherType = new TypeMask.nonNullSubtype(interfaceType.element, closedWorld);
   }
   if (isNullable) otherType = otherType.nullable();
   if (type == null) return otherType;
   return type.intersection(otherType, closedWorld);
 }