Implement await and async for the js-ast.

tests/compiler/dart2js/js_parser_statements_test.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:async';
 import 'package:expect/expect.dart';
 import 'package:async_helper/async_helper.dart';
 import 'mock_compiler.dart';
 import 'package:compiler/src/js/js.dart' as jsAst;
 import 'package:compiler/src/js/js.dart' show js;
@@ skipping 58 matching lines @@
 function foo() {
   /a/;
   1;
   2;
 }''';
 
 
 void main() {
 
   var eOne = js('1');
+  var eTwo = js('2');
   var eTrue = js('true');
   var eVar = js('x');
   var block12 = js.statement('{ 1; 2; }');
+  var stm = js.statement('foo();');
   var seq1 = js('1, 2, 3');
 
   Expect.isTrue(eOne is jsAst.LiteralNumber);
   Expect.isTrue(eTrue is jsAst.LiteralBool);
   Expect.isTrue(block12 is jsAst.Block);
 
   asyncTest(() => Future.wait([
     // Interpolated Expressions are upgraded to ExpressionStatements.
     testStatement('{ #; #; }', [eOne, eOne], '{\n  1;\n  1;\n}'),
     testStatement('{ #a; #b; }', {'a': eOne, 'b': eOne}, '{\n  1;\n  1;\n}'),
@@ skipping 32 matching lines @@
     testStatement('if (#a) #b;',
                   {'a': false, 'b': block12},
                   ';'),
     testStatement('if (#a) 3; else #b;',
                   {'a': true, 'b': block12},
                   '3;'),
     testStatement('if (#a) 3; else #b;',
                   {'a': false, 'b': block12},
                   '{\n  1;\n  2;\n}'),
 
+    testStatement('while (#) #', [eOne, block12], 'while (1) {\n  1;\n  2;\n}'),
+    testStatement('while (#) #;', [eTrue, block12],
+        'while (true) {\n  1;\n  2;\n}'),
+    testStatement('while (#) #;', [eVar, block12],
+        'while (x) {\n  1;\n  2;\n}'),
+    testStatement('while (#) #;', ['a', block12],
+        'while (a) {\n  1;\n  2;\n}'),
+    testStatement('while (#) #;', ['a', stm],
+        'while (a)\n  foo();'),
+
+    testStatement(
+        'do { {print(1);} do while(true); while (false) } while ( true )', [],
+        '''
+do {
+  print(1);
+  do
+    while (true)
+      ;
+  while (false);
+} while (true);
+'''),
+    testStatement('do #; while ( # )', [block12, eOne],
+        'do {\n  1;\n  2;\n} while (1); '),
+    testStatement('do #; while ( # )', [block12, eTrue],
+        'do {\n  1;\n  2;\n} while (true); '),
+    testStatement('do #; while ( # );', [block12, eVar],
+        'do {\n  1;\n  2;\n} while (x);'),
+    testStatement('do { # } while ( # )', [block12, 'a'],
+        'do {\n  1;\n  2;\n} while (a);'),
+    testStatement('do #; while ( # )', [stm, 'a'],
+        'do\n  foo();\nwhile (a);'),
+
+    testStatement('switch (#) {}', [eOne], 'switch (1) {\n}'),
+    testStatement('''
+        switch (#) {
+          case #: { # }
+        }''', [eTrue, eOne, block12],
+        'switch (true) {\n  case 1:\n    1;\n    2;\n}'),
+    testStatement('''
+        switch (#) {
+          case #: { # }
+            break;
+          case #: { # }
+          default: { # }
+        }''', [eTrue, eOne, block12, eTwo, block12, stm], '''
+switch (true) {
+  case 1:
+    1;
+    2;
+    break;
+  case 2:
+    1;
+    2;
+  default:
+    foo();
+}'''),
 
     testStatement(NAMED_FUNCTION_1, [eOne], NAMED_FUNCTION_1_ONE),
     testStatement(NAMED_FUNCTION_1_NAMED_HOLE,
                   {'hole': eOne},
                   NAMED_FUNCTION_1_ONE),
 
     testStatement(MISC_1, [block12], MISC_1_1),
     testStatement(MISC_1_NAMED_HOLE, {'hole': block12}, MISC_1_1),
 
     // Argument list splicing.
@@ skipping 49 matching lines @@
     testStatement('function foo(#){}', [['x', 'y']], 'function foo(x, y) {\n}'),
     testStatement('function foo(#a){}', {'a': new jsAst.Parameter('x')},
         'function foo(x) {\n}'),
     testStatement('function foo(#a){}', {'a': 'x'}, 'function foo(x) {\n}'),
     testStatement('function foo(#a){}', {'a': []}, 'function foo() {\n}'),
     testStatement('function foo(#a){}', {'a': ['x']}, 'function foo(x) {\n}'),
     testStatement('function foo(#a){}',
                   {'a': ['x', 'y']},
                   'function foo(x, y) {\n}'),
 
+    testStatement('function foo() async {}', [], 'function foo() async {\n}'),
+    testStatement('function foo() sync* {}', [], 'function foo() sync* {\n}'),
+    testStatement('function foo() async* {}', [], 'function foo() async* {\n}'),
+
     testStatement('a = #.#', [eVar,eOne], 'a = x[1];'),
     testStatement('a = #.#', [eVar,'foo'], 'a = x.foo;'),
     testStatement('a = #a.#b', {'a': eVar, 'b': eOne}, 'a = x[1];'),
     testStatement('a = #a.#b', {'a': eVar, 'b': 'foo'}, 'a = x.foo;'),
 
     testStatement('function f(#) { return #.#; }', ['x', eVar,'foo'],
         'function f(x) {\n  return x.foo;\n}'),
     testStatement('function f(#a) { return #b.#c; }',
                   {'a': 'x', 'b': eVar, 'c': 'foo'},
                   'function f(x) {\n  return x.foo;\n}'),
@@ skipping 40 matching lines @@
 
     // Use the same name several times.
     testStatement('#a.prototype.#a = function(#b) { return #c.#c };',
                   {'a': 'name1_2',
                    'b': ['r', 'y'],
                    'c': 'name4_5'},
                   'name1_2.prototype.name1_2 = function(r, y) {\n'
                   '  return name4_5.name4_5;\n'
                   '};'),
 
+    testStatement('label: while (a) { label2: break label;}', [],
+        'label:\n  while (a) {\n    label2:\n      break label;\n  }'),
+
   ]));
 }