enable batch mode for dartdevc tests, also fix status so ddc bots pass

tools/testing/dart/compiler_configuration.dart

 // Copyright (c) 2014, 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:io';
 
 import 'command.dart';
 import 'configuration.dart';
 import 'path.dart';
 import 'runtime_configuration.dart';
@@ skipping 36 matching lines @@
 
   factory CompilerConfiguration(Configuration configuration) {
     switch (configuration.compiler) {
       case Compiler.dart2analyzer:
         return new AnalyzerCompilerConfiguration(configuration);
 
       case Compiler.dart2js:
         return new Dart2jsCompilerConfiguration(configuration);
 
       case Compiler.dartdevc:
-        return new DartdevcCompilerConfiguration(configuration);
+        return new DevCompilerConfiguration(configuration);
 
       case Compiler.appJit:
         return new AppJitCompilerConfiguration(configuration);
 
       case Compiler.precompiler:
         return new PrecompilerCompilerConfiguration(configuration);
 
       case Compiler.dartk:
         return new NoneCompilerConfiguration(configuration, useDfe: true);
 
@@ skipping 289 matching lines @@
     Uri sdk = _useSdk
         ? new Uri.directory(_configuration.buildDirectory).resolve('dart-sdk/')
         : new Uri.directory(TestUtils.dartDir.toNativePath()).resolve('sdk/');
     Uri preambleDir = sdk.resolve('lib/_internal/js_runtime/lib/preambles/');
     return runtimeConfiguration.dart2jsPreambles(preambleDir)
       ..add(artifact.filename);
   }
 }
 
 /// Configuration for dart2js compiler.
-class DartdevcCompilerConfiguration extends CompilerConfiguration {
-  DartdevcCompilerConfiguration(Configuration configuration)
+class DevCompilerConfiguration extends CompilerConfiguration {
+  DevCompilerConfiguration(Configuration configuration)
       : super._subclass(configuration);
 
   String computeCompilerPath() {
     var dir = _useSdk ? "${_configuration.buildDirectory}/dart-sdk" : "sdk";
     return "$dir/bin/dartdevc$executableScriptSuffix";
   }
 
   List<String> computeCompilerArguments(
       List<String> vmOptions, List<String> sharedOptions, List<String> args) {
     var result = sharedOptions.toList();
 
     // The file being compiled is the last argument.
     result.add(args.last);
 
     return result;
   }
 
   Command createCommand(
-      String inputFile, String outputFile, List<String> sharedOptions) {
+      String inputFile, String outputFile, List<String> sharedOptions,
+      [Map<String, String> environment = const {}]) {
     var moduleRoot =
         new Path(outputFile).directoryPath.directoryPath.toNativePath();
 
-    var args = [
-      "--dart-sdk",
-      "${_configuration.buildDirectory}/dart-sdk",
+    var args = _useSdk
+        ? ["--dart-sdk", "${_configuration.buildDirectory}/dart-sdk"]
+        // TODO(jmesserly): once we can build DDC's SDK summary+JS as part of
+        // the main build, change this to reflect that output path.
+        : ["--dart-sdk-summary", "pkg/dev_compiler/lib/sdk/ddc_sdk.sum"];
+
+    args.addAll(sharedOptions);
+    args.addAll([
+      "--ignore-unrecognized-flags",
       "--library-root",
       new Path(inputFile).directoryPath.toNativePath(),
       "--module-root",
       moduleRoot,
       "--no-summarize",
       "--no-source-map",
       "-o",
       outputFile,
       inputFile,
-    ];
-
-    args.addAll(sharedOptions);
+    ]);
 
     // Link to the summaries for the available packages, so that they don't
     // get recompiled into the test's own module.
     for (var package in testPackages) {
       args.add("-s");
 
       // Since the summaries for the packages are not near the tests, we give
       // dartdevc explicit module paths for each one. When the test is run, we
       // will tell require.js where to find each package's compiled JS.
       var summary = _configuration.buildDirectory +
           "/gen/utils/dartdevc/pkg/$package.sum";
       args.add("$summary=$package");
     }
 
     return Command.compilation(Compiler.dartdevc.name, outputFile,
-        bootstrapDependencies(), computeCompilerPath(), args, const {});
+        bootstrapDependencies(), computeCompilerPath(), args, environment);
   }
 
-  CommandArtifact computeCompilationArtifact(String tempDir,
-      List<String> arguments, Map<String, String> environmentOverrides) {
+  CommandArtifact computeCompilationArtifact(
+      String tempDir, List<String> arguments, Map<String, String> environment) {
     // The list of arguments comes from a call to our own
     // computeCompilerArguments(). It contains the shared options followed by
     // the input file path.
     // TODO(rnystrom): Jamming these into a list in order to pipe them from
     // computeCompilerArguments() to here seems hacky. Is there a cleaner way?
     var sharedOptions = arguments.sublist(0, arguments.length - 1);
     var inputFile = arguments.last;
     var outputFile = "$tempDir/${inputFile.replaceAll('.dart', '.js')}";
 
     return new CommandArtifact(
-        [createCommand(inputFile, outputFile, sharedOptions)],
+        [createCommand(inputFile, outputFile, sharedOptions, environment)],
         outputFile,
         "application/javascript");
   }
 }
 
 class PrecompilerCompilerConfiguration extends CompilerConfiguration {
   final bool useDfe;
 
   bool get _isAndroid => _configuration.system == System.android;
   bool get _isArm => _configuration.architecture == Architecture.arm;
@@ skipping 301 matching lines @@
   List<String> computeRuntimeArguments(
       RuntimeConfiguration runtimeConfiguration,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     return <String>[];
   }
 }