Add Closure call method to created closure class

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
@@ skipping 78 matching lines @@
       model.capturedScopesMap
           .forEach((ir.Node node, KernelCapturedScope scope) {
         if (scope is KernelCapturedLoopScope) {
           _capturedScopesMap[node] =
               new JsCapturedLoopScope.from(scope, localsMap);
         } else {
           _capturedScopesMap[node] = new JsCapturedScope.from(scope, localsMap);
         }
       });
 
-      Map<ir.TreeNode, KernelScopeInfo> closuresToGenerate =
+      Map<ir.FunctionNode, KernelScopeInfo> closuresToGenerate =
           model.closuresToGenerate;
-      for (ir.TreeNode node in closuresToGenerate.keys) {
+      for (ir.FunctionNode node in closuresToGenerate.keys) {
         _produceSyntheticElements(
             member, node, closuresToGenerate[node], closedWorldRefiner);
       }
     });
   }
 
   /// Inspect members and mark if those members capture any state that needs to
   /// be marked as free variables.
   ClosureModel _buildClosureModel(MemberEntity entity) {
     ClosureModel model = new ClosureModel();
@@ skipping 18 matching lines @@
     }
     return model;
   }
 
   /// 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,
-      JsClosedWorld closedWorldRefiner) {
-    String name = _computeClosureName(node);
+  void _produceSyntheticElements(MemberEntity member, ir.FunctionNode node,
+      KernelScopeInfo info, JsClosedWorld closedWorldRefiner) {
     KernelToLocalsMap localsMap = _globalLocalsMap.getLocalsMap(member);
     KernelClosureClass closureClass = closedWorldRefiner.buildClosureClass(
-        name, member.library, info, node.location, localsMap);
+        member, node, 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;
-    }
+    // 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);
     assert(entity != null);
     _closureRepresentationMap[entity] = 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');
-    }
-    ir.TreeNode node = treeNode.parent;
-    while (node != null &&
-        (node is ir.Constructor ||
-            node is ir.Class ||
-            node is ir.FunctionNode ||
-            node is ir.Procedure)) {
-      // TODO(johnniwinther): Simplify computed names.
-      if (node is ir.Constructor ||
-          node.parent is ir.Constructor ||
-          (node is ir.Procedure && node.kind == ir.ProcedureKind.Factory)) {
-        FunctionEntity entity;
-        if (node.parent is ir.Constructor) {
-          entity = _elementMap.getConstructorBody(node);
-        } else {
-          entity = _elementMap.getMember(node);
-        }
-        parts.add(utils.reconstructConstructorName(entity));
-      } else {
-        String surroundingName = '';
-        if (node is ir.Class) {
-          surroundingName = Elements.operatorNameToIdentifier(node.name);
-        } else if (node is ir.Procedure) {
-          surroundingName = Elements.operatorNameToIdentifier(node.name.name);
-        }
-        parts.add(surroundingName);
-      }
-      // A generative constructors's parent is the class; the class name is
-      // already part of the generative constructor's name.
-      if (node is ir.Constructor) break;
-      node = node.parent;
-    }
-    return parts.reversed.join('_');
-  }
-
   @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) {
       ConstructorBodyEntity constructorBody = entity;
       entity = constructorBody.constructor;
     }
 
@@ skipping 155 matching lines @@
   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;
 
   /// 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(this.name, this.classIndex, this.library,
       KernelScopeInfo info, this.location, KernelToLocalsMap localsMap)
       : 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();
 
   // TODO(efortuna): Implement.
   FieldEntity get thisFieldEntity => null;
 
   void forEachCapturedVariable(f(Local from, JField to)) {
     localToFieldMap.forEach(f);
   }
 
   // TODO(efortuna): Implement.
   @override
   void forEachBoxedVariable(f(Local local, JField field)) {}
 
   // TODO(efortuna): Implement.
   void forEachFreeVariable(f(Local variable, JField field)) {}
 
   // TODO(efortuna): Implement.
   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, int memberIndex, KernelClosureClass containingClass,
-      bool isConst, bool isAssignable)
+class JClosureField extends JField {
+  JClosureField(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);
@@ skipping 25 matching lines @@
   // 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.TreeNode, KernelScopeInfo> closuresToGenerate =
-      <ir.TreeNode, KernelScopeInfo>{};
+  Map<ir.FunctionNode, KernelScopeInfo> closuresToGenerate =
+      <ir.FunctionNode, KernelScopeInfo>{};
 }