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

tests/corelib/date_time_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.
 
 // Dart test program for Date.
 
 class DateTest {
   // Tests if the time moves eventually forward.
   static void testNow() {
     var t1 = new Date.now();
@@ skipping 169 matching lines @@
     Expect.equals(1, dt.millisecond);
     dt = new Date.fromMillisecondsSinceEpoch(SECONDS_YEAR_2035 * 1000 - 1,
                                              isUtc: true);
     Expect.equals(2034, dt.year);
     Expect.equals(12, dt.month);
     Expect.equals(31, dt.day);
     Expect.equals(23, dt.hour);
     Expect.equals(59, dt.minute);
     Expect.equals(59, dt.second);
     Expect.equals(999, dt.millisecond);
-    dt = new Date(2035, 1, 1, 0, 0, 0, 1, isUtc: true);
+    dt = new Date(2035, month: 1, day: 1, hour: 0, minute: 0, second: 0,
+                  millisecond: 1, isUtc: true);
     Expect.equals(SECONDS_YEAR_2035 * 1000 + 1, dt.millisecondsSinceEpoch);
-    dt = new Date(2034, 12, 31, 23, 59, 59, 999, isUtc: true);
+    dt = new Date(2034, month: 12, day: 31, hour: 23, minute: 59, second: 59,
+                  millisecond: 999, isUtc: true);
     Expect.equals(SECONDS_YEAR_2035 * 1000 - 1, dt.millisecondsSinceEpoch);
     dt = new Date.fromMillisecondsSinceEpoch(SECONDS_YEAR_2035 * 1000 + 1);
     Expect.equals(true, (2035 == dt.year && 1 == dt.month && 1 == dt.day) ||
                         (2034 == dt.year && 12 == dt.month && 31 == dt.day));
     Expect.equals(0, dt.second);
     Expect.equals(1, dt.millisecond);
     Date dt2 = new Date(
-        dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second,
-        dt.millisecond);
+        dt.year, month: dt.month, day: dt.day, hour: dt.hour, minute: dt.minute,
+        second: dt.second, millisecond: dt.millisecond);
     Expect.equals(dt.millisecondsSinceEpoch, dt2.millisecondsSinceEpoch);
     dt = new Date.fromMillisecondsSinceEpoch(SECONDS_YEAR_2035 * 1000 - 1);
     Expect.equals(true, (2035 == dt.year && 1 == dt.month && 1 == dt.day) ||
                         (2034 == dt.year && 12 == dt.month && 31 == dt.day));
     Expect.equals(59, dt.second);
     Expect.equals(999, dt.millisecond);
     dt2 = new Date(
-        dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second,
-        dt.millisecond);
+        dt.year, month: dt.month, day: dt.day, hour: dt.hour, minute: dt.minute,
+        second: dt.second, millisecond: dt.millisecond);
     Expect.equals(dt.millisecondsSinceEpoch, dt2.millisecondsSinceEpoch);
     dt = new Date.fromMillisecondsSinceEpoch(2100000000 * 1000, isUtc: true);
     Expect.equals(2036, dt.year);
     Expect.equals(7, dt.month);
     Expect.equals(18, dt.day);
     Expect.equals(13, dt.hour);
     Expect.equals(20, dt.minute);
     Expect.equals(0, dt.second);
     Expect.equals(0, dt.millisecond);
     // Internally this will use the maximum value for the native calls.
-    dt = new Date(2036, 7, 18, 13, 20);
+    dt = new Date(2036, month: 7, day: 18, hour: 13, minute: 20);
     Expect.equals(2036, dt.year);
     Expect.equals(7, dt.month);
     Expect.equals(18, dt.day);
     Expect.equals(13, dt.hour);
     Expect.equals(20, dt.minute);
     Expect.equals(0, dt.second);
     Expect.equals(0, dt.millisecond);
     Expect.equals("2036-07-18 13:20:00.000", dt.toString());
   }
 
@@ skipping 10 matching lines @@
     dt = new Date.fromMillisecondsSinceEpoch(-8640000000000000, isUtc: true);
     Expect.equals(-271821, dt.year);
     Expect.equals(4, dt.month);
     Expect.equals(20, dt.day);
     Expect.equals(0, dt.hour);
     Expect.equals(0, dt.minute);
     Expect.equals(0, dt.second);
     Expect.equals(0, dt.millisecond);
     // Make sure that we can build the extreme dates in local too.
     dt = new Date.fromMillisecondsSinceEpoch(8640000000000000);
-    dt = new Date(dt.year, dt.month, dt.day, dt.hour, dt.minute);
+    dt = new Date(dt.year, month: dt.month, day: dt.day, hour: dt.hour,
+                  minute: dt.minute);
     Expect.equals(8640000000000000, dt.millisecondsSinceEpoch);
     dt = new Date.fromMillisecondsSinceEpoch(-8640000000000000);
-    dt = new Date(dt.year, dt.month, dt.day, dt.hour, dt.minute);
+    dt = new Date(dt.year, month: dt.month, day: dt.day, hour: dt.hour,
+                  minute: dt.minute);
     Expect.equals(-8640000000000000, dt.millisecondsSinceEpoch);
     Expect.throws(() => new Date.fromMillisecondsSinceEpoch(8640000000000001,
                                                             isUtc: true));
     Expect.throws(() => new Date.fromMillisecondsSinceEpoch(-8640000000000001,
                                                             isUtc: true));
     Expect.throws(() => new Date.fromMillisecondsSinceEpoch(8640000000000001));
     Expect.throws(() => new Date.fromMillisecondsSinceEpoch(-8640000000000001));
     dt = new Date.fromMillisecondsSinceEpoch(8640000000000000);
-    Expect.throws(() => new Date(dt.year, dt.month, dt.day,
-                                 dt.hour, dt.minute, 0, 1));
+    Expect.throws(() => new Date(dt.year, month: dt.month, day: dt.day,
+                                 hour: dt.hour, minute: dt.minute, second: 0,
+                                 millisecond: 1));
     dt = new Date.fromMillisecondsSinceEpoch(8640000000000000, isUtc: true);
-    Expect.throws(() => new Date(dt.year, dt.month, dt.day,
-                                 dt.hour, dt.minute, 0, 1, isUtc: true));
+    Expect.throws(() => new Date(dt.year, month: dt.month, day: dt.day,
+                                 hour: dt.hour, minute: dt.minute, second: 0,
+                                 millisecond: 1, isUtc: true));
     dt = new Date.fromMillisecondsSinceEpoch(-8640000000000000);
-    Expect.throws(() => new Date(dt.year, dt.month, dt.day,
-                                 dt.hour, dt.minute, 0, -1));
+    Expect.throws(() => new Date(dt.year, month: dt.month, day: dt.day,
+                                 hour: dt.hour, minute: dt.minute, second: 0,
+                                 millisecond: -1));
     dt = new Date.fromMillisecondsSinceEpoch(-8640000000000000, isUtc: true);
-    Expect.throws(() => new Date(dt.year, dt.month, dt.day,
-                                 dt.hour, dt.minute, 0, -1, isUtc: true));
+    Expect.throws(() => new Date(dt.year, month: dt.month, day: dt.day,
+                                 hour: dt.hour, minute: dt.minute, second: 0,
+                                 millisecond: -1, isUtc: true));
   }
 
   static void testUTCGetters() {
     var dt = new Date.fromMillisecondsSinceEpoch(1305140315000, isUtc: true);
     Expect.equals(2011, dt.year);
     Expect.equals(5, dt.month);
     Expect.equals(11, dt.day);
     Expect.equals(18, dt.hour);
     Expect.equals(58, dt.minute);
     Expect.equals(35, dt.second);
     Expect.equals(0, dt.millisecond);
     Expect.equals(true, dt.isUtc);
     Expect.equals(1305140315000, dt.millisecondsSinceEpoch);
     dt = new Date.fromMillisecondsSinceEpoch(-9999999, isUtc: true);
     Expect.equals(1969, dt.year);
     Expect.equals(12, dt.month);
     Expect.equals(31, dt.day);
     Expect.equals(21, dt.hour);
     Expect.equals(13, dt.minute);
     Expect.equals(20, dt.second);
     Expect.equals(1, dt.millisecond);
   }
 
   static void testLocalGetters() {
     var dt1 = new Date.fromMillisecondsSinceEpoch(1305140315000);
-    var dt2 = new Date(dt1.year, dt1.month, dt1.day,
-                       dt1.hour, dt1.minute, dt1.second,
-                       dt1.millisecond,
+    var dt2 = new Date(dt1.year, month: dt1.month, day: dt1.day,
+                       hour: dt1.hour, minute: dt1.minute, second: dt1.second,
+                       millisecond: dt1.millisecond,
                        isUtc: true);
     Duration zoneOffset = dt1.difference(dt2);
     Expect.equals(true, zoneOffset.inDays == 0);
     Expect.equals(true, zoneOffset.inHours.abs() <= 12);
     Expect.equals(dt1.year, dt2.year);
     Expect.equals(dt1.month, dt2.month);
     Expect.equals(true, (dt1.day - dt2.day).abs() <= 1);
     Expect.equals(true, dt1.hour < 24);
     // There are timezones with 0.5 or 0.25 hour offsets.
     Expect.equals(true,
                   (dt1.minute == dt2.minute) ||
                   ((dt1.minute - dt2.minute).abs() == 30) ||
                   ((dt1.minute - dt2.minute).abs() == 15));
     Expect.equals(dt1.second, dt2.second);
     Expect.equals(dt1.millisecond, dt2.millisecond);
   }
 
   static void testConstructors() {
-    var dt0 = new Date(2011, 5, 11, 18, 58, 35, 0, isUtc: true);
+    var dt0 = new Date(2011, month: 5, day: 11, hour: 18, minute: 58,
+                       second: 35, millisecond: 0, isUtc: true);
     Expect.equals(1305140315000, dt0.millisecondsSinceEpoch);
     var dt1 = new Date.fromMillisecondsSinceEpoch(1305140315000);
     Expect.equals(dt1.millisecondsSinceEpoch, dt0.millisecondsSinceEpoch);
     Expect.equals(true, dt1 == dt0);
-    var dt3 = new Date(dt1.year, dt1.month, dt1.day, dt1.hour, dt1.minute,
-                       dt1.second, dt1.millisecond);
+    var dt3 = new Date(dt1.year, month: dt1.month, day: dt1.day, hour: dt1.hour,
+                       minute: dt1.minute, second: dt1.second,
+                       millisecond: dt1.millisecond);
     Expect.equals(dt1.millisecondsSinceEpoch, dt3.millisecondsSinceEpoch);
     Expect.equals(true, dt1 == dt3);
     dt3 = new Date(
-        dt1.year, dt1.month, dt1.day, dt1.hour, dt1.minute,
-        dt1.second, dt1.millisecond);
+        dt1.year, month: dt1.month, day: dt1.day, hour: dt1.hour,
+        minute: dt1.minute, second: dt1.second, millisecond: dt1.millisecond);
     Expect.equals(dt1.millisecondsSinceEpoch, dt3.millisecondsSinceEpoch);
     Expect.equals(true, dt1 == dt3);
     var dt2 = dt1.toLocal();
-    dt3 = new Date(2011, 5, dt1.day, dt1.hour, dt1.minute, 35, 0);
+    dt3 = new Date(2011, month: 5, day: dt1.day, hour: dt1.hour,
+                   minute: dt1.minute, second: 35, millisecond: 0);
     Expect.equals(dt2.millisecondsSinceEpoch, dt3.millisecondsSinceEpoch);
     Expect.equals(true, dt2 == dt3);
     dt1 = new Date.fromMillisecondsSinceEpoch(-9999999, isUtc: true);
     dt3 = new Date(
-        dt1.year, dt1.month, dt1.day, dt1.hour, dt1.minute,
-        dt1.second, dt1.millisecond, isUtc: true);
+        dt1.year, month: dt1.month, day: dt1.day, hour: dt1.hour,
+        minute: dt1.minute, second: dt1.second, millisecond: dt1.millisecond,
+        isUtc: true);
     Expect.equals(dt1.millisecondsSinceEpoch, dt3.millisecondsSinceEpoch);
-    dt3 = new Date(99, 1, 2, 10, 11, 12, 0, isUtc: true);
+    dt3 = new Date(99, month: 1, day: 2, hour: 10, minute: 11, second: 12,
+                   millisecond: 0, isUtc: true);
     Expect.equals(99, dt3.year);
     Expect.equals(1, dt3.month);
     Expect.equals(2, dt3.day);
     Expect.equals(10, dt3.hour);
     Expect.equals(11, dt3.minute);
     Expect.equals(12, dt3.second);
     Expect.equals(0, dt3.millisecond);
     Expect.equals(true, dt3.isUtc);
-    var dt4 = new Date(99, 1, 2);
+    var dt4 = new Date(99, month: 1, day: 2);
     Expect.equals(99, dt4.year);
     Expect.equals(1, dt4.month);
     Expect.equals(2, dt4.day);
     Expect.equals(0, dt4.hour);
     Expect.equals(0, dt4.minute);
     Expect.equals(0, dt4.second);
     Expect.equals(0, dt4.millisecond);
     Expect.isFalse(dt4.isUtc);
-    var dt5 = new Date(99, 1, 2, isUtc: true);
+    var dt5 = new Date(99, month: 1, day: 2, isUtc: true);
     Expect.equals(99, dt5.year);
     Expect.equals(1, dt5.month);
     Expect.equals(2, dt5.day);
     Expect.equals(0, dt5.hour);
     Expect.equals(0, dt5.minute);
     Expect.equals(0, dt5.second);
     Expect.equals(0, dt5.millisecond);
     Expect.isTrue(dt5.isUtc);
-    var dt6 = new Date(2012, 2, 27, 13, 27, 0);
+    var dt6 = new Date(
+        2012, month: 2, day: 27, hour: 13, minute: 27, second: 0);
     Expect.equals(2012, dt6.year);
     Expect.equals(2, dt6.month);
     Expect.equals(27, dt6.day);
     Expect.equals(13, dt6.hour);
     Expect.equals(27, dt6.minute);
     Expect.equals(0, dt6.second);
     Expect.equals(0, dt6.millisecond);
     Expect.isFalse(dt6.isUtc);
-    var dt7 = new Date(2012, 2, 27, 13, 27, 0, isUtc: true);
+    var dt7 = new Date(
+        2012, month: 2, day: 27, hour: 13, minute: 27, second: 0, isUtc: true);
     Expect.equals(2012, dt7.year);
     Expect.equals(2, dt7.month);
     Expect.equals(27, dt7.day);
     Expect.equals(13, dt7.hour);
     Expect.equals(27, dt7.minute);
     Expect.equals(0, dt7.second);
     Expect.equals(0, dt7.millisecond);
     Expect.isTrue(dt7.isUtc);
   }
 
@@ skipping 31 matching lines @@
     Expect.equals(dt1.minute, dt2.minute);
     Expect.equals(dt1.second + 3, dt2.second);
     Expect.equals(dt1.millisecond + 5, dt2.millisecond);
     var dt3 = dt2.subtract(new Duration(milliseconds:
         3 * Duration.MILLISECONDS_PER_SECOND + 5));
     Expect.equals(true, dt1 == dt3);
     Expect.equals(false, dt1 == dt2);
   }
 
   static void testUnderflowAndOverflow() {
-    final dtBase = new Date(2012, 6, 20, 12, 30, 30, 500);
+    final dtBase = new Date(2012, month: 6, day: 20, hour: 12, minute: 30,
+                            second: 30, millisecond: 500);
 
     // Millisecond
     print("  >>> Millisecond+");
-    var dt = new Date(dtBase.year, dtBase.month, dtBase.day, dtBase.hour,
-                      dtBase.minute, dtBase.second, 1000);
+    var dt = new Date(dtBase.year, month: dtBase.month, day: dtBase.day,
+                      hour: dtBase.hour, minute: dtBase.minute,
+                      second: dtBase.second, millisecond: 1000);
     Expect.equals(dtBase.year, dt.year);
     Expect.equals(dtBase.month, dt.month);
     Expect.equals(dtBase.day, dt.day);
     Expect.equals(dtBase.hour, dt.hour);
     Expect.equals(dtBase.minute, dt.minute);
     Expect.equals(dtBase.second + 1, dt.second);
     Expect.equals(0, dt.millisecond);
 
     print("  >>> Millisecond-");
-    dt = new Date(dtBase.year, dtBase.month, dtBase.day, dtBase.hour,
-                  dtBase.minute, dtBase.second, -1000);
+    dt = new Date(dtBase.year, month: dtBase.month, day: dtBase.day,
+                  hour: dtBase.hour, minute: dtBase.minute,
+                  second: dtBase.second, millisecond: -1000);
     Expect.equals(dtBase.year, dt.year);
     Expect.equals(dtBase.month, dt.month);
     Expect.equals(dtBase.day, dt.day);
     Expect.equals(dtBase.hour, dt.hour);
     Expect.equals(dtBase.minute, dt.minute);
     Expect.equals(dtBase.second - 1, dt.second);
     Expect.equals(0, dt.millisecond);
 
     // Second
     print("  >>> Second+");
-    dt = new Date(dtBase.year, dtBase.month, dtBase.day, dtBase.hour,
-                  dtBase.minute, 60, dtBase.millisecond);
+    dt = new Date(dtBase.year, month: dtBase.month, day: dtBase.day,
+                  hour: dtBase.hour, minute: dtBase.minute, second: 60,
+                  millisecond: dtBase.millisecond);
     Expect.equals(dtBase.year, dt.year);
     Expect.equals(dtBase.month, dt.month);
     Expect.equals(dtBase.day, dt.day);
     Expect.equals(dtBase.hour, dt.hour);
     Expect.equals(dtBase.minute + 1, dt.minute);
     Expect.equals(0, dt.second);
     Expect.equals(dtBase.millisecond, dt.millisecond);
 
     print("  >>> Second-");
-    dt = new Date(dtBase.year, dtBase.month, dtBase.day, dtBase.hour,
-                  dtBase.minute, -60, dtBase.millisecond);
+    dt = new Date(dtBase.year, month: dtBase.month, day: dtBase.day,
+                  hour: dtBase.hour, minute: dtBase.minute,
+                  second: -60, millisecond: dtBase.millisecond);
     Expect.equals(dtBase.year, dt.year);
     Expect.equals(dtBase.month, dt.month);
     Expect.equals(dtBase.day, dt.day);
     Expect.equals(dtBase.hour, dt.hour);
     Expect.equals(dtBase.minute - 1, dt.minute);
     Expect.equals(0, dt.second);
     Expect.equals(dtBase.millisecond, dt.millisecond);
 
     // Minute
     print("  >>> Minute+");
-    dt = new Date(dtBase.year, dtBase.month, dtBase.day, dtBase.hour, 60,
-                  dtBase.second, dtBase.millisecond);
+    dt = new Date(dtBase.year, month: dtBase.month, day: dtBase.day,
+                  hour: dtBase.hour, minute: 60, second: dtBase.second,
+                  millisecond: dtBase.millisecond);
     Expect.equals(dtBase.year, dt.year);
     Expect.equals(dtBase.month, dt.month);
     Expect.equals(dtBase.day, dt.day);
     Expect.equals(dtBase.hour + 1, dt.hour);
     Expect.equals(0, dt.minute);
     Expect.equals(dtBase.second, dt.second);
     Expect.equals(dtBase.millisecond, dt.millisecond);
 
     print("  >>> Minute-");
-    dt = new Date(dtBase.year, dtBase.month, dtBase.day, dtBase.hour, -60,
-                  dtBase.second, dtBase.millisecond);
+    dt = new Date(dtBase.year, month: dtBase.month, day: dtBase.day,
+                  hour: dtBase.hour, minute: -60, second: dtBase.second,
+                  millisecond: dtBase.millisecond);
     Expect.equals(dtBase.year, dt.year);
     Expect.equals(dtBase.month, dt.month);
     Expect.equals(dtBase.day, dt.day);
     Expect.equals(dtBase.hour - 1, dt.hour);
     Expect.equals(0, dt.minute);
     Expect.equals(dtBase.second, dt.second);
     Expect.equals(dtBase.millisecond, dt.millisecond);
 
     // Hour
     print("  >>> Hour+");
-    dt = new Date(dtBase.year, dtBase.month, dtBase.day, 24, dtBase.minute,
-                  dtBase.second, dtBase.millisecond);
+    dt = new Date(dtBase.year, month: dtBase.month, day: dtBase.day, hour: 24,
+                  minute: dtBase.minute, second: dtBase.second,
+                  millisecond: dtBase.millisecond);
     Expect.equals(dtBase.year, dt.year);
     Expect.equals(dtBase.month, dt.month);
     Expect.equals(dtBase.day + 1, dt.day);
     Expect.equals(0, dt.hour);
     Expect.equals(dtBase.minute, dt.minute);
     Expect.equals(dtBase.second, dt.second);
     Expect.equals(dtBase.millisecond, dt.millisecond);
 
     print("  >>> Hour-");
-    dt = new Date(dtBase.year, dtBase.month, dtBase.day, -24, dtBase.minute,
-                  dtBase.second, dtBase.millisecond);
+    dt = new Date(dtBase.year, month: dtBase.month, day: dtBase.day, hour: -24,
+                  minute: dtBase.minute, second: dtBase.second,
+                  millisecond: dtBase.millisecond);
     Expect.equals(dtBase.year, dt.year);
     Expect.equals(dtBase.month, dt.month);
     Expect.equals(dtBase.day - 1, dt.day);
     Expect.equals(0, dt.hour);
     Expect.equals(dtBase.minute, dt.minute);
     Expect.equals(dtBase.second, dt.second);
     Expect.equals(dtBase.millisecond, dt.millisecond);
 
     // Day
     print("  >>> Day+");
-    dt = new Date(dtBase.year, dtBase.month, 31, dtBase.hour, dtBase.minute,
-                  dtBase.second, dtBase.millisecond);
+    dt = new Date(dtBase.year, month: dtBase.month, day: 31, hour: dtBase.hour,
+                  minute: dtBase.minute, second: dtBase.second,
+                  millisecond: dtBase.millisecond);
     Expect.equals(dtBase.year, dt.year);
     Expect.equals(dtBase.month + 1, dt.month);
     Expect.equals(1, dt.day);
     Expect.equals(dtBase.hour, dt.hour);
     Expect.equals(dtBase.minute, dt.minute);
     Expect.equals(dtBase.second, dt.second);
     Expect.equals(dtBase.millisecond, dt.millisecond);
 
     print("  >>> Day-");
-    dt = new Date(dtBase.year, dtBase.month, -30, dtBase.hour, dtBase.minute,
-                  dtBase.second, dtBase.millisecond);
+    dt = new Date(dtBase.year, month: dtBase.month, day: -30, hour: dtBase.hour,
+                  minute: dtBase.minute, second: dtBase.second,
+                  millisecond: dtBase.millisecond);
     Expect.equals(dtBase.year, dt.year);
     Expect.equals(dtBase.month - 1, dt.month);
     Expect.equals(1, dt.day);
     Expect.equals(dtBase.hour, dt.hour);
     Expect.equals(dtBase.minute, dt.minute);
     Expect.equals(dtBase.second, dt.second);
     Expect.equals(dtBase.millisecond, dt.millisecond);
 
     // Month
     print("  >>> Month+");
-    dt = new Date(dtBase.year, 13, dtBase.day, dtBase.hour, dtBase.minute,
-                  dtBase.second, dtBase.millisecond);
+    dt = new Date(dtBase.year, month: 13, day: dtBase.day, hour: dtBase.hour,
+                  minute: dtBase.minute, second: dtBase.second,
+                  millisecond: dtBase.millisecond);
     Expect.equals(dtBase.year + 1, dt.year);
     Expect.equals(1, dt.month);
     Expect.equals(dtBase.day, dt.day);
     Expect.equals(dtBase.hour, dt.hour);
     Expect.equals(dtBase.minute, dt.minute);
     Expect.equals(dtBase.second, dt.second);
     Expect.equals(dtBase.millisecond, dt.millisecond);
 
     print("  >>> Month-");
-    dt = new Date(dtBase.year, -11, dtBase.day, dtBase.hour, dtBase.minute,
-                  dtBase.second, dtBase.millisecond);
+    dt = new Date(dtBase.year, month: -11, day: dtBase.day, hour: dtBase.hour,
+                  minute: dtBase.minute, second: dtBase.second,
+                  millisecond: dtBase.millisecond);
     Expect.equals(dtBase.year - 1, dt.year);
     Expect.equals(1, dt.month);
     Expect.equals(dtBase.day, dt.day);
     Expect.equals(dtBase.hour, dt.hour);
     Expect.equals(dtBase.minute, dt.minute);
     Expect.equals(dtBase.second, dt.second);
     Expect.equals(dtBase.millisecond, dt.millisecond);
 
     // Flowing all the way up the chain.
     print("  >>> Flow+");
-    var dtBase1 = new Date(2012, 12, 31, 23, 59, 59, 999);
-    var dtTick = new Date(dtBase1.year, dtBase1.month, dtBase1.day,
-                          dtBase1.hour, dtBase1.minute, dtBase1.second,
-                          dtBase1.millisecond + 1);
+    var dtBase1 = new Date(2012, month: 12, day: 31, hour: 23, minute: 59,
+                           second: 59, millisecond: 999);
+    var dtTick = new Date(dtBase1.year, month: dtBase1.month, day: dtBase1.day,
+                          hour: dtBase1.hour, minute: dtBase1.minute,
+                          second: dtBase1.second,
+                          millisecond: dtBase1.millisecond + 1);
     Expect.equals(dtBase1.year + 1, dtTick.year);
     Expect.equals(1, dtTick.month);
     Expect.equals(1, dtTick.day);
     Expect.equals(0, dtTick.hour);
     Expect.equals(0, dtTick.minute);
     Expect.equals(0, dtTick.second);
     Expect.equals(0, dtTick.millisecond);
 
     print("  >>> Flow-");
-    dtBase1 = new Date(2012, 1, 1, 0, 0, 0, 0);
-    dtTick = new Date(dtBase1.year, dtBase1.month, dtBase1.day, dtBase1.hour,
-                      dtBase1.minute, dtBase1.second, dtBase1.millisecond - 1);
+    dtBase1 = new Date(2012, month: 1, day: 1, hour: 0, minute: 0, second: 0,
+                       millisecond: 0);
+    dtTick = new Date(dtBase1.year, month: dtBase1.month, day: dtBase1.day,
+                      hour: dtBase1.hour, minute: dtBase1.minute,
+                      second: dtBase1.second,
+                      millisecond: dtBase1.millisecond - 1);
     Expect.equals(dtBase1.year - 1, dtTick.year);
     Expect.equals(12, dtTick.month);
     Expect.equals(31, dtTick.day);
     Expect.equals(23, dtTick.hour);
     Expect.equals(59, dtTick.minute);
     Expect.equals(59, dtTick.second);
     Expect.equals(999, dtTick.millisecond);
 
     print("  >>> extra underflow");
-    dtTick = new Date(dtBase1.year, dtBase1.month, dtBase1.day, -17520,
-                      dtBase1.minute, dtBase1.second, dtBase1.millisecond);
+    dtTick = new Date(dtBase1.year, month: dtBase1.month, day: dtBase1.day,
+                      hour: -17520, minute: dtBase1.minute,
+                      second: dtBase1.second, millisecond: dtBase1.millisecond);
     Expect.equals(dtBase1.year - 2, dtTick.year);
     Expect.equals(dtBase1.month, dtTick.month);
     Expect.equals(dtBase1.day, dtTick.day);
     Expect.equals(dtBase1.hour, dtTick.hour);
     Expect.equals(dtBase1.minute, dtTick.minute);
     Expect.equals(dtBase1.second, dtTick.second);
     Expect.equals(dtBase1.millisecond, dtTick.millisecond);
   }
 
   static void testDateStrings() {
@@ skipping 161 matching lines @@
     Expect.equals(9, dt1.day);
     Expect.equals(9, dt1.hour);
     Expect.equals(9, dt1.minute);
     Expect.equals(9, dt1.second);
     Expect.equals(9, dt1.millisecond);
     Expect.equals(true, dt1.isUtc);
   }
 
   static void testWeekday() {
     // 2011-10-06 is Summertime.
-    var d = new Date(2011, 10, 6, 0, 45, 37, 0);
+    var d = new Date(2011, month: 10, day: 6, hour: 0, minute: 45, second: 37,
+                     millisecond: 0);
     Expect.equals(Date.THU, d.weekday);
-    d = new Date(2011, 10, 6, 0, 45, 37, 0, isUtc: true);
+    d = new Date(2011, month: 10, day: 6, hour: 0, minute: 45, second: 37,
+                 millisecond: 0, isUtc: true);
     Expect.equals(Date.THU, d.weekday);
-    d = new Date(2011, 10, 5, 23, 45, 37, 0);
+    d = new Date(2011, month: 10, day: 5, hour: 0, minute: 45, second: 37,
+                 millisecond: 0);
     Expect.equals(Date.WED, d.weekday);
-    d = new Date(2011, 10, 5, 23, 45, 37, 0, isUtc: true);
+    d = new Date(2011, month: 10, day: 5, hour: 0, minute: 45, second: 37,
+                 millisecond: 0, isUtc: true);
     Expect.equals(Date.WED, d.weekday);
     // 1970-01-01 is Wintertime.
-    d = new Date(1970, 1, 1, 0, 0, 0, 1);
+    d = new Date(1970, month: 1, day: 1, hour: 0, minute: 0, second: 0,
+                 millisecond: 1);
     Expect.equals(Date.THU, d.weekday);
-    d = new Date(1970, 1, 1, 0, 0, 0, 1, isUtc: true);
+    d = new Date(1970, month: 1, day: 1, hour: 0, minute: 0, second: 0,
+                 millisecond: 1, isUtc: true);
     Expect.equals(Date.THU, d.weekday);
-    d = new Date(1969, 12, 31, 23, 59, 59, 999, isUtc: true);
+    d = new Date(1969, month: 12, day: 31, hour: 23, minute: 59, second: 59,
+                 millisecond: 999, isUtc: true);
     Expect.equals(Date.WED, d.weekday);
-    d = new Date(1969, 12, 31, 23, 59, 59, 999);
+    d = new Date(1969, month: 12, day: 31, hour: 23, minute: 59, second: 59,
+                 millisecond: 999);
     Expect.equals(Date.WED, d.weekday);
-    d = new Date(2011, 10, 4, 23, 45, 37, 0);
+    d = new Date(2011, month: 10, day: 4, hour: 23, minute: 45, second: 37,
+                 millisecond: 0);
     Expect.equals(Date.TUE, d.weekday);
-    d = new Date(2011, 10, 3, 23, 45, 37, 0);
+    d = new Date(2011, month: 10, day: 3, hour: 23, minute: 45, second: 37,
+                 millisecond: 0);
     Expect.equals(Date.MON, d.weekday);
-    d = new Date(2011, 10, 2, 23, 45, 37, 0);
+    d = new Date(2011, month: 10, day: 2, hour: 23, minute: 45, second: 37,
+                 millisecond: 0);
     Expect.equals(Date.SUN, d.weekday);
-    d = new Date(2011, 10, 1, 23, 45, 37, 0);
+    d = new Date(2011, month: 10, day: 1, hour: 23, minute: 45, second: 37,
+                 millisecond: 0);
     Expect.equals(Date.SAT, d.weekday);
-    d = new Date(2011, 9, 30, 23, 45, 37, 0);
+    d = new Date(2011, month: 9, day: 30, hour: 23, minute: 45, second: 37,
+                 millisecond: 0);
     Expect.equals(Date.FRI, d.weekday);
   }
 
   static void testMain() {
     testNow();
     testValue();
     testConstructors();
     testUTCGetters();
     testLocalGetters();
     testChangeTimeZone();
     testSubAdd();
     testUnderflowAndOverflow();
     testDateStrings();
     testEquivalentYears();
     testExtremes();
     testFarAwayDates();
     testWeekday();
   }
 }
 
 main() {
   DateTest.testMain();
 }