Implement topLevelMembers, staticMembers, instanceMembers in the VM.

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.
 
 import "dart:collection";
 
 final emptyList = new UnmodifiableListView([]);
 final emptyMap = new _UnmodifiableMapView({});
@@ skipping 142 matching lines @@
   final Symbol _selector;
   _InvocationTrampoline(this._receiver, this._selector);
   noSuchMethod(Invocation msg) {
     if (msg.memberName != #call) return super.noSuchMethod(msg);
     return _receiver.invoke(_selector,
                             msg.positionalArguments,
                             msg.namedArguments);
   }
 }
 
+class _SyntheticAccessor implements MethodMirror {
+  final DeclarationMirror owner;
+  final Symbol simpleName;
+  final bool isGetter;
+  final bool isStatic;
+  final bool isTopLevel;
+  final _target;
+
+  _SyntheticAccessor(this.owner,
+                     this.simpleName,
+                     this.isGetter,
+                     this.isStatic,
+                     this.isTopLevel,
+                     this._target);
+
+  bool get isSynthetic => true;
+  bool get isRegularMethod => false;
+  bool get isOperator => false;
+  bool get isConstructor => false;
+  bool get isConstConstructor => false;
+  bool get isGenerativeConstructor => false;
+  bool get isFactoryConstructor => false;
+  bool get isRedirectingConstructor => false;
+  bool get isAbstract => false;
+
+  bool get isSetter => !isGetter;
+  bool get isPrivate => _n(simpleName).startsWith('_');
+
+  Symbol get qualifiedName => _computeQualifiedName(owner, simpleName);
+  Symbol get constructorName => const Symbol('');
+
+  TypeMirror get returnType => _target.type;
+  List<ParameterMirror> get parameters {
+    if (isGetter) return emptyList;
+    return new UnmodifiableListView(
+        [new _SyntheticSetterParameter(this, this._target)]);
+  }
+
+  List<InstanceMirror> get metadata => emptyList;
+
+  String get source => null;
+}
+
+class _SyntheticSetterParameter implements ParameterMirror {
+  final DeclarationMirror owner;
+  final VariableMirror _target;
+
+  _SyntheticSetterParameter(this.owner, this._target);
+
+  Symbol get simpleName => _target.simpleName;
+  Symbol get qualifiedName => _computeQualifiedName(owner, simpleName);
+  TypeMirror get type => _target.type;
+
+  bool get isOptional => false;
+  bool get isNamed => false;
+  bool get isStatic => false;
+  bool get isTopLevel => false;
+  bool get isConst => false;
+  bool get isFinal => true;
+  bool get isPrivate => false;
+  bool get hasDefaultValue => false;
+  InstanceMirror get defaultValue => null;
+}
+
 abstract class _LocalObjectMirror extends _LocalMirror implements ObjectMirror {
   final _reflectee; // May be a MirrorReference or an ordinary object.
 
   _LocalObjectMirror(this._reflectee);
 
   InstanceMirror invoke(Symbol memberName,
                         List positionalArguments,
                         [Map<Symbol, dynamic> namedArguments]) {
     int numPositionalArguments = positionalArguments.length;
     int numNamedArguments = namedArguments != null ? namedArguments.length : 0;
@@ skipping 312 matching lines @@
           // The reflectee is not a mixin application.
           _mixin = this;
         } else {
           _mixin = reflectType(mixinType);
         }
       }
     }
     return _mixin;
   }
 
+  var _cachedStaticMembers;
+  Map<Symbol, MethodMirror> get staticMembers {
+    if (_cachedStaticMembers != null) return _cachedStaticMembers;
+    var result = new Map<Symbol, MethodMirror>();
+    declarations.values.forEach((decl) {
+      if (decl is MethodMirror && decl.isStatic &&
+          !decl.isConstructor && !decl.isAbstract) {
+        result[decl.simpleName] = decl;
+      }
+      if (decl is VariableMirror && decl.isStatic) {
+        var getterName = decl.simpleName;
+        result[getterName] =
+            new _SyntheticAccessor(this, getterName, true, true, false, decl);
+        if (!decl.isFinal) {
+          var setterName = _asSetter(decl.simpleName, this.owner);
+          result[setterName] = new _SyntheticAccessor(
+              this, setterName, false, true, false, decl);
+        }
+      }
+    });
+    return _cachedStaticMembers = result;

[siva, 2013/12/11 00:54:43]

Would it be more readable to write this as
if (_cachedStaticMembers == null) {
  var result = ...
  ....
  ....
  _cachedStaticMembers = result;
}
return _cachedStaticMembers;

[rmacnak, 2013/12/11 01:17:10]

It's about the same either way, but your suggestion is more consistent with the
rest of the library.

+  }
+
+  var _cachedInstanceMembers;
+  Map<Symbol, MethodMirror> get instanceMembers {
+    if (_cachedInstanceMembers != null) return _cachedInstanceMembers;
+    var result = new Map<Symbol, MethodMirror>();
+    if (superclass != null) {
+      result.addAll(superclass.instanceMembers);
+    }
+    declarations.values.forEach((decl) {
+      if (decl is MethodMirror && !decl.isStatic &&
+          !decl.isConstructor && !decl.isAbstract) {
+        result[decl.simpleName] = decl;
+      }
+      if (decl is VariableMirror && !decl.isStatic) {
+        var getterName = decl.simpleName;
+        result[getterName] =
+            new _SyntheticAccessor(this, getterName, true, false, false, decl);
+        if (!decl.isFinal) {
+          var setterName = _asSetter(decl.simpleName, this.owner);
+          result[setterName] = new _SyntheticAccessor(
+              this, setterName, false, false, false, decl);
+        }
+      }
+    });
+    return _cachedInstanceMembers = result;

[siva, 2013/12/11 00:54:43]

Ditto.

+  }
+
   Map<Symbol, DeclarationMirror> _declarations;
   Map<Symbol, DeclarationMirror> get declarations {
     if (_declarations != null) return _declarations;
     var decls = new Map<Symbol, DeclarationMirror>();
     decls.addAll(_members);
     decls.addAll(_constructors);
     typeVariables.forEach((tv) => decls[tv.simpleName] = tv);
     return _declarations =
         new _UnmodifiableMapView<Symbol, DeclarationMirror>(decls);
   }
@@ skipping 406 matching lines @@
 
   String toString() => "TypedefMirror on '${_n(simpleName)}'";
 
   static _nativeReferent(reflectedType)
       native "TypedefMirror_referent";
 
   static _nativeDeclaration(reflectedType)
       native "TypedefMirror_declaration";
 }
 
-class _LocalLibraryMirror extends _LocalObjectMirror
-    implements LibraryMirror {
+Symbol _asSetter(Symbol getter, LibraryMirror library) {
+  var unwrapped = MirrorSystem.getName(getter);
+  return MirrorSystem.getSymbol('${unwrapped}=', library);
+}
+
+class _LocalLibraryMirror extends _LocalObjectMirror implements LibraryMirror {
   final Symbol simpleName;
   final Uri uri;
 
   _LocalLibraryMirror(reflectee,
                       String simpleName,
                       String url)
       : this.simpleName = _s(simpleName),
         this.uri = Uri.parse(url),
         super(reflectee);
 
@@ skipping 11 matching lines @@
     throw new UnimplementedError('LibraryMirror.location is not implemented');
   }
 
   Map<Symbol, DeclarationMirror> _declarations;
   Map<Symbol, DeclarationMirror> get declarations {
     if (_declarations != null) return _declarations;
     return _declarations =
         new _UnmodifiableMapView<Symbol, DeclarationMirror>(_members);
   }
 
+  Map<Symbol, MethodMirror> get topLevelMembers {
+    throw new UnimplementedError(
+        'LibraryMirror.topLevelMembers is not implemented');
+  }
+
   Map<Symbol, Mirror> _cachedMembers;
   Map<Symbol, Mirror> get _members {
     if (_cachedMembers == null) {
       _cachedMembers = _makeMemberMap(_computeMembers(_reflectee));
     }
     return _cachedMembers;
   }
 
   Map<Symbol, MethodMirror> _cachedFunctions;
   Map<Symbol, MethodMirror> get _functions {
@@ skipping 34 matching lines @@
   _invokeGetter(reflectee, getterName)
       native 'LibraryMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'LibraryMirror_invokeSetter';
 
   _computeMembers(reflectee)
       native "LibraryMirror_members";
 }
 
-class _LocalMethodMirror extends _LocalDeclarationMirror
+class _LocalMethodMirror extends _LocalDeclarationMirror 
     implements MethodMirror {
   final bool isStatic;
   final bool isAbstract;
   final bool isGetter;
   final bool isSetter;
   final bool isConstructor;
   final bool isConstConstructor;
   final bool isGenerativeConstructor;
   final bool isRedirectingConstructor;
   final bool isFactoryConstructor;
@@ skipping 24 matching lines @@
     if (_owner == null) {
       _owner = _MethodMirror_owner(_reflectee);
     }
     return _owner;
   }
 
   bool get isPrivate => _n(simpleName).startsWith('_') ||
                         _n(constructorName).startsWith('_');
 
   bool get isTopLevel => owner is LibraryMirror;
+  bool get isSynthetic => false;
 
   SourceLocation get location {
     throw new UnimplementedError('MethodMirror.location is not implemented');
   }
 
   Type get _instantiator {
     var o = owner;
     while (o is MethodMirror) o = o.owner;
     return o._instantiator;
   }
@@ skipping 273 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }