Refactor to use streams for reusability.

dart/pkg/dart2js_incremental/lib/compiler.dart

 // Copyright (c) 2015, 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:io';
 
 import 'dart:async' show
-    StreamSubscription,
     EventSink,
-    Future;
+    Future,
+    Stream,
+    StreamController,
+    StreamSubscription;
 
 import 'package:dart2js_incremental/dart2js_incremental.dart' show
     IncrementalCompilationFailed,
     IncrementalCompiler;
 
 import 'package:compiler/src/source_file_provider.dart' show
     FormattingDiagnosticHandler;
 
 import 'watcher.dart';
 
-main(List<String> arguments) async {
-  Uri originalInput = Uri.base.resolve(arguments.first);
+main(List<String> arguments) {
+  int updateCount = 0;
+  StreamSubscription<CompilerEvent> subscritpion =

[kasperl, 2015/01/20 13:58:31]

subscription 

[ahe, 2015/01/20 14:04:33]

Done.

+      compile(Uri.base.resolve(arguments.first)).listen(null);
+  subscritpion.onData((CompilerEvent event) {
+    switch (event.kind) {
+      case IncrementalKind.FULL:
+        updateCount = 0;
+        print('// Compiled JavaScript:');
+        print(event['.js']);
+        break;
+
+      case IncrementalKind.INCREMENTAL:
+        Stopwatch sw = event.stopwatch..start();
+        String updates = '${event.compiler.allUpdates()}';
+        sw.stop();
+
+        print('// Patch after ${++updateCount} updates,');
+        print('// computed in ${sw.elapsedMicroseconds/1000000} seconds:');
+        print(updates);
+        break;
+
+      case IncrementalKind.ERROR:
+        updateCount = 0;
+        print("Compilation failed");
+        break;
+
+      default:
+        throw "Unknown kind: ${event.kind}";
+    }
+  });
+  subscritpion.onError((error, StackTrace trace) {
+    if (error is IncrementalCompilationFailed) {
+      print("Incremental compilation failed due to:\n${error.reason}");
+    } else {
+      throw error;
+    }
+  });
+}
+
+Stream<CompilerEvent> compile(Uri originalInput) {
+  StreamController<CompilerEvent> controller =
+      new StreamController<CompilerEvent>();
+  compileToStream(originalInput, controller);
+  return controller.stream;
+}
+
+compileToStream(
+    Uri originalInput,
+    StreamController<CompilerEvent> controller) async {
   var watcher = new Watcher();
 
   Uri libraryRoot = Uri.base.resolve('sdk/');
   Uri packageRoot = Uri.base.resolve('packages/');
 
   FormattingDiagnosticHandler diagnosticHandler =
       new FormattingDiagnosticHandler();
 
   OutputProvider outputProvider = new OutputProvider();
 
   void resilientDiagnosticHandler(
       Uri uri, int begin, int end, String message, kind) {
     try {
       diagnosticHandler(uri, begin, end, message, kind);
     } catch (e) {
       String name = diagnosticHandler.provider.relativizeUri(uri);
       print('$name@$begin+${end - begin}: [$kind] $message}');
     }
   }
 
   Future inputProvider(Uri uri) {
     if (uri.scheme == "file") {
       watcher.watchFile(uri);
     }
     return diagnosticHandler.provider(uri);
   }
 
   while (true) {
+    Stopwatch sw = new Stopwatch()..start();
     IncrementalCompiler compiler = new IncrementalCompiler(
         libraryRoot: libraryRoot,
         packageRoot: packageRoot,
         inputProvider: inputProvider,
         diagnosticHandler: resilientDiagnosticHandler,
         outputProvider: outputProvider);
 
-    if (!await compiler.compile(originalInput)) {
-      print("Compilation failed");
+    bool success = await compiler.compile(originalInput);
+    sw.stop();
+    if (success) {
+      controller.add(
+          new CompilerEvent(
+              IncrementalKind.FULL, compiler, outputProvider.output, sw));
     } else {
-      print('// Compiled JavaScript:');
-      print(outputProvider['.js']);
+      controller.add(
+          new CompilerEvent(
+              IncrementalKind.ERROR, compiler, outputProvider.output, sw));
     }
 
-    int updateCount = 0;
     while (await watcher.hasChanges()) {
       try {
         Map<Uri, Uri> changes = watcher.readChanges();
 
-        Stopwatch sw = new Stopwatch()..start();
+        sw = new Stopwatch()..start();
         await compiler.compileUpdates(changes);
+        sw.stop();
 
-        String updates = '${compiler.allUpdates()}';
+        controller.add(
+            new CompilerEvent(
+                IncrementalKind.INCREMENTAL, compiler, outputProvider.output,
+                sw));
 
-        sw.stop();
-        print('// Patch after ${++updateCount} updates,');
-        print('// computed in ${sw.elapsedMicroseconds/1000000} seconds:');
-        print(updates);
-      } on IncrementalCompilationFailed catch (error) {
-        print("Incremental compilation failed due to:\n${error.reason}");
+      } on IncrementalCompilationFailed catch (error, trace) {
+        controller.addError(error, trace);
         break;
       }
     }
   }
 }
 
 /// Output provider which collects output in [output].
 class OutputProvider {
   final Map<String, String> output = new Map<String, String>();
 
@@ skipping 23 matching lines @@
     throw 'addError($errorEvent, $stackTrace)';
   }
 
   void close() {
     if (data != null) {
       onClose(data.join());
       data = null;
     }
   }
 }
+
+enum IncrementalKind {
+  FULL,
+  INCREMENTAL,
+  ERROR,
+}
+
+class CompilerEvent {
+  final IncrementalKind kind;
+
+  final IncrementalCompiler compiler;
+
+  final Map<String, String> _output;
+
+  final Stopwatch stopwatch;
+
+  CompilerEvent(this.kind, this.compiler, this._output, this.stopwatch);
+
+  String operator[](String key) => _output[key];
+}