Support forEachClassMember on closure classes

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';
+import '../constants/values.dart';
 import '../elements/entities.dart';
 import '../elements/names.dart' show Name;
+import '../elements/types.dart';
 import '../kernel/element_map.dart';
+import '../kernel/env.dart';
 import '../world.dart';
 import 'elements.dart';
 import 'closure_visitors.dart';
 import 'locals.dart';
 import 'js_strategy.dart' show JsClosedWorld;
 
 class KernelClosureAnalysis {
   /// Inspect members and mark if those members capture any state that needs to
   /// be marked as free variables.
   static ClosureModel computeClosureModel(MemberEntity entity, ir.Member node) {
@@ skipping 285 matching lines @@
             .map(localsMap.getLocalVariable)
             .toList(),
         super.from(capturedScope, localsMap);
 
   bool get hasBoxedLoopVariables => boxedLoopVariables.isNotEmpty;
 }
 
 // TODO(johnniwinther): Add unittest for the computed [ClosureClass].
 class KernelClosureClass extends JsScopeInfo
     implements ClosureRepresentationInfo, JClass {
-  final ir.Location location;
-
   final String name;
   final JLibrary library;
   JFunction callMethod;
   final Local closureEntity;
 
   /// Index into the classData, classList and classEnvironment lists where this
   /// entity is stored in [JsToFrontendMapImpl].
   final int classIndex;
 
   final Map<Local, JField> localToFieldMap = new Map<Local, JField>();
 
   KernelClosureClass.fromScopeInfo(
       ir.FunctionNode closureSourceNode,
       this.name,
       this.classIndex,
       this.library,
       KernelScopeInfo info,
-      this.location,
       KernelToLocalsMap localsMap)
       : closureEntity = 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;
@@ skipping 52 matching lines @@
   final BoxLocal box;
   JBoxedField(String name, int memberIndex, this.box,
       KernelClosureClass containingClass, bool isConst, bool isAssignable)
       : super(memberIndex, containingClass.library, containingClass,
             new Name(name, containingClass.library),
             isAssignable: isAssignable, isConst: isConst);
 }
 
 class ClosureClassDefinition implements ClassDefinition {
   final ClassEntity cls;
-  final ir.Location location;
+  final SourceSpan location;
 
   ClosureClassDefinition(this.cls, this.location);
 
   ClassKind get kind => ClassKind.closure;
 
   ir.Node get node =>
       throw new UnsupportedError('ClosureClassDefinition.node for $cls');
 
   String toString() =>
       'ClosureClassDefinition(kind:$kind,cls:$cls,location:$location)';
 }
 
+class ClosureMemberData implements MemberData {
+  final MemberDefinition definition;
+
+  ClosureMemberData(this.definition);
+
+  @override
+  Iterable<ConstantValue> getMetadata(KernelToElementMap elementMap) {
+    return const <ConstantValue>[];
+  }
+}
+
+class ClosureFunctionData extends ClosureMemberData implements FunctionData {
+  final FunctionType functionType;
+
+  ClosureFunctionData(MemberDefinition definition, this.functionType)
+      : 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');
+  }
+
+  @override
+  FunctionType getFunctionType(KernelToElementMap elementMap) {
+    return functionType;
+  }
+}
+
+class ClosureFieldData extends ClosureMemberData implements FieldData {
+  ClosureFieldData(MemberDefinition definition) : super(definition);
+
+  @override
+  ConstantExpression getFieldConstant(
+      KernelToElementMap elementMap, FieldEntity field) {
+    failedAt(
+        field,
+        "Unexpected field $field in "
+        "ClosureFieldData.getFieldConstant");
+    return null;
+  }
+}
+
 class ClosureMemberDefinition implements MemberDefinition {
   final MemberEntity member;
-  final ir.Location location;
+  final SourceSpan location;
   final MemberKind kind;
   final ir.Node node;
 
   ClosureMemberDefinition(this.member, this.location, this.kind, this.node);
 
   String toString() =>
       'ClosureMemberDefinition(kind:$kind,member:$member,location:$location)';
 }
 
 /// Collection of closure data collected for a single member.
 class ClosureModel {
   /// Collection [ScopeInfo] data for the member, if any.
   // TODO(johnniwinther): [scopeInfo] seem to be missing only for fields
   // without initializers; we shouldn't even create a [ClosureModel] in these
   // cases.
   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>{};
 }