Basic support for dev_compiler in test.dart.

tools/testing/dart/command.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:async';
 // We need to use the 'io' prefix here, otherwise io.exitCode will shadow
 // CommandOutput.exitCode in subclasses of CommandOutput.
 import 'dart:io' as io;
 
 import 'command_output.dart';
@@ skipping 22 matching lines @@
   static Command browserHtmlTest(
       String url, Configuration configuration, List<String> expectedMessages,
       {bool retry}) {
     return new BrowserHtmlTestCommand._(
         url, configuration, expectedMessages, retry);
   }
 
   static Command compilation(
       String displayName,
       String outputFile,
-      bool neverSkipCompilation,
       List<Uri> bootstrapDependencies,
       String executable,
       List<String> arguments,
-      Map<String, String> environment) {
-    return new CompilationCommand._(
-        displayName,
-        outputFile,
-        neverSkipCompilation,
-        bootstrapDependencies,
-        executable,
-        arguments,
-        environment);
+      Map<String, String> environment,
+      {bool alwaysCompile: false}) {
+    return new CompilationCommand._(displayName, outputFile, alwaysCompile,
+        bootstrapDependencies, executable, arguments, environment);
   }
 
   static Command kernelCompilation(
       String outputFile,
       bool neverSkipCompilation,
       List<Uri> bootstrapDependencies,
       String executable,
       List<String> arguments,
       Map<String, String> environment) {
     return new KernelCompilationCommand._(outputFile, neverSkipCompilation,
@@ skipping 151 matching lines @@
   Future<bool> get outputIsUpToDate => new Future.value(false);
 
   /// Arguments that are passed to the process when starting batch mode.
   ///
   /// In non-batch mode, they should be passed before [arguments].
   List<String> get batchArguments => const [];
 }
 
 class CompilationCommand extends ProcessCommand {
   final String _outputFile;
-  final bool _neverSkipCompilation;
+
+  /// If true, then the compilation is run even if the input files are older
+  /// than the output file.
+  final bool _alwaysCompile;
   final List<Uri> _bootstrapDependencies;
 
   CompilationCommand._(
       String displayName,
       this._outputFile,
-      this._neverSkipCompilation,
+      this._alwaysCompile,
       this._bootstrapDependencies,
       String executable,
       List<String> arguments,
       Map<String, String> environmentOverrides)
       : super._(displayName, executable, arguments, environmentOverrides);
 
   Future<bool> get outputIsUpToDate {

[Bill Hesse, 2017/06/21 16:33:20]

Surely this is better written using keyword async?
But I guess that isn't in the scope of this CL.

[Bob Nystrom, 2017/06/21 20:18:28]

It is a little out of scope, but what the heck. Actually, it doesn't need to be
asynchronous at all. Made it sync, and updated all of the other relevant code.

-    if (_neverSkipCompilation) return new Future.value(false);
+    if (_alwaysCompile) return new Future.value(false);
 
     Future<List<Uri>> readDepsFile(String path) {
       var file = new io.File(new Path(path).toNativePath());
       if (!file.existsSync()) {
         return new Future.value(null);
       }
       return file.readAsLines().then((List<String> lines) {
         var dependencies = new List<Uri>();
         for (var line in lines) {
           line = line.trim();
@@ skipping 22 matching lines @@
           return true;
         }
       }
       return false;
     });
   }
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(_outputFile);
-    builder.addJson(_neverSkipCompilation);
+    builder.addJson(_alwaysCompile);
     builder.addJson(_bootstrapDependencies);
   }
 
   bool _equal(CompilationCommand other) =>
       super._equal(other) &&
       _outputFile == other._outputFile &&
-      _neverSkipCompilation == other._neverSkipCompilation &&
+      _alwaysCompile == other._alwaysCompile &&
       deepJsonCompare(_bootstrapDependencies, other._bootstrapDependencies);
 }
 
 class KernelCompilationCommand extends CompilationCommand {
   KernelCompilationCommand._(
       String outputFile,
       bool neverSkipCompilation,
       List<Uri> bootstrapDependencies,
       String executable,
       List<String> arguments,
@@ skipping 298 matching lines @@
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(_link);
     builder.addJson(_target);
   }
 
   bool _equal(MakeSymlinkCommand other) =>
       super._equal(other) && _link == other._link && _target == other._target;
 }