Toward a green tools/build.py -cprecompiler -rdart_precompiled:

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 1000 matching lines @@
   void enqueueStandardTest(List<Command> baseCommands,
                            TestInformation info,
                            String testName,
                            Set<Expectation> expectations) {
     var commonArguments = commonArgumentsFromFile(info.filePath,
                                                   info.optionsFromFile);
 
     List<List<String>> vmOptionsList = getVmOptions(info.optionsFromFile);
     assert(!vmOptionsList.isEmpty);
 
-    for (var vmOptions in vmOptionsList) {
+    for (var vmOptionsVarient = 0;
+         vmOptionsVarient < vmOptionsList.length;
+         vmOptionsVarient++) {
+      var vmOptions = vmOptionsList[vmOptionsVarient];
       var allVmOptions = vmOptions;
       if (!extraVmOptions.isEmpty) {
         allVmOptions = new List.from(vmOptions)..addAll(extraVmOptions);
       }
 
       var commands = []..addAll(baseCommands);
-      commands.addAll(makeCommands(info, allVmOptions, commonArguments));
+      commands.addAll(makeCommands(info, vmOptionsVarient,
+                                   allVmOptions, commonArguments));
       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 = expectCompileError(info) ||
         (configuration['checked'] && info.isNegativeIfChecked);
     if (info.hasRuntimeError && hasRuntime) {
       negative = true;
     }
     return negative;
   }
 
-  List<Command> makeCommands(TestInformation info, var vmOptions, var args) {
+  List<Command> makeCommands(TestInformation info,
+                             int vmOptionsVarient,
+                             var vmOptions,
+                             var args) {
     List<Command> commands = <Command>[];
     CompilerConfiguration compilerConfiguration =
         new CompilerConfiguration(configuration);
     List<String> sharedOptions = info.optionsFromFile['sharedOptions'];
 
     List<String> compileTimeArguments = <String>[];
     String tempDir;
     if (compilerConfiguration.hasCompiler) {
       compileTimeArguments =
           compilerConfiguration.computeCompilerArguments(vmOptions,
                                                          sharedOptions,
                                                          args);
       // Avoid doing this for analyzer.
-      tempDir = createCompilationOutputDirectory(info.filePath);
+      var path = info.filePath;
+      if (vmOptionsVarient != 0) {
+        // Ensure a unique directory for each test case.
+        path = path.join(new Path(vmOptionsVarient.toString()));
+      }
+      tempDir = createCompilationOutputDirectory(path);
     }
 
     CommandArtifact compilationArtifact =
         compilerConfiguration.computeCompilationArtifact(
             buildDir,
             tempDir,
             CommandBuilder.instance,
             compileTimeArguments,
             environmentOverrides);
     commands.addAll(compilationArtifact.commands);
@@ skipping 1421 matching lines @@
       for (var key in PATH_REPLACEMENTS.keys) {
         if (path.startsWith(key)) {
           path = path.replaceFirst(key, PATH_REPLACEMENTS[key]);
           break;
         }
       }
     }
     return path;
   }
 }