Remove an unused field from one of the CPS translation classes.

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 458 matching lines @@
   /// or put it in its box, if necessary.
   void _createFunctionParameter(Local parameterElement);
   void _createThisParameter();
 
   /// 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

[Kevin Millikin (Google), 2015/04/15 15:14:58]

I guess this comment was referring to the field I just removed.  I'll ask Johnni
to be sure and remove the comment if so.

   // when [IrBuilder] is a property of [IrBuilderVisitor] instead of a mixin.
 
-  final List<ir.Parameter> _parameters = <ir.Parameter>[];
-
   IrBuilderDelimitedState state;
 
   /// A map from variable indexes to their values.
   ///
   /// [BoxLocal]s map to their box. [LocalElement]s that are boxed are not
   /// in the map; look up their [BoxLocal] instead.
   Environment environment;
 
   // The IR builder maintains a context, which is an expression with a hole in
   // it.  The hole represents the focus where new expressions can be added.
@@ skipping 61 matching lines @@
         ..environment = new Environment.empty();
   }
 
   bool get isOpen => _root == null || _current != null;
 
 
   void buildFieldInitializerHeader({ClosureScope closureScope}) {
     _enterScope(closureScope);
   }
 
-  List<ir.Primitive> buildFunctionHeader(Iterable<Local> parameters,
-                                        {ClosureScope closureScope,
-                                         ClosureEnvironment env}) {
+  void buildFunctionHeader(Iterable<Local> parameters,
+                           {ClosureScope closureScope,
+                            ClosureEnvironment env}) {
     _createThisParameter();
     _enterClosureEnvironment(env);
     _enterScope(closureScope);
     parameters.forEach(_createFunctionParameter);
-    return _parameters;
   }
 
   /// Creates a parameter for [local] and adds it to the current environment.
   ir.Parameter createLocalParameter(Local local) {
     ir.Parameter parameter = new ir.Parameter(local);
-    _parameters.add(parameter);
     environment.extend(local, parameter);
     return parameter;
   }
 
   /// Adds the constant [variableElement] to the environment with [value] as its
   /// constant value.
   void declareLocalConstant(LocalVariableElement variableElement,
                             ConstantExpression value) {
     state.localConstants.add(new ConstDeclaration(variableElement, value));
   }
@@ skipping 1594 matching lines @@
         ir.Primitive value =
             addPrimitive(new ir.GetMutableVariable(mutableVariable));
         environment.update(loopVariable, value);
         dartState.registerizedMutableVariables.add(loopVariable);
       }
     }
   }
 
   void _createFunctionParameter(Local parameterElement) {
     ir.Parameter parameter = new ir.Parameter(parameterElement);
-    _parameters.add(parameter);
     if (isInMutableVariable(parameterElement)) {
       state.functionParameters.add(getMutableVariable(parameterElement));
     } else {
       state.functionParameters.add(parameter);
       environment.extend(parameterElement, parameter);
     }
   }
 
   void _createThisParameter() {
     void create() {
@@ skipping 188 matching lines @@
     scope.capturedVariables.forEach((Local local, ClosureLocation location) {
       assert(!jsState.boxedVariables.containsKey(local));
       if (location.isBox) {
         jsState.boxedVariables[local] = location;
       }
     });
   }
 
   void _createFunctionParameter(Local parameterElement) {
     ir.Parameter parameter = new ir.Parameter(parameterElement);
-    _parameters.add(parameter);
     state.functionParameters.add(parameter);
     ClosureLocation location = jsState.boxedVariables[parameterElement];
     if (location != null) {
       add(new ir.SetField(environment.lookup(location.box),
                           location.field,
                           parameter));
     } else {
       environment.extend(parameterElement, parameter);
     }
   }
@@ skipping 285 matching lines @@
 }
 
 /// Synthetic parameter to a JavaScript factory method that takes the type
 /// argument given for the type variable [variable].
 class TypeInformationParameter implements Local {
   final TypeVariableElement variable;
   final ExecutableElement executableContext;
   TypeInformationParameter(this.variable, this.executableContext);
   String get name => variable.name;
 }