Separate the summarization action from TreeShaker.

PiperOrigin-RevId: 553916303

tree_shaker/src/main/java/com/google/devtools/treeshaker/Options.java

@@ -22,6 +22,7 @@
 import com.google.common.io.Resources;
 import com.google.devtools.j2objc.util.SourceVersion;
 import com.google.devtools.j2objc.util.Version;
+import com.google.protobuf.ExtensionRegistry;
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
@@ -64,6 +65,8 @@ class Options {
  private boolean stripReflection = false;
  private File treeShakerRoots;
  private File outputFile = new File("tree-shaker-report.txt");
+ private LibraryInfo summary;
+ private String summaryOutputFile;
 
  // The default source version number if not passed with -source is determined from the system
  // properties of the running java version after parsing the argument list.
@@ -125,6 +128,18 @@ public File getOutputFile() {
  return outputFile;
  }
 
+ public LibraryInfo getSummary() {
+ return summary;
+ }
+
+ public void setSummary(LibraryInfo summary) {
+ this.summary = summary;
+ }
+
+ public String getSummaryOutputFile() {
+ return summaryOutputFile;
+ }
+
  private void addManifest(String manifestFile) throws IOException {
  BufferedReader in = new BufferedReader(new FileReader(new File(manifestFile)));
  try {
@@ -174,14 +189,6 @@ public static void version() {
  public static Options parse(String[] args) throws IOException {
  Options options = new Options();
  processArgs(args, options);
-
- if (options.treeShakerRoots == null) {
- usage("--tree_shaker_roots not set");
- }
- if (options.sourceFiles.isEmpty()) {
- usage("no source files");
- }
-
  return options;
  }
 
@@ -213,6 +220,13 @@ private static void processArgs(String[] args, Options options) throws IOExcepti
  usage("-classpath requires an argument");
  }
  options.classpath = args[nArg];
+ } else if (arg.equals("-summary")) {
+ if (++nArg == args.length) {
+ usage("-summary requires an argument");
+ }
+ options.setSummary(
+ LibraryInfo.parseFrom(
+ Files.toByteArray(new File(args[nArg])), ExtensionRegistry.getGeneratedRegistry()));
  } else if (arg.equals("--sourcefilelist") || arg.equals("-s")) {
  if (++nArg == args.length) {
  usage("--sourcefilelist requires an argument");
@@ -228,6 +242,11 @@ private static void processArgs(String[] args, Options options) throws IOExcepti
  usage("--output-file");
  }
  options.outputFile = new File(args[nArg]);
+ } else if (arg.equals("--output-summary")) {
+ if (++nArg == args.length) {
+ usage("--output-summary");
+ }
+ options.summaryOutputFile = args[nArg];
  } else if (arg.startsWith(XBOOTCLASSPATH)) {
  // TODO(malvania): Enable the bootclasspath option when we have a class file AST
  // parser that can use class jars.

tree_shaker/src/main/java/com/google/devtools/treeshaker/Summarizer.java

@@ -0,0 +1,39 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.devtools.treeshaker;
+
+import com.google.common.io.Files;
+import com.google.devtools.j2objc.util.ErrorUtil;
+import java.io.File;
+import java.io.IOException;
+
+/** A tool for creating type information summaries of a Java program. */
+public class Summarizer {
+
+ private Summarizer() {}
+
+ public static void main(String[] args) {
+ try {
+ Options options = Options.parse(args);
+ TreeShaker treeShaker = new TreeShaker(options);
+ LibraryInfo summary = treeShaker.createLibraryInfo();
+ File summaryFile = new File(options.getSummaryOutputFile());
+ summaryFile.createNewFile();
+ Files.write(summary.toByteArray(), summaryFile);
+ } catch (IOException e) {
+ ErrorUtil.error(e.getMessage());
+ }
+ }
+
+}

tree_shaker/src/main/java/com/google/devtools/treeshaker/TreeShaker.java

@@ -37,6 +37,7 @@
 import org.jspecify.nullness.Nullable;
 
 /** A tool for finding unused code in a Java program. */
+@SuppressWarnings("FloggerRedundantIsEnabled")
 public class TreeShaker {
  private static final GoogleLogger logger = GoogleLogger.forEnclosingClass();
  private final Options options;
@@ -144,9 +145,8 @@ private File stripIncompatible(List<String> sourceFileNames, Parser parser) thro
  return strippedDir;
  }
 
- @Nullable
  @VisibleForTesting
- CodeReferenceMap findUnusedCode() throws IOException {
+ @Nullable CodeReferenceMap findUnusedCode() throws IOException {
  TypeGraphBuilder tgb = createTypeGraphBuilder();
  if (tgb == null) {
  return null;
@@ -155,7 +155,7 @@ CodeReferenceMap findUnusedCode() throws IOException {
  logger.atFine().log("External Types: %s", String.join(", ", tgb.getExternalTypeReferences()));
  }
  Collection<String> unknownMethodReferences = tgb.getUnknownMethodReferences();
- if (!unknownMethodReferences.isEmpty() && logger.atWarning().isEnabled()) {
+ if (!unknownMethodReferences.isEmpty()) {
  logger.atWarning().log("Unknown Methods: %s", String.join(", ", unknownMethodReferences));
  }
  if (options.useClassHierarchyAnalyzer()) {
@@ -166,9 +166,21 @@ CodeReferenceMap findUnusedCode() throws IOException {
  }
 
  private TypeGraphBuilder createTypeGraphBuilder() throws IOException {
- UsedCodeMarker.Context context =
- new UsedCodeMarker.Context(
- ProGuardUsageParser.parseDeadCodeFile(options.getTreeShakerRoots()));
+ if (options.getSummary() != null) {
+ LibraryInfo info = options.getSummary();
+ LibraryInfo markedInfo = UsedCodeMarker.mark(info, options.getTreeShakerRoots());
+ return new TypeGraphBuilder(markedInfo);
+ }
+ return new TypeGraphBuilder(createLibraryInfo());
+ }
+
+ @Nullable LibraryInfo createLibraryInfo() throws IOException {
+ UsedCodeMarker.Context context;
+ if (options.getTreeShakerRoots() == null) {
+ context = new UsedCodeMarker.Context();
+ } else {
+ context = new UsedCodeMarker.Context(ProGuardUsageParser.parseDeadCodeFile(options.getTreeShakerRoots()));
+ }
  Parser parser = createParser(options);
  List<String> sourceFiles = getSourceFiles();
  if (ErrorUtil.errorCount() > 0) {
@@ -189,7 +201,7 @@ public void handleParsedUnit(String path, CompilationUnit unit) {
  if (ErrorUtil.errorCount() > 0) {
  return null;
  }
- return new TypeGraphBuilder(context.getLibraryInfo());
+ return context.getLibraryInfo();
  }
 
  private List<String> getSourceFiles() {

tree_shaker/src/main/java/com/google/devtools/treeshaker/UsedCodeMarker.java

@@ -58,9 +58,12 @@
 import com.google.devtools.j2objc.ast.VariableDeclarationFragment;
 import com.google.devtools.j2objc.util.CodeReferenceMap;
 import com.google.devtools.j2objc.util.ElementUtil;
+import com.google.devtools.j2objc.util.ProGuardUsageParser;
 import com.google.devtools.j2objc.util.TypeUtil;
+import java.io.File;
 import java.lang.reflect.Modifier;
 import java.util.ArrayDeque;
+import java.util.ArrayList;
 import java.util.Deque;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -494,6 +497,9 @@ private static Annotations getAnnotations(AnnotatedConstruct annotatedConstruct)
  private void startTypeScope(
  String typeName, String superName, List<String> interfaces, boolean isExported) {
  Integer id = getTypeId(typeName);
+ if (!context.currentTypeInfoScope.isEmpty()) {
+ context.currentTypeInfoScope.peek().addInnerTypes(id);
+ }
  Integer eid = getTypeId(superName);
  ImmutableList<Integer> iids =
  interfaces.stream().map(this::getTypeId).collect(toImmutableList());
@@ -626,6 +632,104 @@ private void popClinit() {
  context.referencedTypesScope.pop();
  }
 
+ private static ImmutableSet<String> getExportedClasses(CodeReferenceMap rootSet) {
+ return rootSet == null ? ImmutableSet.of() : rootSet.getReferencedClasses();
+ }
+
+ private static ImmutableSet<String> getExportedMethods(CodeReferenceMap rootSet) {
+ Set<String> exportedMethods = new HashSet<>();
+ if (rootSet != null) {
+ rootSet
+ .getReferencedMethods()
+ .cellSet()
+ .forEach(
+ cell ->
+ cell.getValue()
+ .forEach(
+ signature ->
+ exportedMethods.add(
+ getQualifiedMethodName(
+ cell.getRowKey(), cell.getColumnKey(), signature))));
+ }
+ return ImmutableSet.copyOf(exportedMethods);
+ }
+
+ private static List<TypeInfo> markClasses(
+ List<TypeInfo> types, List<String> typeMap, Set<String> markedClasses) {
+ if (markedClasses.isEmpty()) {
+ return types;
+ }
+ List<TypeInfo> markedTypes = new ArrayList<>();
+ Set<String> nextMarkedClasses = new HashSet<>();
+ for (TypeInfo type : types) {
+ TypeInfo.Builder typeBuilder = type.toBuilder();
+ if (markedClasses.contains(typeMap.get(type.getTypeId()))) {
+ // Set type as exported.
+ typeBuilder.setExported(true).clearMember();
+ for (MemberInfo member : type.getMemberList()) {
+ // Set each method of the type as exported.
+ typeBuilder.addMember(member.toBuilder().setExported(true).build());
+ }
+ // Add inner types that need to be exported to a list.
+ nextMarkedClasses.addAll(
+ type.getInnerTypesList().stream().map(typeMap::get).collect(toImmutableList()));
+ }
+ // Add type to list of marked types
+ markedTypes.add(typeBuilder.build());
+ }
+ // Recursively call with the list of exported classes as the inner classes that need to be
+ // exported.
+ // This is because we do not know if the inner class has inner classes (alternative, while
+ // loop).
+ return markClasses(markedTypes, typeMap, nextMarkedClasses);
+ }
+
+ private static TypeInfo markMethodsOfType(
+ TypeInfo type, List<String> typeMap, Set<String> markedMethods) {
+ TypeInfo.Builder typeBuilder = type.toBuilder().clearMember();
+ for (MemberInfo member : type.getMemberList()) {
+ MemberInfo.Builder memberBuilder = member.toBuilder();
+ if (markedMethods.contains(
+ getQualifiedMethodName(typeMap.get(type.getTypeId()), member.getName()))) {
+ memberBuilder.setExported(true);
+ }
+ typeBuilder.addMember(memberBuilder.build());
+ }
+ return typeBuilder.build();
+ }
+
+ private static ImmutableList<TypeInfo> markMethods(
+ List<TypeInfo> types, List<String> typeMap, Set<String> markedMethods) {
+ List<TypeInfo> typesWithMarkedMembers = new ArrayList<>();
+ for (TypeInfo type : types) {
+ typesWithMarkedMembers.add(markMethodsOfType(type, typeMap, markedMethods));
+ }
+ return ImmutableList.copyOf(typesWithMarkedMembers);
+ }
+
+ /*
+ * Uses exported classes given to 'mark' summary information as 'live' for TypeGraphAnalyzer.
+ */
+ private static LibraryInfo markEntryClasses(
+ LibraryInfo summary,
+ ImmutableSet<String> exportedClasses,
+ ImmutableSet<String> exportedMethods) {
+ return summary.toBuilder()
+ .clearType()
+ .addAllType(
+ markClasses(
+ markMethods(summary.getTypeList(), summary.getTypeMapList(), exportedMethods),
+ summary.getTypeMapList(),
+ exportedClasses))
+ .build();
+ }
+
+ static LibraryInfo mark(LibraryInfo summary, File roots) {
+ CodeReferenceMap rootSet = ProGuardUsageParser.parseDeadCodeFile(roots);
+ return markEntryClasses(
+ summary, getExportedClasses(rootSet), UsedCodeMarker.getExportedMethods(rootSet));
+ }
+
  static final class Context {
  // Map of type names to unique integer.
  private int typeCount;
@@ -653,20 +757,13 @@ static final class Context {
  private final Deque<Set<Integer>> clinitReferencedTypesScope = new ArrayDeque<>();
 
  Context(CodeReferenceMap rootSet) {
+ exportedMethods = getExportedMethods(rootSet);
+ exportedClasses = getExportedClasses(rootSet);
+ }
+
+ Context() {
  exportedMethods = new HashSet<>();
- rootSet
- .getReferencedMethods()
- .cellSet()
- .forEach(
- cell -> {
- String type = cell.getRowKey();
- String name = cell.getColumnKey();
- cell.getValue()
- .forEach(
- signature ->
- exportedMethods.add(getQualifiedMethodName(type, name, signature)));
- });
- exportedClasses = rootSet.getReferencedClasses();
+ exportedClasses = ImmutableSet.copyOf(new HashSet<>());
  }
 
  LibraryInfo getLibraryInfo() {

tree_shaker/src/main/java/com/google/devtools/treeshaker/library_info.proto

@@ -16,6 +16,7 @@ message TypeInfo {
  repeated int32 implements_type = 3;
  repeated MemberInfo member = 4;
  bool exported = 5;
+ repeated int32 inner_types = 6;
 }
 
 message MemberInfo {