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

tests/corelib/future_test.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.
 
 // Tests for Future.immediate
 
 testImmediate() {
   final future = new Future<String>.immediate("42");
   Expect.isTrue(future.isComplete);
   Expect.isTrue(future.hasValue);
@@ skipping 56 matching lines @@
     Expect.equals(future, f);
     Expect.isTrue(f.isComplete);
     Expect.isFalse(f.hasValue);
     err = f.exception;
   });
   Expect.throws(() => future.exception);
   Expect.isNull(err);
   completer.completeException(exception);
   Expect.equals(exception, future.exception);
   Expect.equals(exception, err);
-  Expect.throws(() => future.value, check: (e) => e == exception);
+  Expect.throws(() => future.value, (e) => e == exception);
 }
 
 testCompleteWithCompleteHandlerAfterComplete() {
   final completer = new Completer<int>();
   final future = completer.future;
 
   int after;
   completer.complete(3);
   future.onComplete((f) {
     Expect.equals(future, f);
@@ skipping 13 matching lines @@
   var err;
   completer.completeException(exception);
   future.onComplete((f) {
     Expect.equals(future, f);
     Expect.isTrue(f.isComplete);
     Expect.isFalse(f.hasValue);
     err = f.exception;
   });
   Expect.equals(exception, future.exception);
   Expect.equals(exception, err);
-  Expect.throws(() => future.value, check: (e) => e == exception);
+  Expect.throws(() => future.value, (e) => e == exception);
 }
 
 testCompleteWithManyCompleteHandlers() {
   final completer = new Completer<int>();
   final future = completer.future;
   int before;
   int after1;
   int after2;
 
   future.onComplete((f) { before = f.value; });
@@ skipping 17 matching lines @@
 
   future.onComplete((f) { before = f.exception; });
   completer.completeException(exception);
   future.onComplete((f) { after1 = f.exception; });
   future.onComplete((f) { after2 = f.exception; });
 
   Expect.equals(exception, future.exception);
   Expect.equals(exception, before);
   Expect.equals(exception, after1);
   Expect.equals(exception, after2);
-  Expect.throws(() => future.value, check: (e) => e == exception);
+  Expect.throws(() => future.value, (e) => e == exception);
 }
 
 // Tests for [then]
 
 testCompleteWithSuccessHandlerBeforeComplete() {
   final completer = new Completer<int>();
   final future = completer.future;
 
   int before;
   future.then((int v) { before = v; });
@@ skipping 40 matching lines @@
 
 // Tests for [handleException]
 
 testException() {
   final completer = new Completer<int>();
   final future = completer.future;
   final ex = new Exception();
   future.then((_) {}); // exception is thrown if we plan to use the value
   Expect.throws(
       () { completer.completeException(ex); },
-      check: (e) => e == ex);
+      (e) => e == ex);
 }
 
 testExceptionNoSuccessListeners() {
   final completer = new Completer<int>();
   final future = completer.future;
   final ex = new Exception();
   completer.completeException(ex); // future.then is not called, so no exception
 }
 
 testExceptionHandler() {
@@ skipping 35 matching lines @@
   final completer = new Completer<int>();
   final future = completer.future;
   final ex = new Exception();
 
   bool reached = false;
   future.then((_) {}); // ensure exception is thrown...
   future.handleException((e) { return false; });
   future.handleException((e) { reached = true; return false; }); // overshadowed
   Expect.throws(
       () { completer.completeException(ex); },
-      check: (e) => e == ex);
+      (e) => e == ex);
   Expect.isTrue(reached);
 }
 
 testExceptionHandlerReturnsFalse2() {
   final completer = new Completer<int>();
   final future = completer.future;
   final ex = new Exception();
 
   bool reached = false;
   future.handleException((e) { return false; });
@@ skipping 101 matching lines @@
   final future = completer.future;
   final ex = new Exception();
 
   var exceptionFromCompleteHandler;
   future.onComplete((f) {
     Expect.equals(future, f);
     Expect.isFalse(f.hasValue);
     exceptionFromCompleteHandler = f.exception;
   });
   future.then((v) => Expect.fail("Should not succeed"));
-  Expect.throws(() => completer.completeException(ex), check: (e) => ex == e);
+  Expect.throws(() => completer.completeException(ex), (e) => ex == e);
   Expect.equals(ex, exceptionFromCompleteHandler);
 }
 
 testExceptionWithCompletionAndSuccessAndExceptionHandlers() {
   final completer = new Completer<int>();
   final future = completer.future;
   final ex = new Exception();
 
   var exceptionFromCompleteHandler;
   var exceptionFromExceptionHandler;
@@ skipping 32 matching lines @@
   completer.completeException(error);
   Expect.equals(error, transformedFuture.exception);
 }
 
 testTransformTransformerFails() {
   final completer = new Completer<String>();
   final error = new Exception("Oh no!");
   final transformedFuture = completer.future.transform((x) { throw error; });
   Expect.isFalse(transformedFuture.isComplete);
   transformedFuture.then((v) => null);
-  Expect.throws(() => completer.complete("42"), check: (e) => e == error);
+  Expect.throws(() => completer.complete("42"), (e) => e == error);
   Expect.equals(error, transformedFuture.exception);
 }
 
 // Tests for Future.chain
 
 testChainSuccess() {
   final completerA = new Completer<String>();
   final completerB = new Completer<String>();
   final chainedFuture = completerA.future.chain((x) {
     Expect.equals("42", x);
@@ skipping 19 matching lines @@
 
 testChainTransformerFails() {
   final completerA = new Completer<String>();
   final error = new Exception("Oh no!");
   final chainedFuture = completerA.future.chain((x) {
     Expect.equals("42", x);
     throw error;
   });
   chainedFuture.then((v) => null);
   Expect.isFalse(chainedFuture.isComplete);
-  Expect.throws(() => completerA.complete("42"), check: (e) => e == error);
+  Expect.throws(() => completerA.complete("42"), (e) => e == error);
   Expect.equals(error, chainedFuture.exception);
 }
 
 testChainSecondFutureFails() {
   final completerA = new Completer<String>();
   final completerB = new Completer<String>();
   final error = new Exception("Oh no!");
   final chainedFuture = completerA.future.chain((x) {
     Expect.equals("42", x);
     return completerB.future;
@@ skipping 107 matching lines @@
   testTransformTransformerFails();
   testChainSuccess();
   testChainFirstFutureFails();
   testChainTransformerFails();
   testChainSecondFutureFails();
   testTransformExceptionCompletesNormally();
   testTransformExceptionThrows();
   testTransformExceptionReturns();
   testTransformExceptionReturnsAFuture();
 }