fix #626, add AMD module format and make it default

test/codegen/language/async_await_test.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.
 
 library async_await_test;
 
 import "package:unittest/unittest.dart";
 import "dart:async";
 
 main() {
@@ skipping 1518 matching lines @@
 
     test("sync in async", () {
       return expect42(syncInAsync(f42));
     });
 
     test("async in sync", () {
       return expect42(asyncInSync(f42));
     });
 
     // Equality and identity.
-    test("Identical and equals", () {
+    // TODO(jmesserly): https://github.com/dart-lang/dev_compiler/issues/265
+    skip_test("Identical and equals", () {
       expect(async.instanceMethod, equals(async.instanceMethod));
       expect(Async.staticMethod, same(Async.staticMethod));
       expect(topMethod, same(topMethod));
-    }, skip: 'https://github.com/dart-lang/dev_compiler/issues/265');
+    });
   });
 
   group("await expression", () {
     const c42 = 42;
     final v42 = 42;
 
     test("local variable", () {
       var l42 = 42;
       f() async {
         return await l42;
@@ skipping 62 matching lines @@
     });
 
     test("unary pre-increment operator", () {
       f() async {
         var x = 41;
         return await ++x;
       }
       return expect42(f());
     });
 
-    test("suffix operator + pre-increment", () {
+    // TODO(jmesserly): https://github.com/dart-lang/dev_compiler/issues/265
+    skip_test("suffix operator + pre-increment", () {
       f() async {
         var v = [41];
         return await ++v[0];
       }
       return expect42(f());
-    }, skip: 'https://github.com/dart-lang/dev_compiler/issues/267');
+    });
 
     test("assignment operator", () {
       f() async {
         var x = 37;
         return await (x = 42);
       }
       return expect42(f());
     });
 
     test("assignment-op operator", () {
@@ skipping 313 matching lines @@
   }
   return await inner(f);
 }
 
 /**
  * A non-standard implementation of Future with a value.
  */
 class FakeValueFuture implements Future {
   final _value;
   FakeValueFuture(this._value);
-  Future/*<S>*/ then/*<S>*/(/*=S*/ callback(value), {Function onError}) {
-    return new Future<dynamic /*=S*/>.microtask(() => callback(_value));
+  Future/*<S>*/ then/*<S>*/(callback(value), {Function onError}) {
+    return new Future/*<S>*/.microtask(() => callback(_value));
   }
   Future whenComplete(callback()) {
     return new Future.microtask(() { callback(); });
   }
   Future catchError(Function onError, {bool test(error)}) => this;
   Stream asStream() => (new StreamController()..add(_value)..close()).stream;
   Future timeout(Duration duration, {onTimeout()}) => this;
 }
 
 typedef BinaryFunction(a, b);
 
 /**
  * A non-standard implementation of Future with an error.
  */
 class FakeErrorFuture implements Future {
   final _error;
   FakeErrorFuture(this._error);
-  Future/*<S>*/ then/*<S>*/(/*=S*/ callback(value), {Function onError}) {
+  Future/*<S>*/ then/*<S>*/(callback(value), {Function onError}) {
     if (onError != null) {
       if (onError is BinaryFunction) {
         return new Future/*<S>*/.microtask(() => onError(_error, null));
       }
       return new Future/*<S>*/.microtask(() => onError(_error));
     }
     return new Future/*<S>*/.error(_error);
   }
   Future whenComplete(callback()) {
     return new Future.microtask(() { callback(); }).then((_) => this);
   }
   Future catchError(Function onError, {bool test(error)}) {
     return new Future.microtask(() {
       if (test != null && !test(_error)) return this;
       if (onError is BinaryFunction) {
         return onError(_error, null);
       }
       return onError(_error);
     });
   }
   Stream asStream() =>
       (new StreamController()..addError(_error)..close()).stream;
   Future timeout(Duration duration, {onTimeout()}) => this;
 }