Add put/getSourceErrorsInLibrary to IncrementalCache.

pkg/analyzer/lib/src/summary/incremental_cache.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:convert';
 import 'dart:core' hide Resource;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/summarize_elements.dart';
 import 'package:convert/convert.dart';
 import 'package:crypto/crypto.dart';
 
 /**
  * Storage for cache data.
  */
@@ skipping 131 matching lines @@
         }
         closureBundles.add(new LibraryBundleWithId(source, key, bundle));
       }
       return closureBundles;
     } catch (e) {
       return null;
     }
   }
 
   /**
+   * Return cached errors in the given [source] in the context of the given
+   * [librarySource], or `null` if the cache does not have this information.
+   */
+  List<AnalysisError> getSourceErrorsInLibrary(
+      Source librarySource, Source source) {
+    try {
+      String key = _getSourceErrorsKey(librarySource, source);
+      List<int> bytes = storage.get(key);
+      if (bytes == null) {
+        return null;
+      }
+      CacheSourceErrorsInLibrary errorsObject =
+          new CacheSourceErrorsInLibrary.fromBuffer(bytes);
+      return errorsObject.errors
+          .map((e) => _convertErrorFromCached(source, e))
+          .toList();
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /**
    * Return the kind of the given [source], or `null` if unknown.
    */
   SourceKind getSourceKind(Source source) {
     try {
       CacheSourceContent contentSource = _getCacheSourceContent(source);
       if (contentSource != null) {
         if (contentSource.kind == CacheSourceKind.library) {
           return SourceKind.LIBRARY;
         }
         if (contentSource.kind == CacheSourceKind.part) {
@@ skipping 10 matching lines @@
   void putLibrary(LibraryElement libraryElement) {
     _writeCacheSourceContents(libraryElement);
     String key = _getLibraryBundleKey(libraryElement.source);
     PackageBundleAssembler assembler = new PackageBundleAssembler();
     assembler.serializeLibraryElement(libraryElement);
     List<int> bytes = assembler.assemble().toBuffer();
     storage.put(key, bytes);
   }
 
   /**
+   * Associate the given [errors] with the [source] in the [librarySource].
+   */
+  void putSourceErrorsInLibrary(
+      Source librarySource, Source source, List<AnalysisError> errors) {
+    CacheSourceErrorsInLibraryBuilder builder =
+        new CacheSourceErrorsInLibraryBuilder(
+            errors: errors.map(_convertErrorToCached).toList());
+    String key = _getSourceErrorsKey(librarySource, source);
+    List<int> bytes = builder.toBuffer();
+    storage.put(key, bytes);
+  }
+
+  /**
    * Fill the whole source closure of the library with the given
    * [librarySource]. It includes defining units and parts of the library and
    * all its directly or indirectly imported or exported libraries.
    */
   void _appendLibraryClosure(Set<Source> closure, Source librarySource) {
     if (closure.add(librarySource)) {
       CacheSourceContent contentSource = _getCacheSourceContent(librarySource);
       if (contentSource == null) {
         throw new StateError('No structure for $librarySource');
       }
@@ skipping 27 matching lines @@
     ByteConversionSink byteSink = md5.startChunkedConversion(digestSink);
     // Add data.
     addData(byteSink);
     byteSink.add(configSalt);
     // Done.
     byteSink.close();
     return digest.bytes;
   }
 
   /**
+   * Return the [AnalysisError] to the given [cachedError].
+   */
+  AnalysisError _convertErrorFromCached(
+      Source source, CacheAnalysisError cachedError) {
+    ErrorCode errorCode = _getErrorCode(cachedError);
+    return new AnalysisError.forValues(
+        source,
+        cachedError.offset,
+        cachedError.length,
+        errorCode,
+        cachedError.message,
+        cachedError.correction);
+  }
+
+  CacheAnalysisError _convertErrorToCached(AnalysisError e) {
+    return new CacheAnalysisErrorBuilder(
+        errorCodeClass: e.errorCode.runtimeType.toString(),
+        errorCodeField: e.errorCode.name,
+        offset: e.offset,
+        length: e.length,
+        message: e.message,
+        correction: e.correction);
+  }
+
+  /**
    * Get the content based information about the given [source], maybe `null`
    * if the information is not in the cache.
    */
   CacheSourceContent _getCacheSourceContent(Source source) {
     CacheSourceContent content = _sourceContentMap[source];
     if (content == null) {
       String key = _getCacheSourceContentKey(source);
       List<int> bytes = storage.get(key);
       if (bytes == null) {
         return null;
       }
       content = new CacheSourceContent.fromBuffer(bytes);
       _sourceContentMap[source] = content;
     }
     return content;
   }
 
   /**
    * Return the key of the content based [source] information.
    */
   String _getCacheSourceContentKey(Source source) {
     List<int> hash = _getSourceContentHash(source);
     String hashStr = hex.encode(hash);
     return '$hashStr.content';
   }
 
   /**
+   * Return the [ErrorCode] reference by the given [error], throws if not found.

[Paul Berry, 2016/06/06 20:03:31]

s/reference/referenced/

[scheglov, 2016/06/06 20:23:52]

Fixed.

+   */
+  ErrorCode _getErrorCode(CacheAnalysisError error) {
+    String name = '${error.errorCodeClass}.${error.errorCodeField}';
+    for (ErrorCode errorCode in ErrorCode.values) {

[Paul Berry, 2016/06/06 20:03:31]

I'm concerned that this is going to wind up being a performance bottleneck,
since on average it will have to iterate through 50% of all possible errors in
order to find the matching one.

Consider doing something like this:

final Map<String, ErrorCode> _errorCodeMap = _computeErrorCodeMap();

Map<String, ErrorCode> _computeErrorCodeMap() {
  for (ErrorCode errorCode in ErrorCode.values) {
    _errorCodeMap[errorCode.uniqueName] = errorCode;
  }
}

ErrorCode _getErrorCode(CacheAnalysisError error) {
  String name = '${error.errorCodeClass}.${error.errorCodeField}';
  ErrorCode errorCode = _errorCodeMap[name];
  if (errorCode != null) {
    return errorCode;
  } else {
    throw new StateError(...);
  }
}

[scheglov, 2016/06/06 20:23:52]

Good idea.
I've added the corresponding API to ErrorCode.

+      if (errorCode.uniqueName == name) {
+        return errorCode;
+      }
+    }
+    throw new StateError('Unable to find ErrorCode: $name');
+  }
+
+  /**
    * Get the bundle for the given key.
    */
   PackageBundle _getLibraryBundle(String key) {
     PackageBundle bundle = _bundleMap[key];
     if (bundle == null) {
       List<int> bytes = storage.get(key);
       if (bytes == null) {
         return null;
       }
       bundle = new PackageBundle.fromBuffer(bytes);
@@ skipping 44 matching lines @@
    * Compute a hash of the given [source] contents.
    */
   List<int> _getSourceContentHash(Source source) {
     return _sourceContentHashMap.putIfAbsent(source, () {
       String sourceText = source.contents.data;
       List<int> sourceBytes = UTF8.encode(sourceText);
       return md5.convert(sourceBytes).bytes;
     });
   }
 
+  String _getSourceErrorsKey(Source librarySource, Source source) {
+    List<int> hash = _computeSaltedMD5OfBytes((ByteConversionSink byteSink) {
+      byteSink.add(_getLibraryClosureHash(librarySource));
+      byteSink.add(_getSourceContentHash(source));
+    });
+    String hashStr = hex.encode(hash);
+    return '$hashStr.errorsInLibrary';
+  }
+
   /**
    * Return a source representing the URI that results from resolving the given
    * (possibly relative) [containedUri] against the URI associated with the
    * [containingSource], whether or not the resulting source exists, or `null`
    * if either the [containedUri] is invalid or if it cannot be resolved against
    * the [containingSource]'s URI.
    */
   Source _resolveUri(Source containingSource, String containedUri) {
     // Cache absolute URIs.
     if (containedUri.startsWith('dart:') ||
@@ skipping 86 matching lines @@
    */
   final String id;
 
   /**
    * The payload bundle.
    */
   final PackageBundle bundle;
 
   LibraryBundleWithId(this.source, this.id, this.bundle);
 }