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 1220 matching lines @@
   /**
    * Run through the fields of [cls] and add their potential
    * initializers.
    *
    * Invariant: [classElement] must be an implementation element.
    */
   void buildFieldInitializers(ClassElement classElement,
                               Map<Element, HInstruction> fieldValues) {
     assert(invariant(classElement, classElement.isImplementation));
     classElement.forEachInstanceField(
+        (ClassElement enclosingClass, Element member) {
+          TreeElements definitions = compiler.analyzeElement(member);
+          Node node = member.parseNode(compiler);
+          SendSet assignment = node.asSendSet();
+          HInstruction value;
+          if (assignment === null) {
+            value = graph.addConstantNull(constantSystem);
+          } else {
+            Node right = assignment.arguments.head;
+            TreeElements savedElements = elements;
+            elements = definitions;
+            right.accept(this);
+            elements = savedElements;
+            value = pop();
+          }
+          fieldValues[member] = value;
+        },
         includeBackendMembers: true,
-        includeSuperMembers: false,
-        f: (ClassElement enclosingClass, Element member) {
-      TreeElements definitions = compiler.analyzeElement(member);
-      Node node = member.parseNode(compiler);
-      SendSet assignment = node.asSendSet();
-      HInstruction value;
-      if (assignment === null) {
-        value = graph.addConstantNull(constantSystem);
-      } else {
-        Node right = assignment.arguments.head;
-        TreeElements savedElements = elements;
-        elements = definitions;
-        right.accept(this);
-        elements = savedElements;
-        value = pop();
-      }
-      fieldValues[member] = value;
-    });
+        includeSuperMembers: false);
   }
 
 
   /**
    * Build the factory function corresponding to the constructor
    * [functionElement]:
    *  - Initialize fields with the values of the field initializers of the
    *    current constructor and super constructors or constructors redirected
    *    to, starting from the current constructor.
    *  - Call the the constructor bodies, starting from the constructor(s) in the
@@ skipping 33 matching lines @@
     });
 
     // Analyze the constructor and all referenced constructors and collect
     // initializers and constructor bodies.
     List<FunctionElement> constructors = <FunctionElement>[functionElement];
     buildInitializers(functionElement, constructors, fieldValues);
 
     // Call the JavaScript constructor with the fields as argument.
     List<HInstruction> constructorArguments = <HInstruction>[];
     classElement.forEachInstanceField(
+        (ClassElement enclosingClass, Element member) {
+          constructorArguments.add(
+              potentiallyCheckType(fieldValues[member], member));
+        },
         includeBackendMembers: true,
-        includeSuperMembers: true,
-        f: (ClassElement enclosingClass, Element member) {
-      constructorArguments.add(
-          potentiallyCheckType(fieldValues[member], member));
-    });
+        includeSuperMembers: true);
 
     HForeignNew newObject = new HForeignNew(classElement, constructorArguments);
     add(newObject);
 
     // Create the runtime type information, if needed.
     InterfaceType type = classElement.computeType(compiler);
     List<HInstruction> inputs = <HInstruction>[];
     if (compiler.world.needsRti(classElement)) {
       classElement.typeVariables.forEach((TypeVariableType typeVariable) {
         inputs.add(localsHandler.directLocals[typeVariable.element]);
@@ skipping 1671 matching lines @@
       addDynamicSendArgumentsToList(node, inputs);
       pushWithPosition(new HInvokeClosure(selector, inputs), node);
     }
   }
 
   visitGetterSend(Send node) {
     generateGetter(node, elements[node]);
   }
 
   // TODO(antonm): migrate rest of SsaBuilder to internalError.
-  internalError(String reason, [Node node]) {
+  internalError(String reason, {Node node}) {
     compiler.internalError(reason, node: node);
   }
 
   void generateRuntimeError(Node node, String message) {
     DartString messageObject = new DartString.literal(message);
     Constant messageConstant =
         constantSystem.createString(messageObject, node);
     HInstruction errorMessage = graph.addConstant(messageConstant);
     Element helper = interceptors.getThrowRuntimeError();
     pushInvokeHelper1(helper, errorMessage);
@@ skipping 290 matching lines @@
     for (Link<Node> link = node.elements.nodes;
          !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);
+    SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
     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 949 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;
   }
 }