Add tests for list and async marker

pkg/compiler/lib/src/inferrer/kernel_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 '../closure.dart';
 import '../common.dart';
 import '../common_elements.dart';
 import '../compiler.dart';
@@ skipping 107 matching lines @@
         new KernelTypeGraphBuilder(member, compiler, _elementMap, this, body);
     return visitor.run();
   }
 
   @override
   FunctionEntity lookupCallMethod(ClassEntity cls) {
     throw new UnimplementedError('KernelInferrerEngine.lookupCallMethod');
   }
 
   @override
-  void forEachParameter(FunctionEntity method, void f(Local parameter)) {
-    throw new UnimplementedError('KernelInferrerEngine.forEachParameter');
-  }
-
-  @override
   ir.Node computeMemberBody(MemberEntity member) {
     MemberDefinition definition = _elementMap.getMemberDefinition(member);
     switch (definition.kind) {
       case MemberKind.regular:
         ir.Member node = definition.node;
         if (node is ir.Field) {
           return node.initializer;
         } else if (node is ir.Procedure) {
           return node.function;
         }
@@ skipping 55 matching lines @@
   bool checkListNode(ir.Node node) => true;
 
   @override
   bool checkLoopPhiNode(ir.Node node) => true;
 
   @override
   bool checkPhiNode(ir.Node node) => true;
 
   @override
   void forEachParameter(FunctionEntity function, void f(Local parameter)) {
-    throw new UnimplementedError('KernelTypeSystemStrategy.forEachParameter');
+    KernelToLocalsMap localsMap = _globalLocalsMap.getLocalsMap(function);
+
+    void processFunctionNode(ir.FunctionNode node) {
+      for (ir.VariableDeclaration variable in node.positionalParameters) {
+        f(localsMap.getLocalVariable(variable));
+      }
+      for (ir.VariableDeclaration variable in node.namedParameters) {
+        f(localsMap.getLocalVariable(variable));
+      }
+    }
+
+    MemberDefinition definition = _elementMap.getMemberDefinition(function);
+    switch (definition.kind) {
+      case MemberKind.regular:
+        ir.Node node = definition.node;
+        if (node is ir.Procedure) {
+          processFunctionNode(node.function);
+          return;
+        }
+        break;
+      case MemberKind.constructor:
+      case MemberKind.constructorBody:
+        ir.Node node = definition.node;
+        if (node is ir.Procedure) {
+          processFunctionNode(node.function);
+          return;
+        } else if (node is ir.Constructor) {
+          processFunctionNode(node.function);
+          return;
+        }
+        break;
+      case MemberKind.closureCall:
+        ir.Node node = definition.node;
+        if (node is ir.FunctionDeclaration) {
+          processFunctionNode(node.function);
+          return;
+        } else if (node is ir.FunctionExpression) {
+          processFunctionNode(node.function);
+          return;
+        }
+        break;
+      default:
+    }
+    failedAt(function, "Unexpected function definition $definition.");
   }
 
   @override
   ParameterTypeInformation createParameterTypeInformation(
       Local parameter, TypeSystem<ir.Node> types) {
     MemberEntity context = parameter.memberContext;
     KernelToLocalsMap localsMap = _globalLocalsMap.getLocalsMap(context);
     ir.FunctionNode functionNode =
         localsMap.getFunctionNodeForParameter(parameter);
     DartType type =
@@ skipping 43 matching lines @@
       ConstructorEntity constructor = member;
       if (constructor.isFactoryConstructor) {
         DartType type = _elementEnvironment.getFunctionType(constructor);
         return new FactoryConstructorTypeInformation(constructor, type);
       } else {
         return new GenerativeConstructorTypeInformation(constructor);
       }
     }
   }
 }