Pass shared options to dartdevc in test.dart.

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 76 matching lines @@
     throw "Unknown compiler for: $runtimeType";
   }
 
   bool get hasCompiler => true;
 
   String get executableScriptSuffix => Platform.isWindows ? '.bat' : '';
 
   List<Uri> bootstrapDependencies() => const <Uri>[];
 
   /// Creates a [Command] to compile [inputFile] to [outputFile].
-  Command createCommand(String inputFile, String outputFile) {
+  Command createCommand(
+      String inputFile, String outputFile, List<String> sharedOptions) {
     // TODO(rnystrom): See if this method can be unified with
     // computeCompilationArtifact() and/or computeCompilerArguments() for the
     // other compilers.
     throw new UnsupportedError("$this does not support createCommand().");
   }
 
   CommandArtifact computeCompilationArtifact(String tempDir,
       List<String> arguments, Map<String, String> environmentOverrides) {
     return new CommandArtifact([], null, null);
   }
@@ skipping 250 matching lines @@
 /// Configuration for dart2js compiler.
 class DartdevcCompilerConfiguration extends CompilerConfiguration {
   DartdevcCompilerConfiguration(Configuration configuration)
       : super._subclass(configuration);
 
   String computeCompilerPath() {
     var dir = _useSdk ? "${_configuration.buildDirectory}/dart-sdk" : "sdk";
     return "$dir/bin/dartdevc$executableScriptSuffix";
   }
 
-  Command createCommand(String inputFile, String outputFile) {
+  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) {
     var moduleRoot =
         new Path(outputFile).directoryPath.directoryPath.toNativePath();
 
     var args = [
       "--dart-sdk",
       "${_configuration.buildDirectory}/dart-sdk",
       "--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 {});
   }
 
   CommandArtifact computeCompilationArtifact(String tempDir,
       List<String> arguments, Map<String, String> environmentOverrides) {
-    // TODO(rnystrom): Are there other arguments here that we need to keep?
-    // What about arguments specified in the test itself?
+    // 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)],
-        outputFile, "application/javascript");
+    return new CommandArtifact(
+        [createCommand(inputFile, outputFile, sharedOptions)],
+        outputFile,
+        "application/javascript");
   }
 }
 
 class PrecompilerCompilerConfiguration extends CompilerConfiguration {
   final bool useDfe;
 
   bool get _isAndroid => _configuration.system == System.android;
   bool get _isArm => _configuration.architecture == Architecture.arm;
   bool get _isArm64 => _configuration.architecture == Architecture.arm64;
 
@@ skipping 299 matching lines @@
   List<String> computeRuntimeArguments(
       RuntimeConfiguration runtimeConfiguration,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     return <String>[];
   }
 }