Add AnalysisDriver.getUnitElementSignature() for checking without resynthesizing.

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/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 161 matching lines @@
   final _topLevelNameDeclarationsTasks = <_TopLevelNameDeclarationsTask>[];
 
   /**
    * The mapping from the files for which the index was requested using
    * [getIndex] to the [Completer]s to report the result.
    */
   final _indexRequestedFiles =
       <String, List<Completer<AnalysisDriverUnitIndex>>>{};
 
   /**
+   * The mapping from the files for which the unit element key was requested
+   * using [getUnitElementSignature] to the [Completer]s to report the result.
+   */
+  final _unitElementSignatureRequests = <String, List<Completer<String>>>{};
+
+  /**
    * The mapping from the files for which the unit element was requested using
    * [getUnitElement] to the [Completer]s to report the result.
    */
   final _unitElementRequestedFiles =
       <String, List<Completer<UnitElementResult>>>{};
 
   /**
    * The mapping from the files for which analysis was requested using
    * [getResult], and which were found to be parts without known libraries,
    * to the [Completer]s to report the result.
@@ skipping 171 matching lines @@
     if (_requestedFiles.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
     if (_definingClassMemberNameTasks.isNotEmpty ||
         _referencingNameTasks.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
     if (_indexRequestedFiles.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
+    if (_unitElementSignatureRequests.isNotEmpty) {
+      return AnalysisDriverPriority.interactive;
+    }
     if (_unitElementRequestedFiles.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
     if (_topLevelNameDeclarationsTasks.isNotEmpty) {
       return AnalysisDriverPriority.interactive;
     }
     if (_priorityFiles.isNotEmpty) {
       for (String path in _priorityFiles) {
         if (_fileTracker.isFilePending(path)) {
           return AnalysisDriverPriority.priority;
@@ skipping 223 matching lines @@
     }
     var completer = new Completer<UnitElementResult>();
     _unitElementRequestedFiles
         .putIfAbsent(path, () => <Completer<UnitElementResult>>[])
         .add(completer);
     _scheduler.notify(this);
     return completer.future;
   }
 
   /**
+   * Return a [Future] that completes with the signature for the
+   * [UnitElementResult] for the file with the given [path], or with `null` if
+   * the file cannot be analyzed.
+   *
+   * The signature is based on the content of the file, and the transitive
+   * closure of files imported and exported by the the library of the requested
+   * file.
+   */
+  Future<String> getUnitElementSignature(String path) {
+    if (!_fileTracker.fsState.hasUri(path)) {
+      return new Future.value();
+    }
+    var completer = new Completer<String>();
+    _unitElementSignatureRequests
+        .putIfAbsent(path, () => <Completer<String>>[])
+        .add(completer);
+    _scheduler.notify(this);
+    return completer.future;
+  }
+
+  /**
    * Return a [Future] that completes with a [ParseResult] for the file
    * with the given [path].
    *
    * The [path] must be absolute and normalized.
    *
    * 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).
@@ skipping 126 matching lines @@
     FileState file = _fileTracker.fsState.getFileForPath(path);
     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 key = _getResolvedUnitKey(library, file);
-      return new UnitElementResult(path, file.contentHash, key, element);
+      String signature = _getResolvedUnitSignature(library, file);
+      return new UnitElementResult(path, file.contentHash, signature, element);
     } finally {
       libraryContext.dispose();
     }
   }
 
+  String _computeUnitElementSignature(String path) {
+    FileState file = _fileTracker.fsState.getFileForPath(path);
+    FileState library = file.library ?? file;
+    return _getResolvedUnitSignature(library, file);
+  }
+
   /**
    * Creates a new [FileTracker] object and stores it in [_fileTracker].
    *
    * This is used both on initial construction and whenever the configuration
    * changes.
    */
   void _createFileTracker(PerformanceLog logger) {
     _fillSalt();
     _fileTracker = new FileTracker(logger, _byteStore, _contentOverlay,
         _resourceProvider, sourceFactory, _analysisOptions, _salt, _changeHook);
@@ skipping 64 matching lines @@
         // errors were written.
         throw new StateError('No ErrorCode for $errorName in $file');
       }
       return new AnalysisError.forValues(file.source, error.offset,
           error.length, errorCode, error.message, error.correction);
     }).toList();
   }
 
   /**
    * Return the key to store fully resolved results for the [file] in the
-   * [library] into the cache. Return `null` if the dependency signature is
-   * not known yet.
+   * [library] into the cache.
    */
   String _getResolvedUnitKey(FileState library, FileState file) {
+    String signature = _getResolvedUnitSignature(library, file);
+    return '$signature.resolved';
+  }
+
+  /**
+   * Return the signature that identifies fully resolved results for the [file]
+   * in the [library], e.g. element model, errors, index, etc.
+   */
+  String _getResolvedUnitSignature(FileState library, FileState file) {
     ApiSignature signature = new ApiSignature();
     signature.addUint32List(_salt);
     signature.addString(library.transitiveSignature);
     signature.addString(file.contentHash);
-    return '${signature.toHex()}.resolved';
+    return signature.toHex();
   }
 
   /**
    * 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);
@@ skipping 46 matching lines @@
     // Process an index request.
     if (_indexRequestedFiles.isNotEmpty) {
       String path = _indexRequestedFiles.keys.first;
       AnalysisDriverUnitIndex index = _computeIndex(path);
       _indexRequestedFiles.remove(path).forEach((completer) {
         completer.complete(index);
       });
       return;
     }
 
-    // Process a unit request.
+    // Process a unit element key request.
+    if (_unitElementSignatureRequests.isNotEmpty) {
+      String path = _unitElementSignatureRequests.keys.first;
+      String signature = _computeUnitElementSignature(path);
+      _unitElementSignatureRequests.remove(path).forEach((completer) {
+        completer.complete(signature);
+      });
+      return;
+    }
+
+    // Process a unit element request.
     if (_unitElementRequestedFiles.isNotEmpty) {
       String path = _unitElementRequestedFiles.keys.first;
       UnitElementResult result = _computeUnitElement(path);
       _unitElementRequestedFiles.remove(path).forEach((completer) {
         completer.complete(result);
       });
       return;
     }
 
     // Compute files defining a name.
@@ skipping 663 matching lines @@
    * The path of the file, absolute and normalized.
    */
   final String path;
 
   /**
    * The MD5 hash of the file content.
    */
   final String contentHash;
 
   /**
-   * The key of the [element] based on the transitive closure of files imported
-   * and exported by the requested file.
+   * The signature of the [element] based on the content of the file, and the
+   * transitive closure of files imported and exported by the the library of
+   * the requested file.
    */
-  final String key;
+  final String signature;
 
   /**
    * The element of the file.
    */
   final CompilationUnitElement element;
 
-  UnitElementResult(this.path, this.contentHash, this.key, this.element);
+  UnitElementResult(this.path, this.contentHash, this.signature, this.element);
 }
 
 /**
  * Information about an exception and its context.
  */
 class _ExceptionState {
   final exception;
   final StackTrace stackTrace;
 
   /**
@@ skipping 174 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }