Address follow up comments

pkg/front_end/lib/src/fasta/kernel/kernel_target.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.
 
 library fasta.kernel_target;
 
 import 'dart:async' show Future;
 
 import 'dart:io' show File;
 
@@ skipping 249 matching lines @@
   }
 
   /// Build the kernel representation of the program loaded by this target. The
   /// program will contain full bodies for the code loaded from sources, and
   /// only references to the code loaded by the [DillTarget], which may or may
   /// not include method bodies (depending on what was loaded into that target,
   /// an outline or a full kernel program).
   ///
   /// When [trimDependencies] is true, this also runs a tree-shaker that deletes
   /// anything from the [DillTarget] that is not needed for the source program,
-  /// this includes function bodies and types that are not reachable.
+  /// this includes function bodies and types that are not reachable. This
+  /// option is currently in flux and the internal implementation might change.
+  /// See [trimDependenciesInProgram] for more details.
   ///
   /// If [verify], run the default kernel verification on the resulting program.
   @override
   Future<Program> buildProgram(
       {bool verify: false, bool trimDependencies: false}) async {
     if (loader.first == null) return null;
     if (errors.isNotEmpty) {
       handleInputError(null,
           isFullProgram: true, trimDependencies: trimDependencies);
       if (trimDependencies) trimDependenciesInProgram();
@@ skipping 87 matching lines @@
     library.build(loader.coreLibrary);
     return link(<Library>[library.library]);
   }
 
   /// Creates a program by combining [libraries] with the libraries of
   /// `dillTarget.loader.program`.
   Program link(List<Library> libraries, {CanonicalName nameRoot}) {
     Map<String, Source> uriToSource =
         new Map<String, Source>.from(this.uriToSource);
 
-    List<Library> extraLibraries = dillTarget.loader.libraries;
-    libraries.addAll(extraLibraries);
+    libraries.addAll(dillTarget.loader.libraries);
     // TODO(scheglov) Should we also somehow update `uriToSource`?
 //    uriToSource.addAll(binary.uriToSource);
 
     // TODO(ahe): Remove this line. Kernel seems to generate a default line map
     // that used when there's no fileUri on an element. Instead, ensure all
     // elements have a fileUri.
     uriToSource[""] = new Source(<int>[0], const <int>[]);
     Program program = new Program(
         nameRoot: nameRoot, libraries: libraries, uriToSource: uriToSource);
     if (loader.first != null) {
@@ skipping 287 matching lines @@
 
   void verify() {
     var verifyErrors = verifyProgram(_program);
     errors.addAll(verifyErrors.map((error) => '$error'));
     ticker.logMs("Verified program");
   }
 
   /// Tree-shakes most code from the [dillTarget] by visiting all other
   /// libraries in [_program] and marking the APIs from the [dillTarget]
   /// libraries that are in use.
+  ///
+  /// Note: while it's likely we'll do some trimming of programs for modular
+  /// compilation, it is unclear at this time when and how that trimming should
+  /// happen. We are likely going to remove the extra visitor my either marking
+  /// things while code is built, or by handling tree-shaking after the fact
+  /// (e.g. during serialization).
   trimDependenciesInProgram() {
     var toShake =
         dillTarget.loader.libraries.map((lib) => lib.importUri).toSet();
     var isIncluded = (Uri uri) => !toShake.contains(uri);
     var data = new RetainedDataBuilder();
     // TODO(sigmund): replace this step with data that is directly computed from
     // the builders: we should know the tree-shaking roots without having to do
     // a second visit over the tree.
     new RootsMarker(data).run(_program, isIncluded);
     trimProgram(_program, data, isIncluded);
@@ skipping 16 matching lines @@
   }
   for (Constructor constructor in superclass.constructors) {
     if (constructor.name.name.isEmpty) {
       return constructor.function.requiredParameterCount == 0
           ? constructor
           : null;
     }
   }
   return null;
 }