Change core lib, dart2js, and more for new optional parameters syntax

lib/compiler/implementation/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 3295 matching lines @@
          !link.isEmpty();
          link = link.tail) {
       visit(link.head);
       inputs.add(pop());
     }
     push(new HLiteralList(inputs));
   }
 
   visitConditional(Conditional node) {
     SsaBranchBuilder brancher =
-        new SsaBranchBuilder(this, diagnosticNode: node);
+        new SsaBranchBuilder(this, node);

[floitsch, 2012/10/11 16:52:15]

does this fit on one line?

[regis, 2012/10/11 21:24:19]

Done.

     brancher.handleConditional(() => visit(node.condition),
                                () => visit(node.thenExpression),
                                () => visit(node.elseExpression));
   }
 
   visitStringInterpolation(StringInterpolation node) {
     StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this, node);
     stringBuilder.visit(node);
     stack.add(stringBuilder.result);
   }
@@ skipping 946 matching lines @@
 
     conditionBranch.graph =
         new SubExpression(conditionBranch.block, conditionExitBlock);
   }
 
   /**
    * Returns true if the locals of the [fromBranch] may be reused. A [:true:]
    * return value implies that [mayReuseFromLocals] was set to [:true:].
    */
   bool mergeLocals(SsaBranch fromBranch, SsaBranch toBranch,
-                   [bool mayReuseFromLocals]) {
+                   {bool mayReuseFromLocals}) {
     LocalsHandler fromLocals = fromBranch.exitLocals;
     if (toBranch.startLocals == null) {
       if (mayReuseFromLocals) {
         toBranch.startLocals = fromLocals;
         return false;
       } else {
         toBranch.startLocals = new LocalsHandler.from(fromLocals);
         return true;
       }
     } else {
@@ skipping 38 matching lines @@
     }
 
     _handleDiamondBranch(visitCondition, visitThen, visitElse, false);
   }
 
   handleConditional(void visitCondition(), void visitThen(), void visitElse()) {
     assert(visitElse != null);
     _handleDiamondBranch(visitCondition, visitThen, visitElse, true);
   }
 
-  void handleLogicalAndOr(void left(), void right(), [bool isAnd]) {
+  void handleLogicalAndOr(void left(), void right(), {bool isAnd}) {
     // x && y is transformed into:
     //   t0 = boolify(x);
     //   if (t0) {
     //     t1 = boolify(y);
     //   }
     //   result = phi(t1, false);
     //
     // x || y is transformed into:
     //   t0 = boolify(x);
     //   if (not(t0)) {
@@ skipping 21 matching lines @@
     HConstant notIsAnd =
         builder.graph.addConstantBool(!isAnd, builder.constantSystem);
     HPhi result = new HPhi.manyInputs(null,
                                       <HInstruction>[boolifiedRight, notIsAnd]);
     builder.current.addPhi(result);
     builder.stack.add(result);
   }
 
   void handleLogicalAndOrWithLeftNode(Node left,
                                       void visitRight(),
-                                      [bool isAnd]) {
+                                      {bool isAnd}) {
     // This method is similar to [handleLogicalAndOr] but optimizes the case
     // where left is a logical "and" or logical "or".
     //
     // For example (x && y) && z is transformed into x && (y && z):
     //   t0 = boolify(x);
     //   if (t0) {
     //     t1 = boolify(y);
     //     if (t1) {
     //       t2 = boolify(z);
     //     }
     //     t3 = phi(t2, false);
     //   }
     //   result = phi(t3, false);
 
     Send send = left.asSend();
     if (send !== null &&
         (isAnd ? send.isLogicalAnd : send.isLogicalOr)) {
       Node newLeft = send.receiver;
       Link<Node> link = send.argumentsNode.nodes;
       assert(link.tail.isEmpty());
       Node middle = link.head;
       handleLogicalAndOrWithLeftNode(
           newLeft,
-          () => handleLogicalAndOrWithLeftNode(middle, visitRight, isAnd),
+          () => handleLogicalAndOrWithLeftNode(middle, visitRight,
+                                               isAnd: isAnd),
           isAnd: isAnd);
     } else {
-      handleLogicalAndOr(() => builder.visit(left), visitRight, isAnd);
+      handleLogicalAndOr(() => builder.visit(left), visitRight, isAnd: isAnd);
     }
   }
 
   void _handleDiamondBranch(void visitCondition(),
                             void visitThen(),
                             void visitElse(),
                             bool isExpression) {
     SsaBranch conditionBranch = new SsaBranch(this);
     SsaBranch thenBranch = new SsaBranch(this);
     SsaBranch elseBranch = new SsaBranch(this);
@@ skipping 32 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }