AnalysisDriver.getUnitElement() should return a structure with a key.

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 index was requested using
-   * [getIndex] to the [Completer]s to report the result.
+   * 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<CompilationUnitElement>>>{};
+      <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.
    */
   final _requestedParts = <String, List<Completer<AnalysisResult>>>{};
 
   /**
    * The set of part files that are currently scheduled for analysis.
@@ skipping 393 matching lines @@
    */
   Future<List<TopLevelDeclarationInSource>> getTopLevelNameDeclarations(
       String name) {
     var task = new _TopLevelNameDeclarationsTask(this, name);
     _topLevelNameDeclarationsTasks.add(task);
     _scheduler.notify(this);
     return task.completer.future;
   }
 
   /**
-   * Return a [Future] that completes with the [CompilationUnitElement] for the
+   * Return a [Future] that completes with the [UnitElementResult] for the
    * file with the given [path], or with `null` if the file cannot be analyzed.
    */
-  Future<CompilationUnitElement> getUnitElement(String path) {
+  Future<UnitElementResult> getUnitElement(String path) {
     if (!_fileTracker.fsState.hasUri(path)) {
       return new Future.value();
     }
-    var completer = new Completer<CompilationUnitElement>();
+    var completer = new Completer<UnitElementResult>();
     _unitElementRequestedFiles
-        .putIfAbsent(path, () => <Completer<CompilationUnitElement>>[])
+        .putIfAbsent(path, () => <Completer<UnitElementResult>>[])
         .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.
@@ skipping 121 matching lines @@
       }
     });
   }
 
   AnalysisDriverUnitIndex _computeIndex(String path) {
     AnalysisResult analysisResult = _computeAnalysisResult(path,
         withUnit: false, asIsIfPartWithoutLibrary: true);
     return analysisResult._index;
   }
 
-  CompilationUnitElement _computeUnitElement(String path) {
+  UnitElementResult _computeUnitElement(String path) {
     FileState file = _fileTracker.fsState.getFileForPath(path);
-    FileState libraryFile = file.library ?? file;
+    FileState library = file.library ?? file;
 
     // Create the AnalysisContext to resynthesize elements in.
-    LibraryContext libraryContext = _createLibraryContext(libraryFile);
+    LibraryContext libraryContext = _createLibraryContext(library);
 
     // Resynthesize the CompilationUnitElement in the context.
     try {
-      return libraryContext.computeUnitElement(libraryFile.source, file.source);
+      CompilationUnitElement element =
+          libraryContext.computeUnitElement(library.source, file.source);
+      String key = _getResolvedUnitKey(library, file);
+      return new UnitElementResult(path, file.contentHash, key, element);
     } finally {
       libraryContext.dispose();
     }
   }
 
   /**
    * Creates a new [FileTracker] object and stores it in [_fileTracker].
    *
    * This is used both on initial construction and whenever the configuration
    * changes.
@@ skipping 147 matching lines @@
       AnalysisDriverUnitIndex index = _computeIndex(path);
       _indexRequestedFiles.remove(path).forEach((completer) {
         completer.complete(index);
       });
       return;
     }
 
     // Process a unit request.
     if (_unitElementRequestedFiles.isNotEmpty) {
       String path = _unitElementRequestedFiles.keys.first;
-      CompilationUnitElement unitElement = _computeUnitElement(path);
+      UnitElementResult result = _computeUnitElement(path);
       _unitElementRequestedFiles.remove(path).forEach((completer) {
-        completer.complete(unitElement);
+        completer.complete(result);
       });
       return;
     }
 
     // Compute files defining a name.
     if (_definingClassMemberNameTasks.isNotEmpty) {
       _FilesDefiningClassMemberNameTask task =
           _definingClassMemberNameTasks.first;
       bool isDone = await task.perform();
       if (isDone) {
@@ skipping 636 matching lines @@
    */
   void exit() {
     _timer.stop();
     _logger._level--;
     int ms = _timer.elapsedMilliseconds;
     _logger.writeln('--- $_msg in $ms ms.');
   }
 }
 
 /**
+ * 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 {
+  /**
+   * 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.
+   */
+  final String key;
+
+  /**
+   * The element of the file.
+   */
+  final CompilationUnitElement element;
+
+  UnitElementResult(this.path, this.contentHash, this.key, this.element);
+}
+
+/**
  * Information about an exception and its context.
  */
 class _ExceptionState {
   final exception;
   final StackTrace stackTrace;
 
   /**
    * The key under which the context of the exception was stored, or `null`
    * if unknown, the maximum number of context to store was reached, etc.
    */
@@ skipping 171 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }