Adds limited support for private classes.

reflectable/lib/src/reflectable_transformer_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.
 
 library reflectable.src.mirrors_unimpl;
 
 import 'dart:collection' show UnmodifiableMapView, UnmodifiableListView;
 
 import '../capability.dart';
 import '../mirrors.dart';
@@ skipping 91 matching lines @@
     if (_typeToClassMirrorCache == null) {
       if (classMirrors.isEmpty) {
         // This is the case when the capabilities do not include a
         // `TypeCapability`; it is also the case when there are no
         // supported classes but even then we can do the following.
         _typeToClassMirrorCache = <Type, ClassMirror>{};
       } else {
         _typeToClassMirrorCache = new Map.fromIterables(types, classMirrors);
       }
     }
-    return _typeToClassMirrorCache[type];
+    ClassMirror result = _typeToClassMirrorCache[type];
+    if (result == null && "$type".startsWith("_")) {

[sigurdm, 2015/10/15 12:30:58]

Abstract startsWith("_") to isPrivateName()

[eernst, 2015/10/15 13:46:11]

This section deleted: We do not support reflecting on private classes at this
point after all.

+      for (Type typeKey in _typeToClassMirrorCache.keys) {
+        if (typeKey is FakeType && typeKey.correspondsTo(type)) {
+          return _typeToClassMirrorCache[typeKey];
+        }
+      }
+    }
+    return result;
   }
 }
 
 /// This mapping contains the mirror-data for each reflector.
 /// It will be initialized in the generated code.
 Map<Reflectable, ReflectorData> data =
     throw new StateError("Reflectable has not been initialized. "
         "Did you forget to add the main file to the "
         "reflectable transformer's entry_points in pubspec.yaml?");
 
@@ skipping 369 matching lines @@
   }
 
   String toString() => "ClassMirrorImpl($qualifiedName)";
 
   // Because we take care to only ever create one instance for each
   // type/reflector-combination we can rely on the default `hashCode` and `==`
   // operations.
 }
 
 class LibraryMirrorImpl extends _DataCaching implements LibraryMirror {
-  LibraryMirrorImpl(
-      this.simpleName,
-      this.uri,
-      this._reflector,
-      this._declarationIndices,
-      this.getters,
-      this.setters,
-      this._metadata);
+  LibraryMirrorImpl(this.simpleName, this.uri, this._reflector,
+      this._declarationIndices, this.getters, this.setters, this._metadata);
 
   final ReflectableImpl _reflector;
 
   /// A list of the indices in [ReflectorData.memberMirrors] of the
   /// declarations of the reflected class. This includes method mirrors for
   /// top level functions of this library and it directly corresponds to
   /// `declarations`. Exception: When the given `_reflector.capabilities` do
   /// not support the operation `declarations`, this will be
   /// `<int>[NO_CAPABILITY_INDEX]`. It is enough to check that the list is
   /// non-empty and first element is NO_CAPABILITY_INDEX to detect this
@@ skipping 24 matching lines @@
         // need not have stellar performance, it is almost always a bug to do
         // that.
         if (declarationIndex == NO_CAPABILITY_INDEX) {
           throw new NoSuchCapabilityError(
               "Requesting declarations of '$qualifiedName' without capability");
         }
         DeclarationMirror declarationMirror =
             _data.memberMirrors[declarationIndex];
         result[declarationMirror.simpleName] = declarationMirror;
       }
+      _data.classMirrors.forEach((ClassMirror classMirror) {
+        if (classMirror.owner == this) {
+          result[classMirror.simpleName] = classMirror;
+        }
+      });
       _declarations =
           new UnmodifiableMapView<String, DeclarationMirror>(result);
     }
     return _declarations;
   }
 
   @override
   Object invoke(String memberName, List positionalArguments,
       [Map<Symbol, dynamic> namedArguments]) {
     _StaticGetter getter = getters[memberName];
@@ skipping 41 matching lines @@
     }
     return _metadata;
   }
 
   @override
   DeclarationMirror get owner => null;
 
   @override
   String get qualifiedName => simpleName;
 
-  bool operator ==(other) => _unsupported();
-  int get hashCode => _unsupported();
+  bool operator ==(other) {
+    return other is LibraryMirrorImpl &&
+        other.uri == uri &&
+        other._reflector == _reflector &&
+        other._declarationIndices == _declarationIndices;
+  }
+
+  int get hashCode =>
+      uri.hashCode ^ _reflector.hashCode ^ _declarationIndices.hashCode;
 
   // TODO(sigurdm) implement: Need to implement this. Probably only when a given
   // capability is enabled.
   List<LibraryDependencyMirror> get libraryDependencies => _unsupported();
 }
 
 class MethodMirrorImpl extends _DataCaching implements MethodMirror {
   /// An encoding of the attributes and kind of this mirror.
   final int _descriptor;
 
@@ skipping 621 matching lines @@
     }
     return new UnmodifiableMapView(result);
   }
 
   @override
   Iterable<ClassMirror> get annotatedClasses {
     return new UnmodifiableListView<ClassMirror>(data[this].classMirrors);
   }
 }
 
 // For mixin-applications we need to construct objects that represents their

[sigurdm, 2015/10/15 12:30:58]

I think this comment needs to be updated.

[eernst, 2015/10/15 13:46:11]

Done.

 // type.
 class FakeType implements Type {
   const FakeType(this.description);
 
   final String description;
 
   String toString() => "Type($description)";
+
+  /// Make a best effort attempt to recognize that this fake type represents
+  /// the given [type]. Only private non-mixin-application types are recognized,
+  bool correspondsTo(Type type) {

[sigurdm, 2015/10/15 12:30:58]

I think this support for reflecting on instances of private classes will be very
shaky:
* Type.toString() is not well defined.
* Even given the current behavior of Type.toString() there is no qualified name,
so distinguishing two private classes with the same name cannot be done in
general.

We should try to write up a DEP to allow back-door access to privates.

[eernst, 2015/10/15 13:46:11]

Deleted, too.

+    if (description.contains(" with ")) return false;
+    String typeName = type.toString();
+    if (!typeName.startsWith("_")) return false;
+    return description.contains(".$type");
+  }
 }