Compute and flush sets of transitively referenced files in File[System]State.

pkg/analyzer/test/src/dart/analysis/file_state_test.dart

 // Copyright (c) 2016, 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:convert';
 import 'dart:typed_data';
 
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
@@ skipping 49 matching lines @@
   test_getFileForPath_doesNotExist() {
     String path = _p('/aaa/lib/a.dart');
     FileState file = fileSystemState.getFileForPath(path);
     expect(file.path, path);
     expect(file.uri, FastUri.parse('package:aaa/a.dart'));
     expect(file.content, '');
     expect(file.contentHash, _md5(''));
     expect(file.importedFiles, isEmpty);
     expect(file.exportedFiles, isEmpty);
     expect(file.partedFiles, isEmpty);
-    expect(file.dependencies, isEmpty);
+    expect(file.directReferencedFiles, isEmpty);
     expect(file.isPart, isFalse);
     expect(file.library, isNull);
     expect(file.unlinked, isNotNull);
     expect(file.unlinked.classes, isEmpty);
   }
 
   test_getFileForPath_library() {
     String a1 = _p('/aaa/lib/a1.dart');
     String a2 = _p('/aaa/lib/a2.dart');
     String a3 = _p('/aaa/lib/a3.dart');
@@ skipping 35 matching lines @@
     expect(file.exportedFiles[0].uri, FastUri.parse('package:bbb/b2.dart'));
     expect(file.exportedFiles[0].source, isNotNull);
     expect(file.exportedFiles[1].path, a3);
     expect(file.exportedFiles[1].uri, FastUri.parse('package:aaa/a3.dart'));
     expect(file.exportedFiles[1].source, isNotNull);
 
     expect(file.partedFiles, hasLength(1));
     expect(file.partedFiles[0].path, a4);
     expect(file.partedFiles[0].uri, FastUri.parse('package:aaa/a4.dart'));
 
-    expect(file.dependencies, hasLength(5));
+    expect(file.directReferencedFiles, hasLength(5));
 
     expect(fileSystemState.getFilesForPath(a1), [file]);
   }
 
   test_getFileForPath_part() {
     String a1 = _p('/aaa/lib/a1.dart');
     String a2 = _p('/aaa/lib/a2.dart');
     provider.newFile(
         a1,
         r'''
@@ skipping 11 matching lines @@
     expect(file_a2.path, a2);
     expect(file_a2.uri, FastUri.parse('package:aaa/a2.dart'));
 
     expect(file_a2.unlinked, isNotNull);
     expect(file_a2.unlinked.classes, hasLength(1));
     expect(file_a2.unlinked.classes[0].name, 'A2');
 
     expect(file_a2.importedFiles, isEmpty);
     expect(file_a2.exportedFiles, isEmpty);
     expect(file_a2.partedFiles, isEmpty);
-    expect(file_a2.dependencies, isEmpty);
+    expect(file_a2.directReferencedFiles, isEmpty);
 
     // The library is not known yet.
     expect(file_a2.isPart, isTrue);
     expect(file_a2.library, isNull);
 
     // Ask for the library.
     FileState file_a1 = fileSystemState.getFileForPath(a1);
     expect(file_a1.partedFiles, hasLength(1));
     expect(file_a1.partedFiles[0], same(file_a2));
-    expect(file_a1.dependencies, unorderedEquals([file_a2]));
+    expect(file_a1.directReferencedFiles, unorderedEquals([file_a2]));
 
     // Now the part knows its library.
     expect(file_a2.library, same(file_a1));
 
     // Now update the library, and refresh its file.
     // The 'a2.dart' is not referenced anymore.
     // So the part file does not have the library anymore.
     provider.newFile(
         a1,
         r'''
@@ skipping 79 matching lines @@
     print(222);
   }
 }
 ''');
     bool apiSignatureChanged = file.refresh();
     expect(apiSignatureChanged, isFalse);
 
     expect(file.apiSignature, signature);
   }
 
+  test_transitiveFiles() {
+    String pa = _p('/aaa/lib/a.dart');
+    String pb = _p('/aaa/lib/b.dart');
+    String pc = _p('/aaa/lib/c.dart');
+    String pd = _p('/aaa/lib/d.dart');
+
+    FileState fa = fileSystemState.getFileForPath(pa);
+    FileState fb = fileSystemState.getFileForPath(pb);
+    FileState fc = fileSystemState.getFileForPath(pc);
+    FileState fd = fileSystemState.getFileForPath(pd);
+
+    // Compute transitive closures for all files.
+    fa.transitiveFiles;
+    fb.transitiveFiles;
+    fc.transitiveFiles;
+    fd.transitiveFiles;
+    expect(fileSystemState.test.filesWithoutTransitive, isEmpty);
+
+    // No imports, so just a single file.
+    provider.newFile(pa, "");
+    _assertTransitiveFiles(pa, [pa]);
+
+    // Import b.dart into a.dart, two files now.
+    provider.newFile(pa, "import 'b.dart';");
+    fa.refresh();
+    _assertFilesWithoutTransitive([fa]);
+    _assertTransitiveFiles(pa, [pa, pb]);
+
+    // Update b.dart so that it imports c.dart now.
+    provider.newFile(pb, "import 'c.dart';");
+    fb.refresh();
+    _assertFilesWithoutTransitive([fa, fb]);
+    _assertTransitiveFiles(pa, [pa, pb, pc]);
+    _assertTransitiveFiles(pb, [pb, pc]);
+    _assertFilesWithoutTransitive([]);
+
+    // Update b.dart so that it exports d.dart instead.
+    provider.newFile(pb, "export 'd.dart';");
+    fb.refresh();
+    _assertFilesWithoutTransitive([fa, fb]);
+    _assertTransitiveFiles(pa, [pa, pb, pd]);
+    _assertTransitiveFiles(pb, [pb, pd]);
+    _assertFilesWithoutTransitive([]);
+
+    // Update a.dart so that it does not import b.dart anymore.
+    provider.newFile(pa, "");
+    fa.refresh();
+    _assertFilesWithoutTransitive([fa]);
+    _assertTransitiveFiles(pa, [pa]);
+  }
+
+  test_transitiveFiles_cycle() {
+    String pa = _p('/aaa/lib/a.dart');
+    String pb = _p('/aaa/lib/b.dart');
+
+    provider.newFile(pa, "import 'b.dart';");
+    provider.newFile(pb, "import 'a.dart';");
+
+    FileState fa = fileSystemState.getFileForPath(pa);
+    FileState fb = fileSystemState.getFileForPath(pb);
+
+    // Compute transitive closures for all files.
+    fa.transitiveFiles;
+    fb.transitiveFiles;
+    _assertFilesWithoutTransitive([]);
+
+    // It's a cycle.
+    _assertTransitiveFiles(pa, [pa, pb]);
+    _assertTransitiveFiles(pb, [pa, pb]);
+
+    // Update a.dart so that it does not import b.dart anymore.
+    provider.newFile(pa, "");
+    fa.refresh();
+    _assertFilesWithoutTransitive([fa, fb]);
+    _assertTransitiveFiles(pa, [pa]);
+    _assertTransitiveFiles(pb, [pa, pb]);
+  }
+
+  void _assertFilesWithoutTransitive(List<FileState> expected) {
+    var actual = fileSystemState.test.filesWithoutTransitive;
+    expect(actual, unorderedEquals(expected));
+  }
+
+  void _assertTransitiveFiles(String path, List<String> expectedPaths) {
+    FileState file = fileSystemState.getFileForPath(path);
+    expect(file.transitiveFiles,
+        unorderedEquals(expectedPaths.map(fileSystemState.getFileForPath)));
+  }
+
   String _p(String path) => provider.convertPath(path);
 
   static String _md5(String content) {
     return hex.encode(md5.convert(UTF8.encode(content)).bytes);
   }
 }