Include exports in resolver.libraries

pkg/code_transformers/lib/src/resolver_impl.dart

 // Copyright (c) 2014, 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.
 
 library code_transformer.src.resolver_impl;
 
 import 'dart:async';
 import 'package:analyzer/analyzer.dart' show parseCompilationUnit;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 26 matching lines @@
       <AssetId, _AssetBasedSource>{};
 
   final AnalysisContext _context =
       AnalysisEngine.instance.createAnalysisContext();
 
   /// Transform for which this is currently updating, or null when not updating.
   Transform _currentTransform;
 
   /// The currently resolved entry libraries, or null if nothing is resolved.
   List<LibraryElement> _entryLibraries;
+  Set<LibraryElement> _libraries;
 
   /// Future indicating when this resolver is done in the current phase.
   Future _lastPhaseComplete = new Future.value();
 
   /// Completer for wrapping up the current phase.
   Completer _currentPhaseComplete;
 
   /// Handler for all Dart SDK (dart:) sources.
   DirectoryBasedDartSdk _dartSdk;
 
@@ skipping 37 matching lines @@
 
   void release() {
     if (_currentPhaseComplete == null) {
       throw new StateError('Releasing without current lock.');
     }
     _currentPhaseComplete.complete(null);
     _currentPhaseComplete = null;
 
     // Clear out libraries since they should not be referenced after release.
     _entryLibraries = null;
+    _libraries = null;
     _currentTransform = null;
   }
 
   Future _performResolve(Transform transform, List<AssetId> entryPoints) {
     if (_currentTransform != null) {
       throw new StateError('Cannot be accessed by concurrent transforms');
     }
     _currentTransform = transform;
 
     // Basic approach is to start at the first file, update it's contents
@@ skipping 35 matching lines @@
 
       // Update the analyzer context with the latest sources
       _context.applyChanges(changeSet);
       // Force resolve each entry point (the getter will ensure the library is
       // computed first).
       _entryLibraries = entryPoints
           .map((id) => _context.computeLibraryElement(sources[id])).toList();
     });
   }
 
-  Iterable<LibraryElement> get libraries =>
-      _entryLibraries.expand((lib) => lib.visibleLibraries).toSet();
+  Iterable<LibraryElement> get libraries {
+    if (_libraries == null) {
+      // Note: we don't use `lib.visibleLibraries` because that excludes the
+      // exports seen in the entry libraries.
+      _libraries = new Set<LibraryElement>();
+      _entryLibraries.forEach(_collectLibraries);
+    }
+    return _libraries;
+  }
+
+  void _collectLibraries(LibraryElement lib) {
+    if (lib == null || _libraries.contains(lib)) return;
+    _libraries.add(lib);
+    lib.importedLibraries.forEach(_collectLibraries);
+    lib.exportedLibraries.forEach(_collectLibraries);
+  }
 
   LibraryElement getLibraryByName(String libraryName) =>
       libraries.firstWhere((l) => l.name == libraryName, orElse: () => null);
 
   LibraryElement getLibraryByUri(Uri uri) =>
       libraries.firstWhere((l) => getImportUri(l) == uri, orElse: () => null);
 
   ClassElement getType(String typeName) {
     var dotIndex = typeName.lastIndexOf('.');
     var libraryName = dotIndex == -1 ? '' : typeName.substring(0, dotIndex);
@@ skipping 415 matching lines @@
 
   void apply(ChangeSet changeSet) {
     if (!source.updateContents(content)) return;
     if (source._revision == 1 && source._contents != null) {
       changeSet.addedSource(source);
     } else {
       changeSet.changedSource(source);
     }
   }
 }