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

pkg/compiler/lib/src/js_model/closure_visitors.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 'closure.dart';
 
 /// This builder walks the code to determine what variables are captured/free at
 /// various points to build CapturedScope that can respond to queries
 /// about how a particular variable is being used at any point in the code.
 class CapturedScopeBuilder extends ir.Visitor {
   ir.TreeNode _currentLocalFunction;
 
   ScopeModel _model;
 
   /// A map of each visited call node with the associated information about what
   /// variables are captured/used. Each ir.Node key corresponds to a scope that
   /// was encountered while visiting a closure (initially called through
   /// [translateLazyIntializer] or [translateConstructorOrProcedure]).
   Map<ir.Node, KernelCapturedScope> get _scopesCapturedInClosureMap =>
       _model.capturedScopesMap;
 
   /// A map of the nodes that we have flagged as necessary to generate closure
   /// classes for in a later stage. We map that node to information ascertained
   /// about variable usage in the surrounding scope.
-  Map<ir.FunctionNode, KernelScopeInfo> get _closuresToGenerate =>
+  Map<ir.TreeNode, KernelScopeInfo> get _closuresToGenerate =>
       _model.closuresToGenerate;
 
   /// The local variables that have been declared in the current scope.
   List<ir.VariableDeclaration> _scopeVariables;
 
   /// Pointer to the context in which this closure is executed.
   /// For example, in the expression `var foo = () => 3 + i;`, the executable
   /// context as we walk the nodes in that expression is the ir.Field `foo`.
   ir.TreeNode _executableContext;
 
@@ skipping 175 matching lines @@
         scope.boxedVariables,
         scope.capturedVariablesAccessor,
         boxedLoopVariables,
         scope.context,
         scope.localsUsedInTryOrSync,
         scope.freeVariables,
         scope.hasThisLocal);
   }
 
   void visitInvokable(ir.TreeNode node) {
+    assert(node is ir.Member ||
+        node is ir.FunctionExpression ||
+        node is ir.FunctionDeclaration);
     bool oldIsInsideClosure = _isInsideClosure;
     ir.TreeNode oldExecutableContext = _executableContext;
     KernelScopeInfo oldScopeInfo = _currentScopeInfo;
     ir.TreeNode oldLocalFunction = _currentLocalFunction;
 
     // _outermostNode is only null the first time we enter the body of the
     // field, constructor, or method that is being analyzed.
     _isInsideClosure = _outermostNode != null;
     _executableContext = node;
 
@@ skipping 33 matching lines @@
   /// Return true if [variable]'s context is the same as the current executable
   /// context.
   bool _inCurrentContext(ir.VariableDeclaration variable) {
     ir.TreeNode node = variable;
     while (node != _outermostNode && node != _executableContext) {
       node = node.parent;
     }
     return node == _executableContext;
   }
 
-  void translateLazyInitializer(ir.Field field) {
+  @override
+  void visitField(ir.Field field) {
     visitInvokable(field);
   }
 
-  void translateConstructorOrProcedure(ir.Node constructorOrProcedure) {
-    constructorOrProcedure.accept(this);
+  @override
+  void visitConstructor(ir.Constructor constructor) {
+    visitInvokable(constructor);
   }
 
-  void visitFunctionNode(ir.FunctionNode functionNode) {
-    visitInvokable(functionNode);
+  @override
+  void visitProcedure(ir.Procedure procedure) {
+    visitInvokable(procedure);
+  }
+
+  @override
+  void visitFunctionExpression(ir.FunctionExpression functionExpression) {
+    visitInvokable(functionExpression);
+  }
+
+  @override
+  void visitFunctionDeclaration(ir.FunctionDeclaration functionDeclaration) {
+    visitInvokable(functionDeclaration);
   }
 }