More dart2js strong mode cleanup.

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

 // Copyright (c) 2017, 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 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
@@ skipping 318 matching lines @@
     });
     reporter.log('Added $addedInGraph elements in inferencing graph.');
 
     TypeGraphDump dump = debug.PRINT_GRAPH ? new TypeGraphDump(this) : null;
 
     dump?.beforeAnalysis();
     buildWorkQueue();
     refine();
 
     // Try to infer element types of lists and compute their escape information.
-    types.allocatedLists.values.forEach((ListTypeInformation info) {
+    types.allocatedLists.values.forEach((TypeInformation info) {
       analyzeListAndEnqueue(info);
     });
 
     // Try to infer the key and value types for maps and compute the values'
     // escape information.
-    types.allocatedMaps.values.forEach((MapTypeInformation info) {
+    types.allocatedMaps.values.forEach((TypeInformation info) {
       analyzeMapAndEnqueue(info);
     });
 
     Set<FunctionElement> bailedOutOn = new Set<FunctionElement>();
 
     // Trace closures to potentially infer argument types.
-    types.allocatedClosures.forEach((info) {
+    types.allocatedClosures.forEach((dynamic info) {
       void trace(
           Iterable<FunctionElement> elements, ClosureTracerVisitor tracer) {
         tracer.run();
         if (!tracer.continueAnalyzing) {
           elements.forEach((FunctionElement e) {
             closedWorldRefiner.registerMightBePassedToApply(e);
             if (debug.VERBOSE) print("traced closure $e as ${true} (bail)");
             e.functionSignature.forEachParameter((parameter) {
               types
                   .getInferredTypeOf(parameter)
@@ skipping 64 matching lines @@
       // If the node cannot be reset, we do not need to update its users either.
       if (!info.reset(this)) continue;
       seenTypes.add(info);
       workQueue.addAll(info.users);
     }
 
     workQueue.addAll(seenTypes);
     refine();
 
     if (debug.PRINT_SUMMARY) {
-      types.allocatedLists.values.forEach((ListTypeInformation info) {
+      types.allocatedLists.values.forEach((_info) {
+        ListTypeInformation info = _info;
         print('${info.type} '
             'for ${info.originalType.allocationNode} '
             'at ${info.originalType.allocationElement} '
             'after ${info.refineCount}');
       });
-      types.allocatedMaps.values.forEach((MapTypeInformation info) {
+      types.allocatedMaps.values.forEach((_info) {
+        MapTypeInformation info = _info;
         print('${info.type} '
             'for ${info.originalType.allocationNode} '
             'at ${info.originalType.allocationElement} '
             'after ${info.refineCount}');
       });
       types.allocatedClosures.forEach((TypeInformation info) {
         if (info is ElementTypeInformation) {
           print('${types.getInferredSignatureOf(info.element)} for '
               '${info.element}');
         } else if (info is ClosureTypeInformation) {
@@ skipping 92 matching lines @@
         // assignment. Instance fields are dealt with in the constructor.
         if (Elements.isStaticOrTopLevelField(element)) {
           recordTypeOfNonFinalField(node, element, type);
         }
       } else {
         recordTypeOfNonFinalField(node, element, type);
       }
       if (Elements.isStaticOrTopLevelField(element) &&
           resolvedAst.body != null &&
           !element.isConst) {
-        var argument = resolvedAst.body;
+        dynamic argument = resolvedAst.body;
         // TODO(13429): We could do better here by using the
         // constant handler to figure out if it's a lazy field or not.
         if (argument.asSend() != null ||
             (argument.asNewExpression() != null && !argument.isConst)) {
           recordType(element, types.nullType);
         }
       }
     } else {
       recordReturnType(element, type);
     }
   }
 
   void processLoopInformation() {
-    types.allocatedCalls.forEach((info) {
+    types.allocatedCalls.forEach((dynamic info) {
       if (!info.inLoop) return;
       if (info is StaticCallSiteTypeInformation) {
         closedWorldRefiner
             .addFunctionCalledInLoop(info.calledElement.declaration);
       } else if (info.mask != null && !info.mask.containsAll(closedWorld)) {
         // For instance methods, we only register a selector called in a
         // loop if it is a typed selector, to avoid marking too many
         // methods as being called from within a loop. This cuts down
         // on the code bloat.
         info.targets.forEach((MemberElement element) {
@@ skipping 311 matching lines @@
       TypeInformation receiverType,
       Element caller,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop) {
     if (selector.isClosureCall) {
       return registerCalledClosure(node, selector, mask, receiverType, caller,
           arguments, sideEffects, inLoop);
     }
 
-    closedWorld.locateMembers(selector, mask).forEach((MemberElement callee) {
+    closedWorld.locateMembers(selector, mask).forEach((_callee) {
+      MemberElement callee = _callee;
       updateSideEffects(sideEffects, selector, callee);
     });
 
     CallSiteTypeInformation info = new DynamicCallSiteTypeInformation(
         types.currentMember,
         node,
         caller,
         selector,
         mask,
         receiverType,
@@ skipping 61 matching lines @@
     types.allocatedCalls.add(info);
     return info;
   }
 
   // Sorts the resolved elements by size. We do this for this inferrer
   // to get the same results for [ListTracer] compared to the
   // [SimpleTypesInferrer].
   Iterable<ResolvedAst> sortResolvedAsts() {
     int max = 0;
     Map<int, Setlet<ResolvedAst>> methodSizes = <int, Setlet<ResolvedAst>>{};
-    compiler.enqueuer.resolution.processedEntities
-        .forEach((MemberElement element) {
+    compiler.enqueuer.resolution.processedEntities.forEach((_element) {
+      MemberElement element = _element;
       ResolvedAst resolvedAst = element.resolvedAst;
       element = element.implementation;
       if (element.impliesType) return;
       assert(
           element.isField ||
               element.isFunction ||
               element.isConstructor ||
               element.isGetter ||
               element.isSetter,
           failedAt(element, 'Unexpected element kind: ${element.kind}'));
@@ skipping 88 matching lines @@
   /**
    * Records that the captured variable [local] is read.
    */
   void recordCapturedLocalRead(Local local) {}
 
   /**
    * Records that the variable [local] is being updated.
    */
   void recordLocalUpdate(Local local, TypeInformation type) {}
 }