Add a shrinking reduction for dead continuation parameters.

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 612 matching lines @@
   CreateFunction(this.definition);
 
   accept(Visitor visitor) => visitor.visitCreateFunction(this);
 }
 
 class Parameter extends Primitive {
   Parameter(Entity hint) {
     super.hint = hint;
   }
 
+  // In addition to a parent pointer to the containing Continuation or
+  // FunctionDefinition, parameters have an index into the list of parameters
+  // bound by the parent.  This gives constant-time access to the continuation from

[asgerf, 2015/01/22 16:02:07]

long line

[Kevin Millikin (Google), 2015/01/22 16:16:28]

You are right.  Fixed.

+  // the parent.
+  int parent_index;
+
   accept(Visitor visitor) => visitor.visitParameter(this);
 }
 
 /// Continuations are normally bound by 'let cont'.  A continuation with one
 /// parameter and no body is used to represent a function's return continuation.
 /// The return continuation is bound by the Function, not by 'let cont'.
 class Continuation extends Definition<Continuation> implements InteriorNode {
   final List<Parameter> parameters;
   Expression body = null;
 
@@ skipping 30 matching lines @@
   FieldDefinition(this.element, this.body);
 
   FieldDefinition.withoutInitializer(this.element)
       : this.body = null;
 
   accept(Visitor visitor) => visitor.visitFieldDefinition(this);
   applyPass(Pass pass) => pass.rewriteFieldDefinition(this);
 
   /// `true` if this field has no initializer.
   ///
-  /// If `true` [body] and [returnContinuation] are `null`.
+  /// If `true` [body] is `null`.
   ///
   /// This is different from a initializer that is `null`. Consider this class:
   ///
   ///     class Class {
   ///       final field;
   ///       Class.a(this.field);
   ///       Class.b() : this.field = null;
   ///       Class.c();
   ///     }
   ///
@@ skipping 16 matching lines @@
 }
 
 class RunnableBody extends InteriorNode {
   Expression body;
   final Continuation returnContinuation;
   RunnableBody(this.body, this.returnContinuation);
   accept(Visitor visitor) => visitor.visitRunnableBody(this);
 }
 
 /// A function definition, consisting of parameters and a body.  The parameters
-/// include a distinguished continuation parameter.
+/// include a distinguished continuation parameter (held by the body).
 class FunctionDefinition extends Node
     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;
@@ skipping 13 matching lines @@
                               this.defaultParameterValues)
       : body = null,
         localConstants = const <ConstDeclaration>[],
         closureVariables = const <ClosureVariable>[];
 
   accept(Visitor visitor) => visitor.visitFunctionDefinition(this);
   applyPass(Pass pass) => pass.rewriteFunctionDefinition(this);
 
   /// Returns `true` if this function is abstract or external.
   ///
-  /// If `true`, [body] and [returnContinuation] are `null` and [localConstants]
-  /// is empty.
+  /// If `true`, [body] is `null` and [localConstants] is empty.
   bool get isAbstract => body == null;
 }
 
 abstract class Initializer extends Node {}
 
 class FieldInitializer extends Initializer {
   final FieldElement element;
   final RunnableBody body;
 
   FieldInitializer(this.element, this.body);
@@ skipping 111 matching lines @@
   // while leaving other nodes for subclasses (i.e., visitLiteralList).
   visitNode(Node node) {
     throw "$this is stale, add missing visit override for $node";
   }
 
   processReference(Reference ref) {}
 
   processRunnableBody(RunnableBody node) {}
   visitRunnableBody(RunnableBody node) {
     processRunnableBody(node);
+    visit(node.returnContinuation);
     visit(node.body);
   }
 
   processFieldDefinition(FieldDefinition node) {}
   visitFieldDefinition(FieldDefinition node) {
     processFieldDefinition(node);
     if (node.hasInitializer) {
       visit(node.body);
     }
   }
@@ skipping 159 matching lines @@
     processGetClosureVariable(node);
   }
 
   processParameter(Parameter node) {}
   visitParameter(Parameter node) => processParameter(node);
 
   processContinuation(Continuation node) {}
   visitContinuation(Continuation node) {
     processContinuation(node);
     node.parameters.forEach(visitParameter);
-    visit(node.body);
+    if (node.body != null) visit(node.body);
   }
 
   // Conditions.
 
   processIsTrue(IsTrue node) {}
   visitIsTrue(IsTrue node) {
     processIsTrue(node);
     processReference(node.value);
   }
 
@@ skipping 259 matching lines @@
 
   void visitIdentical(Identical node) {
     visitReference(node.left);
     visitReference(node.right);
   }
 
   void visitInterceptor(Interceptor node) {
     visitReference(node.input);
   }
 }