Store index into AnalysisDriverResolvedUnit and return in AnalysisResult.

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/error/error.dart';
 import 'package:analyzer/error/listener.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/status.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisEngine, AnalysisOptions, ChangeSet;
 import 'package:analyzer/src/generated/source.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/summary/summarize_elements.dart';
@@ skipping 34 matching lines @@
  *
  *
  * TODO(scheglov) Clean up the list of implicitly analyzed files.
  *
  * TODO(scheglov) Handle not existing 'dart:x' URIs (while user is typing).
  */
 class AnalysisDriver {
   /**
    * The version of data format, should be incremented on every format change.
    */
-  static const int DATA_VERSION = 6;
+  static const int DATA_VERSION = 7;
 
   /**
    * The name of the driver, e.g. the name of the folder.
    */
   String name;
 
   /**
    * The scheduler that schedules analysis work in this, and possibly other
    * analysis drivers.
    */
@@ skipping 386 matching lines @@
       // Prepare the key for the cached result.
       String key = _getResolvedUnitKey(libraryFile, file);
       if (key == null) {
         _logger.run('Compute the dependency hash for $path', () {
           _createLibraryContext(libraryFile);
           key = _getResolvedUnitKey(libraryFile, file);
         });
       }
 
       // Check for the cached result.
-      AnalysisResult result = _getCachedAnalysisResult(file, key);
-      if (result != null) {
-        return result;
+      List<int> bytes = _byteStore.get(key);
+      if (bytes != null) {
+        return _getAnalysisResultFromBytes(file, bytes);
       }
     }
 
     // We need the fully resolved unit, or the result is not cached.
     return _logger.run('Compute analysis result for $path', () {
       FileState file = _verifyApiSignature(path);
 
       // 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) Add support for parts.
-        CompilationUnit resolvedUnit = withUnit
-            ? analysisContext.resolveCompilationUnit2(
-                file.source, libraryFile.source)
-            : null;
+        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;
         {
-          List<int> bytes = new AnalysisDriverResolvedUnitBuilder(
+          bytes = new AnalysisDriverResolvedUnitBuilder(
                   errors: errors
                       .map((error) => new AnalysisDriverUnitErrorBuilder(
                           offset: error.offset,
                           length: error.length,
                           uniqueName: error.errorCode.uniqueName,
                           message: error.message,
                           correction: error.correction))
-                      .toList())
+                      .toList(),
+                  index: index)
               .toBuffer();
           String key = _getResolvedUnitKey(libraryFile, file);
           _byteStore.put(key, bytes);
         }
 
         // Return the result, full or partial.
         _logger.writeln('Computed new analysis result.');
-        return new AnalysisResult(
-            _sourceFactory,
-            file.path,
-            file.uri,
-            withUnit ? file.content : null,
-            file.contentHash,
-            file.lineInfo,
-            resolvedUnit,
-            errors);
+        return _getAnalysisResultFromBytes(file, bytes,
+            content: withUnit ? file.content : null,
+            resolvedUnit: withUnit ? resolvedUnit : null);
       } finally {
         analysisContext.dispose();
       }
     });
   }
 
   AnalysisContext _createAnalysisContext(_LibraryContext libraryContext) {
     AnalysisContextImpl analysisContext =
         AnalysisEngine.instance.createAnalysisContext();
     analysisContext.analysisOptions = _analysisOptions;
@@ skipping 113 matching lines @@
     List<int> crossContextOptions =
         _analysisOptions.encodeCrossContextOptions();
     assert(crossContextOptions.length ==
         AnalysisOptions.crossContextOptionsLength);
     for (int i = 0; i < crossContextOptions.length; i++) {
       _salt[i + 1] = crossContextOptions[i];
     }
   }
 
   /**
-   * If we know the result [key] for the [file], try to load the analysis
-   * result from the cache. Return `null` if not found.
+   * Load the [AnalysisResult] for the given [file] from the [bytes]. Set
+   * optional [content] and [resolvedUnit].
    */
-  AnalysisResult _getCachedAnalysisResult(FileState file, String key) {
-    List<int> bytes = _byteStore.get(key);
-    if (bytes != null) {
-      var unit = new AnalysisDriverResolvedUnit.fromBuffer(bytes);
-      List<AnalysisError> errors = unit.errors
-          .map((error) => new AnalysisError.forValues(
-              file.source,
-              error.offset,
-              error.length,
-              errorCodeByUniqueName(error.uniqueName),
-              error.message,
-              error.correction))
-          .toList();
-      return new AnalysisResult(_sourceFactory, file.path, file.uri, null,
-          file.contentHash, file.lineInfo, null, errors);
-    }
-    return null;
+  AnalysisResult _getAnalysisResultFromBytes(FileState file, List<int> bytes,
+      {String content, CompilationUnit resolvedUnit}) {
+    var unit = new AnalysisDriverResolvedUnit.fromBuffer(bytes);
+    List<AnalysisError> errors = unit.errors
+        .map((error) => new AnalysisError.forValues(
+            file.source,
+            error.offset,
+            error.length,
+            errorCodeByUniqueName(error.uniqueName),
+            error.message,
+            error.correction))
+        .toList();
+    return new AnalysisResult(_sourceFactory, file.path, file.uri, content,
+        file.contentHash, file.lineInfo, resolvedUnit, errors, unit.index);
   }
 
   /**
    * 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.
    */
   String _getResolvedUnitKey(FileState library, FileState file) {
     ApiSignature signature = new ApiSignature();
     signature.addUint32List(_salt);
@@ skipping 296 matching lines @@
   /**
    * The fully resolved compilation unit for the [content].
    */
   final CompilationUnit unit;
 
   /**
    * The full list of computed analysis errors, both syntactic and semantic.
    */
   final List<AnalysisError> errors;
 
+  /**
+   * The index of the unit.
+   */
+  final AnalysisDriverUnitIndex index;
+
   AnalysisResult(this.sourceFactory, this.path, this.uri, this.content,
-      this.contentHash, this.lineInfo, this.unit, this.errors);
+      this.contentHash, this.lineInfo, this.unit, this.errors, this.index);
 }
 
 /**
  * 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 {
@@ skipping 134 matching lines @@
   @override
   int get hashCode => uri.hashCode;
 
   bool operator ==(other) {
     return other is _LibraryNode && other.uri == uri;
   }
 
   @override
   String toString() => uri.toString();
 }