dart2dart: Remove the list of closureVariables from FunctionDefinitions.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
@@ skipping 717 matching lines @@
     implements ExecutableDefinition {
   final FunctionElement element;
   /// Mixed list of [Parameter]s and [ClosureVariable]s.
   final List<Definition> parameters;
   final RunnableBody body;
   final List<ConstDeclaration> localConstants;
 
   /// Values for optional parameters.
   final List<ConstantExpression> defaultParameterValues;
 
-  /// Closure variables declared by this function.
-  final List<ClosureVariable> closureVariables;
-
   FunctionDefinition(this.element,
       this.parameters,
       this.body,
       this.localConstants,
-      this.defaultParameterValues,
-      this.closureVariables);
+      this.defaultParameterValues);
 
   FunctionDefinition.abstract(this.element,
                               this.parameters,
                               this.defaultParameterValues)
       : body = null,
-        localConstants = const <ConstDeclaration>[],
-        closureVariables = const <ClosureVariable>[];
+        localConstants = const <ConstDeclaration>[];
 
   accept(Visitor visitor) => visitor.visitFunctionDefinition(this);
   applyPass(Pass pass) => pass.rewriteFunctionDefinition(this);
 
   /// Returns `true` if this function is abstract or external.
   ///
   /// If `true`, [body] is `null` and [localConstants] is empty.
   bool get isAbstract => body == null;
 }
 
@@ skipping 16 matching lines @@
 }
 
 class ConstructorDefinition extends FunctionDefinition {
   final List<Initializer> initializers;
 
   ConstructorDefinition(ConstructorElement element,
                         List<Definition> parameters,
                         RunnableBody body,
                         this.initializers,
                         List<ConstDeclaration> localConstants,
-                        List<ConstantExpression> defaultParameterValues,
-                        List<ClosureVariable> closureVariables)
+                        List<ConstantExpression> defaultParameterValues)
       : super(element, parameters, body, localConstants,
-              defaultParameterValues, closureVariables);
+              defaultParameterValues);
 
   // 'Abstract' here means "has no body" and is used to represent external
   // constructors.
   ConstructorDefinition.abstract(
       ConstructorElement element,
       List<Definition> parameters,
       List<ConstantExpression> defaultParameterValues)
       : initializers = null,
         super.abstract(element, parameters, defaultParameterValues);
 
@@ skipping 538 matching lines @@
 
   void visitIdentical(Identical node) {
     visitReference(node.left);
     visitReference(node.right);
   }
 
   void visitInterceptor(Interceptor node) {
     visitReference(node.input);
   }
 }