Revert "Use native async/await support in pub."

sdk/lib/_internal/pub_generated/lib/src/command/serve.dart

Index: sdk/lib/_internal/pub_generated/lib/src/command/serve.dart
diff --git a/sdk/lib/_internal/pub_generated/lib/src/command/serve.dart b/sdk/lib/_internal/pub_generated/lib/src/command/serve.dart
new file mode 100644
index 0000000000000000000000000000000000000000..5c5062b52638a21204052c145b989feae9a3b3d0
--- /dev/null
+++ b/sdk/lib/_internal/pub_generated/lib/src/command/serve.dart
@@ -0,0 +1,264 @@
+// Copyright (c) 2013, 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 pub.command.serve;
+
+import 'dart:async';
+import 'dart:math' as math;
+
+import 'package:barback/barback.dart';
+
+import '../barback/asset_environment.dart';
+import '../barback/pub_package_provider.dart';
+import '../log.dart' as log;
+import '../utils.dart';
+import 'barback.dart';
+
+final _arrow = getSpecial('\u2192', '=>');
+
+/// Handles the `serve` pub command.
+class ServeCommand extends BarbackCommand {
+  String get name => "serve";
+  String get description =>
+      'Run a local web development server.\n\n'
+          'By default, this serves "web/" and "test/", but an explicit list of \n'
+          'directories to serve can be provided as well.';
+  String get invocation => "pub serve [directories...]";
+  String get docUrl => "http://dartlang.org/tools/pub/cmd/pub-serve.html";
+
+  PubPackageProvider _provider;
+
+  String get hostname => argResults['hostname'];
+
+  /// The base port for the servers.
+  ///
+  /// This will print a usage error and exit if the specified port is invalid.
+  int get port => parseInt(argResults['port'], 'port');
+
+  /// The port for the admin UI.
+  ///
+  /// This will print a usage error and exit if the specified port is invalid.
+  int get adminPort {
+    var adminPort = argResults['admin-port'];
+    return adminPort == null ? null : parseInt(adminPort, 'admin port');
+  }
+
+  /// `true` if Dart entrypoints should be compiled to JavaScript.
+  bool get useDart2JS => argResults['dart2js'];
+
+  /// `true` if the admin server URL should be displayed on startup.
+  bool get logAdminUrl => argResults['log-admin-url'];
+
+  BarbackMode get defaultMode => BarbackMode.DEBUG;
+
+  List<String> get defaultSourceDirectories => ["web", "test"];
+
+  /// This completer is used to keep pub running (by not completing) and to
+  /// pipe fatal errors to pub's top-level error-handling machinery.
+  final _completer = new Completer();
+
+  ServeCommand() {
+    argParser.addOption(
+        'hostname',
+        defaultsTo: 'localhost',
+        help: 'The hostname to listen on.');
+    argParser.addOption(
+        'port',
+        defaultsTo: '8080',
+        help: 'The base port to listen on.');
+
+    // TODO(rnystrom): A hidden option to print the URL that the admin server
+    // is bound to on startup. Since this is currently only used for the Web
+    // Socket interface, we don't want to show it to users, but the tests and
+    // Editor need this logged to know what port to bind to.
+    // Remove this (and always log) when #16954 is fixed.
+    argParser.addFlag('log-admin-url', defaultsTo: false, hide: true);
+
+    // TODO(nweiz): Make this public when issue 16954 is fixed.
+    argParser.addOption('admin-port', hide: true);
+
+    argParser.addFlag(
+        'dart2js',
+        defaultsTo: true,
+        help: 'Compile Dart to JavaScript.');
+    argParser.addFlag(
+        'force-poll',
+        defaultsTo: false,
+        help: 'Force the use of a polling filesystem watcher.');
+  }
+
+  Future onRunTransformerCommand() {
+    final completer0 = new Completer();
+    scheduleMicrotask(() {
+      try {
+        var port = parseInt(argResults['port'], 'port');
+        join0(x0) {
+          var adminPort = x0;
+          join1(x1) {
+            var watcherType = x1;
+            new Future.value(
+                AssetEnvironment.create(
+                    entrypoint,
+                    mode,
+                    watcherType: watcherType,
+                    hostname: hostname,
+                    basePort: port,
+                    useDart2JS: useDart2JS)).then((x2) {
+              try {
+                var environment = x2;
+                var directoryLength = sourceDirectories.map(((dir) {
+                  return dir.length;
+                })).reduce(math.max);
+                new Future.value(
+                    environment.startAdminServer(adminPort)).then((x3) {
+                  try {
+                    var server = x3;
+                    server.results.listen(((_) {
+                      assert(false);
+                    }), onError: _fatalError);
+                    join2() {
+                      environment.pauseUpdates();
+                      var it0 = sourceDirectories.iterator;
+                      break0() {
+                        environment.barback.errors.listen(((error) {
+                          log.error(log.red("Build error:\n$error"));
+                        }));
+                        environment.barback.results.listen(((result) {
+                          if (result.succeeded) {
+                            log.message(
+                                "Build completed ${log.green('successfully')}");
+                          } else {
+                            log.message(
+                                "Build completed with " "${log.red(result.errors.length)} errors.");
+                          }
+                        }), onError: _fatalError);
+                        environment.resumeUpdates();
+                        new Future.value(_completer.future).then((x4) {
+                          try {
+                            x4;
+                            completer0.complete();
+                          } catch (e0, s0) {
+                            completer0.completeError(e0, s0);
+                          }
+                        }, onError: completer0.completeError);
+                      }
+                      var trampoline0;
+                      continue0() {
+                        trampoline0 = null;
+                        if (it0.moveNext()) {
+                          var directory = it0.current;
+                          new Future.value(
+                              _startServer(environment, directory, directoryLength)).then((x5) {
+                            trampoline0 = () {
+                              trampoline0 = null;
+                              try {
+                                x5;
+                                trampoline0 = continue0;
+                                do trampoline0(); while (trampoline0 != null);
+                              } catch (e1, s1) {
+                                completer0.completeError(e1, s1);
+                              }
+                            };
+                            do trampoline0(); while (trampoline0 != null);
+                          }, onError: completer0.completeError);
+                        } else {
+                          break0();
+                        }
+                      }
+                      trampoline0 = continue0;
+                      do trampoline0(); while (trampoline0 != null);
+                    }
+                    if (logAdminUrl) {
+                      log.message(
+                          "Running admin server on " "${log.bold('http://${hostname}:${server.port}')}");
+                      join2();
+                    } else {
+                      join2();
+                    }
+                  } catch (e2, s2) {
+                    completer0.completeError(e2, s2);
+                  }
+                }, onError: completer0.completeError);
+              } catch (e3, s3) {
+                completer0.completeError(e3, s3);
+              }
+            }, onError: completer0.completeError);
+          }
+          if (argResults['force-poll']) {
+            join1(WatcherType.POLLING);
+          } else {
+            join1(WatcherType.AUTO);
+          }
+        }
+        if (argResults['admin-port'] == null) {
+          join0(null);
+        } else {
+          join0(parseInt(argResults['admin-port'], 'admin port'));
+        }
+      } catch (e, s) {
+        completer0.completeError(e, s);
+      }
+    });
+    return completer0.future;
+  }
+
+  Future _startServer(AssetEnvironment environment, String rootDirectory,
+      int directoryLength) {
+    final completer0 = new Completer();
+    scheduleMicrotask(() {
+      try {
+        new Future.value(environment.serveDirectory(rootDirectory)).then((x0) {
+          try {
+            var server = x0;
+            join0() {
+              var prefix =
+                  log.gray(padRight("[${server.rootDirectory}]", directoryLength + 2));
+              server.results.listen(((result) {
+                var buffer = new StringBuffer();
+                buffer.write("$prefix ");
+                if (result.isSuccess) {
+                  buffer.write(
+                      "${log.green('GET')} ${result.url.path} $_arrow ${result.id}");
+                } else {
+                  buffer.write("${log.red('GET')} ${result.url.path} $_arrow");
+                  var error = result.error.toString();
+                  if (error.contains("\n")) {
+                    buffer.write("\n${prefixLines(error)}");
+                  } else {
+                    buffer.write(" $error");
+                  }
+                }
+                log.message(buffer);
+              }), onError: _fatalError);
+              log.message(
+                  "Serving ${entrypoint.root.name} "
+                      "${padRight(server.rootDirectory, directoryLength)} "
+                      "on ${log.bold('http://${hostname}:${server.port}')}");
+              completer0.complete();
+            }
+            if (mode == BarbackMode.RELEASE) {
+              server.allowAsset = ((url) {
+                return !url.path.endsWith(".dart");
+              });
+              join0();
+            } else {
+              join0();
+            }
+          } catch (e0, s0) {
+            completer0.completeError(e0, s0);
+          }
+        }, onError: completer0.completeError);
+      } catch (e, s) {
+        completer0.completeError(e, s);
+      }
+    });
+    return completer0.future;
+  }
+
+  /// Reports [error] and exits the server.
+  void _fatalError(error, [stackTrace]) {
+    if (_completer.isCompleted) return;
+    _completer.completeError(error, stackTrace);
+  }
+}