Add more tests for closures and change closure indexing to be by FunctionExpression or FunctionDecl…

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';
@@ skipping 18 matching lines @@
       ir.Field field = node;
       // Skip top-level/static fields without an initializer.
       if (field.initializer == null) return null;
     }
 
     ScopeModel model = new ScopeModel();
     CapturedScopeBuilder translator = new CapturedScopeBuilder(model,
         hasThisLocal: entity.isInstanceMember || entity.isConstructor);
     if (entity.isField) {
       if (node is ir.Field && node.initializer != null) {
-        translator.translateLazyInitializer(node);
+        node.accept(translator);
       } else {
         assert(entity.isInstanceMember);
         model.scopeInfo = new KernelScopeInfo(true);
       }
     } else {
       assert(node is ir.Procedure || node is ir.Constructor);
-      translator.translateConstructorOrProcedure(node);
+      node.accept(translator);
     }
     return model;
   }
 }
 
 /// 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
@@ skipping 13 matching lines @@
   final Map<MemberEntity, ScopeModel> _closureModels;
 
   /// Map of the scoping information that corresponds to a particular entity.
   Map<MemberEntity, ScopeInfo> _scopeMap = <MemberEntity, ScopeInfo>{};
   Map<ir.Node, CapturedScope> _capturedScopesMap = <ir.Node, CapturedScope>{};
 
   Map<MemberEntity, ClosureRepresentationInfo> _memberClosureRepresentationMap =
       <MemberEntity, ClosureRepresentationInfo>{};
 
   // The key is either a [ir.FunctionDeclaration] or [ir.FunctionExpression].
-  Map<ir.Node, ClosureRepresentationInfo> _localClosureRepresentationMap =
-      <ir.Node, ClosureRepresentationInfo>{};
+  Map<ir.TreeNode, ClosureRepresentationInfo> _localClosureRepresentationMap =
+      <ir.TreeNode, ClosureRepresentationInfo>{};
 
   KernelClosureConversionTask(Measurer measurer, this._elementMap,
       this._globalLocalsMap, this._closureModels)
       : super(measurer);
 
   /// 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
@@ skipping 15 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.FunctionNode, KernelScopeInfo> closuresToGenerate =
+      Map<ir.TreeNode, KernelScopeInfo> closuresToGenerate =
           model.closuresToGenerate;
-      for (ir.FunctionNode node in closuresToGenerate.keys) {
+      for (ir.TreeNode node in closuresToGenerate.keys) {
+        ir.FunctionNode functionNode;
+        if (node is ir.FunctionDeclaration) {
+          functionNode = node.function;
+        } else if (node is ir.FunctionExpression) {
+          functionNode = node.function;
+        } else {
+          failedAt(member, "Unexpected closure node ${node}");
+        }
         KernelClosureClass closureClass = _produceSyntheticElements(
-            member, node, closuresToGenerate[node], closedWorldRefiner);
+            member, functionNode, closuresToGenerate[node], closedWorldRefiner);
         // Add also for the call method.
         _scopeMap[closureClass.callMethod] = closureClass;
       }
     });
   }
 
   /// 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
@@ skipping 66 matching lines @@
     var closure = _memberClosureRepresentationMap[entity];
     assert(
         closure != null,
         "Corresponding closure class not found for $entity. "
         "Closures found for ${_memberClosureRepresentationMap.keys}");
     return closure;
   }
 
   @override
   ClosureRepresentationInfo getClosureInfo(ir.Node node) {
+    assert(node is ir.FunctionExpression || node is ir.FunctionDeclaration);
     var closure = _localClosureRepresentationMap[node];
     assert(
         closure != null,
         "Corresponding closure class not found for $node. "
         "Closures found for ${_localClosureRepresentationMap.keys}");
     return closure;
   }
 }
 
 class KernelScopeInfo {
@@ skipping 361 matching lines @@
 /// Collection of scope data collected for a single member.
 class ScopeModel {
   /// Collection [ScopeInfo] data for the member.
   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>{};
+  Map<ir.TreeNode, KernelScopeInfo> closuresToGenerate =
+      <ir.TreeNode, KernelScopeInfo>{};
 }