Set ContentCache for created AnalysisContext(s) to control its view of the world.

pkg/analyzer/lib/src/dart/analysis/driver.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:async';
 import 'dart:collection';
 import 'dart:typed_data';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart' show CompilationUnitElement;
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/context/context.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/analysis/index.dart';
 import 'package:analyzer/src/dart/analysis/search.dart';
 import 'package:analyzer/src/dart/analysis/status.dart';
 import 'package:analyzer/src/dart/analysis/top_level_declaration.dart';
 import 'package:analyzer/src/generated/engine.dart'
-    show AnalysisContext, AnalysisEngine, AnalysisOptions, ChangeSet;
+    show AnalysisContext, AnalysisEngine, AnalysisOptions;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/services/lint.dart';
 import 'package:analyzer/src/summary/api_signature.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/link.dart';
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/task/dart.dart' show COMPILATION_UNIT_ELEMENT;
 import 'package:analyzer/task/dart.dart' show LibrarySpecificUnit;
 import 'package:meta/meta.dart';
@@ skipping 642 matching lines @@
 
       // Prepare the library file - the file itself, or the known library.
       FileState libraryFile = getLibraryFile(file);
       if (libraryFile == null) {
         return null;
       }
 
       _LibraryContext libraryContext = _createLibraryContext(libraryFile);
       AnalysisContext analysisContext = _createAnalysisContext(libraryContext);
       try {
-        analysisContext.setContents(file.source, file.content);
-
-        // TODO(scheglov) Remove this.
-        // https://github.com/dart-lang/sdk/issues/28110
-        analysisContext.setContents(libraryFile.source, libraryFile.content);
-        for (FileState part in libraryFile.partedFiles) {
-          if (part.exists) {
-            analysisContext.setContents(part.source, part.content);
-          }
-        }
-
         CompilationUnit resolvedUnit = analysisContext.resolveCompilationUnit2(
             file.source, libraryFile.source);
         List<AnalysisError> errors = analysisContext.computeErrors(file.source);
         AnalysisDriverUnitIndexBuilder index = indexUnit(resolvedUnit);
 
         // Store the result into the cache.
         List<int> bytes;
         {
           bytes = new AnalysisDriverResolvedUnitBuilder(
                   errors: errors
@@ skipping 47 matching lines @@
           COMPILATION_UNIT_ELEMENT);
     } finally {
       analysisContext.dispose();
     }
   }
 
   AnalysisContext _createAnalysisContext(_LibraryContext libraryContext) {
     AnalysisContextImpl analysisContext =
         AnalysisEngine.instance.createAnalysisContext();
     analysisContext.analysisOptions = _analysisOptions;
-
     analysisContext.sourceFactory = _sourceFactory.clone();
+    analysisContext.contentCache = new _ContentCacheWrapper(_fsState);
     analysisContext.resultProvider =
         new InputPackagesResultProvider(analysisContext, libraryContext.store);
-    analysisContext
-        .applyChanges(new ChangeSet()..addedSource(libraryContext.file.source));
     return analysisContext;
   }
 
   /**
    * Return the context in which the [library] should be analyzed it.
    */
   _LibraryContext _createLibraryContext(FileState library) {
     return _logger.run('Create library context', () {
       Map<String, FileState> libraries = <String, FileState>{};
       SummaryDataStore store = new SummaryDataStore(const <String>[]);
@@ skipping 744 matching lines @@
    */
   void exit() {
     _timer.stop();
     _logger._level--;
     int ms = _timer.elapsedMilliseconds;
     _logger.writeln('--- $_msg in $ms ms.');
   }
 }
 
 /**
+ * [ContentCache] wrapper around [FileContentOverlay].
+ */
+class _ContentCacheWrapper implements ContentCache {
+  final FileSystemState fsState;
+
+  _ContentCacheWrapper(this.fsState);
+
+  @override
+  void accept(ContentCacheVisitor visitor) {
+    throw new UnimplementedError();
+  }
+
+  @override
+  String getContents(Source source) {
+    return _getFileForSource(source).content;
+  }
+
+  @override
+  bool getExists(Source source) {
+    return _getFileForSource(source).exists;
+  }
+
+  @override
+  int getModificationStamp(Source source) {
+    return getExists(source) ? 0 : -1;

[Paul Berry, 2017/01/04 20:50:50]

Since the contract for `getExists` says it might return `null`, it's not obvious
why this is safe.  Consider adding a quick comment here explaining that this is
safe because our override of `getExists` never returns `null`.

+  }
+
+  @override
+  String setContents(Source source, String contents) {
+    throw new UnimplementedError();
+  }
+
+  FileState _getFileForSource(Source source) {
+    String path = source.fullName;
+    return fsState.getFileForPath(path);
+  }
+}
+
+/**
  * Task that computes the list of files that were added to the driver and
  * have at least one reference to an identifier [name] defined outside of the
  * file.
  */
 class _FilesReferencingNameTask {
   static const int _MS_WORK_INTERVAL = 5;
 
   final AnalysisDriver driver;
   final String name;
   final Completer<List<String>> completer = new Completer<List<String>>();
@@ skipping 105 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }