Fix library cycle computation in the presence of library handles.

pkg/analyzer/lib/src/dart/element/element.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 analyzer.src.dart.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/element/visitor.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/constant.dart'
     show DartObject, EvaluationResultImpl;
+import 'package:analyzer/src/generated/element_handle.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisEngine;
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
@@ skipping 3229 matching lines @@
     // The stack of discovered elements
     List<LibraryElementImpl> stack = [];
     // For a given library that has not yet been processed by this run of the
     // algorithm, compute the strongly connected components.
     int scc(LibraryElementImpl library) {
       int index = counter++;
       int root = index;
       indices[library] = index;
       active.add(library);
       stack.add(library);
+      LibraryElementImpl getActualLibrary(LibraryElement lib) {
+        // TODO(paulberry): this means that computing a library cycle will be
+        // expensive for libraries resynthesized from summaries, since it will
+        // require fully resynthesizing all the libraries in the cycle as well
+        // as any libraries they import or export.  Try to find a better way.

[Brian Wilkerson, 2016/02/25 20:47:39]

Eventually, resynthesis should be lazy, in which case we should only need to
resynthesize the import and export elements. Is that true?

[Paul Berry, 2016/02/25 21:08:30]

Yes, I hope to do that, but even under the optimistic assumption that we can do
that easily, computing a library cycle will still be more expensive than I'd
like, because it will require visiting the import and export elements of all
libraries in the cycle *and* all libraries imported or exported by those
libraries.  That's a lot of libraries to visit, and many of them are probably
libraries we won't need to resynthesize for any other reason.

An alternative, which I think would be easier and result in an even bigger
savings, would be to compute all the library cycles at summary generation time
and store them in the summary.  Then the only thing we would need to
resynthesize in order to figure out the library cycle for library X would be
library X itself.

+        if (lib is LibraryElementHandle) {
+          return lib.actualElement;
+        } else {
+          return lib;
+        }
+      }
       void recurse(LibraryElementImpl child) {
         if (!indices.containsKey(child)) {
           // We haven't visited this child yet, so recurse on the child,
           // returning the lowest numbered node reachable from the child.  If
           // the child can reach a root which is lower numbered than anything
           // we've reached so far, update the root.
           root = min(root, scc(child));
         } else if (active.contains(child)) {
           // The child has been visited, but has not yet been placed into a
           // component.  If the child is higher than anything we've seen so far
           // update the root appropriately.
           root = min(root, indices[child]);
         }
       }
       // Recurse on all of the children in the import/export graph, filtering
       // out those for which library cycles have already been computed.
       library.exportedLibraries
+          .map(getActualLibrary)
           .where((l) => l._libraryCycle == null)
           .forEach(recurse);
       library.importedLibraries
+          .map(getActualLibrary)
           .where((l) => l._libraryCycle == null)
           .forEach(recurse);
 
       if (root == index) {
         // This is the root of a strongly connected component.
         // Pop the elements, and share the component across all
         // of the elements.
         List<LibraryElement> component = <LibraryElement>[];
         LibraryElementImpl cur = null;
         do {
@@ skipping 1504 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }