Add some ArgumentError and RangeError constructors that capture more information.

tools/dom/scripts/systemnative.py

 #!/usr/bin/python
 # 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.
 
 """This module provides shared functionality for the systems to generate
 native binding from the IDL database."""
 
 import emitter
 import os
@@ skipping 346 matching lines @@
   arr_match = array_type(t)
   if arr_match is not None:
     t = EncodeType(arr_match)
     return "A_%s_A" % t
 
   return _type_encoding_map.get(t) or t
 
 class DartiumBackend(HtmlDartGenerator):
   """Generates Dart implementation for one DOM IDL interface."""
 
-  def __init__(self, interface, 
+  def __init__(self, interface,
                cpp_library_emitter, options):
     super(DartiumBackend, self).__init__(interface, options, True)
 
     self._interface = interface
     self._cpp_library_emitter = cpp_library_emitter
     self._database = options.database
     self._template_loader = options.templates
     self._type_registry = options.type_registry
     self._interface_type_info = self._type_registry.TypeInfo(self._interface.id)
     self._metadata = options.metadata
@@ skipping 287 matching lines @@
     self._members_emitter.Emit(
         '\n  $(ANNOTATIONS)factory $CTOR($PARAMS) => _create($FACTORY_PARAMS);\n',
         ANNOTATIONS=annotations,
         CTOR=constructor_info._ConstructorFullName(self._DartType),
         PARAMS=constructor_info.ParametersAsDeclaration(self._DartType),
         FACTORY_PARAMS= \
             constructor_info.ParametersAsArgumentList())
 
     constructor_callback_cpp_name = 'constructorCallback'
     self._EmitConstructorInfrastructure(
-        constructor_info, "", constructor_callback_cpp_name, '_create', 
+        constructor_info, "", constructor_callback_cpp_name, '_create',
         is_custom=True)
 
     self._cpp_declarations_emitter.Emit(
         '\n'
         'void $CPP_CALLBACK(Dart_NativeArguments);\n',
         CPP_CALLBACK=constructor_callback_cpp_name)
 
     return True
 
   def IsConstructorArgumentOptional(self, argument):
     return IsOptional(argument)
 
   def EmitStaticFactoryOverload(self, constructor_info, name, arguments):
-    constructor_callback_cpp_name = name + 'constructorCallback'  
+    constructor_callback_cpp_name = name + 'constructorCallback'
     self._EmitConstructorInfrastructure(
-        constructor_info, name, 'constructorCallback', name, arguments, 
-        emit_to_native=True, 
+        constructor_info, name, 'constructorCallback', name, arguments,
+        emit_to_native=True,
         is_custom=False)
 
     ext_attrs = self._interface.ext_attrs
 
     create_function = 'create'
     if 'NamedConstructor' in ext_attrs:
       create_function = 'createForJSConstructor'
     function_expression = '%s::%s' % (self._interface_type_info.native_type(), create_function)
     self._GenerateNativeCallback(
         constructor_callback_cpp_name,
@@ skipping 338 matching lines @@
 
       # Emit the method which calls the toplevel function, along with
       # the [] operator.
       dart_qualified_name = \
           self.DeriveQualifiedBlinkName(self._interface.id,
                                         dart_native_name)
       self._members_emitter.Emit(
           '\n'
           '  $TYPE operator[](int index) {\n'
           '    if (index < 0 || index >= length)\n'
-          '      throw new RangeError.range(index, 0, length);\n'
+          '      throw new RangeError.index(index, this);\n'
           '    return $(DART_NATIVE_NAME)(this, index);\n'
           '  }\n\n'
           '  $TYPE _nativeIndexedGetter(int index) =>'
           ' $(DART_NATIVE_NAME)(this, index);\n',
           DART_NATIVE_NAME=dart_qualified_name,
           TYPE=self.SecureOutputType(element_type),
           INTERFACE=self._interface.id)
 
     if self._HasNativeIndexSetter():
       self._EmitNativeIndexSetter(dart_element_type)
@@ skipping 37 matching lines @@
     return any(op.id == 'getItem' for op in self._interface.operations)
 
   def _EmitExplicitIndexedGetter(self, dart_element_type):
     if any(op.id == 'getItem' for op in self._interface.operations):
       indexed_getter = 'getItem'
 
     self._members_emitter.Emit(
         '\n'
         '  $TYPE operator[](int index) {\n'
         '    if (index < 0 || index >= length)\n'
-        '      throw new RangeError.range(index, 0, length);\n'
+        '      throw new RangeError.index(index, this);\n'
         '    return $INDEXED_GETTER(index);\n'
         '  }\n',
         TYPE=dart_element_type,
         INDEXED_GETTER=indexed_getter)
 
   def _HasNativeIndexSetter(self):
     return 'CustomIndexedSetter' in self._interface.ext_attrs
 
   def _EmitNativeIndexSetter(self, element_type):
     return_type = 'void'
     formals = ', '.join(['int index', '%s value' % element_type])
     parameters = ['index', 'value']
     dart_declaration = 'void operator[]=(%s)' % formals
-    self._GenerateNativeBinding('numericIndexSetter', 3, 
+    self._GenerateNativeBinding('numericIndexSetter', 3,
       dart_declaration, False, return_type, parameters,
       'Callback', True, False)
 
   def EmitOperation(self, info, html_name):
     """
     Arguments:
       info: An OperationInfo object.
     """
     return_type = self.SecureOutputType(info.type_name, False, True)
     formals = info.ParametersAsDeclaration(self._DartType)
@@ skipping 773 matching lines @@
 
 def _IsCustom(op_or_attr):
   assert(isinstance(op_or_attr, IDLMember))
   return 'Custom' in op_or_attr.ext_attrs or 'DartCustom' in op_or_attr.ext_attrs
 
 def _IsCustomValue(op_or_attr, value):
   if _IsCustom(op_or_attr):
     return op_or_attr.ext_attrs.get('Custom') == value \
            or op_or_attr.ext_attrs.get('DartCustom') == value
   return False