Adds limited support for private classes.

reflectable/lib/src/transformer_implementation.dart

 // (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.transformer_implementation;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 346 matching lines @@
   Iterable<_ClassDomain> get domains => elementToDomain.values;
 }
 
 /// Information about the program parts that can be reflected by a given
 /// Reflector.
 class _ReflectorDomain {
   final Resolver _resolver;
   final AssetId _generatedLibraryId;
   final ClassElement _reflector;
 
-  /// Do not use this, use [classes] which ensures that closures operations
+  /// Do not use this, use [classes] which ensures that closure operations
   /// have been performed as requested in [_capabilities]. Exception: In
   /// `_computeWorld`, [_classes] is filled in with the set of directly
   /// covered classes during creation of this [_ReflectorDomain].
   /// NB: [_classes] should be final, but it is not possible because this
   /// would create a cycle of final fields, which cannot be initialized.
   ClassElementEnhancedSet _classes;
 
   /// Used by [classes], only, to keep track of whether [_classes] has been
   /// properly initialized by means of closure operations.
   bool _classesInitialized = false;
@@ skipping 157 matching lines @@
     // Class related collections.
     Enumerator<FieldElement> fields = new Enumerator<FieldElement>();
     Enumerator<ParameterElement> parameters =
         new Enumerator<ParameterElement>();
     Set<String> instanceGetterNames = new Set<String>();
     Set<String> instanceSetterNames = new Set<String>();
 
     // Library and class related collections.
     Enumerator<ExecutableElement> members = new Enumerator<ExecutableElement>();
 
-    // Fill in [libraries], [members], [fields], [parameters],
-    // [instanceGetterNames], and [instanceSetterNames].
-    for (LibraryElement library in _libraries) {
+    /// Adds a library domain for [library] to [libraries], relying on checks
+    /// for importability and insertion into [importCollector] to have taken
+    /// place already.
+    void uncheckedAddLibrary(LibraryElement library) {
       _LibraryDomain libraryDomain = _createLibraryDomain(library, this);
       libraries.add(libraryDomain);
       libraryMap[library] = libraryDomain;
       libraryDomain._declarations.forEach(members.add);
       libraryDomain._declaredParameters.forEach(parameters.add);
       libraryDomain._declaredVariables.forEach(topLevelVariables.add);
     }
+
+    /// Used to add a library domain for [library] to [libraries], checking
+    /// that it is importable and registering it with [importCollector].
+    void addLibrary(LibraryElement library) {
+      if (!_isImportableLibrary(
+          library, _generatedLibraryId, _resolver)) return;
+      importCollector._addLibrary(library);
+      uncheckedAddLibrary(library);
+    }
+
+    // Fill in [libraries], [members], [fields], [parameters],
+    // [instanceGetterNames], and [instanceSetterNames].
+    _libraries.forEach(uncheckedAddLibrary);
+    classes.forEach((ClassElement classElement) {
+      if (!libraries.items.any((_LibraryDomain libraryDomain) =>
+          libraryDomain._libraryElement == classElement.library)) {
+        addLibrary(classElement.library);
+      }
+    });
     for (_ClassDomain classDomain in classes.domains) {
       // Gather the behavioral interface into [members]. Note that
       // this includes implicitly generated getters and setters, but
       // omits fields. Also note that this does not match the
       // semantics of the `declarations` method in a [ClassMirror].
       classDomain._declarations.forEach(members.add);
 
       // Add the behavioral interface from this class (redundantly, for
       // non-static members) and all superclasses (which matters) to
       // [members], such that it contains both the behavioral parts for
@@ skipping 296 matching lines @@
     String classMetadataCode;
     if (_capabilities._supportsMetadata) {
       classMetadataCode = _extractMetadataCode(classElement, _resolver,
           importCollector, logger, _generatedLibraryId);
     } else {
       classMetadataCode = "null";
     }
 
     int classIndex = classes.indexOf(classElement);
 
-    String result = 'new r.ClassMirrorImpl(r"${classDomain._simpleName}", '
+    return 'new r.ClassMirrorImpl(r"${classDomain._simpleName}", '
         'r"${_qualifiedName(classElement)}", $descriptor, $classIndex, '
         '${_constConstructionCode(importCollector)}, '
         '$declarationsCode, $instanceMembersCode, $staticMembersCode, '
         '$superclassIndex, $staticGettersCode, $staticSettersCode, '
         '$constructorsCode, $ownerIndex, $mixinIndex, '
         '$superinterfaceIndices, $classMetadataCode)';
-    return result;
   }
 
   String _methodMirrorCode(
       ExecutableElement element,
       Enumerator<FieldElement> fields,
       Enumerator<ExecutableElement> members,
       Enumerator<ParameterElement> parameters,
       _ImportCollector importCollector,
       TransformLogger logger,
       bool reflectedTypeRequested) {
@@ skipping 67 matching lines @@
     if (dartType is TypeParameterType) {
       ClassElement owningClassElement = dartType.element.enclosingElement;
       return 'const r.FakeType(r"${_qualifiedName(owningClassElement)}.'
           '${dartType.element}")';
     }
     return _typeCodeOfClass(dartType.element, importCollector);
   }
 
   String _typeCodeOfClass(
       ClassElement classElement, _ImportCollector importCollector) {
-    if (classElement is MixinApplication && classElement.declaredName == null) {
+    if ((classElement is MixinApplication &&
+            classElement.declaredName == null) ||
+        classElement.isPrivate) {
       return 'const r.FakeType(r"${_qualifiedName(classElement)}")';
     }
     if (classElement.type.isDynamic) return "dynamic";
     String prefix = importCollector._getPrefix(classElement.library);
     return "$prefix.${classElement.name}";
   }
 
   String _libraryMirrorCode(
       _LibraryDomain libraryDomain,
       Enumerator<ExecutableElement> members,
@@ skipping 34 matching lines @@
     if (_capabilities._impliesDeclarations) {
       List<int> declarationsIndices = <int>[]
         ..addAll(variableIndices)
         ..addAll(methodsIndices);
       declarationsCode = _formatAsConstList("int", declarationsIndices);
     }
 
     // TODO(sigurdm) clarify: Find out how to get good uri's in a
     // transformer.
     // TODO(sigurdm) implement: Check for `uriCapability`.
-    String uriCode = "null";
+    String uriCode = 'Uri.parse(r"reflectable://$library")';

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

Is this any better?

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

We cannot implement a map from `Uri` to `LibraryMirror` when they all have the
same uri (`null`). This makes them distinct as far as they have distinct library
directives, and then we can implement `Reflectable.libraries` (which was
missing).

But they are still potentially identical for different libraries (e.g., two
libraries with no library directive).

Adjusted to include the `libraries.indexOf(library)` for disambiguation.

 
     String metadataCode;
     if (_capabilities._supportsMetadata) {
       metadataCode = _extractMetadataCode(
           library, _resolver, importCollector, logger, _generatedLibraryId);
     } else {
       metadataCode = "null";
     }
 
     return 'new r.LibraryMirrorImpl(r"${library.name}", $uriCode, '
@@ skipping 1245 matching lines @@
         assert(_isImportableLibrary(reflector.library, dataId, _resolver));
         importCollector._addLibrary(reflector.library);
         return new _ReflectorDomain(_resolver, dataId, reflector, capabilities);
       });
     }
 
     /// Adds [library] to the supported libraries of [reflector].
     void addLibrary(LibraryElement library, ClassElement reflector) {
       _ReflectorDomain domain = getReflectorDomain(reflector);
       if (domain._capabilities.supportsLibraries) {
-        assert(_isImportableLibrary(reflector.library, dataId, _resolver));
+        assert(_isImportableLibrary(library, dataId, _resolver));
         importCollector._addLibrary(library);
         domain._libraries.add(library);
       }
     }
 
     /// Adds a [_ClassDomain] representing [type] to the supported classes of
     /// [reflector]; also adds the enclosing library of [type] to the
     /// supported libraries.
     void addClassDomain(ClassElement type, ClassElement reflector) {
       if (!_isImportable(type, dataId, _resolver)) {
@@ skipping 82 matching lines @@
 
     // Populate [globalPatterns] and [globalMetadata].
     _findGlobalQuantifyAnnotations(globalPatterns, globalMetadata);
 
     // Visits all libraries and all classes in the given entry point,
     // gets their reflectors, and adds them to the domain of that
     // reflector.
     for (LibraryElement library in _resolver.libraries) {
       for (ClassElement reflector
           in getReflectors(library.name, library.metadata)) {
-        assert(_isImportableLibrary(reflector.library, dataId, _resolver));
+        assert(_isImportableLibrary(library, dataId, _resolver));
         addLibrary(library, reflector);
       }
 
       for (CompilationUnitElement unit in library.units) {
         for (ClassElement type in unit.types) {
           for (ClassElement reflector
               in getReflectors(_qualifiedName(type), type.metadata)) {
             addClassDomain(type, reflector);
           }
         }
@@ skipping 1283 matching lines @@
   return classElement == null
       ? "null"
       : "${classElement.library.name}.${classElement.name}";
 }
 
 String _qualifiedFunctionName(FunctionElement functionElement) {
   return functionElement == null
       ? "null"
       : "${functionElement.library.name}.${functionElement.name}";
 }