Mark types of Constructor parameters and preserve referenced typedefs.

pkg/front_end/lib/src/fasta/kernel/kernel_outline_shaker.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.
 
 /// A transformation to create a self-contained modular kernel without
 /// unnecessary references to other libraries.
 library fasta.kernel.kernel_outline_shaker;
 
 import 'package:kernel/ast.dart';
 import 'package:kernel/core_types.dart';
@@ skipping 24 matching lines @@
 /// the [KernelOutlineShaker] when tree-shaking.
 abstract class RetainedData {
   /// Whether a library should be preserved and mark as external.
   bool isLibraryUsed(Library library);
 
   /// Whether a class should be preserved. If a class is preserved, its
   /// supertypes will be preserved too, but some of it members may not be
   /// included.
   bool isClassUsed(Class cls);
 
+  /// Whether a typedef should be preserved. If a typedef is preserved, its
+  /// return type and types of parameters will be preserved too.
+  bool isTypedefUsed(Typedef node);
+
   /// Whether a member should be preserved. If so, its enclosing class/library
   /// will be preserved too.
   bool isMemberUsed(Member member);
 }
 
 /// A builder of [RetainedData] that recursively marks transitive dependencies.
 ///
 /// This builder contains APIs to mark the roots that are needed (e.g.
 /// [markClass] and [markMember]). Note this builder does not determine what
 /// roots to keep, that is done either directly by fasta while it is parsing, or
 /// by using a visitor like the [RootsMarker] below.
 class RetainedDataBuilder extends RetainedData {
   /// Libraries that contained code that is transitively reachable from the
   /// included libraries.
   final Set<Library> libraries = new Set<Library>();
 
   /// Classes that are transitively reachable from the included libraries.
   final Set<Class> classes = new Set<Class>();
 
+  /// Typedefs that are transitively reachable from the included libraries.
+  final Set<Typedef> typedefs = new Set<Typedef>();
+
   /// Members that are transitively reachable from the included libraries.
   final Set<Member> members = new Set<Member>();
 
   TypeMarker typeMarker;
 
   @override
   bool isLibraryUsed(Library library) => libraries.contains(library);
 
   @override
   bool isClassUsed(Class cls) => classes.contains(cls);
 
   @override
+  bool isTypedefUsed(Typedef node) => typedefs.contains(node);
+
+  @override
   bool isMemberUsed(Member m) => members.contains(m);
 
   RetainedDataBuilder() {
     typeMarker = new TypeMarker(this);
   }
 
   /// Mark a library as used.
   void markLibrary(Library lib) {
     libraries.add(lib);
   }
 
   /// Mark a class and it's supertypes as used.
   void markClass(Class cls) {
     if (cls == null || !classes.add(cls)) return;
     markLibrary(cls.parent);
     // TODO(sigmund): retain annotations?
     // visitList(cls.annotations, this);
     markSupertype(cls.supertype);
     markSupertype(cls.mixedInType);
     cls.implementedTypes.forEach(markSupertype);
     cls.typeParameters.forEach((t) => t.bound.accept(typeMarker));
   }
 
+  /// Mark the typedef.
+  void markTypedef(Typedef node) {
+    if (node == null || !typedefs.add(node)) return;
+    markLibrary(node.parent);
+  }
+
   /// Mark the class and type arguments of [node].
   void markSupertype(Supertype node) {
     if (node == null) return;
     markClass(node.classNode);
     node.typeArguments.forEach((t) => t.accept(typeMarker));
   }
 
   /// Mark a member and types mentioned on its interface.
   void markMember(Member m) {
     if (m == null || !members.add(m)) return;
     markMemberInterface(m);
     var parent = m.parent;
     if (parent is Library) {
       markLibrary(parent);
     } else if (parent is Class) {
       markClass(parent);
     }
   }
 
   void markMemberInterface(Member node) {
     if (node is Field) {
       node.type.accept(typeMarker);
+    } else if (node is Constructor) {
+      var function = node.function;
+      function.positionalParameters.forEach((p) => p.type.accept(typeMarker));
+      function.namedParameters.forEach((p) => p.type.accept(typeMarker));
     } else if (node is Procedure) {
       var function = node.function;
       function.typeParameters.forEach((p) => p.bound.accept(typeMarker));
       function.positionalParameters.forEach((p) => p.type.accept(typeMarker));
       function.namedParameters.forEach((p) => p.type.accept(typeMarker));
       function.returnType.accept(typeMarker);
     }
   }
 }
 
 /// A helper visitor used to mark transitive types by the [RetainedDataBuilder].
 class TypeMarker extends DartTypeVisitor {
   RetainedDataBuilder data;
 
   TypeMarker(this.data);
 
   visitInterfaceType(InterfaceType node) {
     data.markClass(node.classNode);
     node.typeArguments.forEach((t) => t.accept(this));
   }
 
   visitFunctionType(FunctionType node) {
     node.typeParameters.forEach((t) => t.bound.accept(this));
     node.positionalParameters.forEach((t) => t.accept(this));
     node.namedParameters.forEach((t) => t.type.accept(this));
     node.returnType.accept(this);
+    data.markTypedef(node.typedefReference?.asTypedef);
   }
 
   visitTypeParameterType(TypeParameterType node) {
     // Note: node.parameter is marked by marking the enclosing element.
   }
 
   visitTypedefType(TypedefType node) {
     node.typeArguments.forEach((t) => t.accept(this));
   }
 }
@@ skipping 65 matching lines @@
     data.markMember(coreTypes.awaitHelperProcedure);
 
     // These are needed by the mixin transformer
     data.markMember(coreTypes.invocationMirrorDefaultConstructor);
     data.markMember(coreTypes.listFromConstructor);
   }
 
   visitConstructor(Constructor node) {
     if (!node.initializers.any((i) => i is SuperInitializer)) {
       // super() is currently implicit.
-      for (var ctor in node.enclosingClass.supertype.classNode.constructors) {
-        if (ctor.name.name == '') data.markMember(ctor);
+      var supertype = node.enclosingClass.supertype;
+      if (supertype != null) {
+        for (var constructor in supertype.classNode.constructors) {
+          if (constructor.name.name == '') data.markMember(constructor);
+        }
       }
     }
     node.visitChildren(this);
   }
 
   @override
   visitSuperInitializer(SuperInitializer node) {
     data.markMember(node.target);
     node.visitChildren(this);
   }
@@ skipping 73 matching lines @@
     node.visitChildren(this);
   }
 
   @override
   visitPropertySet(PropertySet node) {
     data.markMember(node.interfaceTarget);
     node.visitChildren(this);
   }
 
   @override
+  visitFunctionType(FunctionType node) {
+    data.markTypedef(node.typedefReference?.asTypedef);
+    super.visitFunctionType(node);
+  }
+
+  @override
   visitInterfaceType(InterfaceType node) {
     data.markClass(node.classNode);
     node.visitChildren(this);
   }
 
   @override
   visitSupertype(Supertype node) {
     data.markClass(node.classNode);
     node.visitChildren(this);
   }
@@ skipping 40 matching lines @@
   }
 
   Member defaultMember(Member node) {
     if (!data.isMemberUsed(node)) {
       node.canonicalName?.unbind();
       return null;
     } else {
       if (node is Procedure) {
         node.function.body = null;
       } else if (node is Field) {
+        if (node.name.name == '_exports#') return null;
         node.initializer = null;
       } else if (node is Constructor) {
         node.initializers.clear();
         node.function.body = null;
       }
       return node;
     }
   }
 
-  /// Types appear to be encoded directly, so we have no need to preserve
-  /// typedefs.
-  // TODO(sigmund): revisit if this is not the case, the `inputError` in
-  // [RootsMarker] is meant to detect this.
-  Typedef visitTypedef(Typedef node) => null;
+  Typedef visitTypedef(Typedef node) {
+    if (!data.isTypedefUsed(node)) {
+      node.canonicalName?.unbind();
+      return null; // Remove the typedef.
+    } else {
+      node.transformChildren(this);
+      return node;
+    }
+  }
 
   TreeNode defaultTreeNode(TreeNode node) => node;
 }
 
 typedef bool Filter(Uri uri);