Use FileContentOverlay instead of ContentCache in the new driver.

pkg/analyzer/lib/src/dart/analysis/file_state.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 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/summarize_ast.dart';
 import 'package:convert/convert.dart';
 import 'package:crypto/crypto.dart';
 
 /**
+ * [FileContentOverlay] is used to temporary override content of files.
+ */
+class FileContentOverlay {
+  final _map = <String, String>{};
+
+  /**
+   * Return the content of the file with the given [path], or `null` the
+   * overlay does not override the content of the file.
+   *
+   * The [path] must be absolute and normalized.
+   */
+  String operator [](String path) => _map[path];
+
+  /**
+   * Return the new [content] of the file with the given [path].
+   *
+   * The [path] must be absolute and normalized.
+   */
+  void operator []=(String path, String content) {
+    _map[path] = content;

[Paul Berry, 2016/11/01 19:37:31]

If content is `null`, we should do `_map.remove(path)` so that we don't leave a
lot of nulls lying around in the map after overlays are removed.

+  }
+}
+
+/**
  * Information about a file being analyzed, explicitly or implicitly.
  *
  * It provides a consistent view on its properties.
  *
  * The properties are not guaranteed to represent the most recent state
  * of the file system. To update the file to the most recent state, [refresh]
  * should be called.
  */
 class FileState {
   final FileSystemState _fsState;
@@ skipping 61 matching lines @@
 
   /**
    * Read the file content and ensure that all of the file properties are
    * consistent with the read content, including API signature.
    *
    * Return `true` if the API signature changed since the last refresh.
    */
   bool refresh() {
     // Read the content.
     try {
-      _content = _fsState._contentCache.getContents(source);
-      _content ??= source.contents.data;
+      _content = _fsState._contentOverlay[path];
+      _content ??= _fsState._resourceProvider.getFile(path).readAsStringSync();
     } catch (_) {
       _content = '';
       // TODO(scheglov) We fail to report URI_DOES_NOT_EXIST.
       // On one hand we need to provide an unlinked bundle to prevent
       // analysis context from reading the file (we want it to work
       // hermetically and handle one one file at a time). OTOH,
       // ResynthesizerResultProvider happily reports that any source in the
       // SummaryDataStore has MODIFICATION_TIME `0`. We need to return `-1`
       // for missing files. Maybe add this feature to SummaryDataStore?
     }
@@ skipping 38 matching lines @@
       _exportedFiles.add(file);
     }
     for (String uriStr in _unlinked.publicNamespace.parts) {
       FileState file = _fileForRelativeUri(uriStr);
       _partedFiles.add(file);
     }
     // Return whether the API signature changed.
     return apiSignatureChanged;
   }
 
+  @override
+  String toString() => path;
+
   /**
    * Return the [FileState] for the given [relativeUri].
    */
   FileState _fileForRelativeUri(String relativeUri) {
     Source uriSource = _fsState._sourceFactory.resolveUri(source, relativeUri);
     return _fsState.getFile(uriSource.fullName);
   }
 
   /**
    * Return `true` if the given byte lists are equal.
@@ skipping 36 matching lines @@
   }
 }
 
 /**
  * Information about known file system state.
  */
 class FileSystemState {
   final PerformanceLog _logger;
   final ResourceProvider _resourceProvider;
   final ByteStore _byteStore;
-  final ContentCache _contentCache;
+  final FileContentOverlay _contentOverlay;
   final SourceFactory _sourceFactory;
   final AnalysisOptions _analysisOptions;
 
   final Map<String, FileState> _pathToFile = <String, FileState>{};
 
-  FileSystemState(this._logger, this._byteStore, this._contentCache,
+  FileSystemState(this._logger, this._byteStore, this._contentOverlay,
       this._resourceProvider, this._sourceFactory, this._analysisOptions);
 
   /**
    * Return the [FileState] for the give [path]. The returned file has the
    * last known state since if was last refreshed.
    */
   FileState getFile(String path) {
     FileState file = _pathToFile[path];
     if (file == null) {
       Source source = _sourceForPath(path);
       file = new FileState(this, path, source);
       _pathToFile[path] = file;
       file.refresh();
     }
     return file;
   }
 
   /**
    * Return the [Source] for the given [path] in [_sourceFactory].
    */
   Source _sourceForPath(String path) {
     Source fileSource = _resourceProvider.getFile(path).createSource();
     Uri uri = _sourceFactory.restoreUri(fileSource);
     return _resourceProvider.getFile(path).createSource(uri);
   }
 }