Adds limited support for private classes.

reflectable/lib/src/reflectable_mirror_based.dart

 // Copyright (c) 2015, the Dart Team. All rights reserved. Use of this
 // source code is governed by a BSD-style license that can be found in
 // the LICENSE file.
 
 // TODO(sigurdm) doc: Make NoSuchCapability messages streamlined (the same in
 // both `reflectable_mirror_based.dart` and
 // `reflectable_transformer_based.dart`, and explaining as well as possible
 // which capability is missing.)
 
 /// Implementation of the reflectable interface using dart mirrors.
@@ skipping 239 matching lines @@
       }
       return false;
     } else {
       return false;
     }
   }
 
   bool result = reflectable.hasCapability(predicate);
   if (!result &&
       impliesCorrespondingSetter(reflectable.capabilities) &&
-      name.endsWith("=")) {
+      _isSetterName(name)) {
     return reflectableSupportsInstanceInvoke(
-        reflectable, name.substring(0, name.length - 1), classMirror);
+        reflectable, _setterNameToGetterName(name), classMirror);
   }
   return result;
 }
 
 /// Returns true if [classMirror] supports looking up the declaration of the
 /// instance-member named [name] according to the capabilities of [reflectable].
 bool reflectableSupportsDeclaration(
     ReflectableImpl reflectable, String name, dm.ClassMirror classMirror) {
   Symbol nameSymbol = new Symbol(name);
 
@@ skipping 36 matching lines @@
     }
     if (capability is StaticInvokeMetaCapability) {
       return metadataSupported(metadata, capability);
     }
     return false;
   }
 
   bool result = reflectable.hasCapability(predicate);
   if (!result &&
       impliesCorrespondingSetter(reflectable.capabilities) &&
-      name.endsWith("=")) {
+      _isSetterName(name)) {
     result = reflectableSupportsStaticInvoke(
-        reflectable, name.substring(0, name.length - 1), getterMetadata, null);
+        reflectable, _setterNameToGetterName(name), getterMetadata, null);
   }
   return result;
 }
 
 /// Returns true iff [reflectable] supports top-level invoke of [name].
 bool reflectableSupportsTopLevelInvoke(ReflectableImpl reflectable, String name,
-    List<dm.InstanceMirror> metadata) {
+    List<dm.InstanceMirror> metadata, List<dm.InstanceMirror> getterMetadata) {
   // We don't have to check for `libraryCapability` because this method is only
   // ever called from the methods of a `LibraryMirrorImpl` and the existence of
   // an instance of a `LibraryMirrorImpl` implies the `libraryMirrorCapability`.
   // Finally, we do not have to check for the capability as given to a subtype,
   // because a library is never a subtype of anything.
   return reflectable.hasCapability((ApiReflectCapability capability) {
     if (capability == topLevelInvokeCapability) {
       return true;
     } else if (capability is TopLevelInvokeCapability) {
       return new RegExp(capability.namePattern).hasMatch(name);
     }
     if (capability is TopLevelInvokeMetaCapability) {
       return metadataSupported(metadata, capability);
     }
+    if (impliesCorrespondingSetter(reflectable.capabilities) &&
+        _isSetterName(name)) {
+      return reflectableSupportsTopLevelInvoke(
+          reflectable, _setterNameToGetterName(name), getterMetadata, null);
+    }
     return false;
   });
 }
 
 /// Returns true iff [reflectable] supports invoke of [name].
 bool reflectableSupportsConstructorInvoke(
     ReflectableImpl reflectable, dm.ClassMirror classMirror, String name) {
   bool predicate(ApiReflectCapability capability) {
     if (capability == newInstanceCapability) {
       return true;
@@ skipping 19 matching lines @@
 
 bool reflectableSupportsDeclarations(Reflectable reflectable) {
   bool predicate(ApiReflectCapability capability) =>
       capability == declarationsCapability;
   return reflectable.hasCapability(predicate);
 }
 
 /// Returns [setterName] with final "=" removed.
 /// If the it does not have a final "=" it is returned as is.
 String _setterToGetter(String setterName) {
-  if (!setterName.endsWith("=")) {
+  if (!_isSetterName(setterName)) {
     return setterName;
   }
-  return setterName.substring(0, setterName.length - 1);
+  return _setterNameToGetterName(setterName);
 }
 
 /// Returns [getterName] with a final "=" added.
 /// If [getter] already ends with "=" an error is thrown.
 String _getterToSetter(String getterName) {
-  if (getterName.endsWith("=")) {
+  if (_isSetterName(getterName)) {
     throw new ArgumentError(
         "$getterName is a setter name (ends with `=`) already.");
   }
   return '$getterName=';
 }
 
 bool _supportsType(List<ReflectCapability> capabilities) {
   return capabilities
       .any((ReflectCapability capability) => capability is TypeCapability);
 }
@@ skipping 12 matching lines @@
 
   @override
   Uri get uri => _libraryMirror.uri;
 
   @override
   Map<String, rm.DeclarationMirror> get declarations {
     if (!reflectableSupportsDeclarations(_reflectable)) {
       throw new NoSuchCapabilityError(
           "Attempt to get declarations without capability");
     }
-    Map<Symbol, dm.DeclarationMirror> decls = _libraryMirror.declarations;
-    Iterable<Symbol> relevantKeys = decls.keys.where((k) {
-      List<dm.InstanceMirror> metadata = decls[k].metadata;
-      for (var item in metadata) {
-        if (item.hasReflectee && item.reflectee == _reflectable) return true;
+    Map<String, rm.DeclarationMirror> result =
+        new Map<String, rm.DeclarationMirror>();
+    _libraryMirror.declarations
+        .forEach((Symbol nameSymbol, dm.DeclarationMirror declarationMirror) {
+      String name = dm.MirrorSystem.getName(nameSymbol);
+      if (declarationMirror is dm.MethodMirror) {
+        List<dm.InstanceMirror> getterMetadata = null;
+        if (declarationMirror.isSetter &&
+            !declarationMirror.isSynthetic &&
+            _isSetterName(name)) {
+          dm.DeclarationMirror correspondingGetter =
+              _libraryMirror.declarations[
+                  new Symbol(_setterNameToGetterName(name))];
+          getterMetadata = correspondingGetter?.metadata;
+        }
+        if (reflectableSupportsTopLevelInvoke(
+            _reflectable, name, declarationMirror.metadata, getterMetadata)) {
+          result[name] = wrapDeclarationMirror(declarationMirror, _reflectable);
+        }
+      } else if (declarationMirror is dm.VariableMirror) {
+        // For variableMirrors we test both for support of the name and the
+        // derived setter name.
+        if (reflectableSupportsTopLevelInvoke(
+                _reflectable, name, declarationMirror.metadata, null) ||
+            reflectableSupportsTopLevelInvoke(_reflectable,
+                _getterToSetter(name), declarationMirror.metadata, null)) {
+          result[name] = wrapDeclarationMirror(declarationMirror, _reflectable);
+        }
+      } else {
+        // The additional subtypes of [dm.DeclarationMirror] are
+        // [dm.LibraryMirror]: doees not occur inside another library,
+        // [dm.ParameterMirror]: not declared in a library, [dm.TypeMirror],
+        // and the 4 subtypes thereof; [dm.ClassMirror]: processed here,
+        // [dm.TypedefMirror]: not yet supported, [dm.FunctionTypeMirror]: not
+        // yet supported, and [dm.TypeVariableMirror]: not yet supported.
+        if (declarationMirror is dm.ClassMirror) {
+          if (_reflectable._supportedClasses.contains(declarationMirror)) {
+            result[name] =
+                wrapDeclarationMirror(declarationMirror, _reflectable);
+          }
+        } else {
+          // TODO(eernst) implement: currently ignoring the unsupported cases.
+        }
       }
-      return false;
     });
-    return new Map<String, rm.DeclarationMirror>.fromIterable(relevantKeys,
-        key: (k) => dm.MirrorSystem.getName(k),
-        value: (v) => wrapDeclarationMirror(decls[v], _reflectable));
+    return result;
   }
 
   @override
   Object invoke(String memberName, List positionalArguments,
       [Map<Symbol, dynamic> namedArguments]) {
-    if (!reflectableSupportsTopLevelInvoke(_reflectable, memberName,
-        _libraryMirror.declarations[new Symbol(memberName)].metadata)) {
+    dm.DeclarationMirror declaration =
+        _libraryMirror.declarations[new Symbol(memberName)];
+    List<dm.InstanceMirror> metadata = declaration.metadata;
+    List<dm.InstanceMirror> getterMetadata = null;
+    if (impliesCorrespondingSetter(_reflectable.capabilities) &&
+        declaration is dm.MethodMirror &&
+        declaration.isSetter) {
+      dm.MethodMirror correspondingGetter = _libraryMirror.declarations[
+          new Symbol(_setterNameToGetterName(memberName))];
+      getterMetadata = correspondingGetter?.metadata;
+    }
+    if (!reflectableSupportsTopLevelInvoke(
+        _reflectable, memberName, metadata, getterMetadata)) {
       throw new NoSuchInvokeCapabilityError(
           _receiver, memberName, positionalArguments, namedArguments);
     }
-
     return _libraryMirror
         .invoke(new Symbol(memberName), positionalArguments, namedArguments)
         .reflectee;
   }
 
   @override
   Object invokeGetter(String getterName) {
     if (!reflectableSupportsTopLevelInvoke(_reflectable, getterName,
-        _libraryMirror.declarations[new Symbol(getterName)].metadata)) {
+        _libraryMirror.declarations[new Symbol(getterName)].metadata, null)) {
       throw new NoSuchInvokeCapabilityError(_receiver, getterName, [], null);
     }
     Symbol getterNameSymbol = new Symbol(getterName);
     return _libraryMirror.getField(getterNameSymbol).reflectee;
   }
 
   @override
   Object invokeSetter(String setterName, Object value) {
-    if (!reflectableSupportsTopLevelInvoke(_reflectable, setterName,
-        _libraryMirror.declarations[new Symbol(setterName)].metadata)) {
+    dm.DeclarationMirror declaration =
+        _libraryMirror.declarations[new Symbol(setterName)];
+    List<dm.InstanceMirror> metadata = declaration.metadata;
+    List<dm.InstanceMirror> getterMetadata = null;
+    String getterName = _setterToGetter(setterName);
+    Symbol getterNameSymbol = new Symbol(getterName);
+    if (impliesCorrespondingSetter(_reflectable.capabilities) &&
+        declaration is dm.MethodMirror &&
+        declaration.isSetter) {
+      dm.MethodMirror correspondingGetter =
+          _libraryMirror.declarations[getterNameSymbol];
+      getterMetadata = correspondingGetter?.metadata;
+    }
+    if (!reflectableSupportsTopLevelInvoke(
+        _reflectable, setterName, metadata, getterMetadata)) {
       throw new NoSuchInvokeCapabilityError(
           _receiver, setterName, [value], null);
     }
-    String getterName = _setterToGetter(setterName);
-    Symbol getterNameSymbol = new Symbol(getterName);
     return _libraryMirror.setField(getterNameSymbol, value).reflectee;
   }
 
   @override
   bool operator ==(other) {
     return other is _LibraryMirrorImpl
         ? _libraryMirror == other._libraryMirror
         : false;
   }
 
@@ skipping 198 matching lines @@
           included = included ||
               reflectableSupportsConstructorInvoke(
                   _reflectable, _classMirror, name);
         } else {
           // `declarationMirror` is a non-constructor.
           if (declarationMirror.isStatic) {
             // `declarationMirror` is a static method/getter/setter.
             List<dm.InstanceMirror> getterMetadata = null;
             if (declarationMirror.isSetter &&
                 !declarationMirror.isSynthetic &&
-                name.endsWith("=")) {
+                _isSetterName(name)) {
               dm.DeclarationMirror correspondingGetter =
                   _classMirror.declarations[
-                      new Symbol(name.substring(0, name.length - 1))];
+                      new Symbol(_setterNameToGetterName(name))];
               getterMetadata = correspondingGetter?.metadata;
             }
             included = included ||
                 reflectableSupportsStaticInvoke(_reflectable, name,
                     declarationMirror.metadata, getterMetadata);
           } else {
             // `declarationMirror` is an instance method/getter/setter.
             included = included ||
                 reflectableSupportsDeclaration(
                     _reflectable, name, _classMirror);
@@ skipping 78 matching lines @@
   @override
   Object invoke(String memberName, List positionalArguments,
       [Map<Symbol, dynamic> namedArguments]) {
     dm.DeclarationMirror declaration =
         _classMirror.declarations[new Symbol(memberName)];
     List<Object> metadata = declaration == null ? null : declaration.metadata;
     List<dm.InstanceMirror> getterMetadata = null;
     if (declaration is dm.MethodMirror &&
         declaration.isSetter &&
         !declaration.isSynthetic &&
-        memberName.endsWith("=")) {
+        _isSetterName(memberName)) {
       dm.DeclarationMirror correspondingGetter = _classMirror.declarations[
-          memberName.substring(0, memberName.length - 1)];
+          new Symbol(_setterNameToGetterName(memberName))];
       getterMetadata = correspondingGetter?.metadata;
     }
     if (reflectableSupportsStaticInvoke(
         _reflectable, memberName, metadata, getterMetadata)) {
       Symbol memberNameSymbol = new Symbol(memberName);
       return _classMirror
           .invoke(memberNameSymbol, positionalArguments, namedArguments)
           .reflectee;
     }
     throw new NoSuchInvokeCapabilityError(
         _receiver, memberName, positionalArguments, namedArguments);
   }
 
   @override
   Object invokeGetter(String getterName) {
     if (reflectableSupportsStaticInvoke(_reflectable, getterName,
         _classMirror.declarations[new Symbol(getterName)]?.metadata, null)) {
       Symbol getterNameSymbol = new Symbol(getterName);
       return _classMirror.getField(getterNameSymbol).reflectee;
     }
     throw new NoSuchInvokeCapabilityError(_receiver, getterName, [], null);
   }
 
   @override
   Object invokeSetter(String setterName, Object value) {
     List<dm.InstanceMirror> metadata =
         _classMirror.declarations[new Symbol(setterName)]?.metadata;
     List<dm.InstanceMirror> getterMetadata = null;
-    if (setterName.endsWith("=")) {
+    if (_isSetterName(setterName)) {
       dm.DeclarationMirror correspondingGetter = _classMirror.declarations[
-          new Symbol(setterName.substring(0, setterName.length - 1))];
+          new Symbol(_setterNameToGetterName(setterName))];
       getterMetadata = correspondingGetter?.metadata;
     }
     if (reflectableSupportsStaticInvoke(
         _reflectable, setterName, metadata, getterMetadata)) {
       String getterName = _setterToGetter(setterName);
       Symbol getterNameSymbol = new Symbol(getterName);
       return _classMirror.setField(getterNameSymbol, value).reflectee;
     }
     throw new NoSuchInvokeCapabilityError(_receiver, setterName, [value], null);
   }
@@ skipping 574 matching lines @@
       ReflectCapability cap5 = null,
       ReflectCapability cap6 = null,
       ReflectCapability cap7 = null,
       ReflectCapability cap8 = null,
       ReflectCapability cap9 = null])
       : super(cap0, cap1, cap2, cap3, cap4, cap5, cap6, cap7, cap8, cap9);
 
   const ReflectableImpl.fromList(List<ReflectCapability> capabilities)
       : super.fromList(capabilities);
 
-  bool _canReflect(dm.InstanceMirror mirror) =>
-      _supportedClasses.contains(mirror.type.originalDeclaration);
+  bool _canReflect(dm.InstanceMirror mirror) {
+    dm.ClassMirror classMirror = mirror.type.originalDeclaration;
+    return !classMirror.isPrivate && _supportedClasses.contains(classMirror);
+  }
 
   /// Determines whether reflection is supported for the given [o].
   @override
   bool canReflect(Object o) => _canReflect(dm.reflect(o));
 
   /// Returns a mirror of the given object [reflectee]
   @override
   rm.InstanceMirror reflect(Object o) {
     dm.InstanceMirror mirror = dm.reflect(o);
     if (_canReflect(mirror)) return wrapInstanceMirror(mirror, this);
@@ skipping 347 matching lines @@
         for (dm.ParameterMirror parameter in declaration.parameters) {
           dm.TypeMirror typeMirror = parameter.type.originalDeclaration;
           if (typeMirror is dm.ClassMirror) yield typeMirror;
         }
         dm.TypeMirror typeMirror = declaration.returnType;
         if (typeMirror is dm.ClassMirror) yield typeMirror;
       }
     }
   }
 }
+
+bool _isSetterName(String name) => name.endsWith("=");
+
+String _setterNameToGetterName(String name) {
+  assert(_isSetterName(name));
+  return name.substring(0, name.length - 1);
+}