Support async/await in the dart2js frontend.

tests/compiler/dart2js/frontend_checker.dart

+// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file

[floitsch, 2014/11/03 17:55:54]

2014

[Johnni Winther, 2014/11/04 12:24:33]

Done.

+// 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.
+
+// Test that dart2js produces the expected static type warnings for these
+// language tests. This ensures that the analyzer and dart2js agrees on the
+// tests.
+
+import 'dart:async';
+
+import 'package:expect/expect.dart';
+import 'package:async_helper/async_helper.dart';
+
+import 'memory_compiler.dart';
+
+import '../../../tools/testing/dart/multitest.dart'
+    show ExtractTestsFromMultitest;
+import '../../../tools/testing/dart/utils.dart'
+    show Path;
+
+void check(List<String> testFiles,
+           {List<String> arguments: const <String>[],
+            List<String> options: const <String>[]}) {
+  bool outcomeMismatch = false;
+  bool verbose = arguments.contains('-v');
+  var cachedCompiler;
+  asyncTest(() => Future.forEach(testFiles, (String testFile) {
+    Map<String, String> testSources = {};
+    Map<String, Set<String>> testOutcomes = {};
+    String fileName = 'tests/$testFile';
+    ExtractTestsFromMultitest(new Path(fileName), testSources, testOutcomes);
+    return Future.forEach(testSources.keys, (String testName) {
+      String testFileName = '$fileName/$testName';
+      Set<String> expectedOutcome = testOutcomes[testName];
+      DiagnosticCollector collector = new DiagnosticCollector();
+      var compiler = compilerFor(
+           {testFileName: testSources[testName]},
+           diagnosticHandler: collector,
+           options: ['--analyze-only']..addAll(options),
+           showDiagnostics: verbose,
+           cachedCompiler: cachedCompiler);
+      return compiler.run(Uri.parse('memory:$testFileName')).then((_) {
+        if (expectedOutcome.contains('compile-time error')) {
+          if (collector.errors.isEmpty) {
+            print('$testFileName: Missing compile-time error.');
+            outcomeMismatch = true;
+          }
+        } else if (expectedOutcome.contains('static type warning')) {
+          if (collector.warnings.isEmpty) {
+            print('$testFileName: Missing static type warning.');
+            outcomeMismatch = true;
+          }
+        } else {
+          // Expect ok.
+          if (!collector.errors.isEmpty ||
+              !collector.warnings.isEmpty) {
+            collector.errors.forEach((message) {
+              print('$testFileName: Unexpected error: ${message.message}');
+            });
+            collector.warnings.forEach((message) {
+              print('$testFileName: Unexpected warning: ${message.message}');
+            });
+            outcomeMismatch = true;
+          }
+        }
+        cachedCompiler = compiler;
+      });
+    });
+  }).then((_) {
+    Expect.isFalse(outcomeMismatch, 'Outcome mismatch');
+  }));
+}