Remember direct dependencies in LibraryCycle.

pkg/front_end/lib/src/incremental/file_state.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:typed_data';
 
 import 'package:convert/convert.dart';
 import 'package:crypto/crypto.dart';
 import 'package:front_end/file_system.dart';
 import 'package:front_end/src/base/resolve_relative_uri.dart';
+import 'package:front_end/src/byte_store/byte_store.dart';
 import 'package:front_end/src/dependency_walker.dart' as graph;
 import 'package:front_end/src/fasta/uri_translator.dart';
-import 'package:front_end/src/byte_store/byte_store.dart';
 import 'package:front_end/src/incremental/format.dart';
 import 'package:front_end/src/incremental/unlinked_unit.dart';
 import 'package:kernel/target/targets.dart';
 
 /// This function is called for each newly discovered file, and the returned
 /// [Future] is awaited before reading the file content.
 typedef Future<Null> NewFileFn(Uri uri);
 
 /// Information about a file being compiled, explicitly or implicitly.
 ///
@@ skipping 346 matching lines @@
 
   /// Return the [FileState] for the given [fileUri], or `null` if the
   /// [fileUri] does not yet correspond to any referenced [FileState].
   FileState getFileByFileUri(Uri fileUri) => _fileUriToFile[fileUri];
 }
 
 /// List of libraries that reference each other, so form a cycle.
 class LibraryCycle {
   final List<FileState> libraries = <FileState>[];
 
-  /// [LibraryCycle]s that contain libraries directly import or export
-  /// this [LibraryCycle].
+  /// The cycles this cycle directly depends on.
+  final Set<LibraryCycle> directDependencies = new Set<LibraryCycle>();
+
+  /// The cycles that directly import or export this cycle.
   final List<LibraryCycle> directUsers = <LibraryCycle>[];
 
   bool get _isForVm {
     return libraries.any((l) => l.uri.toString().endsWith('dart:_vmservice'));
   }
 
   @override
   String toString() {
     if (_isForVm) {
       return '[core + vm]';
@@ skipping 85 matching lines @@
   @override
   List<_LibraryNode> computeDependencies() {
     return file.directReferencedLibraries.map(walker.getNode).toList();
   }
 }
 
 /// Helper that organizes dependencies of a library into topologically
 /// sorted [LibraryCycle]s.
 class _LibraryWalker extends graph.DependencyWalker<_LibraryNode> {
   final nodesOfFiles = <FileState, _LibraryNode>{};
+  final fileToCycleMap = <FileState, LibraryCycle>{};
   final topologicallySortedCycles = <LibraryCycle>[];
-  final fileToCycleMap = <FileState, LibraryCycle>{};
 
   @override
   void evaluate(_LibraryNode v) {
     evaluateScc([v]);
   }
 
   @override
   void evaluateScc(List<_LibraryNode> scc) {
     var cycle = new LibraryCycle();
 
-    // Build the set of cycles this cycle directly depends on.
-    var directDependencies = new Set<LibraryCycle>();
+    // Compute direct dependencies.
     for (var node in scc) {
       var file = node.file;
       for (var importedLibrary in file.importedLibraries) {
         var importedCycle = fileToCycleMap[importedLibrary];
-        if (importedCycle != null) directDependencies.add(importedCycle);
+        if (importedCycle != null) {
+          cycle.directDependencies.add(importedCycle);
+        }
       }
       for (var exportedLibrary in file.exportedLibraries) {
         var exportedCycle = fileToCycleMap[exportedLibrary];
-        if (exportedCycle != null) directDependencies.add(exportedCycle);
+        if (exportedCycle != null) {
+          cycle.directDependencies.add(exportedCycle);
+        }
       }
     }
 
     // Register this cycle as a direct user of the direct dependencies.
-    for (var directDependency in directDependencies) {
+    for (var directDependency in cycle.directDependencies) {
       directDependency.directUsers.add(cycle);
     }
 
+    // Fill the cycle with libraries.
     for (var node in scc) {
       node.isEvaluated = true;
       cycle.libraries.add(node.file);
       fileToCycleMap[node.file] = cycle;
     }
+
     topologicallySortedCycles.add(cycle);
   }
 
   _LibraryNode getNode(FileState file) {
     return nodesOfFiles.putIfAbsent(file, () => new _LibraryNode(this, file));
   }
 }