Dynamically load packages for dartdevc tests 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 65 matching lines @@
     throw "unreachable";
   }
 
   CompilerConfiguration._subclass(this._configuration);
 
   /// A multiplier used to give tests longer time to run.
   int get timeoutMultiplier => 1;
 
   // TODO(ahe): It shouldn't be necessary to pass [buildDir] to any of these
   // functions. It is fixed for a given configuration.
-  String computeCompilerPath(String buildDir) {
+  String computeCompilerPath() {
     throw "Unknown compiler for: $runtimeType";
   }
 
   bool get hasCompiler => true;
 
   String get executableScriptSuffix => Platform.isWindows ? '.bat' : '';
 
-  List<Uri> bootstrapDependencies(String buildDir) => const <Uri>[];
+  List<Uri> bootstrapDependencies() => const <Uri>[];
 
-  CommandArtifact computeCompilationArtifact(String buildDir, String tempDir,
+  /// Creates a [Command] to compile [inputFile] to [outputFile].
+  Command createCommand(String inputFile, String outputFile) {
+    // 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);
   }
 
   List<String> computeCompilerArguments(
       List<String> vmOptions, List<String> sharedOptions, List<String> args) {
     return sharedOptions.toList()..addAll(args);
   }
 
   List<String> computeRuntimeArguments(
       RuntimeConfiguration runtimeConfiguration,
-      String buildDir,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     return [artifact.filename];
   }
 }
 
 /// The "none" compiler.
 class NoneCompilerConfiguration extends CompilerConfiguration {
   final bool useDfe;
 
   NoneCompilerConfiguration(Configuration configuration, {this.useDfe: false})
       : super._subclass(configuration);
 
   bool get hasCompiler => false;
 
   List<String> computeRuntimeArguments(
       RuntimeConfiguration runtimeConfiguration,
-      String buildDir,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
+    var buildDir = _configuration.buildDirectory;
     var args = <String>[];
     if (useDfe) {
       args.add('--dfe=${buildDir}/gen/kernel-service.dart.snapshot');
       args.add('--kernel-binaries=${buildDir}/patched_sdk');
     }
     if (_isChecked) {
       args.add('--enable_asserts');
       args.add('--enable_type_checks');
     }
     if (_configuration.hotReload) {
@@ skipping 53 matching lines @@
   }
 }
 
 class ComposedCompilerConfiguration extends CompilerConfiguration {
   final List<PipelineCommand> pipelineCommands;
 
   ComposedCompilerConfiguration(
       Configuration configuration, this.pipelineCommands)
       : super._subclass(configuration);
 
-  CommandArtifact computeCompilationArtifact(String buildDir, String tempDir,
+  CommandArtifact computeCompilationArtifact(String tempDir,
       List<String> globalArguments, Map<String, String> environmentOverrides) {
     var allCommands = <Command>[];
 
     // The first compilation command is as usual.
     var arguments = pipelineCommands[0].extractArguments(globalArguments, null);
     CommandArtifact artifact = pipelineCommands[0]
         .compilerConfiguration
-        .computeCompilationArtifact(
-            buildDir, tempDir, arguments, environmentOverrides);
+        .computeCompilationArtifact(tempDir, arguments, environmentOverrides);
     allCommands.addAll(artifact.commands);
 
     // The following compilation commands are based on the output of the
     // previous one.
     for (var i = 1; i < pipelineCommands.length; i++) {
       PipelineCommand command = pipelineCommands[i];
 
       arguments = command.extractArguments(globalArguments, artifact.filename);
-      artifact = command.compilerConfiguration.computeCompilationArtifact(
-          buildDir, tempDir, arguments, environmentOverrides);
+      artifact = command.compilerConfiguration
+          .computeCompilationArtifact(tempDir, arguments, environmentOverrides);
 
       allCommands.addAll(artifact.commands);
     }
 
     return new CommandArtifact(
         allCommands, artifact.filename, artifact.mimeType);
   }
 
   List<String> computeCompilerArguments(vmOptions, sharedOptions, args) {
     // The result will be passed as an input to [extractArguments]
     // (i.e. the arguments to the [PipelineCommand]).
     return <String>[]..addAll(vmOptions)..addAll(sharedOptions)..addAll(args);
   }
 
   List<String> computeRuntimeArguments(
       RuntimeConfiguration runtimeConfiguration,
-      String buildDir,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     CompilerConfiguration lastCompilerConfiguration =
         pipelineCommands.last.compilerConfiguration;
     return lastCompilerConfiguration.computeRuntimeArguments(
         runtimeConfiguration,
-        buildDir,
         info,
         vmOptions,
         sharedOptions,
         originalArguments,
         artifact);
   }
 }
 
 /// Common configuration for dart2js-based tools, such as, dart2js
 class Dart2xCompilerConfiguration extends CompilerConfiguration {
   final String moniker;
   static Map<String, List<Uri>> _bootstrapDependenciesCache = {};
 
   Dart2xCompilerConfiguration(this.moniker, Configuration configuration)
       : super._subclass(configuration);
 
-  String computeCompilerPath(String buildDir) {
+  String computeCompilerPath() {
     var prefix = 'sdk/bin';
     var suffix = executableScriptSuffix;
 
     if (_isHostChecked) {
       // The script dart2js_developer is not included in the
       // shipped SDK, that is the script is not installed in
       // "$buildDir/dart-sdk/bin/"
       return '$prefix/dart2js_developer$suffix';
     }
 
     if (_useSdk) {
-      prefix = '$buildDir/dart-sdk/bin';
+      prefix = '${_configuration.buildDirectory}/dart-sdk/bin';
     }
     return '$prefix/dart2js$suffix';
   }
 
-  Command computeCompilationCommand(String outputFileName, String buildDir,
+  Command computeCompilationCommand(String outputFileName,
       List<String> arguments, Map<String, String> environmentOverrides) {
     arguments = arguments.toList();
     arguments.add('--out=$outputFileName');
 
-    return Command.compilation(
-        moniker,
-        outputFileName,
-        bootstrapDependencies(buildDir),
-        computeCompilerPath(buildDir),
-        arguments,
-        environmentOverrides,
+    return Command.compilation(moniker, outputFileName, bootstrapDependencies(),
+        computeCompilerPath(), arguments, environmentOverrides,
         alwaysCompile: !_useSdk);
   }
 
-  List<Uri> bootstrapDependencies(String buildDir) {
+  List<Uri> bootstrapDependencies() {
     if (!_useSdk) return const <Uri>[];
     return _bootstrapDependenciesCache.putIfAbsent(
-        buildDir,
+        _configuration.buildDirectory,
         () => [
               Uri.base
-                  .resolveUri(new Uri.directory(buildDir))
+                  .resolveUri(new Uri.directory(_configuration.buildDirectory))
                   .resolve('dart-sdk/bin/snapshots/dart2js.dart.snapshot')
             ]);
   }
 }
 
 /// Configuration for dart2js compiler.
 class Dart2jsCompilerConfiguration extends Dart2xCompilerConfiguration {
   Dart2jsCompilerConfiguration(Configuration configuration)
       : super('dart2js', configuration);
 
   int get timeoutMultiplier {
     var multiplier = 1;
     if (_isDebug) multiplier *= 4;
     if (_isChecked) multiplier *= 2;
     if (_isHostChecked) multiplier *= 16;
     return multiplier;
   }
 
-  CommandArtifact computeCompilationArtifact(String buildDir, String tempDir,
+  CommandArtifact computeCompilationArtifact(String tempDir,
       List<String> arguments, Map<String, String> environmentOverrides) {
     var compilerArguments = arguments.toList()
       ..addAll(_configuration.dart2jsOptions);
     return new CommandArtifact([
       computeCompilationCommand(
-          '$tempDir/out.js', buildDir, compilerArguments, environmentOverrides)
+          '$tempDir/out.js', compilerArguments, environmentOverrides)
     ], '$tempDir/out.js', 'application/javascript');
   }
 
   List<String> computeRuntimeArguments(
       RuntimeConfiguration runtimeConfiguration,
-      String buildDir,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     Uri sdk = _useSdk
-        ? new Uri.directory(buildDir).resolve('dart-sdk/')
+        ? 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)
       : super._subclass(configuration);
 
-  String computeCompilerPath(String buildDir) {
-    var dir = _useSdk ? "$buildDir/dart-sdk" : "sdk";
+  String computeCompilerPath() {
+    var dir = _useSdk ? "${_configuration.buildDirectory}/dart-sdk" : "sdk";
     return "$dir/bin/dartdevc$executableScriptSuffix";
   }
 
-  CommandArtifact computeCompilationArtifact(String buildDir, String tempDir,
+  Command createCommand(String inputFile, String outputFile) {
+    var moduleRoot =
+        new Path(outputFile).directoryPath.directoryPath.toString();
+
+    var args = [
+      "--dart-sdk",
+      "${_configuration.buildDirectory}/dart-sdk",
+      "--library-root",
+      new Path(inputFile).directoryPath.toString(),
+      "--module-root",
+      moduleRoot,
+      "--no-summarize",
+      "--no-source-map",
+      "-o",
+      outputFile,
+      inputFile,
+    ];
+
+    // 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): There is a lot of overlap between this code and
-    // _dartdevcCompileCommand() in test_suite.dart. This code path is only hit
-    // when the test is expected to have a compile error. Consider refactoring
-    // to unify the two (and likewise for dart2js).
-
     // TODO(rnystrom): Are there other arguments here that we need to keep?
     // What about arguments specified in the test itself?
     var inputFile = arguments.last;
+    var outputFile = "$tempDir/${inputFile.replaceAll('.dart', '.js')}";
 
-    var compilerArguments = [
-      "--dart-sdk",
-      "$buildDir/dart-sdk",
-      "--library-root",
-      new Path(inputFile).directoryPath.toString(),
-      "-o",
-      "$tempDir/out.js",
-      inputFile
-    ];
-
-    var command = Command.compilation(
-        Compiler.dartdevc.name,
-        "$tempDir/out.js",
-        bootstrapDependencies(buildDir),
-        computeCompilerPath(buildDir),
-        compilerArguments,
-        environmentOverrides);
-
-    return new CommandArtifact(
-        [command], "$tempDir/out.js", "application/javascript");
+    return new CommandArtifact([createCommand(inputFile, outputFile)],
+        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;
 
   PrecompilerCompilerConfiguration(Configuration configuration,
       {this.useDfe: false})
       : super._subclass(configuration);
 
   int get timeoutMultiplier {
     var multiplier = 2;
     if (_isDebug) multiplier *= 4;
     if (_isChecked) multiplier *= 2;
     return multiplier;
   }
 
-  CommandArtifact computeCompilationArtifact(String buildDir, String tempDir,
+  CommandArtifact computeCompilationArtifact(String tempDir,
       List<String> arguments, Map<String, String> environmentOverrides) {
     var commands = [
-      computeCompilationCommand(
-          tempDir, buildDir, arguments, environmentOverrides)
+      computeCompilationCommand(tempDir, arguments, environmentOverrides)
     ];
 
     if (!_configuration.useBlobs) {
-      commands.add(computeAssembleCommand(
-          tempDir, buildDir, arguments, environmentOverrides));
+      commands.add(
+          computeAssembleCommand(tempDir, arguments, environmentOverrides));
       commands.add(computeRemoveAssemblyCommand(
-          tempDir, buildDir, arguments, environmentOverrides));
+          tempDir, arguments, environmentOverrides));
     }
 
     return new CommandArtifact(
         commands, '$tempDir', 'application/dart-precompiled');
   }
 
-  Command computeCompilationCommand(String tempDir, String buildDir,
-      List<String> arguments, Map<String, String> environmentOverrides) {
+  Command computeCompilationCommand(String tempDir, List<String> arguments,
+      Map<String, String> environmentOverrides) {
+    var buildDir = _configuration.buildDirectory;
     String exec;
     if (_isAndroid) {
       if (_isArm) {
         exec = "$buildDir/clang_x86/dart_bootstrap";
       } else if (_configuration.architecture == Architecture.arm64) {
         exec = "$buildDir/clang_x64/dart_bootstrap";
       }
     } else {
       exec = "$buildDir/dart_bootstrap";
     }
@@ skipping 11 matching lines @@
     } else {
       args.add("--snapshot=$tempDir/out.S");
     }
 
     if (_isAndroid && _isArm) {
       args.add('--no-sim-use-hardfp');
     }
 
     args.addAll(arguments);
 
-    return Command.compilation('precompiler', tempDir,
-        bootstrapDependencies(buildDir), exec, args, environmentOverrides,
+    return Command.compilation('precompiler', tempDir, bootstrapDependencies(),
+        exec, args, environmentOverrides,
         alwaysCompile: !_useSdk);
   }
 
-  Command computeAssembleCommand(String tempDir, String buildDir,
-      List arguments, Map<String, String> environmentOverrides) {
+  Command computeAssembleCommand(String tempDir, List arguments,
+      Map<String, String> environmentOverrides) {
     String cc, shared, ldFlags;
     if (_isAndroid) {
       var ndk = "third_party/android_tools/ndk";
       String triple;
       if (_isArm) {
         triple = "arm-linux-androideabi";
       } else if (_isArm64) {
         triple = "aarch64-linux-android";
       }
       String host;
@@ skipping 35 matching lines @@
     var exec = cc;
     var args = <String>[];
     if (ccFlags != null) args.add(ccFlags);
     if (ldFlags != null) args.add(ldFlags);
     args.add(shared);
     args.add('-nostdlib');
     args.add('-o');
     args.add('$tempDir/out.aotsnapshot');
     args.add('$tempDir/out.S');
 
-    return Command.compilation('assemble', tempDir,
-        bootstrapDependencies(buildDir), exec, args, environmentOverrides,
+    return Command.compilation('assemble', tempDir, bootstrapDependencies(),
+        exec, args, environmentOverrides,
         alwaysCompile: !_useSdk);
   }
 
   // This step reduces the amount of space needed to run the precompilation
   // tests by 60%.
-  Command computeRemoveAssemblyCommand(String tempDir, String buildDir,
-      List arguments, Map<String, String> environmentOverrides) {
+  Command computeRemoveAssemblyCommand(String tempDir, List arguments,
+      Map<String, String> environmentOverrides) {
     var exec = 'rm';
     var args = ['$tempDir/out.S'];
 
     return Command.compilation('remove_assembly', tempDir,
-        bootstrapDependencies(buildDir), exec, args, environmentOverrides,
+        bootstrapDependencies(), exec, args, environmentOverrides,
         alwaysCompile: !_useSdk);
   }
 
   List<String> filterVmOptions(List<String> vmOptions) {
     var filtered = vmOptions.toList();
     filtered.removeWhere(
         (option) => option.startsWith("--optimization-counter-threshold"));
     filtered.removeWhere(
         (option) => option.startsWith("--optimization_counter_threshold"));
     return filtered;
   }
 
   List<String> computeCompilerArguments(
       vmOptions, sharedOptions, originalArguments) {
     List<String> args = [];
     if (_isChecked) {
       args.add('--enable_asserts');
       args.add('--enable_type_checks');
     }
     return args
       ..addAll(filterVmOptions(vmOptions))
       ..addAll(sharedOptions)
       ..addAll(originalArguments);
   }
 
   List<String> computeRuntimeArguments(
       RuntimeConfiguration runtimeConfiguration,
-      String buildDir,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     var args = <String>[];
     if (_isChecked) {
       args.add('--enable_asserts');
       args.add('--enable_type_checks');
     }
@@ skipping 18 matching lines @@
   AppJitCompilerConfiguration(Configuration configuration)
       : super._subclass(configuration);
 
   int get timeoutMultiplier {
     var multiplier = 1;
     if (_isDebug) multiplier *= 2;
     if (_isChecked) multiplier *= 2;
     return multiplier;
   }
 
-  CommandArtifact computeCompilationArtifact(String buildDir, String tempDir,
+  CommandArtifact computeCompilationArtifact(String tempDir,
       List<String> arguments, Map<String, String> environmentOverrides) {
     var snapshot = "$tempDir/out.jitsnapshot";
-    return new CommandArtifact([
-      computeCompilationCommand(
-          tempDir, buildDir, arguments, environmentOverrides)
-    ], snapshot, 'application/dart-snapshot');
+    return new CommandArtifact(
+        [computeCompilationCommand(tempDir, arguments, environmentOverrides)],
+        snapshot,
+        'application/dart-snapshot');
   }
 
-  Command computeCompilationCommand(String tempDir, String buildDir,
-      List<String> arguments, Map<String, String> environmentOverrides) {
-    var exec = "$buildDir/dart";
+  Command computeCompilationCommand(String tempDir, List<String> arguments,
+      Map<String, String> environmentOverrides) {
+    var exec = "${_configuration.buildDirectory}/dart";
     var snapshot = "$tempDir/out.jitsnapshot";
     var args = ["--snapshot=$snapshot", "--snapshot-kind=app-jit"];
     args.addAll(arguments);
 
-    return Command.compilation('app_jit', tempDir,
-        bootstrapDependencies(buildDir), exec, args, environmentOverrides,
+    return Command.compilation('app_jit', tempDir, bootstrapDependencies(),
+        exec, args, environmentOverrides,
         alwaysCompile: !_useSdk);
   }
 
   List<String> computeCompilerArguments(
       vmOptions, sharedOptions, originalArguments) {
     var args = <String>[];
     if (_isChecked) {
       args.add('--enable_asserts');
       args.add('--enable_type_checks');
     }
     return args
       ..addAll(vmOptions)
       ..addAll(sharedOptions)
       ..addAll(originalArguments);
   }
 
   List<String> computeRuntimeArguments(
       RuntimeConfiguration runtimeConfiguration,
-      String buildDir,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     var args = <String>[];
     if (_isChecked) {
       args.add('--enable_asserts');
       args.add('--enable_type_checks');
     }
     args..addAll(vmOptions)..addAll(sharedOptions)..addAll(originalArguments);
     for (var i = 0; i < args.length; i++) {
       if (args[i].endsWith(".dart")) {
         args[i] = artifact.filename;
       }
     }
     return args;
   }
 }
 
 class AnalyzerCompilerConfiguration extends CompilerConfiguration {
   AnalyzerCompilerConfiguration(Configuration configuration)
       : super._subclass(configuration);
 
   int get timeoutMultiplier => 4;
 
-  String computeCompilerPath(String buildDir) {
+  String computeCompilerPath() {
     var prefix = 'sdk/bin';
     String suffix = executableScriptSuffix;
     if (_isHostChecked) {
       if (_useSdk) {
         throw "--host-checked and --use-sdk cannot be used together";
       }
       // The script dartanalyzer_developer is not included in the
       // shipped SDK, that is the script is not installed in
       // "$buildDir/dart-sdk/bin/"
       return '$prefix/dartanalyzer_developer$suffix';
     }
     if (_useSdk) {
-      prefix = '$buildDir/dart-sdk/bin';
+      prefix = '${_configuration.buildDirectory}/dart-sdk/bin';
     }
     return '$prefix/dartanalyzer$suffix';
   }
 
-  CommandArtifact computeCompilationArtifact(String buildDir, String tempDir,
+  CommandArtifact computeCompilationArtifact(String tempDir,
       List<String> arguments, Map<String, String> environmentOverrides) {
     arguments = arguments.toList();
     if (_isChecked || _isStrong) {
       arguments.add('--enable_type_checks');
     }
     if (_isStrong) {
       arguments.add('--strong');
     }
 
     // Since this is not a real compilation, no artifacts are produced.
     return new CommandArtifact([
-      Command.analysis(
-          computeCompilerPath(buildDir), arguments, environmentOverrides)
+      Command.analysis(computeCompilerPath(), arguments, environmentOverrides)
     ], null, null);
   }
 
   List<String> computeRuntimeArguments(
       RuntimeConfiguration runtimeConfiguration,
-      String buildDir,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     return <String>[];
   }
 }