Implement promised watch behaviour for used == true.

pkg/front_end/test/src/incremental/file_state_test.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 '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;
+  List<Uri> _newFileUris = <Uri>[];
 
   void setUp() {
     Map<String, Uri> dartLibraries = createSdkFiles(fileSystem);
     uriTranslator.dartLibraries.addAll(dartLibraries);
     _coreUri = Uri.parse('dart:core');
     expect(_coreUri, isNotNull);
-    fsState = new FileSystemState(fileSystem, uriTranslator, <int>[]);
+    fsState = new FileSystemState(fileSystem, uriTranslator, <int>[], (uri) {
+      _newFileUris.add(uri);
+      return new Future.value();
+    });
   }
 
   test_apiSignature() async {
     var path = '/a.dart';
     var uri = writeFile(path, '');
     FileState file = await fsState.getFile(uri);
 
     List<int> lastSignature = file.apiSignature;
 
     /// Assert that the given [newCode] has the same API signature as
@@ skipping 180 matching lines @@
       expect(export_.combinators[1].names, unorderedEquals(['C']));
       expect(export_.combinators[2].isShow, isTrue);
       expect(export_.combinators[2].names, unorderedEquals(['A', 'D']));
       expect(export_.isExposed('A'), isTrue);
       expect(export_.isExposed('B'), isFalse);
       expect(export_.isExposed('C'), isFalse);
       expect(export_.isExposed('D'), isTrue);
     }
   }
 
+  test_newFileListener() async {
+    var a = writeFile('/a.dart', '');
+    var b = writeFile('/b.dart', '');
+    var c = writeFile(
+        '/c.dart',
+        r'''
+import 'a.dart';
+''');
+
+    FileState cFile = await fsState.getFile(c);
+
+    // c.dart uses c.dart and a.dart, but not b.dart yet.
+    expect(_newFileUris, contains(c));
+    expect(_newFileUris, contains(a));
+    expect(_newFileUris, isNot(contains(b)));
+    _newFileUris.clear();
+
+    // Update c.dart to use b.dart too.
+    writeFile(
+        '/c.dart',
+        r'''
+import 'a.dart';
+import 'b.dart';
+''');
+    await cFile.refresh();
+
+    // b.dart is the only new file.
+    expect(_newFileUris, [b]);
+  }
+
   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);
@@ skipping 64 matching lines @@
   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')}
 ''');
   }
 }