Add tests for list and async marker

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 '../common_elements.dart';
@@ skipping 475 matching lines @@
     types.allocatedClosures.forEach((dynamic info) {
       void trace(
           Iterable<FunctionEntity> elements, ClosureTracerVisitor tracer) {
         tracer.run();
         if (!tracer.continueAnalyzing) {
           elements.forEach((FunctionEntity element) {
             closedWorldRefiner.registerMightBePassedToApply(element);
             if (debug.VERBOSE) {
               print("traced closure $element as ${true} (bail)");
             }
-            forEachParameter(element, (Local parameter) {
+            types.strategy.forEachParameter(element, (Local parameter) {
               types
                   .getInferredTypeOfParameter(parameter)
                   .giveUp(this, clearAssignments: false);
             });
           });
           bailedOutOn.addAll(elements);
           return;
         }
         elements
             .where((e) => !bailedOutOn.contains(e))
             .forEach((FunctionEntity element) {
-          forEachParameter(element, (Local parameter) {
+          types.strategy.forEachParameter(element, (Local parameter) {
             ParameterTypeInformation info =
                 types.getInferredTypeOfParameter(parameter);
             info.maybeResume();
             workQueue.add(info);
           });
           if (tracer.tracedType.mightBePassedToFunctionApply) {
             closedWorldRefiner.registerMightBePassedToApply(element);
           }
           if (debug.VERBOSE) {
             print("traced closure $element as "
@@ skipping 123 matching lines @@
     reporter.log('Added $addedInGraph elements in inferencing graph.');
   }
 
   /// Compute a 'size' of [member] used for sorting member for the type
   /// inference work-queue. Smallest members are processed first.
   int computeMemberSize(MemberEntity member);
 
   /// Returns the body node for [member].
   T computeMemberBody(MemberEntity member);
 
-  /// Calls [f] for each parameter of [method].
-  void forEachParameter(FunctionEntity method, void f(Local parameter));
-
   /// Returns the `call` method on [cls] or the `noSuchMethod` if [cls] doesn't
   /// implement `call`.
   FunctionEntity lookupCallMethod(ClassEntity cls);
 
   void analyze(MemberEntity element, T body, ArgumentsTypes arguments) {
     assert(!(element is MemberElement && !element.isDeclaration));
     if (analyzedElements.contains(element)) return;
     analyzedElements.add(element);
 
     TypeInformation type;
@@ skipping 145 matching lines @@
         info.closurizedCount--;
       } else {
         info.closurizedCount++;
         if (callee.isStatic || callee.isTopLevel) {
           types.allocatedClosures.add(info);
         } else {
           // We add the call-site type information here so that we
           // can benefit from further refinement of the selector.
           types.allocatedClosures.add(caller);
         }
-        forEachParameter(callee, (Local parameter) {
+        types.strategy.forEachParameter(callee, (Local parameter) {
           ParameterTypeInformation info =
               types.getInferredTypeOfParameter(parameter);
           info.tagAsTearOffClosureParameter(this);
           if (addToQueue) workQueue.add(info);
         });
       }
     } else {
       FunctionEntity method = callee;
       ParameterStructure parameterStructure = method.parameterStructure;
       int parameterIndex = 0;
-      forEachParameter(callee, (Local parameter) {
+      types.strategy.forEachParameter(callee, (Local parameter) {
         TypeInformation type;
         if (parameterIndex < parameterStructure.requiredParameters) {
           type = arguments.positional[parameterIndex];
         } else if (parameterStructure.namedParameters.isNotEmpty) {
           type = arguments.named[parameter.name];
         } else if (parameterIndex < arguments.positional.length) {
           type = arguments.positional[parameterIndex];
         }
         if (type == null) type = getDefaultTypeOfParameter(parameter);
         TypeInformation info = types.getInferredTypeOfParameter(parameter);
@@ skipping 293 matching lines @@
       // Put the other operators in buckets by size, later to be added in
       // size order.
       int size = computeSize(element);
       Set<MemberEntity> set =
           methodSizes.putIfAbsent(size, () => new Setlet<MemberEntity>());
       set.add(element);
     });
     return methodSizes;
   }
 }