Cache library closure hashes and absolute URIs.

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' show UTF8;
 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/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:crypto/crypto.dart';
 
 /**
  * Storage for cache data.
  */
@@ skipping 10 matching lines @@
    * Otherwise the key-value pair is added to the storage.
    *
    * It is not guaranteed that data will always be accessible using [get], in
    * some implementations association may silently fail or become inaccessible
    * after some time.
    */
   void put(String key, List<int> bytes);
 }
 
 /**
- * A [Folder] based implementation of [CacheStorage].
- */
-class FolderCacheStorage implements CacheStorage {

[Paul Berry, 2016/03/21 20:29:32]

I'm not sure I agree with the idea of removing this from analyzer and adding it
to analyzer_cli later.  It seems like the analysis server could make use of this
class in the future (and perhaps also DDC).  If we move it to analyzer_cli, it
will only be accessible to analyzer_cli.

[scheglov, 2016/03/21 20:58:26]

OK, restored.

-  /**
-   * The folder to read and write files.
-   */
-  final Folder folder;
-
-  /**
-   * To ensure that operations of writing files are atomic we create a temporary
-   * file with this name in the [folder] and then rename it once we are
-   * done writing.
-   */
-  final String tempFileName;
-
-  FolderCacheStorage(this.folder, this.tempFileName);
-
-  @override
-  List<int> get(String key) {
-    Resource file = folder.getChild(key);
-    if (file is File) {
-      try {
-        return file.readAsBytesSync();
-      } on FileSystemException {}
-    }
-    return null;
-  }
-
-  @override
-  void put(String key, List<int> bytes) {
-    String absPath = folder.getChild(key).path;
-    File tempFile = folder.getChild(tempFileName);
-    tempFile.writeAsBytesSync(bytes);
-    try {
-      tempFile.renameSync(absPath);
-    } catch (e) {}
-  }
-}
-
-/**
  * Cache of information to support incremental analysis.
  *
  * Note that currently this class is not intended for interactive use.
  */
 class IncrementalCache {
   /**
    * The storage for the cache data.
    */
   final CacheStorage storage;
 
   /**
    * The context in which this cache is used.
    */
   final AnalysisContext context;
 
   /**
    * Opaque data that reflects the current configuration, such as the [context]
    * options, and is mixed into the hashes.
    */
   final List<int> configSalt;
 
   final Map<Source, CacheSourceContent> _sourceContentMap =
       <Source, CacheSourceContent>{};
   final Map<Source, List<Source>> _libraryClosureMap = <Source, List<Source>>{};
+  final Map<Source, List<int>> _libraryClosureHashMap = <Source, List<int>>{};
   final Map<Source, List<int>> _sourceContentHashMap = <Source, List<int>>{};
 
   /**
    * Mapping from a library closure key to its [PackageBundle].
    */
   final Map<String, PackageBundle> _bundleMap = <String, PackageBundle>{};
 
+  final Map<String, Source> _absoluteUriMap = <String, Source>{};
+
   IncrementalCache(this.storage, this.context, this.configSalt);
 
   /**
    * Clear internal caches so that we read from file system again.
    */
   void clearInternalCaches() {
     _sourceContentMap.clear();
     _libraryClosureMap.clear();
     _sourceContentHashMap.clear();
     _bundleMap.clear();
@@ skipping 10 matching lines @@
    * using [LibraryBundleWithId.id].
    */
   List<LibraryBundleWithId> getLibraryClosureBundles(Source librarySource) {
     try {
       List<Source> closureSources = _getLibraryClosure(librarySource);
       List<LibraryBundleWithId> closureBundles = <LibraryBundleWithId>[];
       for (Source source in closureSources) {
         if (source.isInSystemLibrary) {
           continue;
         }
+        if (getSourceKind(source) == SourceKind.PART) {
+          continue;
+        }
         String key = _getLibraryBundleKey(source);
         PackageBundle bundle = _getLibraryBundle(key);
         if (bundle == null) {
           return null;
         }
         closureBundles.add(new LibraryBundleWithId(source, key, bundle));
       }
       return closureBundles;
     } catch (e) {
       return null;
@@ skipping 36 matching lines @@
    * 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');
       }
       // Append parts.
       for (String partUri in contentSource.partUris) {
-        Source partSource =
-            context.sourceFactory.resolveUri(librarySource, partUri);
+        Source partSource = _resolveUri(librarySource, partUri);
         if (partSource == null) {
           throw new StateError('Unable to resolve $partUri in $librarySource');
         }
         closure.add(partSource);
       }
       // Append imports and exports.
       void appendLibrarySources(String refUri) {
-        Source refSource =
-            context.sourceFactory.resolveUri(librarySource, refUri);
+        Source refSource = _resolveUri(librarySource, refUri);
         if (refSource == null) {
           throw new StateError('Unable to resolve $refUri in $librarySource');
         }
         _appendLibraryClosure(closure, refSource);
       }
       contentSource.importedUris.forEach(appendLibrarySources);
       contentSource.exportedUris.forEach(appendLibrarySources);
     }
   }
 
@@ skipping 60 matching lines @@
       _appendLibraryClosure(closure, librarySource);
       return closure.toList();
     });
   }
 
   /**
    * Return the [context]-specific hash of the closure of the library with
    * the given [librarySource].
    */
   List<int> _getLibraryClosureHash(Source librarySource) {
-    List<Source> closure = _getLibraryClosure(librarySource);
-    MD5 md5 = new MD5();
-    for (Source source in closure) {
-      List<int> sourceHash = _getSourceContentHash(source);
-      md5.add(sourceHash);
-    }
-    md5.add(configSalt);
-    return md5.close();
+    return _libraryClosureHashMap.putIfAbsent(librarySource, () {
+      List<Source> closure = _getLibraryClosure(librarySource);
+      MD5 md5 = new MD5();
+      for (Source source in closure) {
+        List<int> sourceHash = _getSourceContentHash(source);
+        md5.add(sourceHash);
+      }
+      md5.add(configSalt);
+      return md5.close();
+    });
   }
 
   /**
    * 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 (new MD5()..add(sourceBytes)).close();
     });
   }
 
   /**
+   * 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:') ||

[Paul Berry, 2016/03/21 20:29:32]

If the goal is to figure out whether this is an absolute URI, why not use
Uri.isAbsolute?

[scheglov, 2016/03/21 20:58:26]

See the performance results in mail.
URI operations are slow :-(

+        containedUri.startsWith('package:')) {
+      return _absoluteUriMap.putIfAbsent(containedUri, () {
+        return context.sourceFactory.resolveUri(containingSource, containedUri);
+      });
+    }
+    // Resolve relative URIs without caching.
+    return context.sourceFactory.resolveUri(containingSource, containedUri);
+  }
+
+  /**
    * Write the content based information about the given [source].
    */
   void _writeCacheSourceContent(Source source, CacheSourceContentBuilder b) {
     String key = _getCacheSourceContentKey(source);
     List<int> bytes = b.toBuffer();
     storage.put(key, bytes);
     // Put into the cache to avoid reading it later.
     _sourceContentMap[source] = new CacheSourceContent.fromBuffer(bytes);
   }
 
@@ skipping 66 matching lines @@
    */
   final String id;
 
   /**
    * The payload bundle.
    */
   final PackageBundle bundle;
 
   LibraryBundleWithId(this.source, this.id, this.bundle);
 }