Implement more of the mirrors library, primarily stuff to do with types.

runtime/tests/vm/dart/isolate_mirror_local_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.
 //
 // Dart test program for checking implemention of MirrorSystem when
 // inspecting the current isolate.
+//
+// VMOptions=--enable_type_checks
 
 #library('isolate_mirror_local_test');
 
 #import('dart:isolate');
 #import('dart:mirrors');
 
 ReceivePort exit_port;
 Set expectedTests;
 
 void testDone(String test) {
   if (!expectedTests.contains(test)) {
     throw "Unexpected test name '$test'";
   }
   expectedTests.remove(test);
   if (expectedTests.isEmpty()) {
     // All tests are done.
     exit_port.close();
   }
 }
 
 int global_var = 0;
 final int final_global_var = 0;
 
 // Top-level getter and setter.
 int get myVar() { return 5; }
-int set myVar(x) {}
+void set myVar(x) {}
 
 // This function will be invoked reflectively.
 int function(int x) {
   global_var = x;
   return x + 1;
 }
 
+typedef void FuncType(String a);
+
+FuncType myFunc = null;
+
 _stringCompare(String a, String b) => a.compareTo(b);
 sort(list) => list.sort(_stringCompare);
 
 String buildMethodString(MethodMirror func) {
-  var result = '${func.simpleName}';
+  var result = '${func.simpleName} return(${func.returnType.simpleName})';
   if (func.isPrivate) {
     result = '$result private';
   }
   if (func.isTopLevel) {
     result = '$result toplevel';
   }
   if (func.isStatic) {
     result = '$result static';
   }
   if (func.isAbstract) {
@@ skipping 20 matching lines @@
   if (func.isRedirectingConstructor) {
     result = '$result redirecting';
   }
   if (func.isFactoryConstructor) {
     result = '$result factory';
   }
   return result;
 }
 
 String buildVariableString(VariableMirror variable) {
-  var result = '${variable.simpleName}';
+  var result = '${variable.simpleName} type(${variable.type.simpleName})';
   if (variable.isPrivate) {
     result = '$result private';
   }
   if (variable.isTopLevel) {
     result = '$result toplevel';
   }
   if (variable.isStatic) {
     result = '$result static';
   }
   if (variable.isFinal) {
@@ skipping 19 matching lines @@
         Expect.equals('int', retval.type.simpleName);
         Expect.isTrue(retval.hasReflectee);
         Expect.equals(124, retval.reflectee);
         testDone('testRootLibraryMirror');
       });
 
   // Check that the members map is complete.
   List keys = lib_mirror.members.getKeys();
   sort(keys);
   Expect.equals('['
+                'FuncType, '
+                'GenericClass, '
                 'MyClass, '
                 'MyException, '
                 'MyInterface, '
                 'MySuperClass, '
                 '_stringCompare, '
                 'buildMethodString, '
                 'buildVariableString, '
                 'exit_port, '
                 'expectedTests, '
                 'final_global_var, '
                 'function, '
                 'global_var, '
                 'main, '
                 'methodWithError, '
                 'methodWithException, '
+                'myFunc, '
                 'myVar, '
                 'myVar=, '
                 'sort, '
                 'testBoolInstanceMirror, '
                 'testCustomInstanceMirror, '
                 'testDone, '
                 'testIntegerInstanceMirror, '
                 'testLibrariesMap, '
                 'testMirrorErrors, '
                 'testMirrorSystem, '
                 'testNullInstanceMirror, '
                 'testRootLibraryMirror, '
                 'testStringInstanceMirror]',
                 '$keys');
 
   // Check that the classes map is complete.
   keys = lib_mirror.classes.getKeys();
   sort(keys);
   Expect.equals('['
+                'GenericClass, '
                 'MyClass, '
                 'MyException, '
                 'MyInterface, '
                 'MySuperClass]',
                 '$keys');
 
   // Check that the functions map is complete.
   keys = lib_mirror.functions.getKeys();
   sort(keys);
   Expect.equals('['
@@ skipping 29 matching lines @@
   sort(keys);
   Expect.equals('[myVar=]', '$keys');
 
   // Check that the variables map is complete.
   keys = lib_mirror.variables.getKeys();
   sort(keys);
   Expect.equals('['
                 'exit_port, '
                 'expectedTests, '
                 'final_global_var, '
-                'global_var]',
+                'global_var, '
+                'myFunc]',
                 '$keys');
 
   ClassMirror cls_mirror = lib_mirror.members['MyClass'];
+  ClassMirror generic_cls_mirror = lib_mirror.members['GenericClass'];
 
   // Test function mirrors.
   MethodMirror func = lib_mirror.members['function'];
   Expect.isTrue(func is MethodMirror);
-  Expect.equals('function toplevel static method', buildMethodString(func));
+  Expect.equals('function return(int) toplevel static method',
+                buildMethodString(func));
 
   func = lib_mirror.members['myVar'];
   Expect.isTrue(func is MethodMirror);
-  Expect.equals('myVar toplevel static getter', buildMethodString(func));
+  Expect.equals('myVar return(int) toplevel static getter',
+                buildMethodString(func));
 
   func = lib_mirror.members['myVar='];
   Expect.isTrue(func is MethodMirror);
-  Expect.equals('myVar= toplevel static setter', buildMethodString(func));
+  Expect.equals('myVar= return(void) toplevel static setter',
+                buildMethodString(func));
 
   func = cls_mirror.members['method'];
   Expect.isTrue(func is MethodMirror);
-  Expect.equals('method method', buildMethodString(func));
+  Expect.equals('method return(int) method', buildMethodString(func));
 
-  func = cls_mirror.members['MyClass'];
+  func = cls_mirror.constructors['MyClass'];
   Expect.isTrue(func is MethodMirror);
-  Expect.equals('MyClass constructor', buildMethodString(func));
+  Expect.equals('MyClass return(MyClass) constructor', buildMethodString(func));
 
-  func = cls_mirror.members['MyClass.named'];
+  func = cls_mirror.constructors['MyClass.named'];
   Expect.isTrue(func is MethodMirror);
-  Expect.equals('MyClass.named constructor', buildMethodString(func));
+  Expect.equals('MyClass.named return(MyClass) constructor',
+                buildMethodString(func));
+
+  func = generic_cls_mirror.members['method'];
+  Expect.isTrue(func is MethodMirror);
+  Expect.equals('method return(T) method', buildMethodString(func));
 
   // Test variable mirrors.
   VariableMirror variable = lib_mirror.members['global_var'];
   Expect.isTrue(variable is VariableMirror);
-  Expect.equals('global_var toplevel static', buildVariableString(variable));
+  Expect.equals('global_var type(int) toplevel static',
+                buildVariableString(variable));
 
   variable = lib_mirror.members['final_global_var'];
   Expect.isTrue(variable is VariableMirror);
-  Expect.equals('final_global_var toplevel static final',
+  Expect.equals('final_global_var type(int) toplevel static final',
                 buildVariableString(variable));
 
   variable = cls_mirror.members['value'];
   Expect.isTrue(variable is VariableMirror);
-  Expect.equals('value final', buildVariableString(variable));
+  Expect.equals('value type(Dynamic) final', buildVariableString(variable));
+
+  // Test type variable mirrors.
+  var type_var = generic_cls_mirror.members['method'].returnType;
+  Expect.isTrue(type_var is TypeVariableMirror);
+  Expect.equals('GenericClass', type_var.owner.simpleName);
+  Expect.equals('Object', type_var.upperBound.simpleName);
+
+  // Test typedef mirrors.
+  var typedef_mirror = lib_mirror.members['myFunc'].type;
+  Expect.isTrue(typedef_mirror is TypedefMirror);
+  Expect.equals('isolate_mirror_local_test', typedef_mirror.owner.simpleName);
+
+  // Test function type mirrors.
+  var func_cls_mirror = typedef_mirror.referent;
+  Expect.isTrue(func_cls_mirror is FunctionTypeMirror);
+  Expect.equals('void (dart:core.String)', func_cls_mirror.simpleName);
+  Expect.equals('void', func_cls_mirror.returnType.simpleName);
 }
 
 void testLibrariesMap(Map libraries) {
   // Just look for a couple of well-known libs.
   LibraryMirror core_lib = libraries['dart:core'];
   Expect.isTrue(core_lib is LibraryMirror);
 
   LibraryMirror mirror_lib = libraries['dart:mirrors'];
   Expect.isTrue(mirror_lib is LibraryMirror);
 
@@ skipping 95 matching lines @@
   MyClass(this.value) {}
   MyClass.named() {}
 
   final value;
 
   int method(int arg) {
     return arg + value;
   }
 }
 
+class GenericClass<T> {
+  T method(int arg) {
+    return null;
+  }
+}
+
 void testCustomInstanceMirror(InstanceMirror mirror) {
   Expect.isTrue(mirror.hasReflectee);
   bool saw_exception = false;
   try {
     mirror.reflectee;
   } on MirrorException catch (me) {
     saw_exception = true;
   }
   Expect.isFalse(saw_exception);
   Expect.equals("InstanceMirror on instance of 'MyClass'", mirror.toString());
@@ skipping 112 matching lines @@
   // Test that an isolate can reflect on itself.
   mirrorSystemOf(exit_port.toSendPort()).then(testMirrorSystem);
 
   testIntegerInstanceMirror(reflect(1001));
   testStringInstanceMirror(reflect('This\nis\na\nString'));
   testBoolInstanceMirror(reflect(true));
   testNullInstanceMirror(reflect(null));
   testCustomInstanceMirror(reflect(new MyClass(17)));
   testMirrorErrors(currentMirrorSystem());
 }