Add fatal-warnings flag, that turns warnings into compilation errors (the name

tests/compiler/dart2js/exit_code_test.dart

 // 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.
 
 // Test the exit code of dart2js in case of exceptions, errors, warnings, etc.
 
 
 import 'dart:async';
 import 'dart:io' show Platform;
 
@@ skipping 119 matching lines @@
   TestCompiler get compiler => super.compiler;
 
   void computeClassMembers(ClassElement element) {
     compiler.test('ResolverTask.computeClassMembers');
     super.computeClassMembers(element);
   }
 }
 
 int checkedResults = 0;
 
-Future testExitCode(String marker, String type, int expectedExitCode) {
+Future testExitCode(
+    String marker, String type, int expectedExitCode, List options) {
   bool testOccurred = false;
 
   void onTest(String testMarker, String testType) {
     if (testMarker == marker && testType == type) {
       testOccurred = true;
     }
   }
   return new Future(() {
     Future<api.CompilationResult> compile(
         Uri script,
@@ skipping 38 matching lines @@
 
     void exit(exitCode) {
       if (foundExitCode == null) {
         foundExitCode = exitCode;
       }
     };
 
     entry.exitFunc = exit;
     entry.compileFunc = compile;
 
-    Future result = entry.internalMain(
-        ["tests/compiler/dart2js/exit_code_helper.dart"]);
+    List<String> args = new List<String>.from(options)
+        ..add("tests/compiler/dart2js/exit_code_helper.dart");
+    Future result = entry.internalMain(args);
     return result.catchError((e, s) {
       // Capture crashes.
     }).whenComplete(checkResult);
   });
 }
 
-Future testExitCodes(String marker, Map<String,int> expectedExitCodes) {
+Future testExitCodes(
+    String marker, Map<String,int> expectedExitCodes, List<String> options) {
   return Future.forEach(expectedExitCodes.keys, (String type) {
-    return testExitCode(marker, type, expectedExitCodes[type]);
+    return testExitCode(marker, type, expectedExitCodes[type], options);
   });
 }
 
 void main() {
   bool isCheckedMode = false;
   assert((isCheckedMode = true));
 
-  final beforeRun = {
-    '': 0,
-    'NoSuchMethodError': 253,
-    'assert': isCheckedMode ? 253 : 0,
-    'invariant': 253
-  };
+  Map _expectedExitCode({bool beforeRun: false, bool fatalWarnings: false}) {
+    if (beforeRun) {
+      return {
+        '': 0,
+        'NoSuchMethodError': 253,
+        'assert': isCheckedMode ? 253 : 0,
+        'invariant': 253
+      };
+    }
 
-  final duringRun = {
-    '': 0,
-    'NoSuchMethodError': 253,
-    'assert': isCheckedMode ? 253 : 0,
-    'invariant': 253,
-    'warning': 0,
-    'error': 1,
-    'internalError': 253,
-  };
+    // duringRun:
+    return {
+      '': 0,
+      'NoSuchMethodError': 253,
+      'assert': isCheckedMode ? 253 : 0,
+      'invariant': 253,
+      'warning': fatalWarnings ? 1 : 0,
+      'error': 1,
+      'internalError': 253,
+    };
+  }
 
+  const beforeRun = false;
+  const duringRun = true;
   final tests = {
     'Compiler': beforeRun,
     'Compiler.run': beforeRun,
     'Compiler.onLibraryScanned': beforeRun,
     'Compiler.onLibrariesLoaded': beforeRun,
     'ScannerTask.scanElements': duringRun,
     'Compiler.withCurrentElement': duringRun,
     'Compiler.analyzeElement': duringRun,
     'Compiler.codegen': duringRun,
     'ResolverTask.computeClassMembers': duringRun,
   };
+  int totalExpectedErrors = 0;
 
-  asyncStart();
-  Future.forEach(tests.keys, (marker) {
-    return testExitCodes(marker, tests[marker]);
-  }).then((_) {
-    int countResults(Map runType) {
-      return runType.length *
-             tests.values.where((r) => r == runType).length;
+  asyncTest(() async {
+    for (String marker in tests.keys) {
+      var expected = _expectedExitCode(beforeRun: tests[marker]);
+      totalExpectedErrors += expected.length;
+      await testExitCodes(marker, expected, []);
+
+      expected = _expectedExitCode(
+          beforeRun: tests[marker], fatalWarnings: true);
+      totalExpectedErrors += expected.length;
+      await testExitCodes(marker, expected, ['--fatal-warnings']);
     }
 
-    Expect.equals(countResults(beforeRun) + countResults(duringRun),
-                  checkedResults);
-    asyncEnd();
+    Expect.equals(totalExpectedErrors, checkedResults);
   });
 }