Rename Invocation to InvocationMirror.

dart/tests/language/invocation_mirror_test.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.
 
 import "package:expect/expect.dart";
 
-// InvocationMirror and noSuchMethod testing.
+// Invocation and noSuchMethod testing.
 
 /** Class with noSuchMethod that returns the mirror */
 class N {
   // Storage for the last argument to noSuchMethod.
   // Needed for setters, which don't evaluate to the return value.
   var last;
-  noSuchMethod(InvocationMirror m) => last = m;
+  noSuchMethod(Invocation m) => last = m;
 
   flif(int x) { Expect.fail("never get here"); }
   flaf([int x]) { Expect.fail("never get here"); }
   flof({int y}) { Expect.fail("never get here"); }
 
   get wut => this;
   final int plif = 99;
   int get plaf { Expect.fail("never get here"); return 0; }
 }
 
 /** As [N] but also implements 'call', so we can call it with wrong arguments.*/
 class C extends N {
   call(int x) { Expect.fail("never get here"); }
 }
 
 /**
- * Checks the data of an InvocationMirror.
+ * Checks the data of an Invocation.
  *
  * Call without optionals for getters, with only positional for setters,
  * and with both optionals for everything else.
  */
-testInvocationMirror(InvocationMirror im, String name,
+testInvocationMirror(Invocation im, String name,
                      [List positional, Map named]) {
-  Expect.isTrue(im is InvocationMirror, "is InvocationMirror");
+  Expect.isTrue(im is Invocation, "is Invocation");
   Expect.equals(name, im.memberName, "name");
   if (named == null) {
     Expect.isTrue(im.isAccessor, "$name:isAccessor");
     Expect.isFalse(im.isMethod, "$name:isMethod");
     if (positional == null) {
       Expect.isTrue(im.isGetter, "$name:isGetter");
       Expect.isFalse(im.isSetter, "$name:isSetter");
       Expect.equals(0, im.positionalArguments.length, "$name:#positional");
       Expect.equals(0, im.namedArguments.length, "$name:#named");
       return;
@@ skipping 96 matching lines @@
   // Closurizing a method means that calling it badly will not hit the
   // original receivers noSuchMethod, only the one inherited from Object
   // by the closure object.
   Expect.throws(() { var x = n.flif; x(37, 42); },
                 (e) => e is NoSuchMethodError);
   Expect.throws(() { var x = c.call; x(37, 42); },
                 (e) => e is NoSuchMethodError);
 }
 
 class M extends N {
-  noSuchMethod(InvocationMirror m) { throw "never get here"; }
+  noSuchMethod(Invocation m) { throw "never get here"; }
 
   testSuperCalls() {
     // Missing property/method access.
     testInvocationMirror(super.bar, 'bar');
     testInvocationMirror((){super.bar = 42; return last;}(), 'bar=', [42]);
     testInvocationMirror(super.bar(), 'bar', [], {});
     testInvocationMirror(super.bar(42), 'bar', [42], {});
     testInvocationMirror(super.bar(x: 42), 'bar', [], {"x": 42});
     testInvocationMirror(super.bar(37, x: 42), 'bar', [37], {"x": 42});
 
@@ skipping 71 matching lines @@
   test(() => o.hashCode = 42);
   test(() => o.hashCode());  // Thrown by int.noSuchMethod.
   test(() => (n.flif)());  // Extracted method has no noSuchMethod.
 }
 
 main() {
   testInvocationMirrors();
   testNoSuchMethodErrors();
   new M().testSuperCalls();
 }