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 805 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 619 matching lines @@
     for (var element in localScope.getValues()) {
       if (element.isConstructor()) return true;
     }
     return false;
   }
 
   Link<Element> get constructors {
     // TODO(ajohnsen): See if we can avoid this method at some point.
     Link<Element> result = const EmptyLink<Element>();
     // TODO(johnniwinther): Should we include injected constructors?
-    forEachMember((_, Element member) {
+    forEachMember(f: (_, Element member) {

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

there seems to be a mismatch: here the function is named, whereas below in the
function signature the function-argument is unnamed.

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

I guess I did not run this yet. Consistent now.

       if (member.isConstructor()) result = result.prepend(member);
     });
     return result;
   }
 
   /**
    * Returns the super class, if any.
    *
    * The returned element may not be resolved yet.
    */
   ClassElement get superclass {
     assert(supertypeLoadState == STATE_DONE);
     return supertype === null ? null : supertype.element;
   }
 
   /**
    * 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),

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

I'm torn: the reason I made "f" optional was so that I could write
"includeBackendMembers: true", f: () { ... }" (with the backend-members flag
first, so that it wouldn't disappear below a big closure.
However, being forced to write "f:" all the time is not nice either.

In any case: it should probably be consistent with forEachInstanceField below.

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

Yes, I have changed it back and forth too, as shown by the leftover "f:" above
:-)
Having to write "f:" everywhere is not nice, I agree. So I will leave  it as
non-optional.
I have also changed forEachInstanceField for consistency.

+                     {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)';
 }