Merge more Kernel infrastructure from kernel_sdk SDK fork.

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.
 
 library compiler_configuration;
 
 import 'dart:io' show Platform;
 
 import 'runtime_configuration.dart' show RuntimeConfiguration;
 
@@ skipping 71 matching lines @@
       case 'dart2app':
         return new Dart2AppSnapshotCompilerConfiguration(
             isDebug: isDebug, isChecked: isChecked, useBlobs: useBlobs);
       case 'precompiler':
         return new PrecompilerCompilerConfiguration(
             isDebug: isDebug,
             isChecked: isChecked,
             arch: configuration['arch'],
             useBlobs: useBlobs,
             isAndroid: configuration['system'] == 'android');
+      case 'dartk':
+        return ComposedCompilerConfiguration.createDartKConfiguration(
+            isHostChecked: isHostChecked,
+            kernel_transformers: configuration['kernel_transformers'],
+            useSdk: useSdk);
+      case 'dartkp':
+        return ComposedCompilerConfiguration.createDartKPConfiguration(
+            isHostChecked: isHostChecked,
+            arch: configuration['arch'],
+            useBlobs: useBlobs,
+            isAndroid: configuration['system'] == 'android',
+            kernel_transformers: configuration['kernel_transformers'],
+            useSdk: useSdk);
       case 'none':
         return new NoneCompilerConfiguration(
             isDebug: isDebug,
             isChecked: isChecked,
             isHostChecked: isHostChecked,
             useSdk: useSdk,
             hotReload: hotReload,
             hotReloadRollback: hotReloadRollback);
       default:
         throw "Unknown compiler '$compiler'";
@@ skipping 90 matching lines @@
     } else if (hotReloadRollback) {
       args.add('--hot-reload-rollback-test-mode');
     }
     return args
       ..addAll(vmOptions)
       ..addAll(sharedOptions)
       ..addAll(originalArguments);
   }
 }
 
+/// The "dartk" compiler.
+class DartKCompilerConfiguration extends CompilerConfiguration {
+  DartKCompilerConfiguration({bool isHostChecked, bool useSdk})
+      : super._subclass(isHostChecked: isHostChecked, useSdk: useSdk);
+
+  @override
+  String computeCompilerPath(String buildDir) {
+    return 'third_party/pkg/kernel/bin/dartk.dart';
+  }
+
+  CompilationCommand computeCompilationCommand(
+      String outputFileName,
+      String buildDir,
+      CommandBuilder commandBuilder,
+      List arguments,
+      Map<String, String> environmentOverrides) {
+    var extraArguments = [
+      '--sdk',
+      '$buildDir/obj/gen/patched_sdk',
+      '--link',
+      '--target=vm',
+      '--out',
+      outputFileName
+    ];
+    return commandBuilder.getKernelCompilationCommand(
+        'dartk',
+        outputFileName,
+        true,
+        bootstrapDependencies(buildDir),
+        computeCompilerPath(buildDir),
+        []..addAll(arguments)..addAll(extraArguments),
+        environmentOverrides);
+  }
+
+  CommandArtifact computeCompilationArtifact(
+      String buildDir,
+      String tempDir,
+      CommandBuilder commandBuilder,
+      List arguments,
+      Map<String, String> environmentOverrides) {
+    return new CommandArtifact(<Command>[
+      this.computeCompilationCommand('$tempDir/out.dill', buildDir,
+          CommandBuilder.instance, arguments, environmentOverrides)
+    ], '$tempDir/out.dill', 'application/dart');
+  }
+}
+
+typedef List<String> CompilerArgumentsFunction(
+    List<String> globalArguments,
+    String previousCompilerOutput);
+
+class PipelineCommand {
+  final CompilerConfiguration compilerConfiguration;
+  final CompilerArgumentsFunction _argumentsFunction;
+
+  PipelineCommand._(this.compilerConfiguration, this._argumentsFunction);
+
+  factory PipelineCommand.runWithGlobalArguments(CompilerConfiguration conf) {
+    return new PipelineCommand._(conf, (List<String> globalArguments,
+                                        String previousOutput) {
+      assert(previousOutput == null);
+      return globalArguments;
+    });
+  }
+
+  factory PipelineCommand.runWithDartOrKernelFile(CompilerConfiguration conf) {
+    return new PipelineCommand._(conf, (List<String> globalArguments,
+                                        String previousOutput) {
+      var filtered = globalArguments
+        .where((String name) => name.endsWith('.dart') ||
+                                name.endsWith('.dill'))
+        .toList();
+      assert(filtered.length == 1);
+      return filtered;
+    });
+  }
+
+  factory PipelineCommand.runWithPreviousKernelOutput(
+      CompilerConfiguration conf) {
+    return new PipelineCommand._(conf, (List<String> globalArguments,
+                                        String previousOutput) {
+      assert(previousOutput.endsWith('.dill'));
+      return [previousOutput];
+    });
+  }
+
+  List<String> extractArguments(List<String> globalArguments,
+                                String previousOutput) {
+    return _argumentsFunction(globalArguments, previousOutput);
+  }
+}
+
+class ComposedCompilerConfiguration extends CompilerConfiguration {
+  final List<PipelineCommand> pipelineCommands;
+
+  ComposedCompilerConfiguration(this.pipelineCommands)
+      : super._subclass();
+
+  CommandArtifact computeCompilationArtifact(
+      String buildDir,
+      String tempDir,
+      CommandBuilder commandBuilder,
+      List globalArguments,
+      Map<String, String> environmentOverrides) {
+
+    List<Command> allCommands = [];
+
+    // The first compilation command is as usual.
+    var arguments = pipelineCommands[0].extractArguments(globalArguments, null);
+    CommandArtifact artifact =
+        pipelineCommands[0].compilerConfiguration.computeCompilationArtifact(
+          buildDir, tempDir, commandBuilder, arguments, environmentOverrides);
+    allCommands.addAll(artifact.commands);
+
+    // The following compilation commands are based on the output of the
+    // previous one.
+    for (int i = 1; i < pipelineCommands.length; i++) {
+      PipelineCommand pc = pipelineCommands[i];
+
+      arguments = pc.extractArguments(globalArguments, artifact.filename);
+      artifact = pc.compilerConfiguration.computeCompilationArtifact(
+          buildDir, tempDir, commandBuilder, 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 new List<String>.from(sharedOptions)..addAll(args);
+  }
+
+  List<String> computeRuntimeArguments(
+      RuntimeConfiguration runtimeConfiguration,
+      String buildDir,
+      TestInformation info,
+      List<String> vmOptions,
+      List<String> sharedOptions,
+      List<String> originalArguments,
+      CommandArtifact artifact) {
+    return <String>[artifact.filename];
+  }
+
+  static ComposedCompilerConfiguration createDartKPConfiguration(
+      {bool isHostChecked, String arch, bool useBlobs, bool isAndroid,
+       String kernel_transformers, bool useSdk}) {
+    var nested = [];
+
+    // Compile with dartk.
+    nested.add(new PipelineCommand.runWithGlobalArguments(
+        new DartKCompilerConfiguration(isHostChecked: isHostChecked,
+            useSdk: useSdk)));
+
+    // Run zero or more transformations.
+    addKernelTransformations(nested, kernel_transformers);
+
+    // Run the normal precompiler.
+    nested.add(new PipelineCommand.runWithPreviousKernelOutput(
+        new PrecompilerCompilerConfiguration(
+          arch: arch, useBlobs: useBlobs, isAndroid: isAndroid)));
+
+    return new ComposedCompilerConfiguration(nested);
+  }
+
+  static ComposedCompilerConfiguration createDartKConfiguration(
+      {bool isHostChecked, bool useSdk, String kernel_transformers}) {
+    var nested = [];
+
+    // Compile with dartk.
+    nested.add(new PipelineCommand.runWithGlobalArguments(
+        new DartKCompilerConfiguration(isHostChecked: isHostChecked,
+            useSdk: useSdk)));
+
+    // Run zero or more transformations.
+    addKernelTransformations(nested, kernel_transformers);
+
+    return new ComposedCompilerConfiguration(nested);
+  }
+
+  static void addKernelTransformations(List<PipelineCommand> nested,
+                                       String kernel_transformers) {
+    if (kernel_transformers != null && kernel_transformers.length > 0) {
+      List<String> names = kernel_transformers.split(',');
+      for (var name in names) {
+        var transformation = new KernelTransformation(name);
+        nested.add(nested.isEmpty
+            ? new PipelineCommand.runWithDartOrKernelFile(transformation)
+            : new PipelineCommand.runWithPreviousKernelOutput(transformation));
+      }
+    }
+  }
+}
+
+class KernelTransformation extends CompilerConfiguration {
+  final String transformation;
+
+  KernelTransformation(this.transformation) : super._subclass();
+
+  CommandArtifact computeCompilationArtifact(
+      String buildDir,
+      String tempDir,
+      CommandBuilder commandBuilder,
+      List arguments,
+      Map<String, String> environmentOverrides) {
+    assert(arguments.length == 1);
+    assert(arguments.last.contains('/'));
+    assert(arguments.last.endsWith('.dill'));
+
+    // The --kernel-transformers=a,b can be specified as
+    //    a = <name>
+    //    a = <name>:<path-to-transformer-executable>
+    int colonIndex = transformation.indexOf(':');
+    String transformationName = transformation;
+    String executable;
+    if (colonIndex > 0) {
+      executable = transformation.substring(colonIndex + 1);
+      transformationName = transformation.substring(0, colonIndex);
+    }
+
+    // The transformed output will be always written to a new file in the
+    // test-specific temporary directory.
+    var inputFile = arguments.last;
+    var baseInputFilename = inputFile.substring(
+        inputFile.lastIndexOf('/') + 1, inputFile.length - '.dill'.length);
+    var outputFile = '$tempDir/$baseInputFilename.$transformationName.dill';
+
+    // Use the user-supplied transformer or fall back to `transformer.dart`.
+    List<String> transformerArguments;
+    bool useBatchMode = false;
+    if (executable == null) {
+      executable = 'third_party/pkg/kernel/bin/transform.dart';
+      transformerArguments =
+          ['-f', 'bin', '-t', transformation, '-o', outputFile, inputFile];
+      useBatchMode = true;
+    } else {
+      transformerArguments = [inputFile, outputFile];
+    }
+
+    var command = commandBuilder.getKernelTransformationCommand(
+        transformationName, executable, transformerArguments, outputFile,
+        environmentOverrides, useBatchMode);
+
+    return new CommandArtifact(
+        <Command>[ command ], outputFile, 'application/dart');
+  }
+}
+
 /// Common configuration for dart2js-based tools, such as, dart2js
 class Dart2xCompilerConfiguration extends CompilerConfiguration {
   final String moniker;
   static Map<String, List<Uri>> _bootstrapDependenciesCache =
       new Map<String, List<Uri>>();
 
   Dart2xCompilerConfiguration(this.moniker,
       {bool isDebug, bool isChecked, bool isHostChecked, bool useSdk})
       : super._subclass(
             isDebug: isDebug,
@@ skipping 427 matching lines @@
       RuntimeConfiguration runtimeConfiguration,
       String buildDir,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     return <String>[];
   }
 }