Cache output of dart2js compilations that went wrong on disk.

tools/testing/dart/test_runner.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 executing tests.
  *
  * This module includes:
  * - Managing parallel execution of tests, including timeout checks.
  * - Evaluating the output of each test as pass/fail/crash/timeout.
@@ skipping 75 matching lines @@
 
   bool _equal(Command other) {
     return hashCode == other.hashCode &&
         commandLine == other.commandLine &&
         displayName == other.displayName;
   }
 
   String toString() => reproductionCommand;
 
   Future<bool> get outputIsUpToDate => new Future.value(false);
+  
+  Future<String> get cachedOutput => new Future.value(null);
+  Future writeCachedOutput(CommandOutput output) => new Future.value(null);
 }
 
 class ProcessCommand extends Command {
   /** Path to the executable of this command. */
   String executable;
 
   /** Command line arguments to the executable. */
   List<String> arguments;
 
   /** Environment for the command */
@@ skipping 59 matching lines @@
   }
 
   Future<bool> get outputIsUpToDate => new Future.value(false);
 }
 
 class CompilationCommand extends ProcessCommand {
   String _outputFile;
   bool _neverSkipCompilation;
   List<Uri> _bootstrapDependencies;
 
+  Future writeCachedOutput(CommandOutput output) {
+    var file = new io.File(TestUtils.cachedOutputFile(_outputFile));
+    return file.writeAsString(output.json)
+      .catchError((error) { 
+        DebugLogger.warning("Could not write cached output: $error");
+        return null;
+      });
+  }
+
+  Future<CommandOutput> get cachedOutput {
+    var file = new io.File(TestUtils.cachedOutputFile(_outputFile));
+    return file.exists().then((exists) {
+      if (exists) return file.readAsString().then((content) {
+        return new CompilationCommandOutputImpl.fromJson(this, content);
+      });;
+    });
+  }
+
   CompilationCommand._(String displayName,
                        this._outputFile,
                        this._neverSkipCompilation,
                        List<Uri> bootstrapDependencies,
                        String executable,
                        List<String> arguments,
                        Map<String, String> environmentOverrides)
       : super._(displayName, executable, arguments, environmentOverrides) {
     // We sort here, so we can do a fast hashCode/operator==
     _bootstrapDependencies = new List.from(bootstrapDependencies);
@@ skipping 13 matching lines @@
         for (var line in lines) {
           line = line.trim();
           if (line.length > 0) {
             dependencies.add(Uri.parse(line));
           }
         }
         return dependencies;
       });
     }
 
+    bool isUpToDate(lastModified, dependencies) {
+      if (lastModified == null) return false;
+      for (var dependency in dependencies) {
+        var dependencyLastModified =
+          TestUtils.lastModifiedCache.getLastModified(dependency);
+        if (dependencyLastModified == null ||
+            dependencyLastModified.isAfter(lastModified)) {
+          return false;
+        }
+      }
+      return true;
+    }
+
     return readDepsFile("$_outputFile.deps").then((dependencies) {
       if (dependencies != null) {
         dependencies.addAll(_bootstrapDependencies);
-        var jsOutputLastModified = TestUtils.lastModifiedCache.getLastModified(
-            new Uri(scheme: 'file', path: _outputFile));
-        if (jsOutputLastModified != null) {
-          for (var dependency in dependencies) {
-            var dependencyLastModified =
-                TestUtils.lastModifiedCache.getLastModified(dependency);
-            if (dependencyLastModified == null ||
-                dependencyLastModified.isAfter(jsOutputLastModified)) {
-              return false;
-            }
-          }
-          return true;
-        }
+        // We check if the cached output is up to date, if so we return true
+        var cachedOutputFile = TestUtils.cachedOutputFile(_outputFile);
+        var cachedOutputUri = new Uri(scheme: 'file', path: cachedOutputFile);
+        var cachedOutputLastModified = 
+            TestUtils.lastModifiedCache.getLastModified(cachedOutputUri);
+        return isUpToDate(cachedOutputLastModified, dependencies);
       }
       return false;
     });
   }
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.add(_outputFile);
     builder.add(_neverSkipCompilation);
     for (var uri in _bootstrapDependencies) builder.add(uri);
@@ skipping 678 matching lines @@
 
   int get pid;
 
   List<int> get stdout;
 
   List<int> get stderr;
 
   List<String> get diagnostics;
 
   bool get compilationSkipped;
+
+  String get json;
 }
 
 class CommandOutputImpl extends UniqueObject implements CommandOutput {
   Command command;
   int exitCode;
 
   bool timedOut;
   List<int> stdout;
   List<int> stderr;
   Duration time;
@@ skipping 69 matching lines @@
 
   Expectation _negateOutcomeIfNegativeTest(Expectation outcome,
                                            bool isNegative) {
     if (!isNegative) return outcome;
 
     if (outcome.canBeOutcomeOf(Expectation.FAIL)) {
       return Expectation.PASS;
     }
     return Expectation.FAIL;
   }
+
+  String get json => null;
+
 }
 
 class BrowserCommandOutputImpl extends CommandOutputImpl {
   // Although tests are reported as passing, content shell sometimes exits with
   // a nonzero exitcode which makes our dartium builders extremely falky.
   // See: http://dartbug.com/15139.
   static int WHITELISTED_CONTENTSHELL_EXITCODE = -1073740022;
   static bool isWindows = io.Platform.operatingSystem == 'windows';
 
   bool _failedBecauseOfMissingXDisplay;
@@ skipping 577 matching lines @@
       // We expected to run the test, but we got an compile time error.
       // If the compilation succeeded, we wouldn't be in here!
       assert(exitCode != 0);
       return Expectation.COMPILETIME_ERROR;
     }
 
     Expectation outcome =
         exitCode == 0 ? Expectation.PASS : Expectation.COMPILETIME_ERROR;
     return _negateOutcomeIfNegativeTest(outcome, testCase.isNegative);
   }
+
+  String get json {
+    var map = {
+    'stdout': stdout,
+    'stderr': stderr,
+    'exitCode': exitCode,
+    'timedOut': timedOut,
+    };
+    return JSON.encode(map);
+  }
+
+  factory CompilationCommandOutputImpl.fromJson(Command command,
+                                                String json) {
+    var obj = JSON.decode(json);
+    for (var v in ['stdout', 'stderr', 'exitCode', 'timedOut']) {
+      assert(obj.containsKey(v));
+    }
+    return new CompilationCommandOutputImpl(command,
+                                            obj['exitCode'],
+                                            obj['timedOut'],
+                                            obj['stdout'],
+                                            obj['stderr'],
+                                            const Duration(seconds: 0),
+                                            true);
+                                            
+  }
 }
 
 class JsCommandlineOutputImpl extends CommandOutputImpl
                               with UnittestSuiteMessagesMixin {
   JsCommandlineOutputImpl(Command command, int exitCode, bool timedOut,
       List<int> stdout, List<int> stderr, Duration time)
       : super(command, exitCode, timedOut, stdout, stderr, time, false, 0);
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
@@ skipping 177 matching lines @@
   RunningProcess(this.command, this.timeout);
 
   Future<CommandOutput> run() {
     completer = new Completer<CommandOutput>();
     startTime = new DateTime.now();
     _runCommand();
     return completer.future;
   }
 
   void _runCommand() {
-    command.outputIsUpToDate.then((bool isUpToDate) {
+    command.outputIsUpToDate.then((isUpToDate) {
       if (isUpToDate) {
         compilationSkipped = true;
-        _commandComplete(0);
+        command.cachedOutput.then((cached) {
+          _commandComplete(cached.exitCode, cachedOutput: cached);
+        });
       } else {
         var processEnvironment = _createProcessEnvironment();
         Future processFuture =
             io.Process.start(command.executable,
                              command.arguments,
                              environment: processEnvironment,
                              workingDirectory: command.workingDirectory);
         processFuture.then((io.Process process) {
           StreamSubscription stdoutSubscription =
               _drainStream(process.stdout, stdout);
@@ skipping 72 matching lines @@
           print("Process error:");
           print("  Command: $command");
           print("  Error: $e");
           _commandComplete(-1);
           return true;
         });
       }
     });
   }
 
-  void _commandComplete(int exitCode) {
+  void _commandComplete(int exitCode, {cachedOutput: null}) {
     if (timeoutTimer != null) {
       timeoutTimer.cancel();
     }
-    var commandOutput = _createCommandOutput(command, exitCode);
-    completer.complete(commandOutput);
+    if (cachedOutput != null) {
+      completer.complete(cachedOutput);
+    } else {
+      var commandOutput = _createCommandOutput(command, exitCode);
+      command.writeCachedOutput(commandOutput);
+      completer.complete(commandOutput);
+    }
   }
 
   CommandOutput _createCommandOutput(ProcessCommand command, int exitCode) {
     var commandOutput = createCommandOutput(
         command,
         exitCode,
         timedOut,
         stdout.toList(),
         stderr.toList(),
         new DateTime.now().difference(startTime),
@@ skipping 1053 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }