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

lib/compiler/implementation/elements/elements.dart

Index: lib/compiler/implementation/elements/elements.dart
===================================================================
--- lib/compiler/implementation/elements/elements.dart	(revision 13496)
+++ lib/compiler/implementation/elements/elements.dart	(working copy)
@@ -823,7 +823,7 @@
                   VariableListElement this.variables,
                   ElementKind kind,
                   Element enclosing,
-                  [Node node])
+                  {Node node})
     : super(name, kind, enclosing), cachedNode = node;
 
   Node parseNode(DiagnosticListener listener) {
@@ -869,7 +869,8 @@
                         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.
@@ -1509,7 +1510,7 @@
     // 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;
@@ -1535,9 +1536,9 @@
    * 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;
@@ -1583,9 +1584,9 @@
    * 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) {
@@ -1593,7 +1594,9 @@
       }
     }
 
-    forEachMember(fieldFilter, includeBackendMembers, includeSuperMembers);
+    forEachMember(fieldFilter,
+                  includeBackendMembers: includeBackendMembers,
+                  includeSuperMembers: includeSuperMembers);
   }
 
   bool implementsInterface(ClassElement intrface) {