VM: [Kernel] Add --embedder-entry-points-manifest to dartk/transform and pass it to the treeshaker

pkg/kernel/bin/transform.dart

 #!/usr/bin/env dart
 // Copyright (c) 2016, 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:async';
 import 'dart:io';
 
 import 'package:args/args.dart';
 import 'package:kernel/verifier.dart';
 import 'package:kernel/kernel.dart';
 import 'package:kernel/transformations/continuation.dart' as cont;
 import 'package:kernel/transformations/infer_values.dart' as infer_values;
 import 'package:kernel/transformations/mixin_full_resolution.dart' as mix;
 import 'package:kernel/transformations/closure_conversion.dart' as closures;
 import 'package:kernel/transformations/treeshaker.dart' as treeshaker;
 
+import 'util.dart';
 import 'batch_util.dart';
 
 ArgParser parser = new ArgParser()
   ..addOption('format',
       abbr: 'f',
       allowed: ['text', 'bin'],
       defaultsTo: 'bin',
       help: 'Output format.')
   ..addOption('out', abbr: 'o', help: 'Output file.', defaultsTo: null)
   ..addFlag('verbose',
       abbr: 'v',
       negatable: false,
       help: 'Be verbose (e.g. prints transformed main library).',
       defaultsTo: false)
+  ..addOption('embedder-entry-points-manifest',
+      allowMultiple: true,
+      help: 'A path to a file describing entrypoints '
+          '(lines of the form `<library>,<class>,<member>`).')
   ..addOption('transformation',
       abbr: 't',
       help: 'The transformation to apply.',
       defaultsTo: 'continuation');
 
 main(List<String> arguments) async {
   if (arguments.isNotEmpty && arguments[0] == '--batch') {
     if (arguments.length != 1) {
       throw '--batch cannot be used with other arguments';
     }
@@ skipping 13 matching lines @@
 
   var input = options.rest.first;
   var output = options['out'];
   var format = options['format'];
   var verbose = options['verbose'];
 
   if (output == null) {
     output = '${input.substring(0, input.lastIndexOf('.'))}.transformed.dill';
   }
 
+  List<String> embedderEntryPointManifests =
+      options['embedder-entry-points-manifest'] as List<String>;
+  List<treeshaker.ProgramRoot> programRoots =
+      parseProgramRoots(embedderEntryPointManifests);
+
   var program = loadProgramFromBinary(input);
   switch (options['transformation']) {
     case 'continuation':
       program = cont.transformProgram(program);
       break;
     case 'infervalues':
       program = infer_values.transformProgram(program);
       break;
     case 'resolve-mixins':
       program = mix.transformProgram(program);
       break;
     case 'closures':
       program = closures.transformProgram(program);
       break;
     case 'treeshake':
-      program = treeshaker.transformProgram(program);
+      program =
+          treeshaker.transformProgram(program, programRoots: programRoots);
       break;
     default:
       throw 'Unknown transformation';
   }
 
   verifyProgram(program);
 
   if (format == 'text') {
     writeProgramToText(program, path: output);
   } else {
     assert(format == 'bin');
     await writeProgramToBinary(program, output);
   }
 
   if (verbose) {
     writeLibraryToText(program.mainMethod.parent as Library);
   }
 
   return CompilerOutcome.Ok;
 }