Add 'static type error' tags to multitests.

tools/testing/dart/test_suite.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.
 
 /**
  * Classes and methods for enumerating and preparing tests.
  *
  * This library includes:
  *
  * - Creating tests by listing all the Dart files in certain directories,
@@ skipping 17 matching lines @@
 
 /**
  * A simple function that tests [arg] and returns `true` or `false`.
  */
 typedef bool Predicate<T>(T arg);
 
 typedef void CreateTest(Path filePath,
                         bool hasCompileError,
                         bool hasRuntimeError,
                         {bool isNegativeIfChecked,
+                         bool hasCompileErrorIfChecked,
                          bool hasStaticWarning,
                          Set<String> multitestOutcome,
                          String multitestKey,
                          Path originTestPath});
 
 typedef void VoidFunction();
 
 /**
  * Calls [function] asynchronously. Returns a future that completes with the
  * result of the function. If the function is `null`, returns a future that
@@ skipping 260 matching lines @@
     // Test if the selector includes this test.
     RegExp pattern = configuration['selectors'][suiteName];
     if (!pattern.hasMatch(testCase.displayName)) {
       return;
     }
 
     // Update Summary report
     if (configuration['report']) {
       SummaryReport.add(expectations);
       if (testCase.info != null &&
-          testCase.info.hasCompileError &&
+          testCase.expectCompileError &&
           TestUtils.isBrowserRuntime(configuration['runtime']) &&
           configuration['compiler'] != 'none') {
         SummaryReport.addCompileErrorSkipTest();
         return;
       }
     }
 
     // Handle skipped tests
     if (expectations.contains(Expectation.SKIP) ||
         expectations.contains(Expectation.SKIP_BY_DESIGN)) {
@@ skipping 271 matching lines @@
 }
 
 
 class TestInformation {
   Path originTestPath;
   Path filePath;
   Map optionsFromFile;
   bool hasCompileError;
   bool hasRuntimeError;
   bool isNegativeIfChecked;
+  bool hasCompileErrorIfChecked;
   bool hasStaticWarning;
   Set<String> multitestOutcome;
   String multitestKey;
 
   TestInformation(this.filePath, this.optionsFromFile,
                   this.hasCompileError, this.hasRuntimeError,
-                  this.isNegativeIfChecked, this.hasStaticWarning,
+                  this.isNegativeIfChecked, this.hasCompileErrorIfChecked,
+                  this.hasStaticWarning,
                   this.multitestOutcome,
                   {this.multitestKey, this.originTestPath}) {
     assert(filePath.isAbsolute);
     if (originTestPath == null) originTestPath = filePath;
   }
 }
 
 /**
  * A standard [TestSuite] implementation that searches for tests in a
  * directory, and creates [TestCase]s that compile and/or run them.
@@ skipping 296 matching lines @@
           if (optionsFromFile['packageRoot'] == null ||
               optionsFromFile['packageRoot'] == "") {
             optionsFromFile['packageRoot'] = packageRoot.toNativePath();
           }
       }
     }
     String testName = buildTestCaseDisplayName(suiteDir, info.originTestPath,
         multitestName: optionsFromFile['isMultitest'] ? info.multitestKey : "");
 
     Set<Expectation> expectations = testExpectations.expectations(testName);
-    if (configuration['compiler'] != 'none' && info.hasCompileError) {
+    if (configuration['compiler'] != 'none' && expectCompileError(info)) {
       // If a compile-time error is expected, and we're testing a
       // compiler, we never need to attempt to run the program (in a
       // browser or otherwise).
       enqueueStandardTest(baseCommands, info, testName, expectations);
     } else if (TestUtils.isBrowserRuntime(configuration['runtime'])) {
       if (info.optionsFromFile['isMultiHtmlTest']) {
         // A browser multi-test has multiple expectations for one test file.
         // Find all the different sub-test expecations for one entire test file.
         List<String> subtestNames = info.optionsFromFile['subtestNames'];
         Map<String, Set<Expectation>> multiHtmlTestExpectations = {};
@@ skipping 35 matching lines @@
       enqueueNewTestCase(
           new TestCase('$suiteName/$testName',
                        commands,
                        configuration,
                        expectations,
                        isNegative: isNegative(info),
                        info: info));
     }
   }
 
+  bool expectCompileError(TestInformation info) {
+    return info.hasCompileError ||
+        (configuration['checked'] && info.hasCompileErrorIfChecked);
+  }
+
   bool isNegative(TestInformation info) {
-    bool negative = info.hasCompileError ||
+    bool negative = expectCompileError(info) ||
         (configuration['checked'] && info.isNegativeIfChecked);
     if (info.hasRuntimeError && hasRuntime) {
       negative = true;
     }
     return negative;
   }
 
   List<Command> makeCommands(TestInformation info, var vmOptions, var args) {
     var compiler = configuration['compiler'];
     List<String> sharedOptions = info.optionsFromFile['sharedOptions'];
     switch (compiler) {
     case 'dart2js':
       args = new List.from(args);
       String tempDir = createCompilationOutputDirectory(info.filePath);
       args.addAll(sharedOptions);
       args.add('--out=$tempDir/out.js');
 
       var command = CommandBuilder.instance.getCompilationCommand(
           compiler, "$tempDir/out.js", !useSdk,
           dart2JsBootstrapDependencies, compilerPath, args,
           environmentOverrides);
 
       var javascriptFile = '$tempDir/out.js';
       if (configuration['csp']) {
         javascriptFile = '$tempDir/out.precompiled.js';
       }
 
       List<Command> commands = <Command>[command];
-      if (info.hasCompileError) {
+      if (expectCompileError(info)) {
         // Do not attempt to run the compiled result. A compilation
         // error should be reported by the compilation command.
       } else if (configuration['runtime'] == 'd8') {
         commands.add(CommandBuilder.instance.getJSCommandlineCommand(
             "d8", d8FileName, [javascriptFile], environmentOverrides));
       } else if (configuration['runtime'] == 'jsshell') {
         commands.add(CommandBuilder.instance.getJSCommandlineCommand(
             "jsshell", jsShellFileName, [javascriptFile],
             environmentOverrides));
       }
       return commands;
     case 'dart2dart':
       args = new List.from(args);
       args.addAll(sharedOptions);
       args.add('--output-type=dart');
       String tempDir = createCompilationOutputDirectory(info.filePath);
       args.add('--out=$tempDir/out.dart');
 
       List<Command> commands =
           <Command>[CommandBuilder.instance.getCompilationCommand(
               compiler, "$tempDir/out.dart", !useSdk,
               dart2JsBootstrapDependencies, compilerPath, args,
               environmentOverrides)];
-      if (info.hasCompileError) {
+      if (expectCompileError(info)) {
         // Do not attempt to run the compiled result. A compilation
         // error should be reported by the compilation command.
       } else if (configuration['runtime'] == 'vm') {
         // TODO(antonm): support checked.
         var vmArguments = new List.from(vmOptions);
         vmArguments.addAll([
             '--ignore-unrecognized-flags', '$tempDir/out.dart']);
         commands.add(CommandBuilder.instance.getVmCommand(
             vmFileName, vmArguments, environmentOverrides));
       } else {
@@ skipping 23 matching lines @@
         configuration['compiler'], dartShellFileName, arguments,
         environmentOverrides,
         flavor: configuration['compiler']);
   }
 
   CreateTest makeTestCaseCreator(Map optionsFromFile) {
     return (Path filePath,
             bool hasCompileError,
             bool hasRuntimeError,
             {bool isNegativeIfChecked: false,
+             bool hasCompileErrorIfChecked: false,
              bool hasStaticWarning: false,
              Set<String> multitestOutcome: null,
              String multitestKey,
              Path originTestPath}) {
       // Cache the test information for each test case.
       var info = new TestInformation(filePath,
                                      optionsFromFile,
                                      hasCompileError,
                                      hasRuntimeError,
                                      isNegativeIfChecked,
+                                     hasCompileErrorIfChecked,
                                      hasStaticWarning,
                                      multitestOutcome,
                                      multitestKey: multitestKey,
                                      originTestPath: originTestPath);
       cachedTests.add(info);
       enqueueTestCaseFromTestInformation(info);
     };
   }
 
   /**
@@ skipping 1157 matching lines @@
  * $pass tests are expected to pass
  * $failOk tests are expected to fail that we won't fix
  * $fail tests are expected to fail that we should fix
  * $crash tests are expected to crash that we should fix
  * $timeout tests are allowed to timeout
  * $compileErrorSkip tests are skipped on browsers due to compile-time error
 """;
     print(report);
    }
 }