Add Closure call method to created closure class

pkg/compiler/lib/src/kernel/element_map_impl.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.
 
 library dart2js.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
 import '../common/resolution.dart';
 import '../compile_time_constants.dart';
 import '../constants/constant_system.dart';
 import '../constants/constructors.dart';
 import '../constants/evaluation.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../common_elements.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
+import '../elements/entity_utils.dart' as utils;
 import '../elements/names.dart';
 import '../elements/types.dart';
 import '../environment.dart';
 import '../frontend_strategy.dart';
 import '../js_backend/backend_usage.dart';
 import '../js_backend/constant_system_javascript.dart';
 import '../js_backend/interceptor_data.dart';
 import '../js_backend/native_data.dart';
 import '../js_backend/no_such_method_registry.dart';
 import '../js_backend/runtime_types.dart';
@@ skipping 1944 matching lines @@
         return;
       }
       ConstructorData data = _memberData[constructor.memberIndex];
       if (data.constructorBody != null) {
         f(data.constructorBody);
       }
     });
   }
 
   KernelClosureClass constructClosureClass(
-      String name,
+      MemberEntity member,
+      ir.FunctionNode node,
       JLibrary enclosingLibrary,
       KernelScopeInfo info,
       ir.Location location,
       KernelToLocalsMap localsMap,
       InterfaceType supertype) {
+    String name = _computeClosureName(node);
     KernelClosureClass cls = new KernelClosureClass.fromScopeInfo(
         name, _classEnvs.length, enclosingLibrary, info, location, localsMap);
     _classList.add(cls);
     _classEnvs.add(new ClassEnv.closureClass());
 
     // Create a classData and set up the interfaces and subclass
     // relationships that _ensureSupertypes and _ensureThisAndRawType are doing
     var closureData =
         new ClassData(null, new ClosureClassDefinition(cls, cls.location));
     closureData
       ..isMixinApplication = false
       ..thisType =
           closureData.rawType = new InterfaceType(cls, const/*<DartType>*/ [])
       ..supertype = supertype
       ..interfaces = const <InterfaceType>[];
     var setBuilder = new _KernelOrderedTypeSetBuilder(this, cls);
     _classData.add(closureData);
     closureData.orderedTypeSet = setBuilder.createOrderedTypeSet(
         closureData.supertype, const Link<InterfaceType>());
 
     int i = 0;
     for (ir.VariableDeclaration variable in info.freeVariables) {
       // Make a corresponding field entity in this closure class for every
       // single freeVariable in the KernelScopeInfo.freeVariable.
       _constructClosureFields(cls, variable, i, localsMap);
       i++;
     }
 
+    cls.callMethod = new JClosureCallMethod(_memberData.length, cls, member);
+    _memberList.add(cls.callMethod);
+    _memberData.add(new MemberData(
+        null,
+        new ClosureMemberDefinition(
+            member, cls.location, MemberKind.closureCall, node.parent)));
+
     // TODO(efortuna): Does getMetadata get called in ClassData for this object?
     return cls;
   }
 
   _constructClosureFields(
       KernelClosureClass cls,
       ir.VariableDeclaration variable,
       int fieldNumber,
       KernelToLocalsMap localsMap) {
     // 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 (cls.isBoxed(capturedLocal)) {
       // TODO(efortuna): Coming soon.
     } else {
-      var closureField = new ClosureField(
+      var closureField = new JClosureField(
           _getClosureVariableName(capturedLocal.name, fieldNumber),
           _memberData.length,
           cls,
           variable.isConst,
           variable.isFinal || variable.isConst);
       cls.localToFieldMap[capturedLocal] = closureField;
       _memberList.add(closureField);
       _memberData.add(new MemberData(
           null,
           new ClosureMemberDefinition(cls.localToFieldMap[capturedLocal],
               variable.location, MemberKind.closureField, variable)));
     }
   }
 
+  // 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 = getConstructorBody(node);
+        } else {
+          entity = 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('_');
+  }
+
   /// 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";
   }
 
   String getDeferredUri(ir.LibraryDependency node) {
     throw new UnimplementedError('JsKernelToElementMap.getDeferredUri');
   }
 }