Better messages for optimized index errors.

sdk/lib/_internal/compiler/js_lib/js_helper.dart

 // Copyright (c) 2013, 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.
 
 library _js_helper;
 
 import 'dart:_async_await_error_codes' as async_error_codes;
 
 import 'dart:_js_embedded_names' show
     DEFERRED_LIBRARY_URIS,
@@ skipping 1370 matching lines @@
   static void update(cache, String key, value) {
     JS('void', '#[#] = #', cache, key, value);
   }
 }
 
 /**
  * Called by generated code to throw an illegal-argument exception,
  * for example, if a non-integer index is given to an optimized
  * indexed access.
  */
+@NoInline()
 iae(argument) {
   throw _argumentError(argument);
 }
 
 /**
- * Called by generated code to throw an index-out-of-range exception,
- * for example, if a bounds check fails in an optimized indexed
- * access.  This may also be called when the index is not an integer, in
- * which case it throws an illegal-argument exception instead, like
- * [iae], or when the receiver is null.
+ * Called by generated code to throw an index-out-of-range exception, for
+ * example, if a bounds check fails in an optimized indexed access.  This may
+ * also be called when the index is not an integer, in which case it throws an
+ * illegal-argument exception instead, like [iae], or when the receiver is null.
  */
+@NoInline()
 ioore(receiver, index) {
   if (receiver == null) receiver.length; // Force a NoSuchMethodError.
-  if (index is !int) iae(index);
-  throw new RangeError.value(index);
+  throw diagnoseIndexError(receiver, index);
 }
 
+/**
+ * Diagnoses an indexing error. Returns the ArgumentError or RangeError that
+ * describes the problem.
+ */
+@NoInline()
+Error diagnoseIndexError(indexable, index) {
+  if (index is !int) return new ArgumentError.value(index, 'index');
+  int length = indexable.length;
+  // The following returns the same error that would be thrown by calling
+  // [RangeError.checkValidIndex] with no optional parameters provided.
+  if (index < 0 || index >= length) {
+    return new RangeError.index(index, indexable, 'index', null, length);
+  }
+  // The above should always match, but if it does not, use the following.
+  return new RangeError.value(index, 'index');
+}
+
+
 stringLastIndexOfUnchecked(receiver, element, start)
   => JS('int', r'#.lastIndexOf(#, #)', receiver, element, start);
 
 
 /// 'factory' for constructing ArgumentError.value to keep the call sites small.
 @NoInline()
 ArgumentError _argumentError(object) {
   return new ArgumentError.value(object);
 }
 
@@ skipping 590 matching lines @@
     // nothing.
     return saveStackTrace(
         new UnknownJsTypeError(message is String ? message : ''));
   }
 
   if (JS('bool', r'# instanceof RangeError', ex)) {
     if (message is String && contains(message, 'call stack')) {
       return new StackOverflowError();
     }
 
-    // In general, a RangeError is thrown when trying to pass a number
-    // as an argument to a function that does not allow a range that
-    // includes that number.
-    return saveStackTrace(new ArgumentError());
+    // In general, a RangeError is thrown when trying to pass a number as an
+    // argument to a function that does not allow a range that includes that
+    // number. Translate to a Dart ArgumentError with the same message.
+    // TODO(sra): Translate to RangeError.
+    String message = tryStringifyException(ex);
+    if (message is String) {
+      message = JS('String', r'#.replace(/^RangeError:\s*/, "")', message);
+    }
+    return saveStackTrace(new ArgumentError(message));
   }
 
   // Check for the Firefox specific stack overflow signal.
   if (JS('bool',
          r'typeof InternalError == "function" && # instanceof InternalError',
          ex)) {
     if (message is String && message == 'too much recursion') {
       return new StackOverflowError();
     }
   }
 
   // Just return the exception. We should not wrap it because in case
   // the exception comes from the DOM, it is a JavaScript
   // object backed by a native Dart class.
   return ex;
 }
 
+String tryStringifyException(ex) {
+  // Since this function is called from [unwrapException] which is called from
+  // code injected into a catch-clause, use JavaScript try-catch to avoid a
+  // potential loop if stringifying crashes.
+  return JS('String|Null', r'''
+    (function(ex) {
+      try {
+        return String(ex);
+      } catch (e) {}
+      return null;
+    })(#)
+    ''', ex);
+}
+
 /**
  * Called by generated code to fetch the stack trace from an
  * exception. Should never return null.
  */
 StackTrace getTraceFromException(exception) {
   if (exception is ExceptionAndStackTrace) {
     return exception.stackTrace;
   }
   if (exception == null) return new _StackTrace(exception);
   _StackTrace trace = JS('_StackTrace|Null', r'#.$cachedTrace', exception);
@@ skipping 2043 matching lines @@
   // This is a function that will return a helper function that does the
   // iteration of the sync*.
   //
   // Each invocation should give a body with fresh state.
   final dynamic /* js function */ _outerHelper;
 
   SyncStarIterable(this._outerHelper);
 
   Iterator get iterator => new SyncStarIterator(JS('', '#()', _outerHelper));
 }