Add a shrinking reduction for dead continuation parameters.

tests/compiler/dart2js/backend_dart/opt_redundant_phi_test.dart

 // Copyright (c) 2014, 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 'sexpr_unstringifier.dart';
 import "package:expect/expect.dart";
 import 'package:compiler/src/cps_ir/cps_ir_nodes.dart';
 import 'package:compiler/src/cps_ir/cps_ir_nodes_sexpr.dart';
 import 'package:compiler/src/cps_ir/optimizers.dart';
 
@@ skipping 18 matching lines @@
                     (LetPrim (v4 (Constant (Null)))
                       (InvokeContinuation return (v4))))
                   (k2 ()
                     (LetCont
                         ((k3 (v5)
                            (LetCont
                                ((k4 (v6)
                                   (LetPrim (v7 (Constant (Int 1)))
                                     (LetCont
                                         ((k5 (v8)
-                                           (InvokeContinuation* k0 (v2 v8))))
+                                           (InvokeContinuation rec k0 (v2 v8))))
                                       (InvokeMethod v3 + (v7) k5)))))
                              (InvokeStatic print (v5) k4))))
                       (InvokeMethod v2 toString () k3))))
                (LetPrim (v9 (Constant (Int 2)))
                  (LetCont
                      ((k6 (v10)
                         (Branch (IsTrue v10) k2 k1)))
                    (InvokeMethod v3 < (v9) k6))))))
         (InvokeContinuation k0 (v0 v1))))))
 """;
 
 String READ_IN_LOOP_OUT = """
 (FunctionDefinition main () return ()
   (LetPrim (v0 (Constant (Int 42)))
     (LetPrim (v1 (Constant (Int 0)))
       (LetCont
           ((rec k0 (v2)
              (LetCont
                  ((k1 ()
                     (LetPrim (v3 (Constant (Null)))
                       (InvokeContinuation return (v3))))
                   (k2 ()
                     (LetCont
                         ((k3 (v4)
                            (LetCont
                                ((k4 (v5)
                                   (LetPrim (v6 (Constant (Int 1)))
                                     (LetCont
                                         ((k5 (v7)
-                                           (InvokeContinuation* k0 (v7))))
+                                           (InvokeContinuation rec k0 (v7))))
                                       (InvokeMethod v2 + (v6) k5)))))
                              (InvokeStatic print (v4) k4))))
                       (InvokeMethod v0 toString () k3))))
                (LetPrim (v8 (Constant (Int 2)))
                  (LetCont
                      ((k6 (v9)
                         (Branch (IsTrue v9) k2 k1)))
                    (InvokeMethod v2 < (v8) k6))))))
         (InvokeContinuation k0 (v1))))))
 """;
@@ skipping 31 matching lines @@
                       (InvokeMethod v2 toString () k2)))
                   (k4 ()
                     (LetPrim (v7 (Constant (Int 0)))
                       (LetCont
                           ((rec k5 (v8 v9 v10)
                              (LetCont
                                  ((k6 ()
                                     (LetPrim (v11 (Constant (Int 1)))
                                       (LetCont
                                           ((k7 (v12)
-                                             (InvokeContinuation* k0 (v8 v12))))
+                                             (InvokeContinuation rec k0 (v8 v12))))
                                         (InvokeMethod v9 + (v11) k7))))
                                   (k8 ()
                                     (LetCont
                                         ((k9 (v13)
                                            (LetCont
                                                ((k10 (v14)
                                                   (LetPrim (v15 (Constant (Int 1)))
                                                     (LetCont
                                                         ((k11 (v16)
-                                                           (InvokeContinuation* k5 (v8 v9 v16))))
+                                                           (InvokeContinuation rec k5 (v8 v9 v16))))
                                                       (InvokeMethod v10 + (v15) k11)))))
                                              (InvokeStatic print (v13) k10))))
                                       (InvokeMethod v9 toString () k9))))
                                (LetPrim (v17 (Constant (Int 2)))
                                  (LetCont
                                      ((k12 (v18)
                                         (Branch (IsTrue v18) k8 k6)))
                                    (InvokeMethod v10 < (v17) k12))))))
                         (InvokeContinuation k5 (v2 v3 v7))))))
                (LetPrim (v19 (Constant (Int 2)))
@@ skipping 22 matching lines @@
                       (InvokeMethod v0 toString () k2)))
                   (k4 ()
                     (LetPrim (v6 (Constant (Int 0)))
                       (LetCont
                           ((rec k5 (v7)
                              (LetCont
                                  ((k6 ()
                                     (LetPrim (v8 (Constant (Int 1)))
                                       (LetCont
                                           ((k7 (v9)
-                                             (InvokeContinuation* k0 (v9))))
+                                             (InvokeContinuation rec k0 (v9))))
                                         (InvokeMethod v2 + (v8) k7))))
                                   (k8 ()
                                     (LetCont
                                         ((k9 (v10)
                                            (LetCont
                                                ((k10 (v11)
                                                   (LetPrim (v12 (Constant (Int 1)))
                                                     (LetCont
                                                         ((k11 (v13)
-                                                           (InvokeContinuation* k5 (v13))))
+                                                           (InvokeContinuation rec k5 (v13))))
                                                       (InvokeMethod v7 + (v12) k11)))))
                                              (InvokeStatic print (v10) k10))))
                                       (InvokeMethod v2 toString () k9))))
                                (LetPrim (v14 (Constant (Int 2)))
                                  (LetCont
                                      ((k12 (v15)
                                         (Branch (IsTrue v15) k8 k6)))
                                    (InvokeMethod v7 < (v14) k12))))))
                         (InvokeContinuation k5 (v6))))))
                (LetPrim (v16 (Constant (Int 2)))
@@ skipping 24 matching lines @@
                  (LetPrim (v2 (Constant (Null)))
                    (InvokeContinuation return (v2))))
                (k2 ()
                  (LetCont
                      ((k3 (v3)
                         (LetCont
                             ((k4 (v4)
                                (LetPrim (v5 (Constant (Int 1)))
                                  (LetCont
                                      ((k5 (v6)
-                                        (InvokeContinuation* k0 (v6))))
+                                        (InvokeContinuation rec k0 (v6))))
                                    (InvokeMethod v1 + (v5) k5)))))
                           (InvokeStatic print (v3) k4))))
                    (InvokeMethod v1 toString () k3))))
             (LetPrim (v7 (Constant (Int 2)))
               (LetCont
                   ((k6 (v8)
                      (Branch (IsTrue v8) k2 k1)))
                 (InvokeMethod v1 < (v7) k6))))))
       (InvokeContinuation k0 (v0)))))
 """;
@@ skipping 60 matching lines @@
   Expect.equals(expected, actual, "Actual:\n$actual");
 }
 
 void main() {
   testRedundantPhi(READ_IN_LOOP_IN, READ_IN_LOOP_OUT);
   testRedundantPhi(INNER_LOOP_IN, INNER_LOOP_OUT);
   testRedundantPhi(BASIC_LOOP_IN, BASIC_LOOP_OUT);
   testRedundantPhi(SCOPING_IN, SCOPING_OUT);
   testRedundantPhi(NEVER_INVOKED_IN, NEVER_INVOKED_OUT);
 }