Implement the invoke methods (invoke, getField, setField, newInstance, apply) as internal natives.

tests/lib/mirrors/mirrors_test.dart

 // Copyright (c) 2011, 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.
 
-// TODO(rmacnak): Move the existing mirror tests here (a place for
-// cross-implementation tests).
-
 library MirrorsTest;
 import "dart:mirrors";
 import "../../../pkg/unittest/lib/unittest.dart";
 
 var topLevelField;
+u(a, b, c) => {"a": a, "b": b, "c": c};
+_v(a, b) => a + b;
 
 class Class<T> {
   Class() { this.field = "default value"; }
   Class.withInitialValue(this.field);
   var field;
+
+  Class.generative(this.field);
+  Class.redirecting(y) : this.generative(y*2);
+  factory Class.faktory(y) => "FakeClass $y";
+  factory Class.redirectingFactory(y) = Class.faktory;
+
+  m(a, b, c) => {"a": a, "b": b, "c": c};
+  _n(a, b) => a + b;
+  noSuchMethod(invocation) => "DNU";
+
   static var staticField;
-  m(a, b, c) => {"a": a, "b": b, "c": c};
+  static s(a, b, c) => {"a": a, "b": b, "c": c};
+  static _t(a, b) => a + b;
 }
 
 typedef Typedef();
 
-testInvoke(mirrors) {
+testInvoke(mirrors, isDart2js) {
   var instance = new Class();
   var instMirror = reflect(instance);
 
   expect(instMirror.invoke(const Symbol("m"),['A', 'B', instance]).reflectee,
          equals({"a": 'A', "b":'B', "c": instance}));
+  expect(instMirror.invoke(const Symbol("notDefined"), []).reflectee,

[ahe, 2013/07/16 10:40:47]

It would be great if you could avoid making further modifications to this test.

Instead, prefer writing small tests that test a specific part of the mirror API,
much like the tests I have added to this directory.

Big tests tend to take longer to run.  Eventually, a large test will test so
much that it starts timing out.  Also, if a part of a big test is broken, you
lose all test coverage when you mark it as failing.  So in general, we prefer
small tests.

Also, you should avoid using the unittest framework in new tests.  It is likely
that the unittest framework will start relying more and more on reflection. 
This means we will have a hard time testing the mirror API.

Also, when you modified this test, something unexpected happened: it started
passing in dart2js' CSP mode.  I have no idea why that is, but clearly there was
something in the old version that caused problems.  That is another reason to
avoid modifying existing tests.

+         equals("DNU"));
+  expect(instMirror.invoke(const Symbol("m"), []).reflectee,
+         equals("DNU"));  // Wrong arity.
+  // TODO(rmacnak): Implement access to private members. 
+  // expect(instMirror.invoke(const Symbol("_n"), [3, 4]).reflectee,
+  //        equals(7));
+
+  if (isDart2js) return;
+
+  var classMirror = instMirror.type;
+  expect(classMirror.invoke(const Symbol("s"),['A', 'B', instance]).reflectee,
+         equals({"a": 'A', "b":'B', "c": instance}));
+  expect(() => classMirror.invoke(const Symbol("notDefined"), []).reflectee,
+         throws);
+  expect(() => classMirror.invoke(const Symbol("s"), []).reflectee,
+         throws);  // Wrong arity.
+  // TODO(rmacnak): Implement access to private members.
+  // expect(classMirror.invoke(const Symbol("_t"), [3, 4]).reflectee,
+  //        equals(7));
+
+  var libMirror = classMirror.owner;
+  expect(libMirror.invoke(const Symbol("u"),['A', 'B', instance]).reflectee,
+         equals({"a": 'A', "b":'B', "c": instance}));
+  expect(() => libMirror.invoke(const Symbol("notDefined"), []).reflectee,
+         throws);
+  expect(() => libMirror.invoke(const Symbol("u"), []).reflectee,
+         throws);  // Wrong arity.
+  // NB: This works on the VM but fails at compile-time on dart2js.
+  // expect(libMirror.invoke(const Symbol("_v"), [3, 4]).reflectee,
+  //        equals(7));
 }
 
 testInstanceFieldAccess(mirrors) {
   var instance = new Class();
   var instMirror = reflect(instance);
 
   instMirror.setFieldAsync(const Symbol('field'), 44);
   instMirror.getFieldAsync(const Symbol('field')).then(
       expectAsync1((resultMirror) {
         expect(resultMirror.reflectee, equals(44));
@@ skipping 75 matching lines @@
   expect(funcMirror.parameters.length, equals(3));
 
   expect(mirror.apply([7, 8, 9]).reflectee, equals(24));
 
   var future = mirror.applyAsync([2, 4, 8]);
   future.then(expectAsync1((resultMirror) {
     expect(resultMirror.reflectee, equals(14));
   }));
 }
 
-testInvokeConstructor(mirrors) {
+testInvokeConstructor(mirrors, isDart2js) {
   var classMirror = reflectClass(Class);
 
   var instanceMirror = classMirror.newInstance(const Symbol(''),[]);
   expect(instanceMirror.reflectee is Class, equals(true));
   expect(instanceMirror.reflectee.field, equals("default value"));
 
   instanceMirror = classMirror.newInstance(const Symbol('withInitialValue'),
                                            [45]);
   expect(instanceMirror.reflectee is Class, equals(true));
   expect(instanceMirror.reflectee.field, equals(45));
 
+
+  instanceMirror = classMirror.newInstance(const Symbol('generative'),
+                                           [7]);
+  expect(instanceMirror.reflectee is Class, equals(true));
+  expect(instanceMirror.reflectee.field, equals(7));
+
+  instanceMirror = classMirror.newInstance(const Symbol('redirecting'),
+                                           [8]);
+  expect(instanceMirror.reflectee is Class, equals(true));
+  expect(instanceMirror.reflectee.field, equals(16));
+
+
+  if (!isDart2js) {
+    instanceMirror = classMirror.newInstance(const Symbol('faktory'),
+                                             [9]);
+    expect(instanceMirror.reflectee, equals('FakeClass 9'));
+
+    instanceMirror = classMirror.newInstance(const Symbol('redirectingFactory'),
+                                             [10]);
+    expect(instanceMirror.reflectee, equals('FakeClass 10'));
+  }
+
+
   var future = classMirror.newInstanceAsync(const Symbol(''), []);
   future.then(expectAsync1((resultMirror) {
     var instance = resultMirror.reflectee;
     expect(instance is Class, equals(true));
     expect(instance.field, equals("default value"));
   }));
 
   future = classMirror.newInstanceAsync(const Symbol('withInitialValue'), [45]);
   future.then(expectAsync1((resultMirror) {
     var instance = resultMirror.reflectee;
@@ skipping 48 matching lines @@
 
 testLibraryUri(var value, bool check(Uri)) {
   var valueMirror = reflect(value);
   ClassMirror valueClass = valueMirror.type;
   LibraryMirror valueLibrary = valueClass.owner;
   expect(check(valueLibrary.uri), isTrue);
 }
 
 mainWithArgument({bool isDart2js: false, bool isMinified: false}) {
   var mirrors = currentMirrorSystem();
-  test("Test reflective method invocation", () { testInvoke(mirrors); });
+  test("Test reflective method invocation", () { testInvoke(mirrors,
+                                                            isDart2js); });
   test("Test instance field access", () { testInstanceFieldAccess(mirrors); });
   test('Test intercepted objects', () { testIntercepted(mirrors); });
   if (!isMinified) // TODO(ahe): Remove this line.
   test("Test field access", () { testFieldAccess(mirrors); });
   test("Test closure mirrors", () { testClosureMirrors(mirrors); });
-  test("Test invoke constructor", () { testInvokeConstructor(mirrors); });
+  test("Test invoke constructor", () { testInvokeConstructor(mirrors,
+                                                             isDart2js); });
   test("Test current library uri", () {
     testLibraryUri(new Class(),
       (Uri uri) => uri.path.endsWith('/mirrors_test.dart'));
   });
   test("Test dart library uri", () {
     testLibraryUri("test", (Uri uri) => uri == Uri.parse('dart:core'));
   });
   if (!isMinified) // TODO(ahe): Remove this line.
   test("Test simple and qualifiedName", () { testNames(mirrors, isDart2js); });
   if (isDart2js) return; // TODO(ahe): Remove this line.
   test("Test reflect type", () { testReflectClass(mirrors); });
 }
 
 main() {
   mainWithArgument();
 }