Compute topologically sorted library cycles.

In following CLs we will compile (or load already compiled) kernels
for each cycle and compile following cycles against them.

R=paulberry@google.com, sigmund@google.com
BUG=

Review-Url: https://codereview.chromium.org/2879783002 .

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

@@ -6,6 +6,7 @@ import 'dart:async';
 import 'dart:typed_data';
 
 import 'package:front_end/file_system.dart';
+import 'package:front_end/src/dependency_walker.dart' as graph;
 import 'package:front_end/src/fasta/parser/top_level_parser.dart';
 import 'package:front_end/src/fasta/scanner.dart';
 import 'package:front_end/src/fasta/source/directive_listener.dart';
@@ -27,37 +28,40 @@ class FileState {
   bool _exists;
   List<int> _content;
 
-  List<FileState> _importedFiles;
-  List<FileState> _exportedFiles;
+  List<FileState> _importedLibraries;
+  List<FileState> _exportedLibraries;
   List<FileState> _partFiles;
 
-  Set<FileState> _directReferencedFiles = new Set<FileState>();
+  List<FileState> _directReferencedLibraries = <FileState>[];
 
   FileState._(this._fsState, this.fileUri);
 
   /// The content of the file.
   List<int> get content => _content;
 
+  /// Libraries that this library file directly imports or exports.
+  List<FileState> get directReferencedLibraries => _directReferencedLibraries;
+
   /// Whether the file exists.
   bool get exists => _exists;
 
+  /// The list of the libraries exported by this library.
+  List<FileState> get exportedLibraries => _exportedLibraries;
+
   @override
   int get hashCode => fileUri.hashCode;
 
-  /// Return the set of transitive files - the file itself and all of the
-  /// directly or indirectly referenced files.
-  Set<FileState> get transitiveFiles {
-    // TODO(scheglov) add caching.
-    var transitiveFiles = new Set<FileState>();
+  /// The list of the libraries imported by this library.
+  List<FileState> get importedLibraries => _importedLibraries;
 
-    void appendReferenced(FileState file) {
-      if (transitiveFiles.add(file)) {
-        file._directReferencedFiles.forEach(appendReferenced);
-      }
-    }
+  /// The list of files this library file references as parts.
+  List<FileState> get partFiles => _partFiles;
 
-    appendReferenced(this);
-    return transitiveFiles;
+  /// Return topologically sorted cycles of dependencies for this library.
+  List<LibraryCycle> get topologicalOrder {
+    var libraryWalker = new _LibraryWalker();
+    libraryWalker.walk(libraryWalker.getNode(this));
+    return libraryWalker.topologicallySortedCycles;
   }
 
   @override
@@ -84,25 +88,31 @@ class FileState {
     new TopLevelParser(listener).parseUnit(scannerResults.tokens);
 
     // Build the graph.
-    _importedFiles = <FileState>[];
-    _exportedFiles = <FileState>[];
+    _importedLibraries = <FileState>[];
+    _exportedLibraries = <FileState>[];
     _partFiles = <FileState>[];
-    await _addFileForRelativeUri(_importedFiles, 'dart:core');
+    await _addFileForRelativeUri(_importedLibraries, 'dart:core');
     for (String uri in listener.imports) {
-      await _addFileForRelativeUri(_importedFiles, uri);
+      await _addFileForRelativeUri(_importedLibraries, uri);
     }
     for (String uri in listener.exports) {
-      await _addFileForRelativeUri(_exportedFiles, uri);
+      await _addFileForRelativeUri(_exportedLibraries, uri);
     }
     for (String uri in listener.parts) {
       await _addFileForRelativeUri(_partFiles, uri);
     }
 
-    // Compute referenced files.
-    _directReferencedFiles = new Set<FileState>()
-      ..addAll(_importedFiles)
-      ..addAll(_exportedFiles)
-      ..addAll(_partFiles);
+    // Compute referenced libraries.
+    _directReferencedLibraries = (new Set<FileState>()
+          ..addAll(_importedLibraries)
+          ..addAll(_exportedLibraries))
+        .toList();
+  }
+
+  @override
+  String toString() {
+    if (fileUri.scheme == 'file') return fileUri.path;
+    return fileUri.toString();
   }
 
   /// Add the [FileState] for the given [relativeUri] to the [files].
@@ -178,6 +188,14 @@ class FileSystemState {
   }
 }
 
+/// List of libraries that reference each other, so form a cycle.
+class LibraryCycle {
+  final List<FileState> libraries = <FileState>[];
+
+  @override
+  String toString() => '[' + libraries.join(', ') + ']';
+}
+
 /// [FileSystemState] based implementation of [FileSystem].
 /// It provides a consistent view on the known file system state.
 class _FileSystemView implements FileSystem {
@@ -226,3 +244,45 @@ class _FileSystemViewEntry implements FileSystemEntity {
     throw new StateError('The method should not be invoked.');
   }
 }
+
+/// Node in [_LibraryWalker].
+class _LibraryNode extends graph.Node<_LibraryNode> {
+  final _LibraryWalker walker;
+  final FileState file;
+
+  @override
+  bool isEvaluated = false;
+
+  _LibraryNode(this.walker, this.file);
+
+  @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 topologicallySortedCycles = <LibraryCycle>[];
+
+  @override
+  void evaluate(_LibraryNode v) {
+    evaluateScc([v]);
+  }
+
+  @override
+  void evaluateScc(List<_LibraryNode> scc) {
+    var cycle = new LibraryCycle();
+    for (var node in scc) {
+      node.isEvaluated = true;
+      cycle.libraries.add(node.file);
+    }
+    topologicallySortedCycles.add(cycle);
+  }
+
+  _LibraryNode getNode(FileState file) {
+    return nodesOfFiles.putIfAbsent(file, () => new _LibraryNode(this, file));
+  }
+}

pkg/front_end/lib/src/incremental_kernel_generator_impl.dart

@@ -125,13 +125,3 @@ class IncrementalKernelGeneratorImpl implements IncrementalKernelGenerator {
     _invalidatedFiles.clear();
   }
 }
-
-///// Clears canonical names of [NamedNode] references.
-//class _ClearCanonicalNamesVisitor extends Visitor {
-//  defaultNode(Node node) {
-//    if (node is NamedNode) {
-//      node.reference.canonicalName = null;
-//    }
-//    node.visitChildren(this);
-//  }
-//}

pkg/front_end/test/src/incremental/file_state_test.dart

@@ -0,0 +1,155 @@
+// 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 'package:front_end/memory_file_system.dart';
+import 'package:front_end/src/fasta/translate_uri.dart';
+import 'package:front_end/src/incremental/file_state.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'mock_sdk.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(FileSystemStateTest);
+  });
+}
+
+@reflectiveTest
+class FileSystemStateTest {
+  final fileSystem = new MemoryFileSystem(Uri.parse('file:///'));
+  final TranslateUri uriTranslator = new TranslateUri({}, {});
+  FileSystemState fsState;
+
+  Uri _coreUri;
+
+  void setUp() {
+    Map<String, Uri> dartLibraries = createSdkFiles(fileSystem);
+    uriTranslator.dartLibraries.addAll(dartLibraries);
+    _coreUri = uriTranslator.dartLibraries['core'];
+    expect(_coreUri, isNotNull);
+    fsState = new FileSystemState(fileSystem, uriTranslator);
+  }
+
+  test_getFile() async {
+    var a = writeFile('/a.dart', '');
+    var b = writeFile('/b.dart', '');
+    var c = writeFile('/c.dart', '');
+    var d = writeFile(
+        '/d.dart',
+        r'''
+import "a.dart";
+export "b.dart";
+part "c.dart";
+''');
+
+    FileState aFile = await fsState.getFile(a);
+    FileState bFile = await fsState.getFile(b);
+    FileState cFile = await fsState.getFile(c);
+    FileState dFile = await fsState.getFile(d);
+
+    expect(dFile.fileUri, d);
+    expect(dFile.exists, isTrue);
+    _assertImportedUris(dFile, [a, _coreUri]);
+    expect(dFile.importedLibraries, contains(aFile));
+    expect(dFile.exportedLibraries, contains(bFile));
+    expect(dFile.partFiles, contains(cFile));
+
+    expect(aFile.fileUri, a);
+    expect(aFile.exists, isTrue);
+    _assertImportedUris(aFile, [_coreUri]);
+    expect(aFile.exportedLibraries, isEmpty);
+    expect(aFile.partFiles, isEmpty);
+
+    expect(bFile.fileUri, b);
+    expect(bFile.exists, isTrue);
+    _assertImportedUris(bFile, [_coreUri]);
+    expect(bFile.exportedLibraries, isEmpty);
+    expect(bFile.partFiles, isEmpty);
+  }
+
+  test_topologicalOrder_cycleBeforeTarget() async {
+    var aUri = _writeFileDirectives('/a.dart');
+    var bUri = _writeFileDirectives('/b.dart', imports: ['c.dart']);
+    var cUri = _writeFileDirectives('/c.dart', imports: ['b.dart']);
+    var dUri = _writeFileDirectives('/d.dart', imports: ['a.dart', 'b.dart']);
+
+    FileState core = await fsState.getFile(_coreUri);
+    FileState a = await fsState.getFile(aUri);
+    FileState b = await fsState.getFile(bUri);
+    FileState c = await fsState.getFile(cUri);
+    FileState d = await fsState.getFile(dUri);
+
+    List<LibraryCycle> order = d.topologicalOrder;
+    expect(order, hasLength(4));
+    expect(order[0].libraries, contains(core));
+    expect(order[1].libraries, unorderedEquals([a]));
+    expect(order[2].libraries, unorderedEquals([b, c]));
+    expect(order[3].libraries, unorderedEquals([d]));
+  }
+
+  test_topologicalOrder_cycleBeforeTarget_export() async {
+    var aUri = _writeFileDirectives('/a.dart');
+    var bUri = _writeFileDirectives('/b.dart', exports: ['c.dart']);
+    var cUri = _writeFileDirectives('/c.dart', imports: ['b.dart']);
+    var dUri = _writeFileDirectives('/d.dart', imports: ['a.dart', 'b.dart']);
+
+    FileState core = await fsState.getFile(_coreUri);
+    FileState a = await fsState.getFile(aUri);
+    FileState b = await fsState.getFile(bUri);
+    FileState c = await fsState.getFile(cUri);
+    FileState d = await fsState.getFile(dUri);
+
+    List<LibraryCycle> order = d.topologicalOrder;
+    expect(order, hasLength(4));
+    expect(order[0].libraries, contains(core));
+    expect(order[1].libraries, unorderedEquals([a]));
+    expect(order[2].libraries, unorderedEquals([b, c]));
+    expect(order[3].libraries, unorderedEquals([d]));
+  }
+
+  test_topologicalOrder_cycleWithTarget() async {
+    var aUri = _writeFileDirectives('/a.dart');
+    var bUri = _writeFileDirectives('/b.dart', imports: ['c.dart']);
+    var cUri = _writeFileDirectives('/c.dart', imports: ['a.dart', 'b.dart']);
+
+    FileState core = await fsState.getFile(_coreUri);
+    FileState a = await fsState.getFile(aUri);
+    FileState b = await fsState.getFile(bUri);
+    FileState c = await fsState.getFile(cUri);
+
+    List<LibraryCycle> order = c.topologicalOrder;
+    expect(order, hasLength(3));
+    expect(order[0].libraries, contains(core));
+    expect(order[1].libraries, unorderedEquals([a]));
+    expect(order[2].libraries, unorderedEquals([b, c]));
+  }
+
+  /// Write the given [text] of the file with the given [path] into the
+  /// virtual filesystem.  Return the URI of the file.
+  Uri writeFile(String path, String text) {
+    Uri uri = Uri.parse('file://$path');
+    fileSystem.entityForUri(uri).writeAsStringSync(text);
+    return uri;
+  }
+
+  void _assertImportedUris(FileState file, List<Uri> expectedUris) {
+    Iterable<Uri> importedUris = _toFileUris(file.importedLibraries);
+    expect(importedUris, unorderedEquals(expectedUris));
+  }
+
+  Iterable<Uri> _toFileUris(List<FileState> files) {
+    return files.map((f) => f.fileUri);
+  }
+
+  Uri _writeFileDirectives(String path,
+      {List<String> imports: const [], List<String> exports: const []}) {
+    return writeFile(
+        path,
+        '''
+${imports.map((uri) => 'import "$uri";').join('\n')}
+${exports.map((uri) => 'export "$uri";').join('\n')}
+''');
+  }
+}

pkg/front_end/test/src/incremental/test_all.dart

@@ -0,0 +1,16 @@
+// 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 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'byte_store_test.dart' as byte_store;
+import 'file_state_test.dart' as file_state;
+
+/// Utility for manually running all tests.
+main() {
+  defineReflectiveSuite(() {
+    byte_store.main();
+    file_state.main();
+  }, name: 'incremental');
+}

pkg/front_end/test/subpackage_relationships_test.dart

@@ -115,6 +115,7 @@ final subpackageRules = {
   'lib/src/fasta/util': new SubpackageRules(),
   'lib/src/incremental': new SubpackageRules(allowedDependencies: [
     'lib',
+    'lib/src',
     'lib/src/fasta',
     'lib/src/fasta/parser',
     'lib/src/fasta/source',