Clean up FunctionDefinition in the IR S-expression representation.

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';
 
 // The 'read in loop' IR tests the most basic case of redundant phi removal
 // and represents the following source code:
 //
 // void main() {
 //   int j = 42;
 //   for (int i = 0; i < 2; i++) {
 //     print(j.toString());
 //   }
 // }
 
 String READ_IN_LOOP_IN = """
-(FunctionDefinition main (return) (LetPrim v0 (Constant IntConstant(42)))
+(FunctionDefinition main () return ()
+  (LetPrim v0 (Constant IntConstant(42)))
   (LetPrim v1 (Constant IntConstant(0)))
   (LetCont* (k0 v2 v3)
     (LetCont (k1) (LetPrim v4 (Constant NullConstant))
       (InvokeContinuation return v4))
     (LetCont (k2)
       (LetCont (k3 v5)
         (LetCont (k4 v6) (LetPrim v7 (Constant IntConstant(1)))
           (LetCont (k5 v8) (InvokeContinuation* k0 v2 v8))
           (InvokeMethod v3 + v7 k5))
         (InvokeStatic print v5 k4))
       (InvokeMethod v2 toString k3))
     (LetPrim v9 (Constant IntConstant(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 IntConstant(42)))
+(FunctionDefinition main () return ()
+  (LetPrim v0 (Constant IntConstant(42)))
   (LetPrim v1 (Constant IntConstant(0)))
   (LetCont* (k0 v2)
     (LetCont (k1) (LetPrim v3 (Constant NullConstant))
       (InvokeContinuation return v3))
     (LetCont (k2)
       (LetCont (k3 v4)
         (LetCont (k4 v5) (LetPrim v6 (Constant IntConstant(1)))
           (LetCont (k5 v7) (InvokeContinuation* k0 v7))
           (InvokeMethod v2 + v6 k5))
         (InvokeStatic print v4 k4))
@@ skipping 13 matching lines @@
 //       print(i.toString());
 //     }
 //   }
 //   print(j.toString());
 // }
 //
 // This test case ensures that iterative optimization works: first, v8 and v9
 // are removed from k5, and only then can k0 be optimized as well.
 
 const String INNER_LOOP_IN = """
-(FunctionDefinition main (return) (LetPrim v0 (Constant IntConstant(42)))
+(FunctionDefinition main () return ()
+  (LetPrim v0 (Constant IntConstant(42)))
   (LetPrim v1 (Constant IntConstant(0)))
   (LetCont* (k0 v2 v3)
     (LetCont (k1)
       (LetCont (k2 v4)
         (LetCont (k3 v5) (LetPrim v6 (Constant NullConstant))
           (InvokeContinuation return v6))
         (InvokeStatic print v4 k3))
       (InvokeMethod v2 toString k2))
     (LetCont (k4) (LetPrim v7 (Constant IntConstant(0)))
       (LetCont* (k5 v8 v9 v10)
@@ skipping 12 matching lines @@
         (LetCont (k12 v18) (Branch (IsTrue v18) k8 k6))
         (InvokeMethod v10 < v17 k12))
       (InvokeContinuation k5 v2 v3 v7))
     (LetPrim v19 (Constant IntConstant(2)))
     (LetCont (k13 v20) (Branch (IsTrue v20) k4 k1))
     (InvokeMethod v3 < v19 k13))
   (InvokeContinuation k0 v0 v1))
 """;
 
 const String INNER_LOOP_OUT = """
-(FunctionDefinition main ( return) (LetPrim v0 (Constant IntConstant(42)))
+(FunctionDefinition main () return ()
+  (LetPrim v0 (Constant IntConstant(42)))
   (LetPrim v1 (Constant IntConstant(0)))
   (LetCont* (k0 v2)
     (LetCont (k1)
       (LetCont (k2 v3)
         (LetCont (k3 v4) (LetPrim v5 (Constant NullConstant))
           (InvokeContinuation return v5))
         (InvokeStatic print v3 k3))
       (InvokeMethod v0 toString k2))
     (LetCont (k4) (LetPrim v6 (Constant IntConstant(0)))
       (LetCont* (k5 v7)
@@ skipping 22 matching lines @@
 // simply that the optimization does not alter the IR. It represents the
 // following program:
 //
 // void main() {
 //   for (int i = 0; i < 2; i++) {
 //     print(i.toString());
 //   }
 // }
 
 String BASIC_LOOP_IN = """
-(FunctionDefinition main ( return) (LetPrim v0 (Constant IntConstant(0)))
+(FunctionDefinition main () return ()
+  (LetPrim v0 (Constant IntConstant(0)))
   (LetCont* (k0 v1)
     (LetCont (k1) (LetPrim v2 (Constant NullConstant))
       (InvokeContinuation return v2))
     (LetCont (k2)
       (LetCont (k3 v3)
         (LetCont (k4 v4) (LetPrim v5 (Constant IntConstant(1)))
           (LetCont (k5 v6) (InvokeContinuation* k0 v6))
           (InvokeMethod v1 + v5 k5))
         (InvokeStatic print v3 k4))
       (InvokeMethod v1 toString k3))
     (LetPrim v7 (Constant IntConstant(2)))
     (LetCont (k6 v8) (Branch (IsTrue v8) k2 k1))
     (InvokeMethod v1 < v7 k6))
   (InvokeContinuation k0 v0))
 """;
 
 String BASIC_LOOP_OUT = BASIC_LOOP_IN;
 
 // Ensures that proper scoping is preserved, i.e. that the optimized
 // continuation body does reference out of scope primitives.
 // IR written by hand since this case is currently not being generated.
 
 String SCOPING_IN = """
-(FunctionDefinition main ( return)
+(FunctionDefinition main () return ()
   (LetCont (k0 v1)
     (InvokeStatic print v1 return))
   (LetPrim v0 (Constant IntConstant(0)))
   (LetPrim v2 (Constant NullConstant))
   (InvokeContinuation k0 v0))
 """;
 
 String SCOPING_OUT = """
-(FunctionDefinition main ( return)
+(FunctionDefinition main () return ()
   (LetPrim v0 (Constant IntConstant(0)))
   (LetCont (k0)
     (InvokeStatic print v0 return))
   (LetPrim v1 (Constant NullConstant))
   (InvokeContinuation k0 ))
 """;
 
 // Ensures that continuations which are never invoked are not optimized.
 // IR written by hand.
 
 String NEVER_INVOKED_IN = """
-(FunctionDefinition main ( return)
+(FunctionDefinition main () return ()
   (LetPrim v0 (Constant IntConstant(0)))
   (LetCont (k0 v1)
     (InvokeStatic print v1 return))
   (InvokeContinuation return v0))
 """;
 
 String NEVER_INVOKED_OUT = NEVER_INVOKED_IN;
 
 /// Normalizes whitespace by replacing all whitespace sequences by a single
 /// space and trimming leading and trailing whitespace.
@@ skipping 17 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);
 }