Implement named arguments in InstanceMirror.invoke.

dart/tests/lib/mirrors/invoke_named_test.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 test.invoke_named_test;
 
 import 'dart:mirrors';
 
+import 'dart:async' show Future;
+
 import 'package:expect/expect.dart';
 import 'invoke_test.dart';
 
+// TODO(ahe): Remove this variable (http://dartbug.com/12863).
+bool isDart2js = false;
+
 class C {
   a(a, {b:'B', c}) => "$a-$b-$c";
   b({a:'A', b, c}) => "$a-$b-$c";
   c(a, [b, c='C']) => "$a-$b-$c";
   d([a, b='B', c='C']) => "$a-$b-$c";
   e(a, b, c) => "$a-$b-$c";
 }
 
 class D {
   static a(a, {b:'B', c}) => "$a-$b-$c";
@@ skipping 29 matching lines @@
   Expect.equals('X-Y-Z', result.reflectee);
   Expect.throws(() => om.invoke(const Symbol('a'), []),
                 isNoSuchMethodError,
                 'Insufficient positional arguments');
   Expect.throws(() => om.invoke(const Symbol('a'), ['X', 'Y']),
                 isNoSuchMethodError,
                 'Extra positional arguments');
   Expect.throws(() => om.invoke(const Symbol('a'), ['X'], {const Symbol('undef') : 'Y'}),
                 isNoSuchMethodError,
                 'Unmatched named argument');
- 
+
   result = om.invoke(const Symbol('b'), []);
   Expect.equals('A-null-null', result.reflectee);
   result = om.invoke(const Symbol('b'), [], {const Symbol('a') : 'X'});
   Expect.equals('X-null-null', result.reflectee);
   result = om.invoke(const Symbol('b'), [], {const Symbol('b') :'Y', const Symbol('c') :'Z', const Symbol('a') :'X'});
   Expect.equals('X-Y-Z', result.reflectee);
   Expect.throws(() => om.invoke(const Symbol('b'), ['X']),
                 isNoSuchMethodError,
                 'Extra positional arguments');
   Expect.throws(() => om.invoke(const Symbol('b'), ['X'], {const Symbol('undef'): 'Y'}),
                 isNoSuchMethodError,
                 'Unmatched named argument');
 
+  if (!isDart2js) {
   result = om.invoke(const Symbol('c'), ['X']);
   Expect.equals('X-null-C', result.reflectee);
   result = om.invoke(const Symbol('c'), ['X', 'Y']);
   Expect.equals('X-Y-C', result.reflectee);
   result = om.invoke(const Symbol('c'), ['X', 'Y', 'Z']);
   Expect.equals('X-Y-Z', result.reflectee);
   Expect.throws(() => om.invoke(const Symbol('c'), []),
                 isNoSuchMethodError,
                 'Insufficient positional arguments');
   Expect.throws(() => om.invoke(const Symbol('c'), ['X', 'Y', 'Z', 'W']),
@@ skipping 10 matching lines @@
   result = om.invoke(const Symbol('d'), ['X', 'Y']);
   Expect.equals('X-Y-C', result.reflectee);
   result = om.invoke(const Symbol('d'), ['X', 'Y', 'Z']);
   Expect.equals('X-Y-Z', result.reflectee);
   Expect.throws(() => om.invoke(const Symbol('d'), ['X', 'Y', 'Z', 'W']),
                 isNoSuchMethodError,
                 'Extra positional arguments');
   Expect.throws(() => om.invoke(const Symbol('d'), ['X'], {const Symbol('undef'): 'Y'}),
                 isNoSuchMethodError,
                 'Unmatched named argument');
+  }
 
   result = om.invoke(const Symbol('e'), ['X', 'Y', 'Z']);
   Expect.equals('X-Y-Z', result.reflectee);
   Expect.throws(() => om.invoke(const Symbol('e'), ['X']),
                 isNoSuchMethodError,
                 'Insufficient positional arguments');
   Expect.throws(() => om.invoke(const Symbol('e'), ['X', 'Y', 'Z', 'W']),
                 isNoSuchMethodError,
                 'Extra positional arguments');
   Expect.throws(() => om.invoke(const Symbol('e'), ['X'], {const Symbol('undef'): 'Y'}),
@@ skipping 15 matching lines @@
   future = om.invokeAsync(const Symbol('a'), ['X'], {const Symbol('c') : 'Z', const Symbol('b') : 'Y'});
   expectValueThen(future, (result) {
     Expect.equals('X-Y-Z', result.reflectee);
   });
   future = om.invokeAsync(const Symbol('a'), []);
   expectError(future, isNoSuchMethodError, 'Insufficient positional arguments');
   future = om.invokeAsync(const Symbol('a'), ['X', 'Y']);
   expectError(future, isNoSuchMethodError, 'Extra positional arguments');
   future = om.invokeAsync(const Symbol('a'), ['X'], {const Symbol('undef') : 'Y'});
   expectError(future, isNoSuchMethodError, 'Unmatched named argument');
- 
- 
+
+
   future = om.invokeAsync(const Symbol('b'), []);
   expectValueThen(future, (result) {
     Expect.equals('A-null-null', result.reflectee);
   });
   future = om.invokeAsync(const Symbol('b'), [], {const Symbol('a') : 'X'});
   expectValueThen(future, (result) {
     Expect.equals('X-null-null', result.reflectee);
   });
   future = om.invokeAsync(const Symbol('b'), [], {const Symbol('b') :'Y', const Symbol('c') :'Z', const Symbol('a') :'X'});
   expectValueThen(future, (result) {
     Expect.equals('X-Y-Z', result.reflectee);
   });
   future = om.invokeAsync(const Symbol('b'), ['X']);
   expectError(future, isNoSuchMethodError, 'Extra positional arguments');
   future = om.invokeAsync(const Symbol('b'), ['X'], {const Symbol('undef'): 'Y'});
   expectError(future, isNoSuchMethodError, 'Unmatched named argument');
 
-
+  if (!isDart2js) {
   future = om.invokeAsync(const Symbol('c'), ['X']);
   expectValueThen(future, (result) {
     Expect.equals('X-null-C', result.reflectee);
   });
   future = om.invokeAsync(const Symbol('c'), ['X', 'Y']);
   expectValueThen(future, (result) {
     Expect.equals('X-Y-C', result.reflectee);
   });
   future = om.invokeAsync(const Symbol('c'), ['X', 'Y', 'Z']);
   expectValueThen(future, (result) {
@@ skipping 20 matching lines @@
     Expect.equals('X-Y-C', result.reflectee);
   });
   future = om.invokeAsync(const Symbol('d'), ['X', 'Y', 'Z']);
   expectValueThen(future, (result) {
     Expect.equals('X-Y-Z', result.reflectee);
   });
   future = om.invokeAsync(const Symbol('d'), ['X', 'Y', 'Z', 'W']);
   expectError(future, isNoSuchMethodError, 'Extra positional arguments');
   future = om.invokeAsync(const Symbol('d'), ['X'], {const Symbol('undef'): 'Y'});
   expectError(future, isNoSuchMethodError, 'Unmatched named argument');
-
+  }
 
   future = om.invokeAsync(const Symbol('e'), ['X', 'Y', 'Z']);
   expectValueThen(future, (result) {
     Expect.equals('X-Y-Z', result.reflectee);
   });
   future = om.invokeAsync(const Symbol('e'), ['X']);
   expectError(future, isNoSuchMethodError, 'Insufficient positional arguments');
   future = om.invokeAsync(const Symbol('e'), ['X', 'Y', 'Z', 'W']);
   expectError(future, isNoSuchMethodError, 'Extra positional arguments');
   future = om.invokeAsync(const Symbol('e'), ['X'], {const Symbol('undef'): 'Y'});
@@ skipping 12 matching lines @@
   Expect.equals('X-Y-Z', result.reflectee.field);
   Expect.throws(() => cm.newInstance(const Symbol(''), []),
                 isNoSuchMethodError,
                 'Insufficient positional arguments');
   Expect.throws(() => cm.newInstance(const Symbol(''), ['X', 'Y']),
                 isNoSuchMethodError,
                 'Extra positional arguments');
   Expect.throws(() => cm.newInstance(const Symbol(''), ['X'], {const Symbol('undef') : 'Y'}),
                 isNoSuchMethodError,
                 'Unmatched named argument');
- 
+
   result = cm.newInstance(const Symbol('b'), []);
   Expect.equals('A-null-null', result.reflectee.field);
   result = cm.newInstance(const Symbol('b'), [], {const Symbol('a') : 'X'});
   Expect.equals('X-null-null', result.reflectee.field);
   result = cm.newInstance(const Symbol('b'), [], {const Symbol('b') :'Y', const Symbol('c') :'Z', const Symbol('a') :'X'});
   Expect.equals('X-Y-Z', result.reflectee.field);
   Expect.throws(() => cm.newInstance(const Symbol('b'), ['X']),
                 isNoSuchMethodError,
                 'Extra positional arguments');
   Expect.throws(() => cm.newInstance(const Symbol('b'), ['X'], {const Symbol('undef'): 'Y'}),
@@ skipping 59 matching lines @@
   future = cm.newInstanceAsync(const Symbol(''), ['X'], {const Symbol('c') : 'Z', const Symbol('b') : 'Y'});
   expectValueThen(future, (result) {
     Expect.equals('X-Y-Z', result.reflectee.field);
   });
   future = cm.newInstanceAsync(const Symbol(''), []);
   expectError(future, isNoSuchMethodError, 'Insufficient positional arguments');
   future = cm.newInstanceAsync(const Symbol(''), ['X', 'Y']);
   expectError(future, isNoSuchMethodError, 'Extra positional arguments');
   future = cm.newInstanceAsync(const Symbol(''), ['X'], {const Symbol('undef') : 'Y'});
   expectError(future, isNoSuchMethodError, 'Unmatched named argument');
- 
- 
+
+
   future = cm.newInstanceAsync(const Symbol('b'), []);
   expectValueThen(future, (result) {
     Expect.equals('A-null-null', result.reflectee.field);
   });
   future = cm.newInstanceAsync(const Symbol('b'), [], {const Symbol('a') : 'X'});
   expectValueThen(future, (result) {
     Expect.equals('X-null-null', result.reflectee.field);
   });
   future = cm.newInstanceAsync(const Symbol('b'), [], {const Symbol('b') :'Y', const Symbol('c') :'Z', const Symbol('a') :'X'});
   expectValueThen(future, (result) {
@@ skipping 72 matching lines @@
   Expect.equals('X-Y-Z', result.reflectee);
   Expect.throws(() => cm.apply([]),
                 isNoSuchMethodError,
                 'Insufficient positional arguments');
   Expect.throws(() => cm.apply(['X', 'Y']),
                 isNoSuchMethodError,
                 'Extra positional arguments');
   Expect.throws(() => cm.apply(['X'], {const Symbol('undef') : 'Y'}),
                 isNoSuchMethodError,
                 'Unmatched named argument');
- 
+
   cm = reflect(b);
   result = cm.apply([]);
   Expect.equals('A-null-null', result.reflectee);
   result = cm.apply([], {const Symbol('a') : 'X'});
   Expect.equals('X-null-null', result.reflectee);
   result = cm.apply([], {const Symbol('b') :'Y', const Symbol('c') :'Z', const Symbol('a') :'X'});
   Expect.equals('X-Y-Z', result.reflectee);
   Expect.throws(() => cm.apply(['X']),
                 isNoSuchMethodError,
                 'Extra positional arguments');
@@ skipping 64 matching lines @@
   future = cm.applyAsync(['X'], {const Symbol('c') : 'Z', const Symbol('b') : 'Y'});
   expectValueThen(future, (result) {
     Expect.equals('X-Y-Z', result.reflectee);
   });
   future = cm.applyAsync([]);
   expectError(future, isNoSuchMethodError, 'Insufficient positional arguments');
   future = cm.applyAsync(['X', 'Y']);
   expectError(future, isNoSuchMethodError, 'Extra positional arguments');
   future = cm.applyAsync(['X'], {const Symbol('undef') : 'Y'});
   expectError(future, isNoSuchMethodError, 'Unmatched named argument');
- 
+
 
   cm = reflect(b);
   future = cm.applyAsync([]);
   expectValueThen(future, (result) {
     Expect.equals('A-null-null', result.reflectee);
   });
   future = cm.applyAsync([], {const Symbol('a') : 'X'});
   expectValueThen(future, (result) {
     Expect.equals('X-null-null', result.reflectee);
   });
@@ skipping 58 matching lines @@
   });
   future = cm.applyAsync(['X']);
   expectError(future, isNoSuchMethodError, 'Insufficient positional arguments');
   future = cm.applyAsync(['X', 'Y', 'Z', 'W']);
   expectError(future, isNoSuchMethodError, 'Extra positional arguments');
   future = cm.applyAsync(['X'], {const Symbol('undef'): 'Y'});
   expectError(future, isNoSuchMethodError, 'Unmatched named argument');
 }
 
 main() {
-  testSyncInvoke(reflect(new C()));       // InstanceMirror
-  testSyncInvoke(reflectClass(D));        // ClassMirror
-  testSyncInvoke(reflectClass(D).owner);  // LibraryMirror
+  isDart2js = true; /// 01: ok
 
-  testAsyncInvoke(reflect(new C()));       // InstanceMirror
-  testAsyncInvoke(reflectClass(D));        // ClassMirror
-  testAsyncInvoke(reflectClass(D).owner);  // LibraryMirror
+  testSyncInvoke(reflect(new C())); // InstanceMirror
+  if (!isDart2js) testSyncInvoke(reflectClass(D)); // ClassMirror
+  LibraryMirror lib = reflectClass(D).owner;
+  if (!isDart2js) testSyncInvoke(lib); // LibraryMirror
+
+  testAsyncInvoke(reflect(new C())); // InstanceMirror
+
+  if (isDart2js) return;
+
+  testAsyncInvoke(reflectClass(D)); // ClassMirror
+  testAsyncInvoke(lib); // LibraryMirror
 
   testSyncNewInstance();
   testAsyncNewInstance();
-  
+
   testSyncApply();
   testAsyncApply();
 }