Reapply CL: first step for modular support in fasta

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 65 matching lines @@
         KernelNamedTypeBuilder,
         KernelProcedureBuilder,
         LibraryBuilder,
         MemberBuilder,
         NamedTypeBuilder,
         TypeBuilder,
         TypeDeclarationBuilder,
         TypeVariableBuilder;
 
 import 'verifier.dart' show verifyProgram;
+import 'kernel_outline_shaker.dart'
+    show trimProgram, RetainedDataBuilder, RootsMarker;
 
 class KernelTarget extends TargetImplementation {
   /// The [FileSystem] which should be used to access files.
   final FileSystem fileSystem;
 
   final bool strongMode;
 
   final DillTarget dillTarget;
 
   /// Shared with [CompilerContext].
@@ skipping 111 matching lines @@
     cls.implementedTypes.clear();
     cls.supertype = null;
     cls.mixedInType = null;
     builder.supertype = new KernelNamedTypeBuilder("Object", null,
         builder.charOffset, builder.fileUri ?? Uri.parse(cls.fileUri))
       ..builder = objectClassBuilder;
     builder.interfaces = null;
     builder.mixedInType = null;
   }
 
-  void handleInputError(InputError error, {bool isFullProgram}) {
+  void handleInputError(InputError error,
+      {bool isFullProgram, bool trimDependencies: false}) {
     if (error != null) {
       String message = error.format();
       print(message);
       errors.add(message);
     }
     _program = erroneousProgram(isFullProgram);
   }
 
   @override
   Future<Program> buildOutlines({CanonicalName nameRoot}) async {
@@ skipping 21 matching lines @@
       loader.prepareInitializerInference();
       loader.performInitializerInference();
     } on InputError catch (e) {
       handleInputError(e, isFullProgram: false);
     } catch (e, s) {
       return reportCrash(e, s, loader?.currentUriForCrashReporting);
     }
     return _program;
   }
 
+  /// 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

[ahe, 2017/05/22 11:49:04]

This documentation states what is currently going on, but doesn't mention that
it isn't a long-term solution.

[Siggi Cherem (dart-lang), 2017/05/22 23:15:48]

added a note about it.

+  /// anything from the [DillTarget] that is not needed for the source program,
+  /// this includes function bodies and types that are not reachable.
+  ///
+  /// If [verify], run the default kernel verification on the resulting program.
   @override
-  Future<Program> buildProgram({bool verify: false}) async {
+  Future<Program> buildProgram(
+      {bool verify: false, bool trimDependencies: false}) async {
     if (loader.first == null) return null;
     if (errors.isNotEmpty) {
-      handleInputError(null, isFullProgram: true);
+      handleInputError(null,
+          isFullProgram: true, trimDependencies: trimDependencies);
+      if (trimDependencies) trimDependenciesInProgram();
       return _program;
     }
+
     try {
       await loader.buildBodies();
       loader.finishStaticInvocations();
       finishAllConstructors();
       loader.finishNativeMethods();
       runBuildTransformations();
 
       if (verify) this.verify();
       errors.addAll(loader.collectCompileTimeErrors().map((e) => e.format()));
       if (errors.isNotEmpty) {
-        handleInputError(null, isFullProgram: true);
+        handleInputError(null,
+            isFullProgram: true, trimDependencies: trimDependencies);
       }
     } on InputError catch (e) {
-      handleInputError(e, isFullProgram: true);
+      handleInputError(e,
+          isFullProgram: true, trimDependencies: trimDependencies);
     } catch (e, s) {
       return reportCrash(e, s, loader?.currentUriForCrashReporting);
     }
+    if (trimDependencies) trimDependenciesInProgram();
     return _program;
   }
 
   Future writeDepsFile(Uri output, Uri depsFile,
       {Iterable<Uri> extraDependencies}) async {
     String toRelativeFilePath(Uri uri) {
       // Ninja expects to find file names relative to the current working
       // directory. We've tried making them relative to the deps file, but that
       // doesn't work for downstream projects. Making them absolute also
       // doesn't work.
@@ skipping 54 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);
 
-    libraries.addAll(dillTarget.loader.libraries);
+    List<Library> extraLibraries = dillTarget.loader.libraries;
+    libraries.addAll(extraLibraries);

[ahe, 2017/05/22 11:49:04]

Seems like an unnecessary change.

[Siggi Cherem (dart-lang), 2017/05/22 23:15:48]

Ouch, my apologies. I undid a bunch of other changes in this function and I
didn't notice this lingering change. I'll revert it.

     // 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) {
+      // TODO(sigmund): do only for full program
       Builder builder = loader.first.lookup("main", -1, null);
       if (builder is KernelProcedureBuilder) {
         program.mainMethod = builder.procedure;
       }
     }
-    if (errors.isEmpty || dillTarget.isLoaded) {
-      runLinkTransformations(program);
-    }
+
     ticker.logMs("Linked program");
     return program;
   }
 
   void installDefaultSupertypes() {
     Class objectClass = this.objectClass;
     loader.builders.forEach((Uri uri, LibraryBuilder library) {
       library.forEach((String name, Builder builder) {
         if (builder is SourceClassBuilder) {
           Class cls = builder.target;
@@ skipping 245 matching lines @@
     });
   }
 
   /// Run all transformations that are needed when building a program for the
   /// first time.
   void runBuildTransformations() {
     transformMixinApplications();
     otherTransformations();
   }
 
-  /// Run all transformations that are needed when linking a program.
-  void runLinkTransformations(Program program) {}
-
   void transformMixinApplications() {
     new MixinFullResolution().transform(_program);
     ticker.logMs("Transformed mixin applications");
   }
 
   void otherTransformations() {
     // TODO(ahe): Don't generate type variables in the first place.
     if (!strongMode) {
       _program.accept(new Erasure());
       ticker.logMs("Erased type variables in generic methods");
     }
     // TODO(kmillikin): Make this run on a per-method basis.
     transformAsync.transformProgram(_program);
     ticker.logMs("Transformed async methods");
   }
 
   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.
+  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);
+  }
 }
 
 /// Looks for a constructor call that matches `super()` from a constructor in
 /// [cls]. Such a constructor may have optional arguments, but no required
 /// arguments.
 Constructor defaultSuperConstructor(Class cls) {
   Class superclass = cls.superclass;
   while (superclass != null && superclass.isMixinApplication) {
     superclass = superclass.superclass;
   }
   for (Constructor constructor in superclass.constructors) {
     if (constructor.name.name.isEmpty) {
       return constructor.function.requiredParameterCount == 0
           ? constructor
           : null;
     }
   }
   return null;
 }