Make the ClosedWorld build the closure class on the kernel side.

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 '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/entity_utils.dart' as utils;
 import '../elements/names.dart' show Name;
 import '../kernel/element_map.dart';
 import '../world.dart';
 import 'elements.dart';
 import 'closure_visitors.dart';
 import 'locals.dart';
+import 'js_strategy.dart' show JsClosedWorld;
 
 /// Closure conversion code using our new Entity model. Closure conversion is
 /// necessary because the semantics of closures are slightly different in Dart
 /// than JavaScript. Closure conversion is separated out into two phases:
 /// generation of a new (temporary) representation to store where variables need
 /// to be hoisted/captured up at another level to re-write the closure, and then
 /// the code generation phase where we generate elements and/or instructions to
 /// represent this new code path.
 ///
 /// For a general explanation of how closure conversion works at a high level,
@@ skipping 53 matching lines @@
         ir.Field field = definition.node;
         // Skip top-level/static fields without an initializer.
         if (field.initializer == null) return;
       }
       closureModels[entity] = _buildClosureModel(entity);
     });
     return closureModels;
   }
 
   void _createClosureEntities(Map<MemberEntity, ClosureModel> closureModels,
-      ClosedWorldRefiner closedWorldRefiner) {
+      JsClosedWorld closedWorldRefiner) {
     closureModels.forEach((MemberEntity member, ClosureModel model) {
       KernelToLocalsMap localsMap = _globalLocalsMap.getLocalsMap(member);
       if (model.scopeInfo != null) {
         _scopeMap[member] = new JsScopeInfo.from(model.scopeInfo, localsMap);
       }
 
       model.capturedScopesMap
           .forEach((ir.Node node, KernelCapturedScope scope) {
         if (scope is KernelCapturedLoopScope) {
           _capturedScopesMap[node] =
@@ skipping 41 matching lines @@
   /// 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. If this closure captures any variables (meaning
   /// the closure accesses a variable that gets accessed at some point), then
   /// boxForCapturedVariables stores the local context for those variables.
   /// If no variables are captured, this parameter is null.
   void _produceSyntheticElements(
       MemberEntity member,
       ir.TreeNode /* ir.Member | ir.FunctionNode */ node,
       KernelScopeInfo info,
-      ClosedWorldRefiner closedWorldRefiner) {
+      JsClosedWorld closedWorldRefiner) {
     String name = _computeClosureName(node);
     KernelToLocalsMap localsMap = _globalLocalsMap.getLocalsMap(member);
-    KernelClosureClass closureClass = new KernelClosureClass.fromScopeInfo(
+    KernelClosureClass closureClass = closedWorldRefiner.buildClosureClass(
         name, member.library, info, node.location, localsMap);
 
     Entity entity;
     if (node is ir.Member) {
       entity = member;
     } else {
       assert(node is ir.FunctionNode);
       entity = localsMap.getLocalFunction(node.parent);
       // We want the original declaration where that function is used to point
       // to the correct closure class.
       _closureRepresentationMap[closureClass.callMethod] = closureClass;
     }
     assert(entity != null);
     _closureRepresentationMap[entity] = closureClass;
-
-    // Register that a new class has been created.
-    closedWorldRefiner.registerClosureClass(closureClass);
   }
 
   // Returns a non-unique name for the given closure element.
   String _computeClosureName(ir.TreeNode treeNode) {
     var parts = <String>[];
     if (treeNode is ir.Field && treeNode.name.name != "") {
       parts.add(treeNode.name.name);
     } else {
       parts.add('closure');
     }
@@ skipping 202 matching lines @@
 // 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;
 
   /// Index into the classData, classList and classEnvironment lists where this
   /// entity is stored in [JsToFrontendMapImpl].
-  int classIndex;
+  final int classIndex;
 
   final Map<Local, JField> localToFieldMap = new Map<Local, JField>();
 
-  KernelClosureClass.fromScopeInfo(this.name, this.library,
+  KernelClosureClass.fromScopeInfo(this.name, this.classIndex, this.library,
       KernelScopeInfo info, this.location, KernelToLocalsMap localsMap)
-      : super.from(info, localsMap) {
-    // Make a corresponding field entity in this closure class for every single
-    // freeVariable in the KernelScopeInfo.freeVariable.
-    int i = 0;
-    for (ir.VariableDeclaration variable in info.freeVariables) {
-      // NOTE: This construction order may be slightly different than the
-      // old Element version. The old version did all the boxed items and then
-      // all the others.
-      Local capturedLocal = localsMap.getLocalVariable(variable);
-      if (isBoxed(capturedLocal)) {
-        // TODO(efortuna): Coming soon.
-      } else {
-        localToFieldMap[capturedLocal] = new ClosureField(
-            _getClosureVariableName(capturedLocal.name, i),
-            this,
-            variable.isConst,
-            variable.isFinal || variable.isConst);
-        // TODO(efortuna): These probably need to get registered somewhere.
-      }
-      i++;
-    }
-  }
-
-  /// Generate a unique name for the [id]th closure field, with proposed name
-  /// [name].
-  ///
-  /// The result is used as the name of [ClosureFieldElement]s, and must
-  /// therefore be unique to avoid breaking an invariant in the element model
-  /// (classes cannot declare multiple fields with the same name).
-  ///
-  /// Also, the names should be distinct from real field names to prevent
-  /// clashes with selectors for those fields.
-  ///
-  /// These names are not used in generated code, just as element name.
-  String _getClosureVariableName(String name, int id) {
-    return "_captured_${name}_$id";
-  }
+      : super.from(info, localsMap);
 
   // TODO(efortuna): Implement.
   Local get closureEntity => null;
 
   ClassEntity get closureClassEntity => this;
 
   // TODO(efortuna): Implement.
   FunctionEntity get callMethod => null;
 
   List<Local> get createdFieldEntities => localToFieldMap.keys.toList();
@@ skipping 16 matching lines @@
   bool isVariableBoxed(Local variable) => false;
 
   bool get isClosure => true;
 
   bool get isAbstract => false;
 
   String toString() => '${jsElementPrefix}class($name)';
 }
 
 class ClosureField extends JField {
-  ClosureField(String name, KernelClosureClass containingClass, bool isConst,
-      bool isAssignable)
-      : super(-1, containingClass.library, containingClass,
+  ClosureField(String name, int memberIndex, 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;
 
   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 ClosureMemberDefinition implements MemberDefinition {
+  final MemberEntity member;
+  final ir.Location 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.
   KernelScopeInfo scopeInfo;
 
   /// Collected [CapturedScope] data for nodes.
   Map<ir.Node, KernelCapturedScope> capturedScopesMap =
       <ir.Node, KernelCapturedScope>{};
 
   /// Collected [ScopeInof] data for nodes.
   Map<ir.TreeNode, KernelScopeInfo> closuresToGenerate =
       <ir.TreeNode, KernelScopeInfo>{};
 }