Compact incremental cache when we're done using it.

pkg/analyzer_cli/lib/src/incremental_analyzer.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.
 
 library analyzer_cli.src.incremental_analyzer;
 
 import 'dart:io' as io;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
@@ skipping 30 matching lines @@
     CacheStorage storage = new FolderCacheStorage(
         PhysicalResourceProvider.INSTANCE.getFolder(cachePath),
         '${io.pid}.temp');
     List<int> configSalt = <int>[
       context.analysisOptions.encodeCrossContextOptions()
     ];
     IncrementalCache cache = new IncrementalCache(storage, context, configSalt);
     context.resultProvider = new _CacheBasedResultProvider(context, cache);
     // Listen for new libraries to put into the cache.
     _IncrementalAnalysisSession session =
-        new _IncrementalAnalysisSession(options, context, cache);
+        new _IncrementalAnalysisSession(options, storage, context, cache);
     context
         .onResultChanged(LIBRARY_ELEMENT1)
         .listen((ResultChangedEvent event) {
       if (event.wasComputed) {
         session.newLibrarySources.add(event.target.source);
       }
     });
     return session;
   }
   // Incremental analysis cannot be used.
@@ skipping 103 matching lines @@
       if (addedLibraryBundleIds.add(bundleWithId.id)) {
         addBundle(null, bundleWithId.bundle);
       }
     }
     return true;
   }
 }
 
 class _IncrementalAnalysisSession implements IncrementalAnalysisSession {
   final CommandLineOptions commandLineOptions;
+  final CacheStorage cacheStorage;
   final AnalysisContext context;
   final IncrementalCache cache;
 
   final Set<Source> newLibrarySources = new Set<Source>();
 
   _IncrementalAnalysisSession(
-      this.commandLineOptions, this.context, this.cache);
+      this.commandLineOptions, this.cacheStorage, this.context, this.cache);
 
   @override
   void finish() {
     // Finish computing new libraries and put them into the cache.
     for (Source librarySource in newLibrarySources) {
       if (!commandLineOptions.machineFormat) {
         print('Compute library element for $librarySource');
       }
       _putLibrary(librarySource);
     }
+    // Compact the cache.
+    cacheStorage.compact();
   }
 
   @override
   void setAnalyzedSources(Iterable<Source> sources) {
     for (Source source in sources) {
       SourceKind kind = context.computeKindOf(source);
       if (kind == SourceKind.LIBRARY) {
         context.computeResult(source, LINE_INFO);
         context.computeResult(source, IGNORE_INFO);
         context.computeResult(source, INCLUDED_PARTS);
@@ skipping 12 matching lines @@
     // Write errors for the library units.
     for (CompilationUnitElement unit in libraryElement.units) {
       Source unitSource = unit.source;
       List<AnalysisError> errors = context.computeResult(
           new LibrarySpecificUnit(librarySource, unitSource),
           LIBRARY_UNIT_ERRORS);
       cache.putSourceErrorsInLibrary(librarySource, unitSource, errors);
     }
   }
 }