Hook async/await compiler into pub and use it.

sdk/lib/_internal/pub/bin/async_compile.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.
 
 import 'dart:io';
 
+import 'package:async_await/async_await.dart' as async_await;
 import 'package:path/path.dart' as p;
 
 /// The path to pub's root directory (sdk/lib/_internal/pub) in the Dart repo.
 ///
 /// This assumes this script is itself being run from within the repo.
 final sourceDir = p.dirname(p.dirname(p.fromUri(Platform.script)));
 
 /// The [sourceDir] as a URL, for use in import strings.
 final sourceUrl = p.toUri(sourceDir).toString();
 
 /// The directory that compiler output should be written to.
 String buildDir;
 
+/// `true` if any file failed to compile.
+bool hadFailure = false;
+
 /// This runs the async/await compiler on all of the pub source code.
 ///
 /// It reads from the repo and writes the compiled output into the given build
 /// directory (using the same file names and relative layout). Does not
 /// compile files that haven't changed since the last time they were compiled.
 // TODO(rnystrom): Remove this when #104 is fixed.
 void main(List<String> arguments) {
   _validate(arguments.isNotEmpty, "Missing build directory.");
   _validate(arguments.length <= 2, "Unexpected arguments.");
   if (arguments.length == 2) {
@@ skipping 25 matching lines @@
     var destFile = new File(destPath);
     if (!destFile.existsSync() ||
         entry.lastModifiedSync().isAfter(destFile.lastModifiedSync())) {
       compile(sourceFile.path, sourceFile.readAsStringSync(), destPath);
       numCompiled++;
       if (!silent) print("Compiled ${sourceFile.path}.");
     }
   }
 
   if (!silent) print("Compiled $numCompiled out of $numFiles files.");
+
+  if (hadFailure) exit(1);
 }
 
 final _compilerPattern = new RegExp(r"import '(\.\./)+compiler");
 
 void compile(String sourcePath, String source, String destPath) {
   var destDir = new Directory(p.dirname(destPath));
   destDir.createSync(recursive: true);
 
-  // TODO(rnystrom): Do real async/await transformation here!
-  source = source.replaceAll("ASYNC!", "");
+  if (p.isWithin(p.join(sourceDir, "asset"), sourcePath)) {
+    // Don't run the async compiler on the special "asset" source files. These
+    // have preprocessor comments that get discarded by the compiler.

[nweiz, 2014/08/27 20:10:07]

Maybe factor this into a function so you can short-circuit here?

[Bob Nystrom, 2014/08/27 21:35:31]

Done.

+  } else {
+    try {
+      source = async_await.compile(source);
+    } catch (ex) {
+      stderr.writeln("Async compile failed on $sourcePath:\n$ex");
+      hadFailure = true;
+
+      // If the async compile fails, delete the file so that we don't try to
+      // run the stale previous output and so that we try to recompile it later.
+      try {
+        new File(destPath).deleteSync();
+      } on IOException catch (ex) {
+        // Do nothing. This may happen if two instances of the compiler are running

[nweiz, 2014/08/27 20:10:07]

Long lines.

[Bob Nystrom, 2014/08/27 21:35:32]

Done.

+        // concurrently and compile the same file. The second one to try to write
+        // the output may fail if the file is still open. Since they are producing

[nweiz, 2014/08/27 20:10:07]

"write the output" -> "delete the file"

[Bob Nystrom, 2014/08/27 21:35:32]

Done.

+        // the same output anyway, just ignore it when the second one fails.
+      }
+
+      return;
+    }
+  }
 
   // Pub imports dart2js using relative imports that reach outside of pub's
   // source tree. Since the build directory is in a different location, we need
   // to fix those to be valid relative imports from the build directory.
   var compilerDir = p.url.join(sourceUrl, "../compiler");
   var relative = p.url.relative(compilerDir, from: destDir.path);
   source = source.replaceAll(_compilerPattern, "import '$relative");
 
   try {
     new File(destPath).writeAsStringSync(source);
   } on IOException catch (ex) {
     // Do nothing. This may happen if two instances of the compiler are running
     // concurrently and compile the same file. The second one to try to write
     // the output may fail if the file is still open. Since they are producing
     // the same output anyway, just ignore it when the second one fails.
   }
 }
 
 /// Validates command-line argument usage and exits with [message] if [valid]
 /// is `false`.
 void _validate(bool valid, String message) {
   if (valid) return;
 
   stderr.writeln(message);
   stderr.writeln();
   stderr.writeln("Usage: dart async_compile.dart <build dir> [--silent]");
   exit(64);
 }