dart2dart: Remove the list of closureVariables from FunctionDefinitions.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

 // Copyright (c) 2013, 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.ir_builder;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
@@ skipping 230 matching lines @@
                          List<LocalElement> loopVariables);
 
   /// Called before building the update of a for-loop.
   void _enterForLoopUpdate(ClosureScope scope,
                            List<LocalElement> loopVariables);
 
   /// Add the given function parameter to the IR, and bind it in the environment
   /// or put it in its box, if necessary.
   void _createFunctionParameter(ParameterElement parameterElement);
 
-  /// Returns the list of closure variables declared in the given function or
-  /// field initializer.
-  List<ir.ClosureVariable> _getDeclaredClosureVariables(ExecutableElement elm);
-
   /// Creates an access to the receiver from the current (or enclosing) method.
   ///
   /// If inside a closure class, [buildThis] will redirect access through
   /// closure fields in order to access the receiver from the enclosing method.
   ir.Primitive buildThis();
 
   // TODO(johnniwinther): Make these field final and remove the default values
   // when [IrBuilder] is a property of [IrBuilderVisitor] instead of a mixin.
 
   final List<ir.Parameter> _parameters = <ir.Parameter>[];
@@ skipping 336 matching lines @@
           message: "Non-empty body for abstract method $element: $_root"));
       assert(invariant(element, state.localConstants.isEmpty,
           message: "Local constants for abstract method $element: "
                    "${state.localConstants}"));
       return new ir.FunctionDefinition.abstract(
                 element, state.functionParameters, defaults);
     } else {
       ir.RunnableBody body = makeRunnableBody();
       return new ir.FunctionDefinition(
           element, state.functionParameters, body,
-          state.localConstants, defaults,
-          _getDeclaredClosureVariables(element));
+          state.localConstants, defaults);
     }
   }
 
   ir.ConstructorDefinition makeConstructorDefinition(
       List<ConstantExpression> defaults, List<ir.Initializer> initializers) {
     FunctionElement element = state.currentElement;
     if (element.isExternal) {
       assert(invariant(element, _root == null,
           message: "Non-empty body for external constructor $element: $_root"));
       assert(invariant(element, state.localConstants.isEmpty,
           message: "Local constants for external constructor $element: "
                    "${state.localConstants}"));
       return new ir.ConstructorDefinition.abstract(
                 element, state.functionParameters, defaults);
     }
     ir.RunnableBody body = makeRunnableBody();
     return new ir.ConstructorDefinition(
         element, state.functionParameters, body, initializers,
-        state.localConstants, defaults,
-        _getDeclaredClosureVariables(element));
+        state.localConstants, defaults);
   }
 
   /// Create a super invocation where the method name and the argument structure
   /// are defined by [selector] and the argument values are defined by
   /// [arguments].
   ir.Primitive buildSuperInvocation(Element target,
                                     Selector selector,
                                     List<ir.Primitive> arguments);
 
   /// Create a setter invocation on the super class where the setter name and
@@ skipping 925 matching lines @@
 /// Captured variables are translated to ref cells (see [ClosureVariable])
 /// using [GetClosureVariable] and [SetClosureVariable].
 class DartIrBuilder extends IrBuilder {
   final DartIrBuilderSharedState dartState;
 
   IrBuilder _makeInstance() => new DartIrBuilder._blank(dartState);
   DartIrBuilder._blank(this.dartState);
 
   DartIrBuilder(ConstantSystem constantSystem,
                 ExecutableElement currentElement,
-                DartCapturedVariableInfo  closureVariables)
+                DartCapturedVariableInfo closureVariables)
       : dartState = new DartIrBuilderSharedState(closureVariables) {
     _init(constantSystem, currentElement);
   }
 
   /// True if [local] should currently be accessed from a [ClosureVariable].
   bool isInClosureVariable(Local local) {
     return dartState.local2closure.containsKey(local) &&
            !dartState.registerizedClosureVariables.contains(local);
   }
 
@@ skipping 124 matching lines @@
     assert(isOpen);
     if (isInClosureVariable(local)) {
       add(new ir.SetClosureVariable(getClosureVariable(local), value));
     } else {
       value.useElementAsHint(local);
       environment.update(local, value);
     }
     return value;
   }
 
-  List<ir.ClosureVariable> _getDeclaredClosureVariables(
-      ExecutableElement element) {
-    return dartState.getClosureList(element);
-  }
-
   ir.Primitive buildThis() {
     ir.Primitive thisPrim = new ir.This();
     add(new ir.LetPrim(thisPrim));
     return thisPrim;
   }
 
   ir.Primitive buildSuperInvocation(Element target,
                                     Selector selector,
                                     List<ir.Primitive> arguments) {
     return _buildInvokeSuper(target, selector, arguments);
@@ skipping 183 matching lines @@
     add(new ir.LetPrim(newBox));
     for (VariableElement loopVar in scope.boxedLoopVariables) {
       ClosureLocation location = scope.capturedVariables[loopVar];
       ir.Primitive get = new ir.GetField(box, location.field);
       add(new ir.LetPrim(get));
       add(new ir.SetField(newBox, location.field, get));
     }
     environment.update(scope.box, newBox);
   }
 
-  List<ir.ClosureVariable> _getDeclaredClosureVariables(
-      ExecutableElement element) {
-    return <ir.ClosureVariable>[];
-  }
-
   ir.Primitive buildThis() {
     if (jsState.receiver != null) return jsState.receiver;
     ir.Primitive thisPrim = new ir.This();
     add(new ir.LetPrim(thisPrim));
     return thisPrim;
   }
 
   ir.Primitive buildSuperInvocation(Element target,
                                     Selector selector,
                                     List<ir.Primitive> arguments) {
@@ skipping 98 matching lines @@
   ClosureEnvironment(this.selfReference, this.thisLocal, this.freeVariables);
 }
 
 /// Information about which variables are captured by a nested function.
 ///
 /// This is used by the [DartIrBuilder] instead of [ClosureScope] and
 /// [ClosureEnvironment].
 abstract class DartCapturedVariableInfo {
   Iterable<Local> get capturedVariables;
 }