Register created closure class with the world.

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/tasks.dart';
 import '../elements/entities.dart';
 import '../kernel/element_map.dart';
@@ skipping 36 matching lines @@
 
   /// The combined steps of generating our intermediate representation of
   /// closures that need to be rewritten and generating the element model.
   /// Ultimately these two steps will be split apart with the second step
   /// happening later in compilation just before codegen. These steps are
   /// combined here currently to provide a consistent interface to the rest of
   /// the compiler until we are ready to separate these phases.
   @override
   void convertClosures(Iterable<MemberEntity> processedEntities,
       ClosedWorldRefiner closedWorldRefiner) {
-    var closuresToGenerate = <ir.Node, ScopeInfo>{};
+    var closuresToGenerate = <ir.TreeNode, ScopeInfo>{};
     processedEntities.forEach((MemberEntity kEntity) {
       MemberEntity entity = kEntity;
       if (_kToJElementMap != null) {
         entity = _kToJElementMap.toBackendMember(kEntity);
       }
       if (entity.isAbstract) return;
       if (entity.isField && !entity.isInstanceMember) {
         ir.Field field = _elementMap.getMemberNode(entity);
         // Skip top-level/static fields without an initializer.
         if (field.initializer == null) return;
       }
       _buildClosureModel(entity, closuresToGenerate, closedWorldRefiner);
     });
 
-    for (ir.Node node in closuresToGenerate.keys) {
+    for (ir.TreeNode node in closuresToGenerate.keys) {
       _produceSyntheticElements(
           node, closuresToGenerate[node], closedWorldRefiner);
     }
   }
 
   /// Inspect members and mark if those members capture any state that needs to
   /// be marked as free variables.
   void _buildClosureModel(
       MemberEntity entity,
-      Map<ir.Node, ScopeInfo> closuresToGenerate,
+      Map<ir.TreeNode, ScopeInfo> closuresToGenerate,
       ClosedWorldRefiner closedWorldRefiner) {
     ir.Node node = _elementMap.getMemberNode(entity);
     if (_closureScopeMap.keys.contains(node)) return;
     ClosureScopeBuilder translator = new ClosureScopeBuilder(_closureScopeMap,
         closuresToGenerate, _globalLocalsMap.getLocalsMap(entity), _elementMap);
     if (entity.isField) {
       if (node is ir.Field && node.initializer != null) {
         translator.translateLazyInitializer(node);
       }
     } else {
       assert(node is ir.Procedure || node is ir.Constructor);
       translator.translateConstructorOrProcedure(node);
     }
   }
 
   /// Given what variables are captured at each point, construct closure classes
   /// with fields containing the captured variables to replicate the Dart
   /// closure semantics in JS.
   void _produceSyntheticElements(
-      ir.Node node, ScopeInfo info, ClosedWorldRefiner closedWorldRefiner) {
+      ir.TreeNode /* ir.Field | ir.FunctionNode */ node,
+      ScopeInfo info,
+      ClosedWorldRefiner closedWorldRefiner) {
     Entity entity;
     KernelClosureClass closureClass =
         new KernelClosureClass.fromScopeInfo(info);
     if (node is ir.FunctionNode) {
       // We want the original declaration where that function is used to point
       // to the correct closure class.
       // TODO(efortuna): entity equivalent of element.declaration?
       node = (node as ir.FunctionNode).parent;
       _closureRepresentationMap[closureClass.callMethod] = closureClass;
     }
 
     if (node is ir.Member) {
       entity = _elementMap.getMember(node);
     } else {
       entity = _elementMap.getLocalFunction(node);
     }
     assert(entity != null);
 
     _closureRepresentationMap[entity] = closureClass;
+
+    // Register that a new class has been created.
+    closedWorldRefiner.registerClosureClass(
+        closureClass, node is ir.Member && node.isInstanceMember);
   }
 
   @override
   ScopeInfo getScopeInfo(Entity entity) {
     return getClosureRepresentationInfo(entity);
   }
 
   // TODO(efortuna): Eventually closureScopeMap[node] should always be non-null,
   // and we should just test that with an assert.
   ClosureScope _getClosureScope(ir.Node node) =>
@@ skipping 81 matching lines @@
 
   KernelLoopClosureScope(Set<Local> boxedVariables, this.boxedLoopVariables,
       Local context, Local thisLocal)
       : super(boxedVariables, context, thisLocal);
 
   bool get hasBoxedLoopVariables => boxedLoopVariables.isNotEmpty;
 }
 
 // TODO(johnniwinther): Add unittest for the computed [ClosureClass].
 class KernelClosureClass extends KernelScopeInfo
-    implements ClosureRepresentationInfo {
-  KernelClosureClass.fromScopeInfo(ScopeInfo info)
+    implements ClosureRepresentationInfo, JClass {
+  // TODO(efortuna): Generate unique name for each closure class.
+  final String name = 'ClosureClass';
+
+  /// Index into the classData, classList and classEnvironment lists where this
+  /// entity is stored in [JsToFrontendMapImpl].
+  int classIndex;
+
+  final Map<Local, JField> localToFieldMap = new Map<Local, JField>();
+
+  KernelClosureClass.fromScopeInfo(KernelScopeInfo info)
       : super.from(info.thisLocal, info);
 
   // TODO(efortuna): Implement.
   Local get closureEntity => null;
 
-  // TODO(efortuna): Implement.
-  ClassEntity get closureClassEntity => null;
+  ClassEntity get closureClassEntity => this;
 
   // TODO(efortuna): Implement.
   FunctionEntity get callMethod => null;
 
   // TODO(efortuna): Implement.
   List<Local> get createdFieldEntities => const <Local>[];
 
   // TODO(efortuna): Implement.
   FieldEntity get thisFieldEntity => null;
 
   // TODO(efortuna): Implement.
   void forEachCapturedVariable(f(Local from, FieldEntity to)) {}
 
   // TODO(efortuna): Implement.
   @override
   void forEachBoxedVariable(f(Local local, FieldEntity field)) {}
 
   // TODO(efortuna): Implement.
   void forEachFreeVariable(f(Local variable, FieldEntity field)) {}
 
   // TODO(efortuna): Implement.
   bool isVariableBoxed(Local variable) => false;
 
   // TODO(efortuna): Implement.
   // Why is this closure not actually a closure? Well, to properly call
   // ourselves a closure, we need to register the new closure class with the
   // ClosedWorldRefiner, which currently only takes elements. The change to
   // that (and the subsequent adjustment here) will follow soon.
   bool get isClosure => false;
+
+  bool get isAbstract => false;
+
+  // TODO(efortuna): Talk to Johnni.
+  JLibrary get library => null;
+
+  String toString() => '${jsElementPrefix}class($name)';
 }