Add a test for pub's async_await compiler.

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:args/args.dart';
 import 'package:analyzer/src/services/formatter_impl.dart';
 import 'package:async_await/async_await.dart' as async_await;
+import 'package:stack_trace/stack_trace.dart';
 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.
-final generatedDir = p.join(p.dirname(sourceDir), 'pub_generated');
+String generatedDir;
 
 /// `true` if any file failed to compile.
 bool hadFailure = false;
 
 bool verbose = false;
 
 /// Prefix for imports in pub that import dart2js libraries.
 final _compilerPattern = new RegExp(r"import '(\.\./)+compiler");
 
 /// Matches the Git commit hash of the compiler stored in the README.md file.
 ///
 /// This is used both to find the current commit and replace it with the new
 /// one.
 final _commitPattern = new RegExp(r"[a-f0-9]{40}");
 
+/// The template for the README that's added to the generated source.
+///
+/// This is used to store the current commit of the async_await compiler.
+const _README = """
+Pub is currently dogfooding the new Dart async/await syntax. Since the Dart VM
+doesn't natively support it yet, we are using the [async-await][] compiler
+package.
+
+[async-await]: https://github.com/dart-lang/async_await
+
+We run that to compile pub-using-await from sdk/lib/_internal/pub down to
+vanilla Dart code which is what you see here. To interoperate more easily with
+the rest of the repositry, we check in that generated code.
+
+When bug #104 is fixed, we can remove this entirely.
+
+The code here was compiled using the async-await compiler at commit:
+
+    <<COMMIT>>
+
+(Note: this file is also parsed by a tool to update the above commit, so be
+careful not to reformat it.)
+""";
+
 /// 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) {
   var parser = new ArgParser(allowTrailingOptions: true);
 
   parser.addFlag("verbose", callback: (value) => verbose = value);
 
   var force = false;
   parser.addFlag("force", callback: (value) => force = value);
 
+  var snapshot = true;
+  parser.addFlag("snapshot", callback: (value) => snapshot = value);
+
   var buildDir;
 
   try {
     var rest = parser.parse(arguments).rest;
     if (rest.isEmpty) {
+      throw new FormatException('Missing generated and build directory.');
+    } else if (rest.length == 1) {
       throw new FormatException('Missing build directory.');
-    } else if (rest.length > 1) {
+    } else if (rest.length > 2) {
       throw new FormatException(
-          'Unexpected arguments: ${rest.skip(1).join(" ")}.');
+          'Unexpected arguments: ${rest.skip(2).join(" ")}.');
     }
 
-    buildDir = rest.first;
+    generatedDir = rest[0];
+    buildDir = rest[1];
   } on FormatException catch(ex) {
     stderr.writeln(ex);
     stderr.writeln();
     stderr.writeln(
-        "Usage: dart async_compile.dart [--verbose] [--force] <build dir>");
+        "Usage: dart async_compile.dart [--verbose] [--force] [--no-snapshot] "
+        "<generated dir> <build dir>");

[Bob Nystrom, 2014/12/02 19:15:50]

Is the build dir only used for the snapshot now? If so, how about making
"--snapshot-build-dir" an option where the directory is the option's value?

[nweiz, 2014/12/02 21:14:13]

Done.

     exit(64);
   }
 
   // See what version (i.e. Git commit) of the async-await compiler we
   // currently have. If this is different from the version that was used to
   // compile the sources, recompile everything.
   var currentCommit = _getCurrentCommit();
 
   var readmePath = p.join(generatedDir, "README.md");
   var lastCommit;
-  var readme = new File(readmePath).readAsStringSync();
-  var match = _commitPattern.firstMatch(readme);
-  if (match == null) {
-    stderr.writeln("Could not find compiler commit hash in README.md.");
-    exit(1);
+  try {
+    var readme = new File(readmePath).readAsStringSync();
+    var match = _commitPattern.firstMatch(readme);
+    if (match == null) {
+      stderr.writeln("Could not find compiler commit hash in README.md.");
+      exit(1);
+    }
+
+    lastCommit = match[0];
+  } on IOException catch (error, stackTrace) {
+    if (verbose) {
+      stderr.writeln("Failed to load $readmePath: $error\n"
+          "${new Trace.from(stackTrace)}");
+    }
   }
 
-  lastCommit = match[0];
-
   var numFiles = 0;
   var numCompiled = 0;
 
   // Compile any modified or missing files.
   var sources = new Set();
   for (var entry in new Directory(sourceDir).listSync(recursive: true)) {
     if (p.extension(entry.path) != ".dart") continue;
 
     numFiles++;
     var relative = p.relative(entry.path, from: sourceDir);
@@ skipping 19 matching lines @@
     var relative = p.relative(entry.path, from: generatedDir);
 
     if (!sources.contains(relative)) {
       _deleteFile(entry.path);
       if (verbose) print("Deleted  $relative");
     }
   }
 
   // Update the README.
   if (currentCommit != lastCommit) {
-    readme = readme.replaceAll(_commitPattern, currentCommit);
-    _writeFile(readmePath, readme);
+    _writeFile(readmePath, _README.replaceAll("<<COMMIT>>", currentCommit));
     if (verbose) print("Updated README.md");
   }
 
-  if (numCompiled > 0) _generateSnapshot(buildDir);
+  if (numCompiled > 0 && snapshot) _generateSnapshot(buildDir);
 
   if (verbose) print("Compiled $numCompiled out of $numFiles files");
 
   if (hadFailure) exit(1);
 }
 
 String _getCurrentCommit() {
   var command = "git";
   var args = ["rev-parse", "HEAD"];
 
@@ skipping 65 matching lines @@
   var relative = p.url.relative(compilerDir,
       from: p.url.dirname(p.toUri(destPath).toString()));
   return source.replaceAll(_compilerPattern, "import '$relative");
 }
 
 /// Regenerate the pub snapshot from the async/await-compiled output. We do
 /// this here since the tests need it and it's faster than doing a full SDK
 /// build.
 void _generateSnapshot(String buildDir) {
   buildDir = p.normalize(buildDir);
+  new Directory(dir).createSync(recursive: true);
 
   var entrypoint = p.join(generatedDir, 'bin/pub.dart');
   var packageRoot = p.join(buildDir, 'packages');
   var snapshot = p.join(buildDir, 'dart-sdk/bin/snapshots/pub.dart.snapshot');
 
   var result = Process.runSync(Platform.executable, [
     "--package-root=$packageRoot",
     "--snapshot=$snapshot",
     entrypoint
   ]);
@@ skipping 24 matching lines @@
 ///
 /// This swallows errors to accommodate multiple compilers running concurrently.
 /// Since they will produce the same output anyway, a failure of one is fine.
 void _writeFile(String path, String contents) {
   try {
     new File(path).writeAsStringSync(contents);
   } on IOException catch (ex) {
     // Do nothing.
   }
 }