Revert "Change signature of noSuchMethod to take an InvocationMirror."

lib/compiler/implementation/lib/js_helper.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.
 
 #library('dart:_js_helper');
 
 #import('dart:coreimpl');
 #import('dart:collection');
 
 #source('constant_map.dart');
@@ skipping 335 matching lines @@
   ListIterator(List<T> this.list) : i = 0;
   bool get hasNext => i < JS('int', r'#.length', list);
   T next() {
     if (!hasNext) throw new StateError("No more elements");
     var value = JS('Object', r'#[#]', list, i);
     i += 1;
     return value;
   }
 }
 
-createInvocationMirror(name, internalName, type, arguments, argumentNames) =>
-    new JSInvocationMirror(name, internalName, type, arguments, argumentNames);
-
-class JSInvocationMirror implements InvocationMirror {
-  static const METHOD = 0;
-  static const GETTER = 1;
-  static const SETTER = 2;
-
-  final String memberName;
-  final String _internalName;
-  final int _kind;
-  final List _arguments;
-  final List _namedArgumentNames;
-  /** Map from argument name to index in _arguments. */
-  Map<String,dynamic> _namedIndices = null;
-
-  JSInvocationMirror(this.memberName,
-                     this._internalName,
-                     this._kind,
-                     this._arguments,
-                     this._namedArgumentNames);
-
-  bool get isMethod => _kind == METHOD;
-  bool get isGetter => _kind == GETTER;
-  bool get isSetter => _kind == SETTER;
-  bool get isAccessor => _kind != METHOD;
-
-  List get positionalArguments {
-    if (isGetter) return null;
-    var list = [];
-    var argumentCount =
-        _arguments.length - _namedArgumentNames.length;
-    for (var index = 0 ; index < argumentCount ; index++) {
-      list.add(_arguments[index]);
-    }
-    return list;
-  }
-
-  Map<String,dynamic> get namedArguments {
-    if (isAccessor) return null;
-    var map = <String,dynamic>{};
-    int namedArgumentCount = _namedArgumentNames.length;
-    int namedArgumentsStartIndex = _arguments.length - namedArgumentCount;
-    for (int i = 0; i < namedArgumentCount; i++) {
-      map[_namedArgumentNames[i]] = _arguments[namedArgumentsStartIndex + i];
-    }
-    return map;
-  }
-
-  invokeOn(Object object) {
-    List arguments = _arguments;
-    if (!isJsArray(arguments)) arguments = new List.from(arguments);
-    return JS("var", "#[#].apply(#, #)",
-              object, _internalName, object, arguments);
-  }
-}
-
 class Primitives {
   static int hashCodeSeed = 0;
 
   static int objectHashCode(object) {
     int hash = JS('var', r'#.$identityHash', object);
     if (hash == null) {
       // TOOD(ahe): We should probably randomize this somehow.
       hash = ++hashCodeSeed;
       JS('void', r'#.$identityHash = #', object, hash);
     }
@@ skipping 275 matching lines @@
       JS('void', '#.sort()', listOfNamedArguments);
       listOfNamedArguments.forEach((String name) {
         buffer.add('\$$name');
         arguments.add(namedArguments[name]);
       });
     }
 
     String selectorName = 'call\$$argumentCount$buffer';
     var jsFunction = JS('var', '#[#]', function, selectorName);
     if (jsFunction == null) {
-      throw new NoSuchMethodError(function, selectorName, arguments, {});
+      throw new NoSuchMethodError(function, selectorName, arguments);
     }
     // We bound 'this' to [function] because of how we compile
     // closures: escaped local variables are stored and accessed through
     // [function].
     return JS('var', '#.apply(#, #)', jsFunction, function, arguments);
   }
 }
 
 /**
  * Called by generated code to throw an illegal-argument exception,
@@ skipping 220 matching lines @@
     // allow us to get very detailed information about what kind of
     // exception occurred.
     var type = JS('var', r'#.type', ex);
     var name = JS('var', r'#.arguments ? #.arguments[0] : ""', ex, ex);
     if (type == 'property_not_function' ||
         type == 'called_non_callable' ||
         type == 'non_object_property_call' ||
         type == 'non_object_property_load') {
       return new NullPointerException();
     } else if (type == 'undefined_method') {
-      return new NoSuchMethodError('', name, [], {});
+      return new NoSuchMethodError('', name, []);
     }
 
     var ieErrorCode = JS('int', '#.number & 0xffff', ex);
     var ieFacilityNumber = JS('int', '#.number>>16 & 0x1FFF', ex);
     // If we cannot use [type] to determine what kind of exception
     // we're dealing with we fall back on looking at the exception
     // message if it is available and a string.
     if (message is String) {
       if (message.endsWith('is null') ||
           message.endsWith('is undefined') ||
           message.endsWith('is null or undefined')) {
         return new NullPointerException();
       } else if (message.contains(' is not a function') ||
                  (ieErrorCode == 438 && ieFacilityNumber == 10)) {
         // Examples:
         //  x.foo is not a function
         //  'undefined' is not a function (evaluating 'x.foo(1,2,3)')
         // Object doesn't support property or method 'foo' which sets the error
         // code 438 in IE.
         // TODO(kasperl): Compute the right name if possible.
-        return new NoSuchMethodError('', '<unknown>', [], {});
+        return new NoSuchMethodError('', '<unknown>', []);
       }
     }
 
     // If we cannot determine what kind of error this is, we fall back
     // to reporting this as a generic exception. It's probably better
     // than nothing.
     return new Exception(message is String ? message : '');
   }
 
   if (JS('bool', r'# instanceof RangeError', ex)) {
@@ skipping 446 matching lines @@
   // Compare to true to avoid boolean conversion check in checked
   // mode.
   if (!identical(condition, true)) throw new AssertionError();
 }
 
 /**
  * Called by generated code when a method that must be statically
  * resolved cannot be found.
  */
 void throwNoSuchMethod(obj, name, arguments, expectedArgumentNames) {
-  throw new NoSuchMethodError(obj, name, arguments, const {},
-                              expectedArgumentNames);
+  throw new NoSuchMethodError(obj, name, arguments, expectedArgumentNames);
 }
 
 /**
  * Called by generated code when a static field's initializer references the
  * field that is currently being initialized.
  */
 void throwCyclicInit(String staticName) {
   throw new RuntimeError("Cyclic initialization for static $staticName");
 }
 
@@ skipping 11 matching lines @@
     JS('void', r'#.runtimeTypeCache[#] = #', JS_CURRENT_ISOLATE(), key,
        runtimeType);
   }
   return runtimeType;
 }
 
 String getRuntimeTypeString(var object) {
   var typeInfo = JS('Object', r'#.builtin$typeInfo', object);
   return JS('String', r'#.runtimeType', typeInfo);
 }