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];
+    return  _typeToClassMirrorCache[type];
   }
 }
 
 /// 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
-// type.
+// For mixin-applications and private classes we need to construct objects
+// that represents their type.
 class FakeType implements Type {
   const FakeType(this.description);
 
   final String description;
 
   String toString() => "Type($description)";
 }