More mirrors changes to bring vm mirrors more in line with the

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.
 
 #library('isolate_mirror_local_test');
 
 #import('dart:isolate');
@@ skipping 24 matching lines @@
 int function(int x) {
   global_var = x;
   return x + 1;
 }
 
 _stringCompare(String a, String b) => a.compareTo(b);
 sort(list) => list.sort(_stringCompare);
 
 String buildMethodString(MethodMirror func) {
   var result = '${func.simpleName}';
+  if (func.isPrivate) {
+    result = '$result private';
+  }
   if (func.isTopLevel) {
     result = '$result toplevel';
   }
   if (func.isStatic) {
     result = '$result static';
   }
-  if (func.isMethod) {
+  if (func.isAbstract) {
+    result = '$result abstract';
+  }
+  if (func.isRegularMethod) {
     result = '$result method';
   }
   if (func.isGetter) {
     result = '$result getter';
   }
   if (func.isSetter) {
     result = '$result setter';
   }
   if (func.isConstructor) {
     result = '$result constructor';
   }
   if (func.isConstConstructor) {
     result = '$result const';
   }
   if (func.isGenerativeConstructor) {
     result = '$result generative';
   }
   if (func.isRedirectingConstructor) {
     result = '$result redirecting';
   }
   if (func.isFactoryConstructor) {
     result = '$result factory';
   }
   return result;
 }
 
 String buildVariableString(VariableMirror variable) {
   var result = '${variable.simpleName}';
+  if (variable.isPrivate) {
+    result = '$result private';
+  }
   if (variable.isTopLevel) {
     result = '$result toplevel';
   }
   if (variable.isStatic) {
     result = '$result static';
   }
   if (variable.isFinal) {
     result = '$result final';
   }
   return result;
 }
 
 void testRootLibraryMirror(LibraryMirror lib_mirror) {
   Expect.equals('isolate_mirror_local_test', lib_mirror.simpleName);
+  Expect.equals('isolate_mirror_local_test', lib_mirror.qualifiedName);
+  Expect.equals(null, lib_mirror.owner);
+  Expect.isFalse(lib_mirror.isPrivate);
   Expect.isTrue(lib_mirror.url.contains('isolate_mirror_local_test.dart'));
   Expect.equals("LibraryMirror on 'isolate_mirror_local_test'",
                 lib_mirror.toString());
 
   // Test library invocation by calling function(123).
   Expect.equals(0, global_var);
   lib_mirror.invoke('function', [ 123 ]).then(
       (InstanceMirror retval) {
         Expect.equals(123, global_var);
         Expect.equals('int', retval.type.simpleName);
@@ skipping 65 matching lines @@
                 'testDone, '
                 'testIntegerInstanceMirror, '
                 'testLibrariesMap, '
                 'testMirrorErrors, '
                 'testMirrorSystem, '
                 'testNullInstanceMirror, '
                 'testRootLibraryMirror, '
                 'testStringInstanceMirror]',
                 '$keys');
 
+  // Check that the getters map is complete.
+  keys = lib_mirror.getters.getKeys();
+  sort(keys);
+  Expect.equals('[myVar]', '$keys');
+
+  // Check that the setters map is complete.
+  keys = lib_mirror.setters.getKeys();
+  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]',
                 '$keys');
 
@@ skipping 13 matching lines @@
   Expect.equals('myVar= toplevel static setter', buildMethodString(func));
 
   func = cls_mirror.members['method'];
   Expect.isTrue(func is MethodMirror);
   Expect.equals('method method', buildMethodString(func));
 
   func = cls_mirror.members['MyClass'];
   Expect.isTrue(func is MethodMirror);
   Expect.equals('MyClass constructor', buildMethodString(func));
 
+  func = cls_mirror.members['MyClass.named'];
+  Expect.isTrue(func is MethodMirror);
+  Expect.equals('MyClass.named constructor', 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));
 
   variable = lib_mirror.members['final_global_var'];
   Expect.isTrue(variable is VariableMirror);
   Expect.equals('final_global_var toplevel static final',
                 buildVariableString(variable));
 
   variable = cls_mirror.members['value'];
   Expect.isTrue(variable is VariableMirror);
   Expect.equals('value final', buildVariableString(variable));
 }
 
 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);
 
   // Lookup an interface from a library and make sure it is sane.
   ClassMirror list_intf = core_lib.members['List'];
   Expect.isTrue(list_intf is ClassMirror);
   Expect.equals('List', list_intf.simpleName);
+  Expect.equals('dart:core.List', list_intf.qualifiedName);
+  Expect.isFalse(list_intf.isPrivate);
   Expect.equals('Object', list_intf.superclass.simpleName);
   Expect.equals('ListFactory', list_intf.defaultFactory.simpleName);
-  Expect.equals('dart:core', list_intf.library.simpleName);
+  Expect.equals('dart:core', list_intf.owner.simpleName);
   Expect.isFalse(list_intf.isClass);
   Expect.equals('Collection', list_intf.superinterfaces[0].simpleName);
   Expect.equals("ClassMirror on 'List'", list_intf.toString());
 
   // Lookup a class from a library and make sure it is sane.
   ClassMirror oom_cls = core_lib.members['OutOfMemoryException'];
   Expect.isTrue(oom_cls is ClassMirror);
   Expect.equals('OutOfMemoryException', oom_cls.simpleName);
+  Expect.equals('dart:core.OutOfMemoryException', oom_cls.qualifiedName);
+  Expect.isFalse(oom_cls.isPrivate);
   Expect.equals('Object', oom_cls.superclass.simpleName);
   Expect.isTrue(oom_cls.defaultFactory === null);
-  Expect.equals('dart:core', oom_cls.library.simpleName);
+  Expect.equals('dart:core', oom_cls.owner.simpleName);
   Expect.isTrue(oom_cls.isClass);
   Expect.equals('Exception', oom_cls.superinterfaces[0].simpleName);
   Expect.equals("ClassMirror on 'OutOfMemoryException'",
                 oom_cls.toString());
   testDone('testLibrariesMap');
 }
 
 void testMirrorSystem(MirrorSystem mirrors) {
   Expect.isTrue(mirrors.isolate.debugName.contains('main'));
   testRootLibraryMirror(mirrors.isolate.rootLibrary);
@@ skipping 54 matching lines @@
 }
 
 class MySuperClass {
 }
 
 class MyInterface {
 }
 
 class MyClass extends MySuperClass implements MyInterface {
   MyClass(this.value) {}
+  MyClass.named() {}
 
   final value;
 
   int method(int arg) {
     return arg + value;
   }
 }
 
 void testCustomInstanceMirror(InstanceMirror mirror) {
   Expect.isTrue(mirror.hasReflectee);
   bool saw_exception = false;
   try {
     mirror.reflectee;
   } catch (MirrorException me) {
     saw_exception = true;
   }
   Expect.isFalse(saw_exception);
   Expect.equals("InstanceMirror on instance of 'MyClass'", mirror.toString());
 
   ClassMirror cls = mirror.type;
   Expect.isTrue(cls is ClassMirror);
   Expect.equals('MyClass', cls.simpleName);
   Expect.equals('MySuperClass', cls.superclass.simpleName);
   Expect.isTrue(cls.defaultFactory === null);
-  Expect.equals('isolate_mirror_local_test', cls.library.simpleName);
+  Expect.equals('isolate_mirror_local_test', cls.owner.simpleName);
   Expect.isTrue(cls.isClass);
   Expect.equals('MyInterface', cls.superinterfaces[0].simpleName);
   Expect.equals("ClassMirror on 'MyClass'",
                 cls.toString());
 
   // Invoke mirror.method(1000).
   mirror.invoke('method', [ 1000 ]).then(
       (InstanceMirror retval) {
         Expect.equals('int', retval.type.simpleName);
         Expect.isTrue(retval.hasReflectee);
@@ skipping 95 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());
 }