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

pkg/kernel/lib/transformations/treeshaker.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 kernel.tree_shaker;
 
 import '../ast.dart';
 import '../class_hierarchy.dart';
 import '../core_types.dart';
 import '../type_environment.dart';
 
-Program transformProgram(Program program) {
-  new TreeShaker(program).transform(program);
+Program transformProgram(Program program, {List<ProgramRoot> programRoots}) {
+  new TreeShaker(program, programRoots: programRoots).transform(program);
   return program;
 }
 
+enum ProgramRootKind {
+  /// The root is a class which will be instantiated by
+  /// external / non-Dart code.
+  ExternallyInstantiatedClass,
+
+  /// The root is a setter function or a field.
+  Setter,
+
+  /// The root is a getter function or a field.
+  Getter,
+
+  /// The root is some kind of constructor.
+  Constructor,
+
+  /// The root is a field, normal procedure or constructor.
+  Other,
+}
+
+/// A program root which the vm or embedder uses and needs to be retained.
+class ProgramRoot {
+  /// The library the root is contained in.
+  final String library;
+
+  /// The name of the class inside the library (optional).
+  final String klass;
+
+  /// The name of the member inside the library (or class, optional).
+  final String member;
+
+  /// The kind of this program root.
+  final ProgramRootKind kind;
+
+  ProgramRoot(this.library, this.klass, this.member, this.kind);
+
+  String toString() => "ProgramRoot($library, $klass, $member, $kind)";
+}
+
 /// Tree shaking based on class hierarchy analysis.
 ///
 /// Any dynamic dispatch not on `this` is conservatively assumed to target
 /// any instantiated class that implements a member matching the selector.
 ///
 /// Member bodies are analyzed relative to a given "host class" which is the
 /// concrete type of `this` (or null if in static context), so dispatches on
 /// `this` can be resolved more precisely.
 ///
 /// The tree shaker computes the following in a fixed-point iteration:
 /// - a set of instantiated classes
 /// - for each member, a set of potential host classes
 /// - a set of names used in dynamic dispatch not on `this`
 ///
 /// If the `dart:mirrors` library is used then nothing will be tree-shaken.
 //
-// TODO(asgerf): Shake off parts of the core libraries based on the Target.
 // TODO(asgerf): Tree shake unused instance fields.
 class TreeShaker {
   final Program program;
   final ClassHierarchy hierarchy;
   final CoreTypes coreTypes;
   final bool strongMode;
+  final List<ProgramRoot> programRoots;
 
   /// Map from classes to set of names that have been dispatched with that class
   /// as the static receiver type (meaning any subtype of that class can be
   /// the potential concrete receiver).
   ///
   /// The map is implemented as a list, indexed by
   /// [ClassHierarchy.getClassIndex].
   final List<Set<Name>> _dispatchedNames;
 
   /// Map from names to the set of classes that might be the concrete receiver
@@ skipping 50 matching lines @@
   /// AST visitor for analyzing type annotations on external members.
   _ExternalTypeVisitor _covariantVisitor;
   _ExternalTypeVisitor _contravariantVisitor;
   _ExternalTypeVisitor _invariantVisitor;
 
   Library _mirrorsLibrary;
 
   /// Set to true if any use of the `dart:mirrors` API is found.
   bool isUsingMirrors = false;
 
+  /// If we have roots, we will shake, even if we encounter some elements from
+  /// the mirrors library.
+  bool get forceShaking => programRoots != null && programRoots.isNotEmpty;
+
   TreeShaker(Program program,
-      {ClassHierarchy hierarchy, CoreTypes coreTypes, bool strongMode: false})
+      {ClassHierarchy hierarchy,
+      CoreTypes coreTypes,
+      bool strongMode: false,
+      List<ProgramRoot> programRoots})
       : this._internal(program, hierarchy ?? new ClassHierarchy(program),
-            coreTypes ?? new CoreTypes(program), strongMode);
+            coreTypes ?? new CoreTypes(program), strongMode, programRoots);
 
   bool isMemberBodyUsed(Member member) {
     return _usedMembers.containsKey(member);
   }
 
   bool isMemberOverridden(Member member) {
     return _overriddenMembers.contains(member);
   }
 
   bool isMemberUsed(Member member) {
@@ skipping 14 matching lines @@
   }
 
   /// Applies the tree shaking results to the program.
   ///
   /// This removes unused classes, members, and hierarchy data.
   void transform(Program program) {
     if (isUsingMirrors) return; // Give up if using mirrors.
     new _TreeShakingTransformer(this).transform(program);
   }
 
-  TreeShaker._internal(
-      this.program, ClassHierarchy hierarchy, this.coreTypes, this.strongMode)
+  TreeShaker._internal(this.program, ClassHierarchy hierarchy, this.coreTypes,
+      this.strongMode, this.programRoots)
       : this.hierarchy = hierarchy,
         this._dispatchedNames = new List<Set<Name>>(hierarchy.classes.length),
         this._usedMembersWithHost =
             new List<Set<Member>>(hierarchy.classes.length),
         this._classRetention = new List<ClassRetention>.filled(
             hierarchy.classes.length, ClassRetention.None) {
     _visitor = new _TreeShakerVisitor(this);
     _covariantVisitor = new _ExternalTypeVisitor(this, isCovariant: true);
     _contravariantVisitor =
         new _ExternalTypeVisitor(this, isContravariant: true);
@@ skipping 12 matching lines @@
       throw 'Cannot perform tree shaking on a program without a main method';
     }
     if (program.mainMethod.function.positionalParameters.length > 0) {
       // The main method takes a List<String> as argument.
       _addInstantiatedExternalSubclass(coreTypes.listClass);
       _addInstantiatedExternalSubclass(coreTypes.stringClass);
     }
     _addDispatchedName(hierarchy.rootClass, new Name('noSuchMethod'));
     _addPervasiveUses();
     _addUsedMember(null, program.mainMethod);
+    programRoots?.forEach(_addUsedRoot);
+
     _iterateWorklist();
 
     // Mark overridden members in order to preserve abstract members as
     // necessary.
     if (strongMode) {
       for (int i = hierarchy.classes.length - 1; i >= 0; --i) {
         Class class_ = hierarchy.classes[i];
         if (isHierarchyUsed(class_)) {
           hierarchy.forEachOverridePair(class_,
               (Member ownMember, Member superMember, bool isSetter) {
@@ skipping 171 matching lines @@
   ///
   /// Ensures that all annotations on the class are analyzed.
   void _propagateClassNamespaceLevel(
       Class classNode, ClassRetention oldRetention) {
     if (oldRetention.index >= ClassRetention.Namespace.index) {
       return;
     }
     visitList(classNode.annotations, _visitor);
   }
 
+  /// Registers the given root as being used.
+  void _addUsedRoot(ProgramRoot root) {
+    Library rootLibrary = _findLibraryRoot(root, program);
+
+    if (root.kind == ProgramRootKind.ExternallyInstantiatedClass) {
+      Class rootClass = _findClassRoot(root, rootLibrary);
+
+      // This is a class which will be instantiated by non-Dart code (whether it
+      // has a valid generative construtor or not).
+      _addInstantiatedClass(rootClass);
+
+      // We keep all the constructors of externally instantiated classes.
+      // Sometimes the runtime might do a constructor call and sometimes it
+      // might just allocate the class without invoking the constructor.
+      // So we try to be on the safe side here!
+      for (var constructor in rootClass.constructors) {
+        _addUsedMember(rootClass, constructor);
+      }
+
+      // We keep all factory constructors as well for the same reason.
+      for (var member in rootClass.procedures) {
+        if (member.isStatic && member.kind == ProcedureKind.Factory) {
+          _addUsedMember(rootClass, member);
+        }
+      }
+    } else {
+      if (root.klass != null) {
+        // For class members we mark the Field/Procedure/Constructor as used.
+        // We also mark it as instantiated if it's a constructor.
+        Class rootClass = _findClassRoot(root, rootLibrary);
+        Member rootMember = _findMemberRoot(root, rootClass.members);
+        _addUsedMember(rootClass, rootMember);
+        if (rootMember is Constructor) {
+          _addInstantiatedClass(rootClass);
+        }
+      } else {
+        // For library members we mark the Field/Procedure as used.
+        Member rootMember = _findMemberRoot(root, rootLibrary.members);
+        _addUsedMember(null, rootMember);
+      }
+    }
+  }
+
   /// Registers the given class as being used in a type annotation.
   void _addClassUsedInType(Class classNode) {
     int index = hierarchy.getClassIndex(classNode);
     ClassRetention retention = _classRetention[index];
     if (retention.index < ClassRetention.Hierarchy.index) {
       _classRetention[index] = ClassRetention.Hierarchy;
       _propagateClassHierarchyLevel(classNode, retention);
     }
   }
 
@@ skipping 10 matching lines @@
     }
   }
 
   /// Registers the given member as being used, in the following sense:
   /// - Fields are used if they can be read or written or their initializer is
   ///   evaluated.
   /// - Constructors are used if they can be invoked, either directly or through
   ///   the initializer list of another constructor.
   /// - Procedures are used if they can be invoked or torn off.
   void _addUsedMember(Class host, Member member) {
-    if (member.enclosingLibrary == _mirrorsLibrary) {
+    if (!forceShaking && member.enclosingLibrary == _mirrorsLibrary) {
       throw new _UsingMirrorsException();
     }
     if (host != null) {
       // Check if the member has been seen with this host before.
       int index = hierarchy.getClassIndex(host);
       Set<Member> members = _usedMembersWithHost[index] ??= new Set<Member>();
       if (!members.add(member)) return;
       _usedMembers.putIfAbsent(member, _makeIncompleteSummary);
     } else {
       // Check if the member has been seen before.
@@ skipping 387 matching lines @@
   final TreeShaker shaker;
 
   _TreeShakingTransformer(this.shaker);
 
   Member _translateInterfaceTarget(Member target) {
     return target != null && shaker.isMemberUsed(target) ? target : null;
   }
 
   void transform(Program program) {
     for (var library in program.libraries) {
-      if (library.importUri.scheme == 'dart') {
+      if (!shaker.forceShaking && library.importUri.scheme == 'dart') {
         // The backend expects certain things to be present in the core
         // libraries, so we currently don't shake off anything there.
         continue;
       }
       library.transformChildren(this);
       // Note: we can't shake off empty libraries yet since we don't check if
       // there are private names that use the library.
     }
     for (Expression node in shaker._typedCalls) {
       // We should not leave dangling references, so if the target of a typed
@@ skipping 150 matching lines @@
         classNode == coreTypes.futureClass ||
         classNode == coreTypes.streamClass ||
         classNode == coreTypes.listClass ||
         classNode == coreTypes.mapClass;
   }
 }
 
 /// Exception that is thrown to stop the tree shaking analysis when a use
 /// of `dart:mirrors` is found.
 class _UsingMirrorsException {}
+
+Library _findLibraryRoot(ProgramRoot root, Program program) {
+  for (var library in program.libraries) {
+    if (library.importUri.toString() == root.library) {
+      return library;
+    }
+  }
+
+  throw "$root not found!";
+}
+
+Class _findClassRoot(ProgramRoot root, Library rootLibrary) {
+  for (var klass in rootLibrary.classes) {
+    if (klass.name == root.klass) {
+      return klass;
+    }
+  }
+  throw "$root not found!";
+}
+
+Member _findMemberRoot(ProgramRoot root, Iterable<Member> membersToSearch) {
+  for (var member in membersToSearch) {
+    if (member.name.name == root.member) {
+      switch (root.kind) {
+        case ProgramRootKind.Constructor:
+          if (member is Procedure && member.kind == ProcedureKind.Factory ||
+              member is Constructor) {
+            return member;
+          }
+          break;
+        case ProgramRootKind.Setter:
+          if (member is Procedure && member.kind == ProcedureKind.Setter ||
+              member is Field) {
+            return member;
+          }
+          break;
+        case ProgramRootKind.Getter:
+          if (member is Procedure && member.kind == ProcedureKind.Getter ||
+              member is Field) {
+            return member;
+          }
+          break;
+        case ProgramRootKind.Other:
+          return member;
+        default:
+      }
+    }
+  }
+  throw "$root not found!";
+}