Add source kind to the incremental cache.

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';
@@ skipping 25 matching lines @@
    * 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, CacheLibraryUris> _libraryUrisMap =
-      <Source, CacheLibraryUris>{};
+  final Map<Source, CacheSourceContent> _sourceContentMap =
+      <Source, CacheSourceContent>{};
   final Map<Source, List<Source>> _libraryClosureMap = <Source, List<Source>>{};
   final Map<Source, List<int>> _sourceContentHashMap = <Source, List<int>>{};
 
   LibraryBundleCache(
       this.tempFileName, this.cacheFolder, this.context, this.configSalt);
 
   /**
    * Clear internal caches so that we read from file system again.
    */
   void clearInternalCaches() {
-    _libraryUrisMap.clear();
+    _sourceContentMap.clear();
     _libraryClosureMap.clear();
     _sourceContentHashMap.clear();
   }
 
   /**
+   * 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) {
+          return SourceKind.PART;
+        }
+      }
+    } catch (e) {}
+    return null;
+  }
+
+  /**
    * Write information about the [library] into the cache.
    */
   void putLibrary(LibraryElement library) {
     try {
-      _writeUris(library);
+      _writeCacheSourceContents(library);
       List<int> hash = _getLibraryClosureHash(library.source);
       String hashStr = CryptoUtils.bytesToHex(hash);
       PackageBundleAssembler assembler = new PackageBundleAssembler();
       assembler.serializeLibraryElement(library);
       List<int> bytes = assembler.assemble().toBuffer();
       _safeWriteBytes('$hashStr.sum', bytes);
     } catch (e) {}
   }
 
   /**
@@ skipping 16 matching lines @@
     }
   }
 
   /**
    * 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)) {
-      CacheLibraryUris libraryUris = _getUris(librarySource);
-      if (libraryUris == null) {
-        throw new StateError('No URIs for $librarySource');
+      CacheSourceContent contentSource = _getCacheSourceContent(librarySource);
+      if (contentSource == null) {
+        throw new StateError('No structure for $librarySource');
       }
       // Append parts.
-      for (String partUri in libraryUris.partUris) {
+      for (String partUri in contentSource.partUris) {
         Source partSource =
             context.sourceFactory.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);
         if (refSource == null) {
           throw new StateError('Unable to resolve $refUri in $librarySource');
         }
         _appendLibraryClosure(closure, refSource);
       }
-      libraryUris.importedUris.forEach(appendLibrarySources);
-      libraryUris.exportedUris.forEach(appendLibrarySources);
+      contentSource.importedUris.forEach(appendLibrarySources);
+      contentSource.exportedUris.forEach(appendLibrarySources);
     }
   }
 
   /**
+   * 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 fileName = _getCacheSourceContentFileName(source);
+      List<int> bytes = _safeReadBytes(fileName);
+      if (bytes == null) {
+        return null;
+      }
+      content = new CacheSourceContent.fromBuffer(bytes);
+      _sourceContentMap[source] = content;
+    }
+    return content;
+  }
+
+  /**
+   * Return the name of the file with the content based [source] information.
+   */
+  String _getCacheSourceContentFileName(Source source) {
+    List<int> hash = _getSourceContentHash(source);
+    String hashStr = CryptoUtils.bytesToHex(hash);
+    return '$hashStr.content';
+  }
+
+  /**
    * Return the whole source closure of the library with the given
    * [librarySource]. It includes defining units and parts of the library and
    * of all its directly or indirectly imported or exported libraries.
    */
   List<Source> _getLibraryClosure(Source librarySource) {
     return _libraryClosureMap.putIfAbsent(librarySource, () {
       Set<Source> closure = new Set<Source>();
       _appendLibraryClosure(closure, librarySource);
       return closure.toList();
     });
@@ skipping 19 matching lines @@
    */
   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();
     });
   }
 
   /**
-   * Get the URIs information of the library with the given [librarySource],
-   * maybe `null` if the information is not in the cache.
-   */
-  CacheLibraryUris _getUris(Source librarySource) {
-    CacheLibraryUris uris = _libraryUrisMap[librarySource];
-    if (uris == null) {
-      String fileName = _getUrisFileName(librarySource);
-      List<int> bytes = _safeReadBytes(fileName);
-      if (bytes == null) {
-        return null;
-      }
-      uris = new CacheLibraryUris.fromBuffer(bytes);
-      _libraryUrisMap[librarySource] = uris;
-    }
-    return uris;
-  }
-
-  /**
-   * Return the name of the file with the [librarySource] URIs information.
-   */
-  String _getUrisFileName(Source librarySource) {
-    List<int> hash = _getSourceContentHash(librarySource);
-    String hashStr = CryptoUtils.bytesToHex(hash);
-    return '$hashStr.uris';
-  }
-
-  /**
    * Return bytes of the file with the given [relPath] in the cache, or `null`
    * if the file does not exist.
    */
   List<int> _safeReadBytes(String relPath) {
-    Resource urisFile = cacheFolder.getChild(relPath);
-    if (urisFile is File) {
+    Resource file = cacheFolder.getChild(relPath);
+    if (file is File) {
       try {
-        return urisFile.readAsBytesSync();
+        return file.readAsBytesSync();
       } on FileSystemException {}
     }
     return null;
   }
 
   /**
    * Atomically write the given [bytes] into the file with the given [relPath].
    * Silently ignores any errors.
    */
   void _safeWriteBytes(String relPath, List<int> bytes) {
     try {
       String absPath = cacheFolder.getChild(relPath).path;
       File tempFile = cacheFolder.getChild(tempFileName);
       tempFile.writeAsBytesSync(bytes);
       tempFile.renameSync(absPath);
     } catch (e) {}
   }
 
   /**
-   * Write URIs information for the given [library] and its direct and
-   * indirect imports/exports.
+   * Write the content based information about the given [source].
    */
-  void _writeUris(LibraryElement library,
+  void _writeCacheSourceContent(Source source, CacheSourceContentBuilder b) {
+    String fileName = _getCacheSourceContentFileName(source);
+    List<int> bytes = b.toBuffer();
+    _safeWriteBytes(fileName, bytes);
+    // Put into the cache to avoid reading it later.
+    _sourceContentMap[source] = new CacheSourceContent.fromBuffer(bytes);
+  }
+
+  /**
+   * Write [CacheSourceContent] for every unit of the given [library] and its
+   * direct and indirect imports/exports.
+   */
+  void _writeCacheSourceContents(LibraryElement library,
       [Set<LibraryElement> writtenLibraries]) {
     Source librarySource = library.source;
     // Do nothing if already cached.
-    if (_libraryUrisMap.containsKey(librarySource)) {
+    if (_sourceContentMap.containsKey(librarySource)) {
       return;
     }
     // Stop recursion cycle.
     writtenLibraries ??= new Set<LibraryElement>();
     if (!writtenLibraries.add(library)) {
       return;
     }
-    // Prepare import/export URIs.
+    // Write parts.
+    List<String> partUris = <String>[];
+    for (CompilationUnitElement part in library.parts) {
+      partUris.add(part.uri);
+      _writeCacheSourceContent(part.source,

[Paul Berry, 2016/03/18 18:38:14]

As per our discussion, this could corrupt the cache in the event that there is
invalid code.  For example:

a.dart:
import 'b.dart';
part 'c.dart';

b.dart:
import 'c.dart';

c.dart:
...

c.dart will first be inserted into the cache as a part, then it will be inserted
into the cache as a library (overwriting the old data).  Let's say c.dart is
actually intended to be a part.  If the user tries to correct the error by
removing the line "import 'c.dart';", then the cache will still say that c.dart
is a library.

If you'd like to address this in a future CL, please add a TODO comment so that
we don't forget about this corner case.

[scheglov, 2016/03/18 19:42:06]

Done.

+          new CacheSourceContentBuilder(kind: CacheSourceKind.part));
+    }
+    // Write imports.
     List<String> importUris = <String>[];
-    List<String> exportUris = <String>[];
     for (ImportElement element in library.imports) {
       String uri = element.uri;
       if (uri != null) {
         importUris.add(uri);
-        _writeUris(element.importedLibrary, writtenLibraries);
+        _writeCacheSourceContents(element.importedLibrary, writtenLibraries);
       }
     }
+    // Write exports.
+    List<String> exportUris = <String>[];
     for (ExportElement element in library.exports) {
       String uri = element.uri;
       if (uri != null) {
         exportUris.add(uri);
-        _writeUris(element.exportedLibrary, writtenLibraries);
+        _writeCacheSourceContents(element.exportedLibrary, writtenLibraries);
       }
     }
-    // Write the URIs.
-    CacheLibraryUrisBuilder b = new CacheLibraryUrisBuilder(
-        importedUris: importUris,
-        exportedUris: exportUris,
-        partUris: library.parts.map((e) => e.uri).toList());
-    List<int> bytes = b.toBuffer();
-    String fileName = _getUrisFileName(librarySource);
-    _safeWriteBytes(fileName, bytes);
-    // Put into the cache to avoid reading it later.
-    _libraryUrisMap[librarySource] = new CacheLibraryUris.fromBuffer(bytes);
+    // Write the library.
+    _writeCacheSourceContent(
+        librarySource,
+        new CacheSourceContentBuilder(
+            kind: CacheSourceKind.library,
+            importedUris: importUris,
+            exportedUris: exportUris,
+            partUris: partUris));
   }
 }