Put tree-shaking behind a flag in dartk.

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;
 import 'runtime_configuration.dart' show DartPrecompiledAdbRuntimeConfiguration;
@@ skipping 51 matching lines @@
     bool isHostChecked = configuration['host_checked'];
     bool useSdk = configuration['use_sdk'];
     bool isCsp = configuration['csp'];
     bool useCps = configuration['cps_ir'];
     bool useBlobs = configuration['use_blobs'];
     bool hotReload = configuration['hot_reload'];
     bool hotReloadRollback = configuration['hot_reload_rollback'];
     bool useFastStartup = configuration['fast_startup'];
     bool verifyKernel = configuration['verify-ir'];
     bool useStandaloneDartK = configuration['use-standalone-dartk'];
+    bool treeShake = !configuration['no-tree-shake'];
 
     switch (compiler) {
       case 'dart2analyzer':
         return new AnalyzerCompilerConfiguration(
             isDebug: isDebug,
             isChecked: isChecked,
             isStrong: isStrong,
             isHostChecked: isHostChecked,
             useSdk: useSdk);
       case 'dart2js':
@@ skipping 17 matching lines @@
             arch: configuration['arch'],
             useBlobs: useBlobs,
             isAndroid: configuration['system'] == 'android');
       case 'dartk':
         if (useStandaloneDartK) {
           return ComposedCompilerConfiguration.createDartKConfiguration(
               isChecked: isChecked,
               isHostChecked: isHostChecked,
               useSdk: useSdk,
               verify: verifyKernel,
-              strong: isStrong);
+              strong: isStrong,
+              treeShake: treeShake);
         }
 
         return new NoneCompilerConfiguration(
               isDebug: isDebug,
               isChecked: isChecked,
               isHostChecked: isHostChecked,
               useSdk: useSdk,
               hotReload: hotReload,
               hotReloadRollback: hotReloadRollback,
               useDFEIsolate: true);
 
       case 'dartkp':
         return ComposedCompilerConfiguration.createDartKPConfiguration(
             isChecked: isChecked,
             isHostChecked: isHostChecked,
             arch: configuration['arch'],
             useBlobs: useBlobs,
             isAndroid: configuration['system'] == 'android',
             useSdk: useSdk,
             verify: verifyKernel,
-            strong: isStrong);
+            strong: isStrong,
+            treeShake: treeShake);
       case 'none':
         return new NoneCompilerConfiguration(
             isDebug: isDebug,
             isChecked: isChecked,
             isHostChecked: isHostChecked,
             useSdk: useSdk,
             hotReload: hotReload,
             hotReloadRollback: hotReloadRollback);
       default:
         throw "Unknown compiler '$compiler'";
@@ skipping 95 matching lines @@
     }
     return args
       ..addAll(vmOptions)
       ..addAll(sharedOptions)
       ..addAll(originalArguments);
   }
 }
 
 /// The "dartk" compiler.
 class DartKCompilerConfiguration extends CompilerConfiguration {
-  final bool verify, strong;
+  final bool verify, strong, treeShake;
 
   DartKCompilerConfiguration({bool isChecked, bool isHostChecked, bool useSdk,
-        this.verify, this.strong})
+        this.verify, this.strong, this.treeShake})
       : 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,
       List arguments,
       Map<String, String> environmentOverrides) {
     Iterable<String> extraArguments = [
       '--sdk',
       '$buildDir/patched_sdk',
       '--link',
       '--target=vm',
+      treeShake ? '--tree-shake' : null,
       strong ? '--strong' : null,
       verify ? '--verify-ir' : null,
       '--out',
       outputFileName
     ].where((x) => x != null);
     return commandBuilder.getKernelCompilationCommand(
         'dartk',
         outputFileName,
         true,
         bootstrapDependencies(buildDir),
@@ skipping 136 matching lines @@
       CommandArtifact artifact) {
     CompilerConfiguration lastCompilerConfiguration =
         pipelineCommands.last.compilerConfiguration;
     return lastCompilerConfiguration.computeRuntimeArguments(
         runtimeConfiguration, buildDir, info, vmOptions, sharedOptions,
         originalArguments, artifact);
   }
 
   static ComposedCompilerConfiguration createDartKPConfiguration(
       {bool isChecked, bool isHostChecked, String arch, bool useBlobs,
-       bool isAndroid, bool useSdk, bool verify, bool strong}) {
+       bool isAndroid, bool useSdk, bool verify, bool strong, bool treeShake}) {
     var nested = [];
 
     // Compile with dartk.
     nested.add(new PipelineCommand.runWithGlobalArguments(
         new DartKCompilerConfiguration(isChecked: isChecked,
             isHostChecked: isHostChecked, useSdk: useSdk, verify: verify,
-            strong: strong)));
+            strong: strong, treeShake: treeShake)));
 
     // Run the normal precompiler.
     nested.add(new PipelineCommand.runWithPreviousKernelOutput(
         new PrecompilerCompilerConfiguration(
           isChecked: isChecked, arch: arch, useBlobs: useBlobs,
           isAndroid: isAndroid)));
 
     return new ComposedCompilerConfiguration(nested);
   }
 
   static ComposedCompilerConfiguration createDartKConfiguration(
       {bool isChecked, bool isHostChecked, bool useSdk, bool verify,
-       bool strong}) {
+       bool strong, bool treeShake}) {
     var nested = [];
 
     // Compile with dartk.
     nested.add(new PipelineCommand.runWithGlobalArguments(
         new DartKCompilerConfiguration(isChecked: isChecked,
             isHostChecked: isHostChecked, useSdk: useSdk,
-            verify: verify, strong: strong)));
+            verify: verify, strong: strong, treeShake: treeShake)));
 
     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>>();
@@ skipping 451 matching lines @@
       RuntimeConfiguration runtimeConfiguration,
       String buildDir,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     return <String>[];
   }
 }