Use async/await.

dart/pkg/dart2js_incremental/lib/server.dart

 // Copyright (c) 2012, 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 dart2js_incremental.server;
 
 import 'dart:io';
 
 import 'dart:async' show
     Future,
@@ skipping 35 matching lines @@
 
   Future badRequest(String problem) {
     response
         ..headers.set(CONTENT_TYPE, 'text/html')
         ..statusCode = HttpStatus.BAD_REQUEST
         ..write(
             htmlInfo("Bad request", "Bad request '${request.uri}': $problem"));
     return response.close();
   }
 
-  Future handleSocket() {
+  Future handleSocket() async {
     if (false && request.uri.path == '/ws/watch') {
-      return WebSocketTransformer.upgrade(request).then((WebSocket socket) {
-        socket.add(JSON.encode({'create': []}));
-        // WatchHandler handler = new WatchHandler(socket, files);
-        // handlers.add(handler);
-        // socket.listen(
-        //     handler.onData, cancelOnError: true, onDone: handler.onDone);
-      });
+      WebSocket socket = await WebSocketTransformer.upgrade(request);
+      socket.add(JSON.encode({'create': []}));
+      // WatchHandler handler = new WatchHandler(socket, files);
+      // handlers.add(handler);
+      // socket.listen(
+      //     handler.onData, cancelOnError: true, onDone: handler.onDone);
     } else {
       response.done
           .then(onClosed)
           .catchError(onError);
-      return notFound(request.uri);
+      return await notFound(request.uri);

[kasperl, 2015/01/19 14:22:59]

I don't think you have to await here. The futures are automatically "flattened".
Not sure if it ever makes (a lot of) sense to await as the last part of a return
expression.

[ahe, 2015/01/19 14:52:37]

(We discussed this in person, attempting to summarize here).

Yes. I don't have to await here. However, if I were to wrap the code above in a
try/catch block, I wouldn't get the desired behavior. So as a matter of style, I
think the right thing do to is to always await in an async method.

     }
   }
 
   Future handle() {
     response.done
-      .then(onClosed)
-      .catchError(onError);
+        .then(onClosed)
+        .catchError(onError);
 
     Uri uri = request.uri;
     if (uri.path.endsWith('/')) {
       uri = uri.resolve('index.html');
     }
     if (uri.path.contains('..') || uri.path.contains('%')) {
       return notFound(uri);
     }
     String path = uri.path;
     Uri root = documentRoot;
     if (path.startsWith('${PACKAGES_PATH}/')) {
       root = packageRoot;
       path = path.substring(PACKAGES_PATH.length);
     }
 
     Uri resolvedRequest = root.resolve('.$path');
     switch (request.method) {
       case 'GET':
         return handleGet(resolvedRequest);
       default:
         String method = const HtmlEscape().convert(request.method);
         return badRequest("Unsupported method: '$method'");
     }
   }
 
-  Future handleGet(Uri uri) {
+  Future handleGet(Uri uri) async {
     String path = uri.path;
     var f = new File.fromUri(uri);
-    return f.exists().then((bool exists) {
-      if (!exists) {
-        if (path.endsWith('.dart.js')) {
-          Uri dartScript = uri.resolve(path.substring(0, path.length - 3));
-          return new File.fromUri(dartScript).exists().then((bool exists) {
-            if (exists) {
-              return compileToJavaScript(dartScript);
-            } else {
-              return notFound(request.uri);
-            }
-          });
+    if (!await f.exists()) {
+      if (path.endsWith('.dart.js')) {
+        Uri dartScript = uri.resolve(path.substring(0, path.length - 3));
+        if (await new File.fromUri(dartScript).exists()) {
+          return await compileToJavaScript(dartScript);
         }
-        return notFound(request.uri);
       }
-      if (path.endsWith('.html')) {
-        response.headers.set(CONTENT_TYPE, 'text/html');
-      } else if (path.endsWith('.dart')) {
-        response.headers.set(CONTENT_TYPE, 'application/dart');
-      } else if (path.endsWith('.js')) {
-        response.headers.set(CONTENT_TYPE, 'application/javascript');
-      } else if (path.endsWith('.ico')) {
-        response.headers.set(CONTENT_TYPE, 'image/x-icon');
-      } else if (path.endsWith('.appcache')) {
-        response.headers.set(CONTENT_TYPE, 'text/cache-manifest');
-      }
-      return f.openRead().pipe(response);
-    });
+      return await notFound(request.uri);
+    } else if (path.endsWith('.html')) {
+      response.headers.set(CONTENT_TYPE, 'text/html');
+    } else if (path.endsWith('.dart')) {
+      response.headers.set(CONTENT_TYPE, 'application/dart');
+    } else if (path.endsWith('.js')) {
+      response.headers.set(CONTENT_TYPE, 'application/javascript');
+    } else if (path.endsWith('.ico')) {
+      response.headers.set(CONTENT_TYPE, 'image/x-icon');
+    } else if (path.endsWith('.appcache')) {
+      response.headers.set(CONTENT_TYPE, 'text/cache-manifest');
+    }
+    return await f.openRead().pipe(response);
   }
 
   Future compileToJavaScript(Uri dartScript) {
     Uri outputUri = request.uri;
     print("Compiling $dartScript to $outputUri");
     // TODO(ahe): Implement this.
     throw new UnimplementedError("compileToJavaScript");
     return notFound(request.uri);
   }
 
-  Future dispatch() {
-    return new Future.sync(() {
-      return WebSocketTransformer.isUpgradeRequest(request)
+  Future dispatch() async {
+    try {
+      return await WebSocketTransformer.isUpgradeRequest(request)

[kasperl, 2015/01/19 14:22:59]

Here you definitely need the await.

[ahe, 2015/01/19 14:52:37]

Acknowledged.

           ? handleSocket()
           : handle();
-    }).catchError(onError);
+    } catch (e, s) {
+      onError(e, s);
+    }
   }
 
-  static Future onRequest(HttpRequest request) {
+  static Future onRequest(HttpRequest request) async {
     HttpResponse response = request.response;
-    return
-        new Future.sync(() => new Conversation(request, response).dispatch())
-        .catchError((error, [stack]) {
-          onStaticError(error, stack);
-          return
-              new Future.sync(() => response.close()).catchError(onStaticError);
-        });
+    try {
+      return await new Conversation(request, response).dispatch();
+    } catch (e, s) {
+      try {
+        onStaticError(e, s);
+        return await response.close();
+      } catch (e, s) {
+        onStaticError(e, s);
+      }
+    }
   }
 
-  void onError(error, [stack]) {
-    onStaticError(error, stack);
-    new Future.sync(() => response.close()).catchError(onStaticError);
+  Future onError(error, [stack]) async {
+    try {
+      onStaticError(error, stack);
+      return await response.close();
+    } catch (e, s) {
+      onStaticError(e, s);
+    }
   }
 
   static void onStaticError(error, [stack]) {
     if (error is HttpException) {
       print('Error: ${error.message}');
     } else {
       print('Error: ${error}');
     }
     if (stack != null) {
       print(stack);
@@ skipping 12 matching lines @@
 </head>
 <body>
 <h1>$title</h1>
 <p style='white-space:pre'>$text</p>
 </body>
 </html>
 """;
   }
 }
 
-main(List<String> arguments) {
+main(List<String> arguments) async {
   Options options = Options.parse(arguments);
   if (options == null) {
     exit(1);
   }
   if (!options.arguments.isEmpty) {
     Conversation.documentRoot = Uri.base.resolve(options.arguments.single);
   }
   Conversation.packageRoot = options.packageRoot;
   String host = options.host;
   int port = options.port;
-  HttpServer.bind(host, port).then((HttpServer server) {
+  try {
+    HttpServer server = await HttpServer.bind(host, port);
     print('HTTP server started on http://$host:${server.port}/');
     server.listen(Conversation.onRequest, onError: Conversation.onStaticError);
-  }).catchError((e) {
+  } catch (e) {
     print("HttpServer.bind error: $e");
     exit(1);
-  });
+  };
 }