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

lib/compiler/implementation/resolver.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.
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(TypeAnnotation annotation);
   bool isParameterChecked(Element element);
 }
@@ skipping 993 matching lines @@
     } else {
       return scope.lookup(typeName.source);
     }
   }
 
   // TODO(johnniwinther): Change  [onFailure] and [whenResolved] to use boolean
   // flags instead of closures.
   // TODO(johnniwinther): Should never return [null] but instead an erroneous
   // type.
   DartType resolveTypeAnnotation(TypeAnnotation node,
-                                 [Scope inScope, ClassElement inClass,
+                                 {Scope inScope, ClassElement inClass,
                                  onFailure(Node, MessageKind, [List arguments]),
-                                 whenResolved(Node, Type)]) {
+                                 whenResolved(Node, Type)}) {
     if (onFailure === null) {
       onFailure = (n, k, [arguments]) {};
     }
     if (whenResolved === null) {
       whenResolved = (n, t) {};
     }
     if (inClass !== null) {
       inScope = inClass.buildScope();
     }
     if (inScope === null) {
@@ skipping 211 matching lines @@
     if (type !== null) {
       if (inCheckContext) {
         compiler.enqueuer.resolution.registerIsCheck(type);
       }
       return type.element;
     }
     return null;
   }
 
   Element defineElement(Node node, Element element,
-                        [bool doAddToScope = true]) {
+                        {bool doAddToScope: true}) {
     compiler.ensure(element !== null);
     mapping[node] = element;
     if (doAddToScope) {
       Element existing = scope.add(element);
       if (existing != element) {
         error(node, MessageKind.DUPLICATE_DEFINITION, [node]);
       }
     }
     return element;
   }
@@ skipping 568 matching lines @@
     // [constructor.defaultImplementation] might be the implementation element
     // and only declaration elements may be registered.
     world.registerStaticUse(constructor.defaultImplementation.declaration);
     ClassElement cls = constructor.defaultImplementation.getEnclosingClass();
     // [cls] might be the implementation element and only declaration elements
     // may be registered.
     world.registerInstantiatedClass(cls.declaration);
     // [cls] might be the declaration element and we want to include injected
     // members.
     cls.implementation.forEachInstanceField(
+        (ClassElement enclosingClass, Element member) {
+          world.addToWorkList(member);
+        },
         includeBackendMembers: false,
-        includeSuperMembers: true,
-        f: (ClassElement enclosingClass, Element member) {
-          world.addToWorkList(member);
-        });
+        includeSuperMembers: true);
     return null;
   }
 
   /**
    * Try to resolve the constructor that is referred to by [node].
    * Note: this function may return an ErroneousFunctionElement instead of
    * [null], if there is no corresponding constructor, class or library.
    */
   FunctionElement resolveConstructor(NewExpression node) {
     // Resolve the constructor that [node] refers to.
@@ skipping 1300 matching lines @@
     return result;
   }
   Element lookup(SourceString name) => localLookup(name);
   Element lexicalLookup(SourceString name) => localLookup(name);
 
   Element add(Element newElement) {
     throw "Cannot add an element in a patch library scope";
   }
   String toString() => 'PatchLibraryScope($origin,$patch)';
 }