Refactor LibraryUpdater to prepare for parts.

dart/site/try/poi/poi.dart

 // Copyright (c) 2014, 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 trydart.poi;
 
 import 'dart:async' show
     Completer,
     Future;
 
 import 'dart:io' as io;
 
 import 'dart:convert' show
     UTF8;
 
 import 'package:dart2js_incremental/dart2js_incremental.dart' show
     INCREMENTAL_OPTIONS,
     reuseCompiler;
 
 import 'package:dart2js_incremental/library_updater.dart' show
+    IncrementalCompilerContext,
     LibraryUpdater;
 
 import 'package:compiler/src/source_file_provider.dart' show
     FormattingDiagnosticHandler;
 
 import 'package:compiler/compiler.dart' as api;
 
 import 'package:compiler/src/dart2jslib.dart' show
     Compiler,
     CompilerTask,
@@ skipping 368 matching lines @@
     options.add('--minify');
   }
 
   LibraryUpdater updater;
 
   Future<bool> reuseLibrary(LibraryElement library) {
     return poiTask.measure(() => updater.reuseLibrary(library));
   }
 
   Future<Compiler> invokeReuseCompiler() {
+    var context = new IncrementalCompilerContext();
     updater = new LibraryUpdater(
-        cachedCompiler, inputProvider, script, printWallClock, printVerbose);
+        cachedCompiler, inputProvider, printWallClock, printVerbose, context);
+    context.registerUriWithUpdates([script]);
     return reuseCompiler(
         diagnosticHandler: handler,
         inputProvider: inputProvider,
         options: options,
         cachedCompiler: cachedCompiler,
         libraryRoot: libraryRoot,
         packageRoot: packageRoot,
         packagesAreImmutable: true,
         reuseLibrary: reuseLibrary);
   }
 
   return invokeReuseCompiler().then((Compiler newCompiler) {
     // TODO(ahe): Move this "then" block to [reuseCompiler].
     if (updater.failed) {
       cachedCompiler = null;
       return invokeReuseCompiler();
     } else {
       return newCompiler;
     }
   }).then((Compiler newCompiler) {
     if (!isCompiler) {
       newCompiler.enqueuerFilter = new ScriptOnlyFilter(script);
     }
-    return runPoiInternal(newCompiler, sw, updater, position);
+    return runPoiInternal(newCompiler, sw, updater, script, position);
   });
 }
 
 Future<Element> runPoiInternal(
     Compiler newCompiler,
     Stopwatch sw,
     LibraryUpdater updater,
+    Uri uri,
     int position) {
   bool isFullCompile = cachedCompiler != newCompiler;
   cachedCompiler = newCompiler;
   if (poiTask == null || poiTask.compiler != cachedCompiler) {
     poiTask = new PoiTask(cachedCompiler);
     cachedCompiler.tasks.add(poiTask);
   }
 
   if (!isFullCompile) {
     printFormattedTime(
         'Analyzing changes and updating elements took', sw.elapsedMicroseconds);
   }
   sw.reset();
 
   Future<bool> compilation;
 
   if (updater.hasPendingUpdates) {
     compilation = new Future(() {
       var node = js.statement(
           r'var $dart_patch = #', js.escapedString(updater.computeUpdateJs()));
       print(updater.prettyPrintJs(node));
 
       return !cachedCompiler.compilationFailed;
     });
   } else {
-    compilation = cachedCompiler.run(updater.uri);
+    compilation = cachedCompiler.run(uri);
   }
 
   return compilation.then((success) {
     printVerbose('Compiler queue processed in ${sw.elapsedMicroseconds}us');
     if (isVerbose) {
       for (final task in cachedCompiler.tasks) {
         int time = task.timingMicroseconds;
         if (time != 0) {
           printFormattedTime('${task.name} took', time);
         }
@@ skipping 71 matching lines @@
     f(work);
     printWallClock('Processed ${work.element}.');
   }
 }
 
 class PoiTask extends CompilerTask {
   PoiTask(Compiler compiler) : super(compiler);
 
   String get name => 'POI';
 }