Update core/errors.dart

tool/input_sdk/lib/core/errors.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.
 
 part of dart.core;
 
 /**
  * Error objects thrown in the case of a program failure.
  *
  * An `Error` object represents a program failure that the programmer
@@ skipping 139 matching lines @@
    *
    *    "Invalid argument (foo): null"
    *
    * The `name` should match the argument name of the function, but if
    * the function is a method implementing an interface, and its argument
    * names differ from the interface, it might be more useful to use the
    * interface method's argument name (or just rename arguments to match).
    */
   ArgumentError.value(value,
                       [String this.name,
-                       String this.message = "Invalid argument"])
+                       String this.message])
       : invalidValue = value,
         _hasValue = true;
 
   /**
    * Create an argument error for a `null` argument that must not be `null`.
-   *
-   * Shorthand for calling [ArgumentError.value] with a `null` value and a
-   * message of `"Must not be null"`.
    */
-  ArgumentError.notNull([String name])
-      : this.value(null, name, "Must not be null");
+  ArgumentError.notNull([this.name])
+      : _hasValue = false,
+        message = "Must not be null",
+        invalidValue = null;
+
+  // Helper functions for toString overridden in subclasses.
+  String get _errorName => "Invalid argument${!_hasValue ? "(s)" : ""}";
+  String get _errorExplanation => "";
 
   String toString() {
-    if (!_hasValue) {
-      var result = "Invalid arguments(s)";
-      if (message != null) {
-        result = "$result: $message";
-      }
-      return result;
-    }
     String nameString = "";
     if (name != null) {
       nameString = " ($name)";
     }
-    return "$message$nameString: ${Error.safeToString(invalidValue)}";
+    var message = (this.message == null) ? "" : ": ${this.message}";
+    String prefix = "$_errorName$nameString$message";
+    if (!_hasValue) return prefix;
+    // If we know the invalid value, we can try to describe the problem.
+    String explanation = _errorExplanation;
+    String errorValue = Error.safeToString(invalidValue);
+    return "$prefix$explanation: $errorValue";
   }
 }
 
 /**
  * Error thrown due to an index being outside a valid range.
  */
 class RangeError extends ArgumentError {
   /** The minimum value that [value] is allowed to assume. */
   final num start;
   /** The maximum value that [value] is allowed to assume. */
@@ skipping 71 matching lines @@
 
   /**
    * Check that a value is a valid index into an indexable object.
    *
    * Throws if [index] is not a valid index into [indexable].
    *
    * An indexable object is one that has a `length` and a and index-operator
    * `[]` that accepts an index if `0 <= index < length`.
    *
    * If [length] is provided, it is used as the length of the indexable object,
-   * otherwise the length is found as `idexable.length`.
+   * otherwise the length is found as `indexable.length`.
    */
   static void checkValidIndex(int index, var indexable,
                               [String name, int length, String message]) {
     if (length == null) length = indexable.length;
-    if (index < 0 || index >= length) {
+    // Comparing with `0` as receiver produces better dart2js type inference.
+    if (0 > index || index >= length) {
       if (name == null) name = "index";
       throw new RangeError.index(index, indexable, name, message, length);
     }
   }
 
   /**
    * Check that a range represents a slice of an indexable object.
    *
    * Throws if the range is not valid for an indexable object with
    * the given [length].
    * A range is valid for an indexable object with a given [length]
    *
    * if `0 <= [start] <= [end] <= [length]`.
    * An `end` of `null` is considered equivalent to `length`.
    *
    * The [startName] and [endName] defaults to `"start"` and `"end"`,
    * respectively.
+   *
+   * Returns the actual `end` value, which is `length` if `end` is `null`,
+   * and `end` otherwise.
    */
-  static void checkValidRange(int start, int end, int length,
+  static int checkValidRange(int start, int end, int length,
                               [String startName, String endName,
                                String message]) {
-    if (start < 0 || start > length) {
+    // Comparing with `0` as receiver produces better dart2js type inference.
+    // Ditto `start > end` below.
+    if (0 > start || start > length) {
       if (startName == null) startName = "start";
       throw new RangeError.range(start, 0, length, startName, message);
     }
-    if (end != null && (end < start || end > length)) {
-      if (endName == null) endName = "end";
-      throw new RangeError.range(end, start, length, endName, message);
+    if (end != null) {
+      if (start > end || end > length) {
+        if (endName == null) endName = "end";
+        throw new RangeError.range(end, start, length, endName, message);
+      }
+      return end;
     }
+    return length;
   }
 
   /**
    * Check that an integer value isn't negative.
    *
    * Throws if the value is negative.
    */
   static void checkNotNegative(int value, [String name, String message]) {
     if (value < 0) throw new RangeError.range(value, 0, null, name, message);
   }
 
-  String toString() {
-    if (!_hasValue) return "RangeError: $message";
-    String value = Error.safeToString(invalidValue);
+  String get _errorName => "RangeError";
+  String get _errorExplanation {
+    assert(_hasValue);
     String explanation = "";
     if (start == null) {
       if (end != null) {
         explanation = ": Not less than or equal to $end";
       }
       // If both are null, we don't add a description of the limits.
     } else if (end == null) {
       explanation = ": Not greater than or equal to $start";
     } else if (end > start) {
-      explanation = ": Not in range $start..$end, inclusive.";
+      explanation = ": Not in range $start..$end, inclusive";
     } else if (end < start) {
       explanation = ": Valid value range is empty";
     } else {
       // end == start.
       explanation = ": Only valid value is $start";
     }
-    return "RangeError: $message ($value)$explanation";
+    return explanation;
   }
 }
 
 /**
  * A specialized [RangeError] used when an index is not in the range
  * `0..indexable.length-1`.
  *
  * Also contains the indexable object, its length at the time of the error,
  * and the invalid index itself.
  */
@@ skipping 16 matching lines @@
              [String name, String message, int length])
       : this.indexable = indexable,
         this.length = (length != null) ? length : indexable.length,
         super.value(invalidValue, name,
                     (message != null) ? message : "Index out of range");
 
   // Getters inherited from RangeError.
   int get start => 0;
   int get end => length - 1;
 
-  String toString() {
+  String get _errorName => "RangeError";
+  String get _errorExplanation {
     assert(_hasValue);
-    String target = Error.safeToString(indexable);
-    var explanation = "index should be less than $length";
     if (invalidValue < 0) {
-      explanation = "index must not be negative";
+      return ": index must not be negative";
     }
-    return "RangeError: $message ($target[$invalidValue]): $explanation";
+    if (length == 0) {
+      return ": no indices are valid";
+    }
+    return ": index should be less than $length";
   }
 }
 
 
 /**
  * Error thrown when control reaches the end of a switch case.
  *
  * The Dart specification requires this error to be thrown when
  * control reaches the end of a switch case (except the last case
  * of a switch) without meeting a break or similar end of the control
@@ skipping 151 matching lines @@
  * the first time it is read. If evaluating the initializer expression causes
  * another read of the variable, this error is thrown.
  */
 class CyclicInitializationError extends Error {
   final String variableName;
   CyclicInitializationError([this.variableName]);
   String toString() => variableName == null
       ? "Reading static variable during its initialization"
       : "Reading static variable '$variableName' during its initialization";
 }