Implement method and variable reflection in dart:mirrors.

runtime/lib/mirrors_impl.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.
 
 // VM-specific implementation of the dart:mirrors library.
 
 // These values are allowed to be passed directly over the wire.
 bool isSimpleValue(var value) {
   return (value === null || value is num || value is String || value is bool);
 }
 
+Map filterMap(Map old_map, bool filter(key, value)) {
+  Map new_map = new Map();
+  old_map.forEach((key, value) {
+      if (filter(key, value)) {
+        new_map[key] = value;
+      }
+    });
+  return new_map;
+}
+
 abstract class _LocalMirrorImpl implements Mirror {
   // Local mirrors always return the same IsolateMirror.  This field
   // is more interesting once we implement remote mirrors.
   IsolateMirror get isolate() { return _Mirrors.currentIsolateMirror(); }
 }
 
 class _LocalIsolateMirrorImpl extends _LocalMirrorImpl
     implements IsolateMirror {
   _LocalIsolateMirrorImpl(this.debugName, this.rootLibrary, this._libraries) {}
 
   final String debugName;
   final LibraryMirror rootLibrary;
   final Map<String, LibraryMirror> _libraries;
 
   Map<String, LibraryMirror> libraries() { return _libraries; }
 
+  InterfaceMirror _sharedDynamic = null;
+
+  InterfaceMirror _dynamicMirror() {
+    if (_sharedDynamic === null) {
+      _sharedDynamic =
+          new _LocalInterfaceMirrorImpl(
+              null, 'Dynamic', false, null, null, [], null, const {});
+    }
+    return _sharedDynamic;
+  }
+
+  InterfaceMirror _sharedVoid = null;
+
+  InterfaceMirror _voidMirror() {
+    if (_sharedVoid === null) {
+      _sharedVoid =
+          new _LocalInterfaceMirrorImpl(
+              null, 'void', false, null, null, [], null, const {});
+    }
+    return _sharedVoid;
+  }
+
   String toString() {
     return "IsolateMirror on '$debugName'";
   }
 }
 
 // A VMReference is used to hold a reference to a VM-internal object,
 // which can include things like libraries, classes, etc.
 class VMReference extends NativeFieldWrapperClass1 {
 }
 
@@ skipping 47 matching lines @@
 // Prints a string as it might appear in dart program text.
 // TODO(turnidge): Consider truncating.
 String _dartEscape(String str) {
   bool isNice(int code) {
     return (code >= 32 && code <= 126);
   }
 
   StringBuffer buf = new StringBuffer();
   for (int i = 0; i < str.length; i++) {
     var input = str[i];
-    String output; 
+    String output;
     switch (input) {
       case '\\' :
         output = @'\\';
         break;
       case "\'" :
         output = @"\'";
         break;
       case '\n' :
         output = @'\n';
         break;
@@ skipping 63 matching lines @@
     } else {
       return "InstanceMirror on instance of '${getClass().simpleName}'";
     }
   }
 }
 
 class _LazyInterfaceMirror {
   _LazyInterfaceMirror(this.libraryName, this.interfaceName) {}
 
   InterfaceMirror resolve(IsolateMirror isolate) {
+    if (libraryName === null) {
+      if (interfaceName == 'Dynamic') {
+        return isolate._dynamicMirror();
+      } else if (interfaceName == 'void') {
+        return isolate._dynamicMirror();
+      } else {
+        throw new NotImplementedException(
+            "Mirror for type '$interfaceName' not implemented");
+      }
+    }
     return isolate.libraries()[libraryName].members()[interfaceName];
   }
 
   final String libraryName;
   final String interfaceName;
 }
 
 class _LocalInterfaceMirrorImpl extends _LocalObjectMirrorImpl
     implements InterfaceMirror {
   _LocalInterfaceMirrorImpl(ref,
                             this.simpleName,
                             this.isClass,
                             this._library,
                             this._superclass,
                             this._superinterfaces,
-                            this._defaultFactory) : super(ref) {}
+                            this._defaultFactory,
+                            this._members) : super(ref) {}
 
   final String simpleName;
   final bool isClass;
 
   var _library;
   LibraryMirror get library() {
     if (_library is _LazyLibraryMirror) {
       _library = _library.resolve(isolate);
     }
     return _library;
@@ skipping 21 matching lines @@
   }
 
   var _defaultFactory;
   InterfaceMirror defaultFactory() {
     if (_defaultFactory is _LazyInterfaceMirror) {
       _defaultFactory = _defaultFactory.resolve(isolate);
     }
     return _defaultFactory;
   }
 
+  Map<String, InterfaceMirror> _members;
+  Map<String, InterfaceMirror> _methods = null;
+  Map<String, InterfaceMirror> _variables = null;
+
+  Map<String, Mirror> members() { return _members; }
+
+  Map<String, MethodMirror> methods() {
+    if (_methods == null) {
+      _methods = filterMap(members(),
+                           (key, value) => (value is MethodMirror));
+    }
+    return _methods;
+  }
+
+  Map<String, VariableMirror> variables() {
+    if (_variables == null) {
+      _variables = filterMap(members(),
+                             (key, value) => (value is VariableMirror));
+    }
+    return _variables;
+  }
+
   String toString() {
     return "InterfaceMirror on '$simpleName'";
   }
 }
 
 class _LazyLibraryMirror {
   _LazyLibraryMirror(this.libraryName) {}
 
   LibraryMirror resolve(IsolateMirror isolate) {
     return isolate.libraries()[libraryName];
   }
 
   final String libraryName;
 }
 
 class _LocalLibraryMirrorImpl extends _LocalObjectMirrorImpl
     implements LibraryMirror {
   _LocalLibraryMirrorImpl(ref,
                           this.simpleName,
                           this.url,
                           this._members) : super(ref) {}
 
   final String simpleName;
   final String url;
   Map<String, InterfaceMirror> _members;
+  Map<String, InterfaceMirror> _classes = null;
+  Map<String, InterfaceMirror> _functions = null;
+  Map<String, InterfaceMirror> _variables = null;
 
   Map<String, Mirror> members() { return _members; }
 
+  Map<String, InterfaceMirror> classes() {
+    if (_classes == null) {
+      _classes = filterMap(members(),
+                           (key, value) => (value is InterfaceMirror));
+    }
+    return _classes;
+  }
+
+  Map<String, MethodMirror> functions() {
+    if (_functions == null) {
+      _functions = filterMap(members(),
+                             (key, value) => (value is MethodMirror));
+    }
+    return _functions;
+  }
+
+  Map<String, VariableMirror> variables() {
+    if (_variables == null) {
+      _variables = filterMap(members(),
+                             (key, value) => (value is VariableMirror));
+    }
+    return _variables;
+  }
+
   String toString() {
     return "LibraryMirror on '$simpleName'";
   }
 }
 
+class _LocalMethodMirrorImpl extends _LocalMirrorImpl
+    implements MethodMirror {
+  _LocalMethodMirrorImpl(this.simpleName,
+                         this._owner,
+                         this.isStatic,
+                         this.isAbstract,
+                         this.isGetter,
+                         this.isSetter,
+                         this.isConstructor,
+                         this.isConstConstructor,
+                         this.isGenerativeConstructor,
+                         this.isRedirectingConstructor,
+                         this.isFactoryConstructor) {}
+
+  final String simpleName;
+
+  var _owner;
+  Mirror get owner() {
+    if (_owner is! Mirror) {
+      _owner = _owner.resolve(isolate);
+    }
+    return _owner;
+  }
+
+  bool get isTopLevel() {
+    return owner is LibraryMirror;
+  }
+
+  final bool isStatic;
+
+  bool get isMethod() {
+    return !isGetter && !isSetter && !isConstructor;
+  }
+
+  final bool isAbstract;
+  final bool isGetter;
+  final bool isSetter;
+  final bool isConstructor;
+
+  final bool isConstConstructor;
+  final bool isGenerativeConstructor;
+  final bool isRedirectingConstructor;
+  final bool isFactoryConstructor;
+
+  String toString() {
+    return "MethodMirror on '$simpleName'";
+  }
+}
+
+class _LocalVariableMirrorImpl extends _LocalMirrorImpl
+    implements VariableMirror {
+  _LocalVariableMirrorImpl(this.simpleName,
+                           this._owner,
+                           this.isStatic,
+                           this.isFinal) {}
+
+  final String simpleName;
+
+  var _owner;
+  Mirror get owner() {
+    if (_owner is! Mirror) {
+      _owner = _owner.resolve(isolate);
+    }
+    return _owner;
+  }
+
+  bool get isTopLevel() {
+    return owner is LibraryMirror;
+  }
+
+  final bool isStatic;
+  final bool isFinal;
+
+  String toString() {
+    return "VariableMirror on '$simpleName'";
+  }
+}
+
 class _Mirrors {
   // Does a port refer to our local isolate?
   static bool isLocalPort(SendPort port) native 'Mirrors_isLocalPort';
 
   static IsolateMirror _currentIsolateMirror = null;
 
   // Creates a new local IsolateMirror.
   static IsolateMirror makeLocalIsolateMirror()
       native 'Mirrors_makeLocalIsolateMirror';
 
@@ skipping 23 matching lines @@
 
   // Creates a new local InstanceMirror
   static InstanceMirror makeLocalInstanceMirror(Object reflectee)
       native 'Mirrors_makeLocalInstanceMirror';
 
   // The IsolateMirror for the current isolate.
   static InstanceMirror mirrorOf(Object reflectee) {
     return makeLocalInstanceMirror(reflectee);
   }
 }