Added support for skipping redundant dart2js compilations.

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.
  */
 #library("test_runner");
 
 #import("dart:io");
 #import("dart:isolate");
+#import("dart:uri");
 #import("status_file_parser.dart");
 #import("test_progress.dart");
 #import("test_suite.dart");
 
 const int NO_TIMEOUT = 0;
 const int SLOW_TIMEOUT_MULTIPLIER = 4;
 
 typedef void TestCaseEvent(TestCase testCase);
 typedef void ExitCodeEvent(int exitCode);
 typedef void EnqueueMoreWork(ProcessQueue queue);
@@ skipping 13 matching lines @@
     if (Platform.operatingSystem == 'windows') {
       // Windows can't handle the first command if it is a .bat file or the like
       // with the slashes going the other direction.
       // TODO(efortuna): Remove this when fixed (Issue 1306).
       executable = executable.replaceAll('/', '\\');
     }
     commandLine = "$executable ${Strings.join(arguments, ' ')}";
   }
 
   String toString() => commandLine;
+
+  Future<bool> get outputIsUpToDate => new Future.immediate(false);
+}
+
+class Dart2JsCommand extends Command {
+  String _jsOutputFile;
+  bool _neverSkipCompilation;
+  List<Uri> _bootstrapDependencies;
+
+  Dart2JsCommand(this._jsOutputFile,
+                 this._neverSkipCompilation,
+                 this._bootstrapDependencies,
+                 String executable,
+                 List<String> arguments)
+      : super(executable, arguments);
+
+  Future<bool> get outputIsUpToDate {
+    if (_neverSkipCompilation) return new Future.immediate(false);
+
+    Future<List<Uri>> readDepsFile(String path) {
+      var file = new File(new Path(path).toNativePath());
+      if (!file.existsSync()) {
+        return new Future.immediate(null);
+      }
+      return file.readAsLines().transform((List<String> lines) {
+        var dependencies = new List<Uri>();
+        for (var line in lines) {
+          line = line.trim();
+          if (line.length > 0) {
+            dependencies.add(new Uri(line));
+          }
+        }
+        return dependencies;
+      });
+    }
+
+    return readDepsFile("$_jsOutputFile.deps").transform((dependencies) {
+      if (dependencies != null) {
+        dependencies.addAll(_bootstrapDependencies);
+        var jsOutputLastModified = TestUtils.lastModifiedCache.getLastModified(
+            new Uri.fromComponents(scheme: 'file', path: _jsOutputFile));
+        if (jsOutputLastModified != null) {
+          for (var dependency in dependencies) {
+            var dependencyLastModified =
+                TestUtils.lastModifiedCache.getLastModified(dependency);
+            if (dependencyLastModified == null ||
+                dependencyLastModified > jsOutputLastModified) {
+              return false;
+            }
+          }
+          return true;
+        }
+      }
+      return false;
+    });
+  }
 }
 
 /**
  * TestCase contains all the information needed to run a test and evaluate
  * its output.  Running a test involves starting a separate process, with
  * the executable and arguments given by the TestCase, and recording its
  * stdout and stderr output streams, and its exit code.  TestCase only
  * contains static information about the test; actually running the test is
  * performed by [ProcessQueue] using a [RunningProcess] object.
  *
@@ skipping 196 matching lines @@
  * [TestCase] this is the output of.
  */
 abstract class CommandOutput {
   factory CommandOutput.fromCase(TestCase testCase,
                                  Command command,
                                  int exitCode,
                                  bool incomplete,
                                  bool timedOut,
                                  List<String> stdout,
                                  List<String> stderr,
-                                 Duration time) {
-    return new CommandOutputImpl.fromCase(testCase, 
+                                 Duration time,
+                                 bool compilationSkipped) {
+    return new CommandOutputImpl.fromCase(testCase,
                                           command,
                                           exitCode,
                                           incomplete,
                                           timedOut,
                                           stdout,
                                           stderr,
-                                          time);
+                                          time,
+                                          compilationSkipped);
   }
 
   bool get incomplete;
 
   String get result;
 
   bool get unexpectedOutput;
 
   bool get hasCrashed;
 
   bool get hasTimedOut;
 
   bool get didFail;
 
   bool requestRetry;
 
   Duration get time;
 
   int get exitCode;
 
   List<String> get stdout;
 
   List<String> get stderr;
 
   List<String> get diagnostics;
+
+  bool get compilationSkipped;
 }
 
 class CommandOutputImpl implements CommandOutput {
   TestCase testCase;
   int exitCode;
 
   /// Records if all commands were run, true if they weren't.
   final bool incomplete;
 
   bool timedOut;
   bool failed = false;
   List<String> stdout;
   List<String> stderr;
   Duration time;
   List<String> diagnostics;
+  bool compilationSkipped;
 
   /**
    * A flag to indicate we have already printed a warning about ignoring the VM
    * crash, to limit the amount of output produced per test.
    */
   bool alreadyPrintedWarning = false;
 
   /**
    * Set to true if we encounter a condition in the output that indicates we
    * need to rerun this test.
    */
   bool requestRetry = false;
 
   // Don't call this constructor, call CommandOutput.fromCase() to
   // get a new TestOutput instance.
   CommandOutputImpl(TestCase this.testCase,
                     Command command,
                     int this.exitCode,
                     bool this.incomplete,
                     bool this.timedOut,
                     List<String> this.stdout,
                     List<String> this.stderr,
-                    Duration this.time) {
+                    Duration this.time,
+                    bool this.compilationSkipped) {
     testCase.commandOutputs[command] = this;
     diagnostics = [];
   }
   factory CommandOutputImpl.fromCase(TestCase testCase,
                                      Command command,
                                      int exitCode,
                                      bool incomplete,
                                      bool timedOut,
                                      List<String> stdout,
                                      List<String> stderr,
-                                     Duration time) {
+                                     Duration time,
+                                     bool compilationSkipped) {
     if (testCase is BrowserTestCase) {
       return new BrowserCommandOutputImpl(testCase,
                                           command,
-                                          exitCode, 
+                                          exitCode,
                                           incomplete,
                                           timedOut,
                                           stdout,
                                           stderr,
-                                          time);
+                                          time,
+                                          compilationSkipped);
     } else if (testCase.configuration['compiler'] == 'dartc') {
       return new AnalysisCommandOutputImpl(testCase,
                                            command,
                                            exitCode,
                                            timedOut,
                                            stdout,
                                            stderr,
-                                           time);
+                                           time,
+                                           compilationSkipped);
     }
     return new CommandOutputImpl(testCase,
                                  command,
                                  exitCode,
-                                 incomplete, 
+                                 incomplete,
                                  timedOut,
                                  stdout,
                                  stderr,
-                                 time);
+                                 time,
+                                 compilationSkipped);
   }
 
   String get result =>
       hasCrashed ? CRASH : (hasTimedOut ? TIMEOUT : (hasFailed ? FAIL : PASS));
 
   bool get unexpectedOutput => !testCase.expectedOutcomes.contains(result);
 
   bool get hasCrashed {
     // The Java dartc runner and dart2js exits with code 253 in case
     // of unhandled exceptions.
@@ skipping 28 matching lines @@
 
 class BrowserCommandOutputImpl extends CommandOutputImpl {
   BrowserCommandOutputImpl(
       testCase,
       command,
       exitCode,
       incomplete,
       timedOut,
       stdout,
       stderr,
-      time) :
+      time,
+      compilationSkipped) :
     super(testCase,
           command,
           exitCode,
           incomplete,
           timedOut,
           stdout,
           stderr,
-          time);
+          time,
+          compilationSkipped);
 
   bool get didFail {
     // Browser case:
     // If the browser test failed, it may have been because DumpRenderTree
     // and the virtual framebuffer X server didn't hook up, or DRT crashed with
     // a core dump. Sometimes DRT crashes after it has set the stdout to PASS,
     // so we have to do this check first.
     for (String line in super.stderr) {
       if (line.contains('Gtk-WARNING **: cannot open display: :99') ||
         line.contains('Failed to run command. return code=1')) {
@@ skipping 31 matching lines @@
 // to stderr.
 class AnalysisCommandOutputImpl extends CommandOutputImpl {
   // An error line has 8 fields that look like:
   // ERROR|COMPILER|MISSING_SOURCE|file:/tmp/t.dart|15|1|24|Missing source.
   final int ERROR_LEVEL = 0;
   final int ERROR_TYPE = 1;
   final int FORMATTED_ERROR = 7;
 
   bool alreadyComputed = false;
   bool failResult;
+
   AnalysisCommandOutputImpl(testCase,
                             command,
                             exitCode,
                             timedOut,
-                            stdout, 
+                            stdout,
                             stderr,
-                            time) :
-    super(testCase, command, exitCode, false, timedOut, stdout, stderr, time);
+                            time,
+                            compilationSkipped) :
+    super(testCase,
+          command,
+          exitCode,
+          false,
+          timedOut,
+          stdout,
+          stderr,
+          time,
+          compilationSkipped);
 
   bool get didFail {
     if (!alreadyComputed) {
       failResult = _didFail();
       alreadyComputed = true;
     }
     return failResult;
   }
 
   bool _didFail() {
@@ skipping 147 matching lines @@
  */
 class RunningProcess {
   ProcessQueue processQueue;
   Process process;
   TestCase testCase;
   bool timedOut = false;
   Date startTime;
   Timer timeoutTimer;
   List<String> stdout;
   List<String> stderr;
+  bool compilationSkipped;
   bool allowRetries;
 
   /** Which command of [testCase.commands] is currently being executed. */
   int currentStep;
 
   RunningProcess(TestCase this.testCase,
       [this.allowRetries = false, this.processQueue]);
 
   /**
-   * Called when all commands are executed. 
+   * Called when all commands are executed.
    */
   void testComplete(CommandOutput lastCommandOutput) {
-    timeoutTimer.cancel();
+    if (timeoutTimer != null) {
+      timeoutTimer.cancel();
+    }
     if (lastCommandOutput.unexpectedOutput
         && testCase.configuration['verbose'] != null
         && testCase.configuration['verbose']) {
       print(testCase.displayName);
       for (var line in lastCommandOutput.stderr) print(line);
       for (var line in lastCommandOutput.stdout) print(line);
     }
     if (allowRetries && testCase.usesWebDriver
         && lastCommandOutput.unexpectedOutput
         && (testCase as BrowserTestCase).numRetries > 0) {
@@ skipping 41 matching lines @@
       // One compilation step successfully completed, move on to the
       // next step.
       stderr.add('test.dart: Compilation finished $suffix\n');
       stdout.add('test.dart: Compilation finished $suffix\n');
       if (currentStep == totalSteps - 1 && testCase.usesWebDriver &&
           !testCase.configuration['noBatch']) {
         // Note: processQueue will always be non-null for runtime == ie9, ie10,
         // ff, safari, chrome, opera. (It is only null for runtime == vm)
         // This RunningProcess object is done, and hands over control to
         // BatchRunner.startTest(), which handles reporting, etc.
-        timeoutTimer.cancel();
+        if (timeoutTimer != null) {
+          timeoutTimer.cancel();
+        }
         processQueue._getBatchRunner(testCase).startTest(testCase);
       } else {
         runCommand(testCase.commands[currentStep++], commandComplete);
       }
     }
   }
 
   /**
    * Called for all executed commands.
    */
   CommandOutput createCommandOutput(Command command,
                                     int exitCode,
                                     bool incomplete) {
     var commandOutput = new CommandOutput.fromCase(
         testCase,
         command,
         exitCode,
         incomplete,
         timedOut,
         stdout,
         stderr,
-        new Date.now().difference(startTime));
+        new Date.now().difference(startTime),
+        compilationSkipped);
     resetLocalOutputInformation();
     return commandOutput;
   }
 
   void resetLocalOutputInformation() {
     stdout = new List<String>();
     stderr = new List<String>();
+    compilationSkipped = false;
   }
-  
+
   VoidFunction makeReadHandler(StringInputStream source,
                                List<String> destination) {
     void handler () {
       if (source.closed) return;  // TODO(whesse): Remove when bug is fixed.
       var line = source.readLine();
       while (null != line) {
         destination.add(line);
         line = source.readLine();
       }
     }
     return handler;
   }
 
   void start() {
     Expect.isFalse(testCase.expectedOutcomes.contains(SKIP));
     resetLocalOutputInformation();
     currentStep = 0;
     startTime = new Date.now();
     runCommand(testCase.commands[currentStep++], commandComplete);
   }
 
   void runCommand(Command command, void commandCompleteHandler(Command, int)) {
     void processExitHandler(int returnCode) {
       commandCompleteHandler(command, returnCode);
     }
-    ProcessOptions options = new ProcessOptions();
-    options.environment = new Map<String, String>.from(Platform.environment);
-    options.environment['DART_CONFIGURATION'] =
-        TestUtils.configurationDir(testCase.configuration);
-    Future processFuture = Process.start(command.executable,
-                                         command.arguments,
-                                         options);
-    processFuture.then((Process p) {
-      process = p;
-      process.onExit = processExitHandler;
-      var stdoutStringStream = new StringInputStream(process.stdout);
-      var stderrStringStream = new StringInputStream(process.stderr);
-      stdoutStringStream.onLine =
-          makeReadHandler(stdoutStringStream, stdout);
-      stderrStringStream.onLine =
-          makeReadHandler(stderrStringStream, stderr);
-      if (timeoutTimer == null) {
-        // Create one timeout timer when starting test case, remove it at end.
-        timeoutTimer = new Timer(1000 * testCase.timeout, timeoutHandler);
+
+    command.outputIsUpToDate.then((bool isUpToDate) {
+      if (isUpToDate) {
+        stdout.add("Skipped compilation because the old output is "
+                   "still up to date!");
+        compilationSkipped = true;
+        commandComplete(command, 0);
+      } else {
+        ProcessOptions options = new ProcessOptions();
+        options.environment =
+            new Map<String, String>.from(Platform.environment);
+        options.environment['DART_CONFIGURATION'] =
+            TestUtils.configurationDir(testCase.configuration);
+        Future processFuture = Process.start(command.executable,
+                                             command.arguments,
+                                             options);
+        processFuture.then((Process p) {
+          process = p;
+          process.onExit = processExitHandler;
+          var stdoutStringStream = new StringInputStream(process.stdout);
+          var stderrStringStream = new StringInputStream(process.stderr);
+          stdoutStringStream.onLine =
+              makeReadHandler(stdoutStringStream, stdout);
+          stderrStringStream.onLine =
+              makeReadHandler(stderrStringStream, stderr);
+          if (timeoutTimer == null) {
+            // Create one timeout timer when starting test case, remove it at
+            // the end.
+            timeoutTimer = new Timer(1000 * testCase.timeout, timeoutHandler);
+          }
+          // If the timeout fired in between two commands, kill the just
+          // started process immediately.
+          if (timedOut) safeKill(process);
+        });
+        processFuture.handleException((e) {
+          print("Process error:");
+          print("  Command: $command");
+          print("  Error: $e");
+          testComplete(createCommandOutput(command, -1, false));
+          return true;
+        });
       }
-      // If the timeout fired in between two commands, kill the just
-      // started process immediately.
-      if (timedOut) safeKill(process);
-    });
-    processFuture.handleException((e) {
-      print("Process error:");
-      print("  Command: $command");
-      print("  Error: $e");
-      testComplete(createCommandOutput(command, -1, false));
-      return true;
     });
   }
 
   void timeoutHandler(Timer unusedTimer) {
     timedOut = true;
     safeKill(process);
   }
 
   void safeKill(Process p) {
     if (p != null) {
@@ skipping 129 matching lines @@
     var exitCode = 0;
     if (outcome == "CRASH") exitCode = -10;
     if (outcome == "FAIL" || outcome == "TIMEOUT") exitCode = 1;
     new CommandOutput.fromCase(_currentTest,
                                _command,
                                exitCode,
                                false,
                                (outcome == "TIMEOUT"),
                                _testStdout,
                                _testStderr,
-                               new Date.now().difference(_startTime));
+                               new Date.now().difference(_startTime),
+                               false);
     var test = _currentTest;
     _currentTest = null;
     test.completed();
   }
 
   void _stderrDone() {
     _stderrDrained = true;
     // Move on when both stdout and stderr has been drained.
     if (_stdoutDrained) _reportResult();
   }
@@ skipping 444 matching lines @@
         // the developer doesn't waste his or her time trying to fix a bunch of
         // tests that appear to be broken but were actually just flakes that
         // didn't get retried because there had already been one failure.
         bool allowRetry = _MAX_FAILED_NO_RETRY > _progress.numFailedTests;
         new RunningProcess(test, allowRetry, this).start();
       }
       _numProcesses++;
     }
   }
 }