Make RangeError.toString use the name field that it inherits from ArgumentError.

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");
 
+  // Helper functions for toString overridden in subclasses.
+  String get _errorName => "Invalid argument${name == null ? "(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 (invalidValue == null) 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) {
       if (name == null) name = "index";
       throw new RangeError.index(index, indexable, name, message, length);
     }
   }
 
@@ skipping 25 matching lines @@
 
   /**
    * 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";
+    var explanation = ": index should be less than $length";
     if (invalidValue < 0) {
-      explanation = "index must not be negative";
+      explanation = ": index must not be negative";
     }
-    return "RangeError: $message ($target[$invalidValue]): $explanation";
+    return explanation;
   }
 }
 
 
 /**
  * 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";
 }