Compact incremental cache when we're done using it.

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:collection';
 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';
@@ skipping 36 matching lines @@
     return 1;
   }
   return 0;
 }
 
 /**
  * Storage for cache data.
  */
 abstract class CacheStorage {
   /**
+   * Compact the storage, e.g. remove unused entries.
+   */
+  void compact();
+
+  /**
    * Return bytes for the given [key], `null` if [key] is not in the storage.
    */
   List<int> get(String key);
 
   /**
    * Associate the [key] with the given [bytes].
    *
    * If the [key] was already in the storage, its associated value is changed.
    * 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 {
   /**
+   * The maximum number of entries to keep in the cache.
+   */
+  static const MAX_ENTRIES = 20000;
+
+  /**
    * 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);
+  /**
+   * The set of recently used entries, with the most recently used entries
+   * on the bottom.
+   */
+  final LinkedHashSet<String> _recentEntries = new LinkedHashSet<String>();
+
+  FolderCacheStorage(this.folder, this.tempFileName) {
+    try {
+      File file = folder.getChildAssumingFile('.entries');
+      if (file.exists) {
+        String entriesString = file.readAsStringSync();
+        List<String> entriesLists = entriesString.split('\n');
+        _recentEntries.addAll(entriesLists);
+      }
+    } catch (_) {}
+  }
+
+  @override
+  void compact() {
+    while (_recentEntries.length > MAX_ENTRIES) {
+      String key = _recentEntries.first;
+      _recentEntries.remove(key);
+      try {
+        folder.getChildAssumingFile(key).delete();
+      } catch (_) {}
+    }
+    try {
+      List<int> bytes = UTF8.encode(_recentEntries.join('\n'));
+      folder.getChildAssumingFile('.entries').writeAsBytesSync(bytes);
+    } catch (_) {}
+  }
 
   @override
   List<int> get(String key) {
     Resource file = folder.getChild(key);
     if (file is File) {
       try {
-        return file.readAsBytesSync();
+        List<int> bytes = file.readAsBytesSync();
+        _accessedKey(key);
+        return bytes;
       } 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);
+      _accessedKey(key);
     } catch (e) {}
   }
+
+  /**
+   * The given [key] was accessed, update recently used entries.
+   */
+  void _accessedKey(String key) {
+    _recentEntries.remove(key);
+    _recentEntries.add(key);
+  }
 }
 
 /**
  * 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.
@@ skipping 468 matching lines @@
    */
   final String id;
 
   /**
    * The payload bundle.
    */
   final PackageBundle bundle;
 
   LibraryBundleWithId(this.source, this.id, this.bundle);
 }