Add AnalysisSession to analyzer

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/context/context_root.dart';
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/analysis/results.dart' as results;
+import 'package:analyzer/dart/analysis/session.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart'
     show CompilationUnitElement, LibraryElement;
 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/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/analysis/file_tracker.dart';
 import 'package:analyzer/src/dart/analysis/index.dart';
 import 'package:analyzer/src/dart/analysis/library_analyzer.dart';
 import 'package:analyzer/src/dart/analysis/library_context.dart';
 import 'package:analyzer/src/dart/analysis/search.dart';
+import 'package:analyzer/src/dart/analysis/session.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,
         PerformanceStatistics;
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source.dart';
@@ skipping 238 matching lines @@
    * once and cache all the resolved units.
    */
   final bool disableChangesAndCacheAllResults;
 
   /**
    * The cache to use with [disableChangesAndCacheAllResults].
    */
   final Map<String, AnalysisResult> _allCachedResults = {};
 
   /**
+   * The current analysis session.
+   *
+   * TODO(brianwilkerson) Create a new session when the current session might
+   * produce inconsistent results.
+   */
+  AnalysisSession _currentSession;
+
+  /**
    * Create a new instance of [AnalysisDriver].
    *
    * 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,
       PerformanceLog logger,
       this._resourceProvider,
       this._byteStore,
       this._contentOverlay,
       this.contextRoot,
       SourceFactory sourceFactory,
       this._analysisOptions,
       {PackageBundle sdkBundle,
       this.disableChangesAndCacheAllResults: false,
       SummaryDataStore externalSummaries})
       : _logger = logger,
         _sourceFactory = sourceFactory.clone(),
         _sdkBundle = sdkBundle,
         _externalSummaries = externalSummaries {
+    _currentSession = new DriverBasedAnalysisSession(this);
     _onResults = _resultController.stream.asBroadcastStream();
     _testView = new AnalysisDriverTestView(this);
     _createFileTracker();
     _scheduler.add(this);
     _search = new Search(this);
   }
 
   /**
    * Return the set of files explicitly added to analysis using [addFile].
    */
   Set<String> get addedFiles => _fileTracker.addedFiles;
 
   /**
    * Return the analysis options used to control analysis.
    */
   AnalysisOptions get analysisOptions => _analysisOptions;
 
   /**
+   * Return the current analysis session.
+   */
+  AnalysisSession get currentSession => _currentSession;
+
+  /**
    * Return the stream that produces [ExceptionResult]s.
    */
   Stream<ExceptionResult> get exceptions => _exceptionController.stream;
 
   /**
    * The current file system state.
    */
   FileSystemState get fsState => _fsState;
 
   @override
@@ skipping 199 matching lines @@
     // If no cached analysis result, it will be computed.
     AnalysisResult analysisResult = _computeAnalysisResult(path);
 
     // If not computed yet, because a part file without a known library,
     // we have to compute the full analysis result, with the unit.
     analysisResult ??= await getResult(path);
     if (analysisResult == null) {
       return null;
     }
 
-    return new ErrorsResult(path, analysisResult.uri, analysisResult.lineInfo,
-        analysisResult.errors);
+    return new ErrorsResult(currentSession, path, analysisResult.uri,
+        analysisResult.lineInfo, analysisResult.errors);
   }
 
   /**
    * Return a [Future] that completes with the list of added files that
    * define a class member with the given [name].
    */
   Future<List<String>> getFilesDefiningClassMemberName(String name) {
     var task = new _FilesDefiningClassMemberNameTask(this, name);
     _definingClassMemberNameTasks.add(task);
     _scheduler.notify(this);
@@ skipping 173 matching lines @@
    * The [path] can be any file - explicitly or implicitly analyzed, or neither.
    *
    * The parsing is performed in the method itself, and the result is not
    * produced through the [results] stream (just because it is not a fully
    * resolved unit).
    */
   Future<ParseResult> parseFile(String path) async {
     FileState file = _fileTracker.verifyApiSignature(path);
     RecordingErrorListener listener = new RecordingErrorListener();
     CompilationUnit unit = file.parse(listener);
-    return new ParseResult(file.path, file.uri, file.content, unit.lineInfo,
-        unit, listener.errors);
+    return new ParseResult(currentSession, file.path, file.uri, file.content,
+        unit.lineInfo, unit, listener.errors);
   }
 
   @override
   Future<Null> performWork() async {
     if (_fileTracker.verifyChangedFilesIfNeeded()) {
       return;
     }
 
     // Analyze a requested file.
     if (_requestedFiles.isNotEmpty) {
@@ skipping 312 matching lines @@
     FileState library = file.library ?? file;
 
     // Create the AnalysisContext to resynthesize elements in.
     LibraryContext libraryContext = _createLibraryContext(library);
 
     // Resynthesize the CompilationUnitElement in the context.
     try {
       CompilationUnitElement element =
           libraryContext.computeUnitElement(library.source, file.source);
       String signature = library.transitiveSignature;
-      return new UnitElementResult(path, file.uri, signature, element);
+      return new UnitElementResult(
+          currentSession, path, file.uri, signature, element);
     } finally {
       libraryContext.dispose();
     }
   }
 
   String _computeUnitElementSignature(String path) {
     FileState file = _fsState.getFileForPath(path);
     FileState library = file.library ?? file;
     return library.transitiveSignature;
   }
@@ skipping 511 matching lines @@
  * The result of analyzing of a single file.
  *
  * These results are self-consistent, i.e. [content], [contentHash], the
  * resolved [unit] correspond to each other. All referenced elements, even
  * external ones, are also self-consistent. But none of the results is
  * guaranteed to be consistent with the state of the files.
  *
  * Every result is independent, and is not guaranteed to be consistent with
  * any previously returned result, even inside of the same library.
  */
-class AnalysisResult implements results.ResolveResult {
+class AnalysisResult extends BaseAnalysisResult
+    implements results.ResolveResult {
   static final _UNCHANGED = new AnalysisResult(
       null, null, null, null, null, null, null, null, null, null, null);
 
   /**
    * The [AnalysisDriver] that produced this result.
    */
   final AnalysisDriver driver;
 
   /**
    * The [SourceFactory] with which the file was analyzed.
    */
   final SourceFactory sourceFactory;
 
-  @override
-  final String path;
-
-  @override
-  final Uri uri;
-
   /**
    * Return `true` if the file exists.
    */
   final bool exists;
 
   @override
   final String content;
 
   @override
   final LineInfo lineInfo;
@@ skipping 12 matching lines @@
   final List<AnalysisError> errors;
 
   /**
    * The index of the unit.
    */
   final AnalysisDriverUnitIndex _index;
 
   AnalysisResult(
       this.driver,
       this.sourceFactory,
-      this.path,
-      this.uri,
+      String path,
+      Uri uri,
       this.exists,
       this.content,
       this.lineInfo,
       this._signature,
       this.unit,
       this.errors,
-      this._index);
+      this._index)
+      : super(driver?.currentSession, path, uri);
 
   @override
   LibraryElement get libraryElement => unit.element.library;
 
   @override
   results.ResultState get state =>
       exists ? results.ResultState.VALID : results.ResultState.NOT_A_FILE;
 
   @override
   TypeProvider get typeProvider => unit.element.context.typeProvider;
 }
 
+abstract class BaseAnalysisResult implements results.AnalysisResult {
+  @override
+  final String path;
+
+  @override
+  final AnalysisSession session;

[scheglov, 2017/06/26 15:30:03]

This field should be the first.

[Brian Wilkerson, 2017/06/26 16:06:19]

Done

+
+  @override
+  final Uri uri;
+
+  BaseAnalysisResult(this.session, this.path, this.uri);
+}
+
 class DriverPerformance {
   static final PerformanceTag driver =
       PerformanceStatistics.analyzer.createChild('driver');
 
   static final PerformanceTag cache = driver.createChild('cache');
 }
 
 /**
  * An object that watches for the creation and removal of analysis drivers.
  *
@@ skipping 12 matching lines @@
   void removedDriver(AnalysisDriver driver);
 }
 
 /**
  * The errors in a single file.
  *
  * These results are self-consistent, i.e. [content], [contentHash], [errors]
  * correspond to each other. But none of the results is guaranteed to be
  * consistent with the state of the files.
  */
-class ErrorsResult implements results.ErrorsResult {
-  @override
-  final String path;
-
-  @override
-  final Uri uri;
-
+class ErrorsResult extends BaseAnalysisResult implements results.ErrorsResult {
   @override
   final LineInfo lineInfo;
 
   @override
   final List<AnalysisError> errors;
 
-  ErrorsResult(this.path, this.uri, this.lineInfo, this.errors);
+  ErrorsResult(
+      AnalysisSession session, String path, Uri uri, this.lineInfo, this.errors)
+      : super(session, path, uri);
 
   @override
   results.ResultState get state => results.ResultState.VALID;
 }
 
 /**
  * Exception that happened during analysis.
  */
 class ExceptionResult {
   /**
@@ skipping 19 matching lines @@
   ExceptionResult(this.path, this.exception, this.contextKey);
 }
 
 /**
  * The result of parsing of a single file.
  *
  * These results are self-consistent, i.e. [content], [contentHash], the
  * resolved [unit] correspond to each other. But none of the results is
  * guaranteed to be consistent with the state of the files.
  */
-class ParseResult implements results.ParseResult {
-  @override
-  final String path;
-
-  @override
-  final Uri uri;
-
+class ParseResult extends BaseAnalysisResult implements results.ParseResult {
   @override
   final String content;
 
   @override
   final LineInfo lineInfo;
 
   @override
   final CompilationUnit unit;
 
   @override
   final List<AnalysisError> errors;
 
-  ParseResult(
-      this.path, this.uri, this.content, this.lineInfo, this.unit, this.errors);
+  ParseResult(AnalysisSession session, String path, Uri uri, this.content,
+      this.lineInfo, this.unit, this.errors)
+      : super(session, path, uri);
 
   @override
   results.ResultState get state => results.ResultState.VALID;
 }
 
 /**
  * The result with the [CompilationUnitElement] of a single file.
  *
  * These results are self-consistent, i.e. all elements and types accessible
  * through [element], including defined in other files, correspond to each
  * other. But none of the results is guaranteed to be consistent with the state
  * of the files.
  *
  * Every result is independent, and is not guaranteed to be consistent with
  * any previously returned result, even inside of the same library.
  */
-class UnitElementResult implements results.UnitElementResult {
-  @override
-  final String path;
-
-  @override
-  final Uri uri;
-
+class UnitElementResult extends BaseAnalysisResult
+    implements results.UnitElementResult {
   /**
    * The signature of the [element] is based the APIs of the files of the
    * library (including the file itself) of the requested file and the
    * transitive closure of files imported and exported by the library.
    */
   final String signature;
 
   /**
    * The element of the file.
    */
   final CompilationUnitElement element;
 
-  UnitElementResult(this.path, this.uri, this.signature, this.element);
+  UnitElementResult(AnalysisSession session, String path, Uri uri,
+      this.signature, this.element)
+      : super(session, path, uri);
 
   @override
   results.ResultState get state => results.ResultState.VALID;
 }
 
 /**
  * Information about an exception and its context.
  */
 class _ExceptionState {
   final exception;
@@ skipping 177 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }