Remove some hacks in the testing scripts & prepare for checked mode handling with kernel

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 73 matching lines @@
             isDebug: isDebug, isChecked: isChecked);
       case 'precompiler':
         return new PrecompilerCompilerConfiguration(
             isDebug: isDebug,
             isChecked: isChecked,
             arch: configuration['arch'],
             useBlobs: useBlobs,
             isAndroid: configuration['system'] == 'android');
       case 'dartk':
         return ComposedCompilerConfiguration.createDartKConfiguration(
+            isChecked: isChecked,
             isHostChecked: isHostChecked,
             useSdk: useSdk,
             verify: verifyKernel,
             strong: isStrong);
       case 'dartkp':
         return ComposedCompilerConfiguration.createDartKPConfiguration(
+            isChecked: isChecked,
             isHostChecked: isHostChecked,
             arch: configuration['arch'],
             useBlobs: useBlobs,
             isAndroid: configuration['system'] == 'android',
             useSdk: useSdk,
             verify: verifyKernel,
             strong: isStrong);
       case 'none':
         return new NoneCompilerConfiguration(
             isDebug: isDebug,
@@ skipping 101 matching lines @@
       ..addAll(vmOptions)
       ..addAll(sharedOptions)
       ..addAll(originalArguments);
   }
 }
 
 /// The "dartk" compiler.
 class DartKCompilerConfiguration extends CompilerConfiguration {
   final bool verify, strong;
 
-  DartKCompilerConfiguration({bool isHostChecked, bool useSdk, this.verify,
-        this.strong})
-      : super._subclass(isHostChecked: isHostChecked, useSdk: useSdk);
+  DartKCompilerConfiguration({bool isChecked, bool isHostChecked, bool useSdk,
+        this.verify, this.strong})
+      : super._subclass(isChecked: isChecked, isHostChecked: isHostChecked,
+                        useSdk: useSdk);
 
   @override
   String computeCompilerPath(String buildDir) {
     return 'tools/dartk_wrappers/dartk$executableScriptSuffix';
   }
 
   CompilationCommand computeCompilationCommand(
       String outputFileName,
       String buildDir,
       CommandBuilder commandBuilder,
@@ skipping 72 matching lines @@
   }
 
   List<String> extractArguments(List<String> globalArguments,
                                 String previousOutput) {
     return _argumentsFunction(globalArguments, previousOutput);
   }
 }
 
 class ComposedCompilerConfiguration extends CompilerConfiguration {
   final List<PipelineCommand> pipelineCommands;
-  final bool isPrecompiler;
 
-  ComposedCompilerConfiguration(this.pipelineCommands, {this.isPrecompiler: false})
-      : super._subclass();
+  ComposedCompilerConfiguration(this.pipelineCommands) : super._subclass();
 
   CommandArtifact computeCompilationArtifact(
       String buildDir,
       String tempDir,
       CommandBuilder commandBuilder,
       List globalArguments,
       Map<String, String> environmentOverrides) {
 
     List<Command> allCommands = [];
 
@@ skipping 27 matching lines @@
   }
 
   List<String> computeRuntimeArguments(
       RuntimeConfiguration runtimeConfiguration,
       String buildDir,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
-    final String suffix = isPrecompiler ? "/out.aotsnapshot" : "";
-    return <String>["${artifact.filename}${suffix}"];
+    CompilerConfiguration lastCompilerConfiguration =
+        pipelineCommands.last.compilerConfiguration;
+    return lastCompilerConfiguration.computeRuntimeArguments(
+        runtimeConfiguration, buildDir, info, vmOptions, sharedOptions,
+        originalArguments, artifact);
   }
 
   static ComposedCompilerConfiguration createDartKPConfiguration(
-      {bool isHostChecked, String arch, bool useBlobs, bool isAndroid,
-       bool useSdk, bool verify, bool strong}) {
+      {bool isChecked, bool isHostChecked, String arch, bool useBlobs,
+       bool isAndroid, bool useSdk, bool verify, bool strong}) {
     var nested = [];
 
     // Compile with dartk.
     nested.add(new PipelineCommand.runWithGlobalArguments(
-        new DartKCompilerConfiguration(isHostChecked: isHostChecked,
-            useSdk: useSdk, verify: verify, strong: strong)));
+        new DartKCompilerConfiguration(isChecked: isChecked,
+            isHostChecked: isHostChecked, useSdk: useSdk, verify: verify,
+            strong: strong)));
 
     // Run the normal precompiler.
     nested.add(new PipelineCommand.runWithPreviousKernelOutput(
         new PrecompilerCompilerConfiguration(
-          arch: arch, useBlobs: useBlobs, isAndroid: isAndroid)));
+          isChecked: isChecked, arch: arch, useBlobs: useBlobs,
+          isAndroid: isAndroid)));
 
-    return new ComposedCompilerConfiguration(nested, isPrecompiler: true);
+    return new ComposedCompilerConfiguration(nested);
   }
 
   static ComposedCompilerConfiguration createDartKConfiguration(
-      {bool isHostChecked, bool useSdk, bool verify, bool strong}) {
+      {bool isChecked, bool isHostChecked, bool useSdk, bool verify,
+       bool strong}) {
     var nested = [];
 
     // Compile with dartk.
     nested.add(new PipelineCommand.runWithGlobalArguments(
-        new DartKCompilerConfiguration(isHostChecked: isHostChecked,
-            useSdk: useSdk, verify: verify, strong: strong)));
+        new DartKCompilerConfiguration(isChecked: isChecked,
+            isHostChecked: isHostChecked, useSdk: useSdk,
+            verify: verify, strong: strong)));
 
-    return new ComposedCompilerConfiguration(nested, isPrecompiler: false);
+    return new ComposedCompilerConfiguration(nested);
   }
 }
 
 /// 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,
@@ skipping 281 matching lines @@
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     List<String> args = [];
     if (isChecked) {
       args.add('--enable_asserts');
       args.add('--enable_type_checks');
     }
+    var newOriginalArguments = new List<String>.from(originalArguments);
+    for (var i = 0; i < newOriginalArguments .length; i++) {
+      if (newOriginalArguments[i].endsWith(".dart")) {
+        newOriginalArguments[i] = "${artifact.filename}/out.aotsnapshot";
+      }
+    }

[kustermann, 2017/01/17 15:19:54]

Maybe I can also get rid of this at some point, but at least it's now in a
central place.

     return args
       ..addAll(vmOptions)
       ..addAll(sharedOptions)
-      ..addAll(originalArguments);
+      ..addAll(newOriginalArguments);
   }
 }
 
 class Dart2AppSnapshotCompilerConfiguration extends CompilerConfiguration {
   Dart2AppSnapshotCompilerConfiguration({bool isDebug, bool isChecked})
       : super._subclass(isDebug: isDebug, isChecked: isChecked);
 
   int computeTimeoutMultiplier() {
     int multiplier = 2;
     if (isDebug) multiplier *= 4;
@@ skipping 134 matching lines @@
       RuntimeConfiguration runtimeConfiguration,
       String buildDir,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     return <String>[];
   }
 }