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

lib/compiler/implementation/elements/elements.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.
 
 #library('elements');
 
 #import('dart:uri');
 
 // TODO(ahe): Rename prefix to 'api' when VM bug is fixed.
 #import('../../compiler.dart', prefix: 'api_e');
@@ skipping 803 matching lines @@
 class VariableElement extends Element {
   final VariableListElement variables;
   Expression cachedNode; // The send or the identifier in the variables list.
 
   Modifiers get modifiers => variables.modifiers;
 
   VariableElement(SourceString name,
                   VariableListElement this.variables,
                   ElementKind kind,
                   Element enclosing,
-                  [Node node])
+                  {Node node})
     : super(name, kind, enclosing), cachedNode = node;
 
   Node parseNode(DiagnosticListener listener) {
     if (cachedNode !== null) return cachedNode;
     VariableDefinitions definitions = variables.parseNode(listener);
     for (Link<Node> link = definitions.definitions.nodes;
          !link.isEmpty(); link = link.tail) {
       Expression initializedIdentifier = link.head;
       Identifier identifier = initializedIdentifier.asIdentifier();
       if (identifier === null) {
@@ skipping 25 matching lines @@
  * [:A(this.field):].
  */
 class FieldParameterElement extends VariableElement {
   VariableElement fieldElement;
 
   FieldParameterElement(SourceString name,
                         this.fieldElement,
                         VariableListElement variables,
                         Element enclosing,
                         Node node)
-      : super(name, variables, ElementKind.FIELD_PARAMETER, enclosing, node);
+      : super(name, variables, ElementKind.FIELD_PARAMETER, enclosing,
+              node: node);
 }
 
 // This element represents a list of variable or field declaration.
 // It contains the node, and the type. A [VariableElement] always
 // references its [VariableListElement]. It forwards its
 // [computeType] and [parseNode] methods to this element.
 class VariableListElement extends Element {
   VariableDefinitions cachedNode;
   DartType type;
   final Modifiers modifiers;
@@ skipping 645 matching lines @@
   /**
    * Runs through all members of this class.
    *
    * The enclosing class is passed to the callback. This is useful when
    * [includeSuperMembers] is [:true:].
    *
    * When called on an implementation element both the members in the origin
    * and patch class are included.
    */
   // TODO(johnniwinther): Clean up lookup to get rid of the include predicates.
-  void forEachMember([void f(ClassElement enclosingClass, Element member),
-                      includeBackendMembers = false,
-                      includeSuperMembers = false]) {
+  void forEachMember(void f(ClassElement enclosingClass, Element member),
+                     {includeBackendMembers: false,
+                      includeSuperMembers: false}) {
     bool includeInjectedMembers = isPatch;
     Set<ClassElement> seen = new Set<ClassElement>();
     ClassElement classElement = declaration;
     do {
       if (seen.contains(classElement)) return;
       seen.add(classElement);
 
       // Iterate through the members in textual order, which requires
       // to reverse the data structure [localMembers] we created.
       // Textual order may be important for certain operations, for
@@ skipping 25 matching lines @@
    * The enclosing class is passed to the callback. This is useful when
    * [includeSuperMembers] is [:true:].
    *
    * When [includeBackendMembers] and [includeSuperMembers] are both [:true:]
    * then the fields are visited in the same order as they need to be given
    * to the JavaScript constructor.
    *
    * When called on the implementation element both the fields declared in the
    * origin and in the patch are included.
    */
-  void forEachInstanceField([void f(ClassElement enclosingClass, Element field),
-                             includeBackendMembers = false,
-                             includeSuperMembers = false]) {
+  void forEachInstanceField(void f(ClassElement enclosingClass, Element field),
+                            {includeBackendMembers: false,
+                             includeSuperMembers: false}) {
     // Filters so that [f] is only invoked with instance fields.
     void fieldFilter(ClassElement enclosingClass, Element member) {
       if (member.isInstanceMember() && member.kind == ElementKind.FIELD) {
         f(enclosingClass, member);
       }
     }
 
-    forEachMember(fieldFilter, includeBackendMembers, includeSuperMembers);
+    forEachMember(fieldFilter,
+                  includeBackendMembers: includeBackendMembers,
+                  includeSuperMembers: includeSuperMembers);
   }
 
   bool implementsInterface(ClassElement intrface) {
     for (DartType implementedInterfaceType in allSupertypes) {
       ClassElement implementedInterface = implementedInterfaceType.element;
       if (implementedInterface === intrface) {
         return true;
       }
     }
     return false;
@@ skipping 340 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }