Implement forEachParameter in closures, deal with not all closures being localFunctions

pkg/compiler/lib/src/js_model/closure.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/tasks.dart';
 import '../constants/expressions.dart';
@@ skipping 113 matching lines @@
   /// If no variables are captured, this parameter is null.
   void _produceSyntheticElements(MemberEntity member, ir.FunctionNode node,
       KernelScopeInfo info, JsClosedWorld closedWorldRefiner) {
     KernelToLocalsMap localsMap = _globalLocalsMap.getLocalsMap(member);
     KernelClosureClass closureClass = closedWorldRefiner.buildClosureClass(
         member, node, member.library, info, node.location, localsMap);
 
     // We want the original declaration where that function is used to point
     // to the correct closure class.
     _closureRepresentationMap[closureClass.callMethod] = closureClass;
-    Entity entity = localsMap.getLocalFunction(node.parent);
+    Entity entity;
+    if (node.parent is ir.Member) {
+      entity = _elementMap.getMember(node.parent);
+    } else {
+      entity = localsMap.getLocalFunction(node.parent);
+    }
     assert(entity != null);
     _closureRepresentationMap[entity] = closureClass;
   }
 
   @override
   ScopeInfo getScopeInfo(Entity entity) {
     // TODO(johnniwinther): Remove this check when constructor bodies a created
     // eagerly with the J-model; a constructor body should have it's own
     // [ClosureRepresentationInfo].
     if (entity is ConstructorBodyEntity) {
@@ skipping 185 matching lines @@
 
   final Map<Local, JField> localToFieldMap = new Map<Local, JField>();
 
   KernelClosureClass.fromScopeInfo(
       ir.FunctionNode closureSourceNode,
       this.name,
       this.classIndex,
       this.library,
       KernelScopeInfo info,
       KernelToLocalsMap localsMap)
-      : closureEntity = localsMap.getLocalFunction(closureSourceNode.parent),
+      : closureEntity = closureSourceNode.parent is ir.Member
+            ? null
+            : localsMap.getLocalFunction(closureSourceNode.parent),
         super.from(info, localsMap);
 
   ClassEntity get closureClassEntity => this;
 
   List<Local> get createdFieldEntities => localToFieldMap.keys.toList();
 
   // TODO(efortuna): Implement.
   FieldEntity get thisFieldEntity => null;
 
   void forEachCapturedVariable(f(Local from, JField to)) {
@@ skipping 76 matching lines @@
   ClosureMemberData(this.definition);
 
   @override
   Iterable<ConstantValue> getMetadata(KernelToElementMap elementMap) {
     return const <ConstantValue>[];
   }
 }
 
 class ClosureFunctionData extends ClosureMemberData implements FunctionData {
   final FunctionType functionType;
+  final ir.FunctionNode functionNode;
 
-  ClosureFunctionData(MemberDefinition definition, this.functionType)
+  ClosureFunctionData(
+      ClosureMemberDefinition definition, this.functionType, this.functionNode)
       : super(definition);
 
-  @override
   void forEachParameter(KernelToElementMapForBuilding elementMap,
       void f(DartType type, String name, ConstantValue defaultValue)) {
-    // TODO(johnniwinther,efortuna): Implement this.
-    throw new UnimplementedError('ClosureFunctionData.forEachParameter');
+    void handleParameter(ir.VariableDeclaration node, {bool isOptional: true}) {
+      DartType type = elementMap.getDartType(node.type);
+      String name = node.name;
+      ConstantValue defaultValue;
+      if (isOptional) {
+        if (node.initializer != null) {
+          defaultValue = elementMap.getConstantValue(node.initializer);
+        } else {
+          defaultValue = new NullConstantValue();
+        }
+      }
+      f(type, name, defaultValue);
+    }
+
+    for (int i = 0; i < functionNode.positionalParameters.length; i++) {
+      handleParameter(functionNode.positionalParameters[i],
+          isOptional: i < functionNode.requiredParameterCount);
+    }
+    functionNode.namedParameters.toList()
+      ..sort(namedOrdering)
+      ..forEach(handleParameter);
   }
 
   @override
   FunctionType getFunctionType(KernelToElementMap elementMap) {
     return functionType;
   }
 }
 
 class ClosureFieldData extends ClosureMemberData implements FieldData {
   ClosureFieldData(MemberDefinition definition) : super(definition);
@@ skipping 30 matching lines @@
   KernelScopeInfo scopeInfo;
 
   /// Collected [CapturedScope] data for nodes.
   Map<ir.Node, KernelCapturedScope> capturedScopesMap =
       <ir.Node, KernelCapturedScope>{};
 
   /// Collected [ScopeInfo] data for nodes.
   Map<ir.FunctionNode, KernelScopeInfo> closuresToGenerate =
       <ir.FunctionNode, KernelScopeInfo>{};
 }