Deprecate use of timezones.

runtime/lib/date.dart

 // Copyright (c) 2011, 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 core library.
 
 class TimeZoneImplementation implements TimeZone {
   const TimeZoneImplementation.utc() : isUtc = true;
   TimeZoneImplementation.local() : isUtc = false {}
 
   bool operator ==(Object other) {
     if (!(other is TimeZoneImplementation)) return false;
     return isUtc == other.isUtc;
   }
 
   final bool isUtc;
 }
 
-// JavaScript implementation of DateImplementation.
+// VM implementation of DateImplementation.
 class DateImplementation implements Date {
-  factory DateImplementation(int years,
-                             [int month = 1,
-                              int day = 1,
-                              int hours = 0,
-                              int minutes = 0,
-                              int seconds = 0,
-                              int milliseconds = 0]) {
-    return new DateImplementation.withTimeZone(
-        years, month, day,
-        hours, minutes, seconds, milliseconds,
-        new TimeZoneImplementation.local());
+  static final int _SECONDS_YEAR_2035 = 2051222400;
+
+  DateImplementation(int years,
+                     [int month = 1,
+                      int day = 1,
+                      int hours = 0,
+                      int minutes = 0,
+                      int seconds = 0,
+                      int milliseconds = 0,
+                      bool isUtc = false])
+      : _isUtc = isUtc,
+        value = _brokenDownDateToMillisecondsSinceEpoch(
+            years, month, day, hours, minutes, seconds, milliseconds, isUtc) {
+    if (value === null) throw new IllegalArgumentException();
   }
 
   DateImplementation.withTimeZone(int years,
                                   int month,
                                   int day,
                                   int hours,
                                   int minutes,
                                   int seconds,
                                   int milliseconds,
                                   TimeZone timeZone)
-  : timeZone = timeZone,
-    value = _brokenDownDateToMillisecondsSinceEpoch(
-               years, month, day, hours, minutes, seconds, milliseconds,
-               timeZone.isUtc) {
-    if (value === null) throw new IllegalArgumentException();
-  }
+      : this(years, month, day, hours, minutes, seconds, milliseconds,
+             timeZone.isUtc);
 
   DateImplementation.now()
-  : timeZone = new TimeZone.local(),
-    value = _getCurrentMs() {
+      : _isUtc = true,
+        value = _getCurrentMs() {
   }
 
   factory DateImplementation.fromString(String formattedString) {
     // Read in (a subset of) ISO 8601.
     // Examples:
     //    - "2012-02-27 13:27:00"
     //    - "2012-02-27 13:27:00.423z"
     //    - "20120227 13:27:00"
     //    - "20120227T132700"
     //    - "20120227"
@@ skipping 23 matching lines @@
       int minutes = parseIntOrZero(match[5]);
       int seconds = parseIntOrZero(match[6]);
       bool addOneMillisecond = false;
       int milliseconds = (parseDoubleOrZero(match[7]) * 1000).round().toInt();
       if (milliseconds == 1000) {
         addOneMillisecond = true;
         milliseconds = 999;
       }
       // TODO(floitsch): we should not need to test against the empty string.
       bool isUtc = (match[8] !== null) && (match[8] != "");
-      TimeZone timezone = isUtc ? const TimeZone.utc() : new TimeZone.local();
       int epochValue = _brokenDownDateToMillisecondsSinceEpoch(
           years, month, day, hours, minutes, seconds, milliseconds, isUtc);
       if (epochValue === null) {
         throw new IllegalArgumentException(formattedString);
       }
       if (addOneMillisecond) epochValue++;
-      return new DateImplementation.fromEpoch(epochValue, timezone);
+      return new DateImplementation.fromEpoch(epochValue, isUtc);
     } else {
       throw new IllegalArgumentException(formattedString);
     }
   }
 
-  const DateImplementation.fromEpoch(int this.value,
-                                     TimeZone this.timeZone);
+  DateImplementation.fromEpoch(int this.value, [bool isUtc = false])
+      : _isUtc = isUtc;
 
   bool operator ==(Object other) {
-    if (!(other is DateImplementation)) return false;
-    return value == other.value && timeZone == other.timeZone;
+    if (other is !DateImplementation) return false;
+    return value == other.value;
   }
 
   bool operator <(Date other) => value < other.value;
 
   bool operator <=(Date other) => value <= other.value;
 
   bool operator >(Date other) => value > other.value;
 
   bool operator >=(Date other) => value >= other.value;
 
   int compareTo(Date other) => value.compareTo(other.value);
   int hashCode() => value;
 
+  Date toLocal() {
+    if (isUtc()) return new DateImplementation.fromEpoch(value, false);
+    return this;
+  }
+
+  Date toUtc() {
+    if (isUtc()) return this;
+    return new DateImplementation.fromEpoch(value, true);
+  }
+
   Date changeTimeZone(TimeZone targetTimeZone) {
     if (targetTimeZone === null) {
       targetTimeZone = new TimeZoneImplementation.local();
     }
-    return new Date.fromEpoch(value, targetTimeZone);
+    return new Date.fromEpoch(value, targetTimeZone.isUtc);
   }
 
   String get timeZoneName() {
     if (isUtc()) return "UTC";
     return _timeZoneName(_equivalentSeconds(_secondsSinceEpoch));
   }
 
   Duration get timeZoneOffset() {
     if (isUtc()) return new Duration(0);
     int offsetInSeconds =
         _timeZoneOffsetInSeconds(_equivalentSeconds(_secondsSinceEpoch));
     return new Duration(seconds: offsetInSeconds);
   }
 
   int get year() {
     int secondsSinceEpoch = _secondsSinceEpoch;
     // According to V8 some library calls have troubles with negative values.
     // Therefore clamp to 0 - year 2035 (which is less than the size of 32bit).
     if (secondsSinceEpoch >= 0 && secondsSinceEpoch < _SECONDS_YEAR_2035) {
-      return _getYear(secondsSinceEpoch, timeZone.isUtc);
+      return _getYear(secondsSinceEpoch, isUtc());
     }
 
     // Approximate the result. We don't take timeZone into account.
     int approximateYear = _yearsFromSecondsSinceEpoch(secondsSinceEpoch);
     int equivalentYear = _equivalentYear(approximateYear);
-    int y = _getYear(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
+    int y = _getYear(_equivalentSeconds(_secondsSinceEpoch), isUtc());
     return approximateYear + (y - equivalentYear);
   }
 
   int get month() {
-    return _getMonth(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
+    return _getMonth(_equivalentSeconds(_secondsSinceEpoch), isUtc());
   }
 
   int get day() {
-    return _getDay(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
+    return _getDay(_equivalentSeconds(_secondsSinceEpoch), isUtc());
   }
 
   int get hours() {
-    return _getHours(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
+    return _getHours(_equivalentSeconds(_secondsSinceEpoch), isUtc());
   }
 
   int get minutes() {
-    return _getMinutes(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
+    return _getMinutes(_equivalentSeconds(_secondsSinceEpoch), isUtc());
   }
 
   int get seconds() {
-    return _getSeconds(_equivalentSeconds(_secondsSinceEpoch), timeZone.isUtc);
+    return _getSeconds(_equivalentSeconds(_secondsSinceEpoch), isUtc());
   }
 
   int get milliseconds() {
     return value % Duration.MILLISECONDS_PER_SECOND;
   }
 
   int get _secondsSinceEpoch() {
     // Always round down.
     if (value < 0) {
       return (value + 1) ~/ Duration.MILLISECONDS_PER_SECOND - 1;
     } else {
       return value ~/ Duration.MILLISECONDS_PER_SECOND;
     }
   }
 
   int get weekday() {
-    final Date unixTimeStart =
-    new Date.withTimeZone(1970, 1, 1, 0, 0, 0, 0, timeZone);
+    final Date unixTimeStart = new Date(1970, 1, 1, 0, 0, 0, 0, isUtc());
     int msSince1970 = this.difference(unixTimeStart).inMilliseconds;
     // Adjust the milliseconds to avoid problems with summer-time.
     if (hours < 2) {
       msSince1970 += 2 * Duration.MILLISECONDS_PER_HOUR;
     }
     // Compute the floor of msSince1970 / Duration.MS_PER_DAY.
     int daysSince1970;
     if (msSince1970 >= 0) {
       daysSince1970 = msSince1970 ~/ Duration.MILLISECONDS_PER_DAY;
     } else {
       daysSince1970 = (msSince1970 - Duration.MILLISECONDS_PER_DAY + 1) ~/
                       Duration.MILLISECONDS_PER_DAY;
     }
     // 1970-1-1 was a Thursday.
     return ((daysSince1970 + Date.THU) % Date.DAYS_IN_WEEK);
   }
 
-  bool isLocalTime() {
-    return !timeZone.isUtc;
-  }
-
-  bool isUtc() {
-    return timeZone.isUtc;
-  }
+  bool isUtc() => _isUtc;
 
   String toString() {
     String fourDigits(int n) {
       int absN = n.abs();
       String sign = n < 0 ? "-" : "";
       if (absN >= 1000) return "$n";
       if (absN >= 100) return "${sign}0$absN";
       if (absN >= 10) return "${sign}00$absN";
       if (absN >= 1) return "${sign}000$absN";
     }
     String threeDigits(int n) {
       if (n >= 100) return "${n}";
       if (n >= 10) return "0${n}";
       return "00${n}";
     }
     String twoDigits(int n) {
       if (n >= 10) return "${n}";
       return "0${n}";
     }
 
     String y = fourDigits(year);
     String m = twoDigits(month);
     String d = twoDigits(day);
     String h = twoDigits(hours);
     String min = twoDigits(minutes);
     String sec = twoDigits(seconds);
     String ms = threeDigits(milliseconds);
-    if (timeZone.isUtc) {
+    if (isUtc()) {
       return "$y-$m-$d $h:$min:$sec.${ms}Z";
     } else {
       return "$y-$m-$d $h:$min:$sec.$ms";
     }
   }
 
   // Adds the [duration] to this Date instance.
   Date add(Duration duration) {
     return new DateImplementation.fromEpoch(value + duration.inMilliseconds,
-                                            timeZone);
+                                            isUtc());
   }
 
   // Subtracts the [duration] from this Date instance.
   Date subtract(Duration duration) {
     return new DateImplementation.fromEpoch(value - duration.inMilliseconds,
-                                            timeZone);
+                                            isUtc());
   }
 
   // Returns a [Duration] with the difference of [this] and [other].
   Duration difference(Date other) {
     return new DurationImplementation(milliseconds: value - other.value);
   }
 
-  final int value;
-  final TimeZoneImplementation timeZone;
-
-  static final int _SECONDS_YEAR_2035 = 2051222400;
-
   // Returns the UTC year for the corresponding [secondsSinceEpoch].
   // It is relatively fast for values in the range 0 to year 2098.
   // Code is adapted from V8.
   static int _yearsFromSecondsSinceEpoch(int secondsSinceEpoch) {
     final int DAYS_IN_4_YEARS = 4 * 365 + 1;
     final int DAYS_IN_100_YEARS = 25 * DAYS_IN_4_YEARS - 1;
     final int DAYS_IN_400_YEARS = 4 * DAYS_IN_100_YEARS + 1;
     final int DAYS_1970_TO_2000 = 30 * 365 + 7;
     final int DAYS_OFFSET = 1000 * DAYS_IN_400_YEARS + 5 * DAYS_IN_400_YEARS -
                             DAYS_1970_TO_2000;
@@ skipping 113 matching lines @@
     } else {
       equivalentYear = years;
       offsetInSeconds = 0;
     }
     int secondsSinceEpoch = _brokenDownDateToSecondsSinceEpoch(
         equivalentYear, month, day, hours, minutes, seconds, isUtc);
     int adjustedSeconds = secondsSinceEpoch + offsetInSeconds;
     return adjustedSeconds * Duration.MILLISECONDS_PER_SECOND + milliseconds;
   }
 
+  final bool _isUtc;
+  final int value;
+
+
   // Natives
   static _brokenDownDateToSecondsSinceEpoch(
       int years, int month, int day, int hours, int minutes, int seconds,
       bool isUtc) native "DateNatives_brokenDownToSecondsSinceEpoch";
 
   static int _getCurrentMs() native "DateNatives_currentTimeMillis";
 
   static String _timeZoneName(int secondsSinceEpoch)
       native "DateNatives_timeZoneName";
 
@@ skipping 13 matching lines @@
 
   static int _getHours(int secondsSinceEpoch, bool isUtc)
       native "DateNatives_getHours";
 
   static int _getMinutes(int secondsSinceEpoch, bool isUtc)
       native "DateNatives_getMinutes";
 
   static int _getSeconds(int secondsSinceEpoch, bool isUtc)
       native "DateNatives_getSeconds";
 }