Fix bug when packages file changes in new driver

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;
@@ skipping 91 matching lines @@
    */
   final ByteStore _byteStore;
 
   /**
    * This [ContentCache] is consulted for a file content before reading
    * the content from the file.
    */
   final FileContentOverlay _contentOverlay;
 
   /**
+   * The analysis options to analyze with.
+   */
+  AnalysisOptions _analysisOptions;
+
+  /**
    * The [SourceFactory] is used to resolve URIs to paths and restore URIs
    * from file paths.
    */
-  final SourceFactory sourceFactory;
-
-  /**
-   * The analysis options to analyze with.
-   */
-  final AnalysisOptions analysisOptions;
+  SourceFactory _sourceFactory;
 
   /**
    * The salt to mix into all hashes used as keys for serialized data.
    */
   final Uint32List _salt =
       new Uint32List(1 + AnalysisOptions.crossContextOptionsLength);
 
   /**
    * The current file system state.
    */
@@ skipping 95 matching lines @@
    * The given [SourceFactory] is cloned to ensure that it does not contain a
    * reference to a [AnalysisContext] in which it could have been used.
    */
   AnalysisDriver(
       this._scheduler,
       this._logger,
       this._resourceProvider,
       this._byteStore,
       this._contentOverlay,
       SourceFactory sourceFactory,
-      this.analysisOptions)
-      : sourceFactory = sourceFactory.clone() {
+      this._analysisOptions)
+      : _sourceFactory = sourceFactory.clone() {
     _fillSalt();
     _sdkBundle = sourceFactory.dartSdk.getLinkedBundle();
     _fsState = new FileSystemState(
         _logger,
         _byteStore,
         _contentOverlay,
         _resourceProvider,
         sourceFactory,
-        analysisOptions,
+        _analysisOptions,
         _salt,
         _sdkBundle.apiSignature);
     _scheduler._add(this);
     _search = new Search(this);
   }
 
   /**
    * Return the set of files explicitly added to analysis using [addFile].
    */
   Set<String> get addedFiles => _addedFiles;
 
   /**
+   * Return the analysis options used to control analysis.
+   */
+  AnalysisOptions get analysisOptions => _analysisOptions;
+
+  /**
    * Return the stream that produces [ExceptionResult]s.
    */
   Stream<ExceptionResult> get exceptions => _exceptionController.stream;
 
   /**
    * The current file system state.
    */
   FileSystemState get fsState => _fsState;
 
   /**
@@ skipping 57 matching lines @@
    * using [addFile], for example when [getResult] was called for a file.
    */
   Stream<AnalysisResult> get results => _resultController.stream;
 
   /**
    * Return the search support for the driver.
    */
   Search get search => _search;
 
   /**
+   * Return the source factory used to resolve URIs to paths and restore URIs
+   * from file paths.
+   */
+  SourceFactory get sourceFactory => _sourceFactory;
+
+  /**
    * Return the stream that produces [AnalysisStatus] events.
    */
   Stream<AnalysisStatus> get status => _statusSupport.stream;
 
   /**
    * Return the priority of work that the driver needs to perform.
    */
   AnalysisDriverPriority get _workPriority {
     if (_requestedFiles.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
@@ skipping 183 matching lines @@
    */
   Future<ParseResult> parseFile(String path) async {
     FileState file = _verifyApiSignature(path);
     RecordingErrorListener listener = new RecordingErrorListener();
     CompilationUnit unit = file.parse(listener);
     return new ParseResult(file.path, file.uri, file.content, file.contentHash,
         unit.lineInfo, unit, listener.errors);
   }
 
   /**
+   * Some state on which analysis depends has changed, so everything needs to be
+   * re-analyzed.
+   *
+   * At least one of the optional parameters should be provided, but only those
+   * that represent state that has changed need be provided.
+   */
+  void reanalyze(

[scheglov, 2016/12/12 18:42:04]

Maybe call this "configure" and don't actually specify that it will reanalyze
everything.
We will implement it as analysis of everything, but this could be changed in the
future.

Yes, we need to reset the file state because URI resolution might be different
now, unlinked summaries are different because of different parsing options, etc.

+      {AnalysisOptions analysisOptions, SourceFactory sourceFactory}) {
+    if (analysisOptions != null) {
+      _analysisOptions = analysisOptions;
+    }
+    if (sourceFactory != null) {
+      _sourceFactory = sourceFactory;
+    }
+    _filesToAnalyze.addAll(_addedFiles);
+    _statusSupport.transitionToAnalyzing();
+    _scheduler._notify(this);
+  }
+
+  /**
    * Remove the file with the given [path] from the list of files to analyze.
    *
    * The [path] must be absolute and normalized.
    *
    * The results of analysis of the file might still be produced by the
    * [results] stream. The driver will try to stop producing these results,
    * but does not guarantee this.
    */
   void removeFile(String path) {
     _addedFiles.remove(path);
@@ skipping 117 matching lines @@
           new LibrarySpecificUnit(libraryFile.source, file.source),
           COMPILATION_UNIT_ELEMENT);
     } finally {
       analysisContext.dispose();
     }
   }
 
   AnalysisContext _createAnalysisContext(_LibraryContext libraryContext) {
     AnalysisContextImpl analysisContext =
         AnalysisEngine.instance.createAnalysisContext();
-    analysisContext.analysisOptions = analysisOptions;
+    analysisContext.analysisOptions = _analysisOptions;
 
-    analysisContext.sourceFactory = sourceFactory.clone();
+    analysisContext.sourceFactory = _sourceFactory.clone();
     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.
    */
@@ skipping 49 matching lines @@
       });
 
       Map<String, LinkedLibraryBuilder> linkedLibraries = {};
       _logger.run('Link bundles', () {
         linkedLibraries = link(libraryUrisToLink, (String uri) {
           LinkedLibrary linkedLibrary = store.linkedMap[uri];
           return linkedLibrary;
         }, (String uri) {
           UnlinkedUnit unlinkedUnit = store.unlinkedMap[uri];
           return unlinkedUnit;
-        }, (_) => null, analysisOptions.strongMode);
+        }, (_) => null, _analysisOptions.strongMode);
         _logger.writeln('Linked ${linkedLibraries.length} bundles.');
       });
 
       linkedLibraries.forEach((uri, linkedBuilder) {
         FileState library = libraries[uri];
         String key = '${library.transitiveSignature}.linked';
         List<int> bytes = linkedBuilder.toBuffer();
         LinkedLibrary linked = new LinkedLibrary.fromBuffer(bytes);
         store.addLinkedLibrary(uri, linked);
         _byteStore.put(key, bytes);
       });
 
       return new _LibraryContext(library, store);
     });
   }
 
   /**
    * Fill [_salt] with data.
    */
   void _fillSalt() {
     _salt[0] = DATA_VERSION;
-    List<int> crossContextOptions = analysisOptions.encodeCrossContextOptions();
+    List<int> crossContextOptions =
+        _analysisOptions.encodeCrossContextOptions();
     assert(crossContextOptions.length ==
         AnalysisOptions.crossContextOptionsLength);
     for (int i = 0; i < crossContextOptions.length; i++) {
       _salt[i + 1] = crossContextOptions[i];
     }
   }
 
   /**
    * Load the [AnalysisResult] for the given [file] from the [bytes]. Set
    * optional [content] and [resolvedUnit].
    */
   AnalysisResult _getAnalysisResultFromBytes(FileState file, List<int> bytes,
       {String content, bool withErrors: true, CompilationUnit resolvedUnit}) {
     var unit = new AnalysisDriverResolvedUnit.fromBuffer(bytes);
     List<AnalysisError> errors = withErrors
         ? _getErrorsFromSerialized(file, unit.errors)
         : const <AnalysisError>[];
-    return new AnalysisResult(this, sourceFactory, file.path, file.uri, content,
-        file.contentHash, file.lineInfo, resolvedUnit, errors, unit.index);
+    return new AnalysisResult(
+        this,
+        _sourceFactory,
+        file.path,
+        file.uri,
+        content,
+        file.contentHash,
+        file.lineInfo,
+        resolvedUnit,
+        errors,
+        unit.index);
   }
 
   /**
    * Return [AnalysisError]s for the given [serialized] errors.
    */
   List<AnalysisError> _getErrorsFromSerialized(
       FileState file, List<AnalysisDriverUnitError> serialized) {
     return serialized.map((error) {
       String errorName = error.uniqueName;
       ErrorCode errorCode =
@@ skipping 23 matching lines @@
   }
 
   /**
    * Return the lint code with the given [errorName], or `null` if there is no
    * lint registered with that name or the lint is not enabled in the analysis
    * options.
    */
   ErrorCode _lintCodeByUniqueName(String errorName) {
     if (errorName.startsWith('_LintCode.')) {
       String lintName = errorName.substring(10);
-      List<Linter> lintRules = analysisOptions.lintRules;
+      List<Linter> lintRules = _analysisOptions.lintRules;
       for (Linter linter in lintRules) {
         if (linter.name == lintName) {
           return linter.lintCode;
         }
       }
     }
     return null;
   }
 
   /**
@@ skipping 685 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }