Implement new startup API

Change-Id: I32b5999179c4e5cbb8e95dd91659b25e07eaef4d

src/main/java/com/android/tools/r8/D8Command.java

diff --git a/src/main/java/com/android/tools/r8/D8Command.java b/src/main/java/com/android/tools/r8/D8Command.java
index 172bfa2..24df37d 100644
--- a/src/main/java/com/android/tools/r8/D8Command.java
+++ b/src/main/java/com/android/tools/r8/D8Command.java
@@ -690,10 +690,7 @@
 
     internal.configureAndroidPlatformBuild(getAndroidPlatformBuild());
 
-    // TODO(b/238173796): Change StartupOptions to store a Collection<StartupProfileProvider>.
-    if (getStartupProfileProviders().size() == 1) {
-      internal.getStartupOptions().setStartupProfileProvider(getStartupProfileProviders().get(0));
-    }
+    internal.getStartupOptions().setStartupProfileProviders(getStartupProfileProviders());
 
     internal.setDumpInputFlags(getDumpInputFlags());
     internal.dumpOptions = dumpOptions();

src/main/java/com/android/tools/r8/R8Command.java

diff --git a/src/main/java/com/android/tools/r8/R8Command.java b/src/main/java/com/android/tools/r8/R8Command.java
index 6adecce..c9fd4f2 100644
--- a/src/main/java/com/android/tools/r8/R8Command.java
+++ b/src/main/java/com/android/tools/r8/R8Command.java
@@ -1067,10 +1067,7 @@
 
     internal.configureAndroidPlatformBuild(getAndroidPlatformBuild());
 
-    // TODO(b/238173796): Change StartupOptions to store a Collection<StartupProfileProvider>.
-    if (getStartupProfileProviders().size() == 1) {
-      internal.getStartupOptions().setStartupProfileProvider(getStartupProfileProviders().get(0));
-    }
+    internal.getStartupOptions().setStartupProfileProviders(getStartupProfileProviders());
 
     if (!DETERMINISTIC_DEBUGGING) {
       assert internal.threadCount == ThreadUtils.NOT_SPECIFIED;

src/main/java/com/android/tools/r8/StringResource.java

diff --git a/src/main/java/com/android/tools/r8/StringResource.java b/src/main/java/com/android/tools/r8/StringResource.java
index 515f2ab..4d097e0 100644
--- a/src/main/java/com/android/tools/r8/StringResource.java
+++ b/src/main/java/com/android/tools/r8/StringResource.java
@@ -105,13 +105,5 @@
         throw new ResourceException(origin, e);
       }
     }
-
-    public String getStringWithRuntimeException() {
-      try {
-        return getString();
-      } catch (ResourceException e) {
-        throw new RuntimeException(e);
-      }
-    }
   }
 }

src/main/java/com/android/tools/r8/dex/StartupMixedSectionLayoutStrategy.java

diff --git a/src/main/java/com/android/tools/r8/dex/StartupMixedSectionLayoutStrategy.java b/src/main/java/com/android/tools/r8/dex/StartupMixedSectionLayoutStrategy.java
index 4d9a8ca..0833358 100644
--- a/src/main/java/com/android/tools/r8/dex/StartupMixedSectionLayoutStrategy.java
+++ b/src/main/java/com/android/tools/r8/dex/StartupMixedSectionLayoutStrategy.java
@@ -82,21 +82,23 @@
             virtualFile.classes().size());
     LensCodeRewriterUtils rewriter = new LensCodeRewriterUtils(appView, true);
     StartupIndexedItemCollection indexedItemCollection = new StartupIndexedItemCollection();
-    for (StartupItem<DexType, DexMethod, ?> startupItem : startupOrderForWriting.getItems()) {
-      // All synthetic startup items should be removed after calling
-      // StartupOrder#toStartupOrderForWriting.
-      assert !startupItem.isSynthetic();
+    for (StartupItem startupItem : startupOrderForWriting.getItems()) {
       startupItem.accept(
           startupClass ->
               collectStartupItems(startupClass, indexedItemCollection, virtualFileDefinitions),
           startupMethod ->
               collectStartupItems(
-                  startupMethod, indexedItemCollection, virtualFileDefinitions, rewriter));
+                  startupMethod, indexedItemCollection, virtualFileDefinitions, rewriter),
+          syntheticStartupMethod -> {
+            // All synthetic startup items should be removed after calling
+            // StartupOrder#toStartupOrderForWriting.
+            assert false;
+          });
     }
   }
 
   private void collectStartupItems(
-      StartupClass<DexType, DexMethod> startupClass,
+      StartupClass startupClass,
       StartupIndexedItemCollection indexedItemCollection,
       Map<DexType, DexProgramClass> virtualFileDefinitions) {
     DexProgramClass definition = virtualFileDefinitions.get(startupClass.getReference());
@@ -119,7 +121,7 @@
   }
 
   private void collectStartupItems(
-      StartupMethod<DexType, DexMethod> startupMethod,
+      StartupMethod startupMethod,
       StartupIndexedItemCollection indexedItemCollection,
       Map<DexType, DexProgramClass> virtualFileDefinitions,
       LensCodeRewriterUtils rewriter) {

src/main/java/com/android/tools/r8/dex/VirtualFile.java

diff --git a/src/main/java/com/android/tools/r8/dex/VirtualFile.java b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
index fafe700..f6b057a 100644
--- a/src/main/java/com/android/tools/r8/dex/VirtualFile.java
+++ b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
@@ -1396,7 +1396,7 @@
         return;
       }
 
-      assert options.getStartupOptions().hasStartupProfileProvider();
+      assert options.getStartupOptions().hasStartupProfileProviders();
 
       // In practice, all startup classes should fit in a single dex file, so optimistically try to
       // commit the startup classes using a single transaction.

src/main/java/com/android/tools/r8/experimental/startup/EmptyStartupOrder.java

diff --git a/src/main/java/com/android/tools/r8/experimental/startup/EmptyStartupOrder.java b/src/main/java/com/android/tools/r8/experimental/startup/EmptyStartupOrder.java
index 8913368..fb1fc24 100644
--- a/src/main/java/com/android/tools/r8/experimental/startup/EmptyStartupOrder.java
+++ b/src/main/java/com/android/tools/r8/experimental/startup/EmptyStartupOrder.java
@@ -6,7 +6,6 @@
 
 import com.android.tools.r8.experimental.startup.profile.StartupItem;
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.GraphLens;
 import com.android.tools.r8.graph.PrunedItems;
@@ -24,7 +23,7 @@
   }
 
   @Override
-  public Collection<StartupItem<DexType, DexMethod, ?>> getItems() {
+  public Collection<StartupItem> getItems() {
     return Collections.emptyList();
   }
 

src/main/java/com/android/tools/r8/experimental/startup/NonEmptyStartupOrder.java

diff --git a/src/main/java/com/android/tools/r8/experimental/startup/NonEmptyStartupOrder.java b/src/main/java/com/android/tools/r8/experimental/startup/NonEmptyStartupOrder.java
index 164475b..76020fc 100644
--- a/src/main/java/com/android/tools/r8/experimental/startup/NonEmptyStartupOrder.java
+++ b/src/main/java/com/android/tools/r8/experimental/startup/NonEmptyStartupOrder.java
@@ -7,11 +7,10 @@
 import com.android.tools.r8.experimental.startup.profile.StartupClass;
 import com.android.tools.r8.experimental.startup.profile.StartupItem;
 import com.android.tools.r8.experimental.startup.profile.StartupMethod;
+import com.android.tools.r8.experimental.startup.profile.SyntheticStartupMethod;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexApplication;
-import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexReference;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.GraphLens;
 import com.android.tools.r8.graph.PrunedItems;
@@ -28,24 +27,22 @@
 
 public class NonEmptyStartupOrder extends StartupOrder {
 
-  private final LinkedHashSet<StartupItem<DexType, DexMethod, ?>> startupItems;
+  private final LinkedHashSet<StartupItem> startupItems;
 
   // Sets to allow efficient querying without boxing.
   private final Set<DexType> nonSyntheticStartupClasses = Sets.newIdentityHashSet();
   private final Set<DexType> syntheticStartupClasses = Sets.newIdentityHashSet();
 
-  NonEmptyStartupOrder(LinkedHashSet<StartupItem<DexType, DexMethod, ?>> startupItems) {
+  NonEmptyStartupOrder(LinkedHashSet<StartupItem> startupItems) {
     assert !startupItems.isEmpty();
     this.startupItems = startupItems;
-    for (StartupItem<DexType, DexMethod, ?> startupItem : startupItems) {
-      if (startupItem.isSynthetic()) {
-        assert startupItem.isStartupClass();
-        syntheticStartupClasses.add(startupItem.asStartupClass().getReference());
-      } else {
-        DexReference reference =
-            startupItem.apply(StartupClass::getReference, StartupMethod::getReference);
-        nonSyntheticStartupClasses.add(reference.getContextType());
-      }
+    for (StartupItem startupItem : startupItems) {
+      startupItem.apply(
+          startupClass -> nonSyntheticStartupClasses.add(startupClass.getReference()),
+          startupMethod ->
+              nonSyntheticStartupClasses.add(startupMethod.getReference().getHolderType()),
+          syntheticStartupMethod ->
+              syntheticStartupClasses.add(syntheticStartupMethod.getSyntheticContextType()));
     }
   }
 
@@ -72,7 +69,7 @@
   }
 
   @Override
-  public Collection<StartupItem<DexType, DexMethod, ?>> getItems() {
+  public Collection<StartupItem> getItems() {
     return startupItems;
   }
 
@@ -83,27 +80,28 @@
 
   @Override
   public StartupOrder rewrittenWithLens(GraphLens graphLens) {
-    LinkedHashSet<StartupItem<DexType, DexMethod, ?>> rewrittenStartupItems =
-        new LinkedHashSet<>(startupItems.size());
-    for (StartupItem<DexType, DexMethod, ?> startupItem : startupItems) {
-      if (startupItem.isStartupClass()) {
-        StartupClass<DexType, DexMethod> startupClass = startupItem.asStartupClass();
-        rewrittenStartupItems.add(
-            StartupClass.dexBuilder()
-                .setClassReference(graphLens.lookupType(startupClass.getReference()))
-                .setSynthetic(startupItem.isSynthetic())
-                .build());
-      } else {
-        assert !startupItem.isSynthetic();
-        StartupMethod<DexType, DexMethod> startupMethod = startupItem.asStartupMethod();
-        // TODO(b/238173796): This should account for one-to-many mappings. e.g., when a bridge is
-        //  created.
-        rewrittenStartupItems.add(
-            StartupMethod.dexBuilder()
-                .setMethodReference(
-                    graphLens.getRenamedMethodSignature(startupMethod.getReference()))
-                .build());
-      }
+    LinkedHashSet<StartupItem> rewrittenStartupItems = new LinkedHashSet<>(startupItems.size());
+    for (StartupItem startupItem : startupItems) {
+      // TODO(b/238173796): This should account for one-to-many mappings. e.g., when a bridge is
+      //  created.
+      startupItem.apply(
+          startupClass ->
+              rewrittenStartupItems.add(
+                  StartupClass.builder()
+                      .setClassReference(graphLens.lookupType(startupClass.getReference()))
+                      .build()),
+          startupMethod ->
+              rewrittenStartupItems.add(
+                  StartupMethod.builder()
+                      .setMethodReference(
+                          graphLens.getRenamedMethodSignature(startupMethod.getReference()))
+                      .build()),
+          syntheticStartupMethod ->
+              rewrittenStartupItems.add(
+                  SyntheticStartupMethod.builder()
+                      .setSyntheticContextReference(
+                          graphLens.lookupType(syntheticStartupMethod.getSyntheticContextType()))
+                      .build()));
     }
     return createNonEmpty(rewrittenStartupItems);
   }
@@ -129,29 +127,27 @@
    */
   @Override
   public StartupOrder toStartupOrderForWriting(AppView<?> appView) {
-    LinkedHashSet<StartupItem<DexType, DexMethod, ?>> rewrittenStartupItems =
-        new LinkedHashSet<>(startupItems.size());
+    LinkedHashSet<StartupItem> rewrittenStartupItems = new LinkedHashSet<>(startupItems.size());
     Map<DexType, List<DexProgramClass>> syntheticContextsToSyntheticClasses =
         appView.getSyntheticItems().computeSyntheticContextsToSyntheticClasses(appView);
-    for (StartupItem<DexType, DexMethod, ?> startupItem : startupItems) {
+    for (StartupItem startupItem : startupItems) {
       addStartupItem(
           startupItem, rewrittenStartupItems, syntheticContextsToSyntheticClasses, appView);
     }
-    assert rewrittenStartupItems.stream().noneMatch(StartupItem::isSynthetic);
+    assert rewrittenStartupItems.stream().noneMatch(StartupItem::isSyntheticStartupMethod);
     return createNonEmpty(rewrittenStartupItems);
   }
 
   private static void addStartupItem(
-      StartupItem<DexType, DexMethod, ?> startupItem,
-      LinkedHashSet<StartupItem<DexType, DexMethod, ?>> rewrittenStartupItems,
+      StartupItem startupItem,
+      LinkedHashSet<StartupItem> rewrittenStartupItems,
       Map<DexType, List<DexProgramClass>> syntheticContextsToSyntheticClasses,
       AppView<?> appView) {
-    if (startupItem.isSynthetic()) {
-      assert startupItem.isStartupClass();
-      StartupClass<DexType, DexMethod> startupClass = startupItem.asStartupClass();
+    if (startupItem.isSyntheticStartupMethod()) {
+      SyntheticStartupMethod syntheticStartupMethod = startupItem.asSyntheticStartupMethod();
       List<DexProgramClass> syntheticClassesForContext =
           syntheticContextsToSyntheticClasses.getOrDefault(
-              startupClass.getReference(), Collections.emptyList());
+              syntheticStartupMethod.getSyntheticContextType(), Collections.emptyList());
       for (DexProgramClass clazz : syntheticClassesForContext) {
         addClassAndParentClasses(clazz, rewrittenStartupItems, appView);
         addAllMethods(clazz, rewrittenStartupItems);
@@ -167,16 +163,13 @@
   }
 
   private static boolean addClass(
-      DexProgramClass clazz,
-      LinkedHashSet<StartupItem<DexType, DexMethod, ?>> rewrittenStartupItems) {
+      DexProgramClass clazz, LinkedHashSet<StartupItem> rewrittenStartupItems) {
     return rewrittenStartupItems.add(
-        StartupClass.dexBuilder().setClassReference(clazz.getType()).build());
+        StartupClass.builder().setClassReference(clazz.getType()).build());
   }
 
   private static void addClassAndParentClasses(
-      DexType type,
-      LinkedHashSet<StartupItem<DexType, DexMethod, ?>> rewrittenStartupItems,
-      AppView<?> appView) {
+      DexType type, LinkedHashSet<StartupItem> rewrittenStartupItems, AppView<?> appView) {
     DexProgramClass definition = appView.app().programDefinitionFor(type);
     if (definition != null) {
       addClassAndParentClasses(definition, rewrittenStartupItems, appView);
@@ -184,54 +177,53 @@
   }
 
   private static void addClassAndParentClasses(
-      DexProgramClass clazz,
-      LinkedHashSet<StartupItem<DexType, DexMethod, ?>> rewrittenStartupItems,
-      AppView<?> appView) {
+      DexProgramClass clazz, LinkedHashSet<StartupItem> rewrittenStartupItems, AppView<?> appView) {
     if (addClass(clazz, rewrittenStartupItems)) {
       addParentClasses(clazz, rewrittenStartupItems, appView);
     }
   }
 
   private static void addParentClasses(
-      DexProgramClass clazz,
-      LinkedHashSet<StartupItem<DexType, DexMethod, ?>> rewrittenStartupItems,
-      AppView<?> appView) {
+      DexProgramClass clazz, LinkedHashSet<StartupItem> rewrittenStartupItems, AppView<?> appView) {
     clazz.forEachImmediateSupertype(
         supertype -> addClassAndParentClasses(supertype, rewrittenStartupItems, appView));
   }
 
   private static void addAllMethods(
-      DexProgramClass clazz,
-      LinkedHashSet<StartupItem<DexType, DexMethod, ?>> rewrittenStartupItems) {
+      DexProgramClass clazz, LinkedHashSet<StartupItem> rewrittenStartupItems) {
     clazz.forEachProgramMethod(
         method ->
             rewrittenStartupItems.add(
-                StartupMethod.dexBuilder().setMethodReference(method.getReference()).build()));
+                StartupMethod.builder().setMethodReference(method.getReference()).build()));
   }
 
   @Override
   public StartupOrder withoutPrunedItems(PrunedItems prunedItems, SyntheticItems syntheticItems) {
-    LinkedHashSet<StartupItem<DexType, DexMethod, ?>> rewrittenStartupItems =
-        new LinkedHashSet<>(startupItems.size());
+    LinkedHashSet<StartupItem> rewrittenStartupItems = new LinkedHashSet<>(startupItems.size());
     LazyBox<Set<DexType>> contextsOfLiveSynthetics =
         new LazyBox<>(
             () -> computeContextsOfLiveSynthetics(prunedItems.getPrunedApp(), syntheticItems));
-    for (StartupItem<DexType, DexMethod, ?> startupItem : startupItems) {
+    for (StartupItem startupItem : startupItems) {
       // Only prune non-synthetic classes, since the pruning of a class does not imply that all
       // classes synthesized from it have been pruned.
-      if (startupItem.isSynthetic()) {
-        assert startupItem.isStartupClass();
-        StartupClass<DexType, DexMethod> startupClass = startupItem.asStartupClass();
-        if (contextsOfLiveSynthetics.computeIfAbsent().contains(startupClass.getReference())) {
-          rewrittenStartupItems.add(startupClass);
-        }
-      } else {
-        DexReference reference =
-            startupItem.apply(StartupClass::getReference, StartupMethod::getReference);
-        if (!prunedItems.isRemoved(reference)) {
-          rewrittenStartupItems.add(startupItem);
-        }
-      }
+      startupItem.accept(
+          startupClass -> {
+            if (!prunedItems.isRemoved(startupClass.getReference())) {
+              rewrittenStartupItems.add(startupItem);
+            }
+          },
+          startupMethod -> {
+            if (!prunedItems.isRemoved(startupMethod.getReference())) {
+              rewrittenStartupItems.add(startupItem);
+            }
+          },
+          syntheticStartupMethod -> {
+            if (contextsOfLiveSynthetics
+                .computeIfAbsent()
+                .contains(syntheticStartupMethod.getSyntheticContextType())) {
+              rewrittenStartupItems.add(syntheticStartupMethod);
+            }
+          });
     }
     return createNonEmpty(rewrittenStartupItems);
   }
@@ -248,8 +240,7 @@
     return contextsOfLiveSynthetics;
   }
 
-  private StartupOrder createNonEmpty(
-      LinkedHashSet<StartupItem<DexType, DexMethod, ?>> startupItems) {
+  private StartupOrder createNonEmpty(LinkedHashSet<StartupItem> startupItems) {
     if (startupItems.isEmpty()) {
       assert false;
       return empty();

src/main/java/com/android/tools/r8/experimental/startup/StartupCompleteness.java

diff --git a/src/main/java/com/android/tools/r8/experimental/startup/StartupCompleteness.java b/src/main/java/com/android/tools/r8/experimental/startup/StartupCompleteness.java
index 43e306a..e6a0f85 100644
--- a/src/main/java/com/android/tools/r8/experimental/startup/StartupCompleteness.java
+++ b/src/main/java/com/android/tools/r8/experimental/startup/StartupCompleteness.java
@@ -4,12 +4,9 @@
 
 package com.android.tools.r8.experimental.startup;
 
-import com.android.tools.r8.experimental.startup.profile.StartupClass;
 import com.android.tools.r8.experimental.startup.profile.StartupItem;
-import com.android.tools.r8.experimental.startup.profile.StartupMethod;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexReference;
 import com.android.tools.r8.graph.DexType;
@@ -81,26 +78,20 @@
     Set<DexReference> startupItems = Sets.newIdentityHashSet();
     Map<DexType, List<DexProgramClass>> syntheticContextsToSyntheticClasses =
         appView.getSyntheticItems().computeSyntheticContextsToSyntheticClasses(appView);
-    for (StartupItem<DexType, DexMethod, ?> startupItem : startupOrder.getItems()) {
-      if (startupItem.isSynthetic()) {
-        assert startupItem.isStartupClass();
-        List<DexProgramClass> syntheticClasses =
-            syntheticContextsToSyntheticClasses.getOrDefault(
-                startupItem.asStartupClass().getReference(), Collections.emptyList());
-        for (DexProgramClass syntheticClass : syntheticClasses) {
-          startupItems.add(syntheticClass.getType());
-          syntheticClass.forEachProgramMethod(method -> startupItems.add(method.getReference()));
-        }
-      } else {
-        if (startupItem.isStartupClass()) {
-          StartupClass<DexType, DexMethod> startupClass = startupItem.asStartupClass();
-          startupItems.add(startupClass.getReference());
-        } else {
-          assert startupItem.isStartupMethod();
-          StartupMethod<DexType, DexMethod> startupMethod = startupItem.asStartupMethod();
-          startupItems.add(startupMethod.getReference());
-        }
-      }
+    for (StartupItem startupItem : startupOrder.getItems()) {
+      startupItem.accept(
+          startupClass -> startupItems.add(startupClass.getReference()),
+          startupMethod -> startupItems.add(startupMethod.getReference()),
+          syntheticStartupMethod -> {
+            List<DexProgramClass> syntheticClasses =
+                syntheticContextsToSyntheticClasses.getOrDefault(
+                    syntheticStartupMethod.getSyntheticContextType(), Collections.emptyList());
+            for (DexProgramClass syntheticClass : syntheticClasses) {
+              startupItems.add(syntheticClass.getType());
+              syntheticClass.forEachProgramMethod(
+                  method -> startupItems.add(method.getReference()));
+            }
+          });
     }
     return startupItems;
   }

src/main/java/com/android/tools/r8/experimental/startup/StartupOptions.java

diff --git a/src/main/java/com/android/tools/r8/experimental/startup/StartupOptions.java b/src/main/java/com/android/tools/r8/experimental/startup/StartupOptions.java
index 86df003..01bfd2b 100644
--- a/src/main/java/com/android/tools/r8/experimental/startup/StartupOptions.java
+++ b/src/main/java/com/android/tools/r8/experimental/startup/StartupOptions.java
@@ -6,13 +6,13 @@
 
 import static com.android.tools.r8.utils.SystemPropertyUtils.parseSystemPropertyForDevelopmentOrDefault;
 
-import com.android.tools.r8.StringResource;
-import com.android.tools.r8.errors.Unimplemented;
-import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.startup.StartupProfileBuilder;
 import com.android.tools.r8.startup.StartupProfileProvider;
+import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.SystemPropertyUtils;
+import com.google.common.collect.ImmutableList;
 import java.nio.file.Paths;
+import java.util.Collection;
+import java.util.Collections;
 
 public class StartupOptions {
 
@@ -52,28 +52,18 @@
   private boolean enableStartupLayoutOptimizations =
       parseSystemPropertyForDevelopmentOrDefault("com.android.tools.r8.startup.layout", true);
 
-  private StartupProfileProvider startupProfileProvider =
-      SystemPropertyUtils.applySystemProperty(
-          "com.android.tools.r8.startup.profile",
-          propertyValue ->
-              new StartupProfileProvider() {
-                @Override
-                public String get() {
-                  return StringResource.fromFile(Paths.get(propertyValue))
-                      .getStringWithRuntimeException();
-                }
+  private Collection<StartupProfileProvider> startupProfileProviders;
 
-                @Override
-                public void getStartupProfile(StartupProfileBuilder startupProfileBuilder) {
-                  throw new Unimplemented();
-                }
-
-                @Override
-                public Origin getOrigin() {
-                  return Origin.unknown();
-                }
-              },
-          () -> null);
+  public StartupOptions(InternalOptions options) {
+    this.startupProfileProviders =
+        SystemPropertyUtils.applySystemProperty(
+            "com.android.tools.r8.startup.profile",
+            propertyValue ->
+                ImmutableList.of(
+                    StartupProfileProviderUtils.createFromFile(
+                        Paths.get(propertyValue), options.reporter)),
+            Collections::emptyList);
+  }
 
   public boolean isMinimalStartupDexEnabled() {
     return enableMinimalStartupDex;
@@ -112,16 +102,17 @@
     return this;
   }
 
-  public boolean hasStartupProfileProvider() {
-    return startupProfileProvider != null;
+  public boolean hasStartupProfileProviders() {
+    return startupProfileProviders != null && !startupProfileProviders.isEmpty();
   }
 
-  public StartupProfileProvider getStartupProfileProvider() {
-    return startupProfileProvider;
+  public Collection<StartupProfileProvider> getStartupProfileProviders() {
+    return startupProfileProviders;
   }
 
-  public StartupOptions setStartupProfileProvider(StartupProfileProvider startupProfileProvider) {
-    this.startupProfileProvider = startupProfileProvider;
+  public StartupOptions setStartupProfileProviders(
+      Collection<StartupProfileProvider> startupProfileProviders) {
+    this.startupProfileProviders = startupProfileProviders;
     return this;
   }
 }

src/main/java/com/android/tools/r8/experimental/startup/StartupOrder.java

diff --git a/src/main/java/com/android/tools/r8/experimental/startup/StartupOrder.java b/src/main/java/com/android/tools/r8/experimental/startup/StartupOrder.java
index aa3d454..78a5970 100644
--- a/src/main/java/com/android/tools/r8/experimental/startup/StartupOrder.java
+++ b/src/main/java/com/android/tools/r8/experimental/startup/StartupOrder.java
@@ -7,7 +7,6 @@
 import com.android.tools.r8.experimental.startup.profile.StartupItem;
 import com.android.tools.r8.experimental.startup.profile.StartupProfile;
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.GraphLens;
 import com.android.tools.r8.graph.PrunedItems;
@@ -34,7 +33,7 @@
 
   public abstract boolean contains(DexType type, SyntheticItems syntheticItems);
 
-  public abstract Collection<StartupItem<DexType, DexMethod, ?>> getItems();
+  public abstract Collection<StartupItem> getItems();
 
   public abstract boolean isEmpty();
 

src/main/java/com/android/tools/r8/experimental/startup/StartupProfileProviderUtils.java

diff --git a/src/main/java/com/android/tools/r8/experimental/startup/StartupProfileProviderUtils.java b/src/main/java/com/android/tools/r8/experimental/startup/StartupProfileProviderUtils.java
new file mode 100644
index 0000000..2924e48
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/experimental/startup/StartupProfileProviderUtils.java
@@ -0,0 +1,46 @@
+// Copyright (c) 2022, the R8 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.
+
+package com.android.tools.r8.experimental.startup;
+
+import com.android.tools.r8.experimental.startup.profile.StartupProfileParser;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.origin.PathOrigin;
+import com.android.tools.r8.startup.StartupProfileBuilder;
+import com.android.tools.r8.startup.StartupProfileProvider;
+import com.android.tools.r8.utils.FileUtils;
+import com.android.tools.r8.utils.Reporter;
+import com.android.tools.r8.utils.StringDiagnostic;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.Path;
+
+public class StartupProfileProviderUtils {
+
+  public static StartupProfileProvider createFromFile(Path path, Reporter reporter) {
+    return new StartupProfileProvider() {
+
+      @Override
+      public void getStartupProfile(StartupProfileBuilder startupProfileBuilder) {
+        try {
+          StartupProfileParser.create()
+              .parseLines(
+                  FileUtils.readAllLines(path).stream(),
+                  startupProfileBuilder,
+                  error ->
+                      reporter.warning(
+                          new StringDiagnostic(
+                              "Invalid descriptor for startup class or method: " + error)));
+        } catch (IOException e) {
+          throw new UncheckedIOException(e);
+        }
+      }
+
+      @Override
+      public Origin getOrigin() {
+        return new PathOrigin(path);
+      }
+    };
+  }
+}

src/main/java/com/android/tools/r8/experimental/startup/profile/StartupClass.java

diff --git a/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupClass.java b/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupClass.java
index baab7f9..dbd8ef6 100644
--- a/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupClass.java
+++ b/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupClass.java
@@ -4,79 +4,104 @@
 
 package com.android.tools.r8.experimental.startup.profile;
 
-import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.startup.StartupClassBuilder;
+import com.android.tools.r8.utils.ClassReferenceUtils;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
-// TODO(b/238173796): When updating the compiler to have support for taking a list of startup
-//  methods, this class may likely be removed along with the StartupItem class, so that only
-//  StartupMethod remains.
-public class StartupClass<C, M> extends StartupItem<C, M, C> {
+public class StartupClass extends StartupItem {
 
-  public StartupClass(int flags, C reference) {
-    super(flags, reference);
+  private final DexType type;
+
+  StartupClass(DexType type) {
+    this.type = type;
   }
 
-  public static <C, M> Builder<C, M> builder() {
-    return new Builder<>();
+  public static Builder builder() {
+    return new Builder();
   }
 
-  public static Builder<DexType, DexMethod> dexBuilder() {
-    return new Builder<>();
-  }
-
-  public static Builder<ClassReference, MethodReference> referenceBuilder() {
-    return new Builder<>();
+  public static Builder builder(DexItemFactory dexItemFactory) {
+    return new Builder(dexItemFactory);
   }
 
   @Override
   public void accept(
-      Consumer<StartupClass<C, M>> classConsumer, Consumer<StartupMethod<C, M>> methodConsumer) {
+      Consumer<StartupClass> classConsumer,
+      Consumer<StartupMethod> methodConsumer,
+      Consumer<SyntheticStartupMethod> syntheticMethodConsumer) {
     classConsumer.accept(this);
   }
 
   @Override
   public <T> T apply(
-      Function<StartupClass<C, M>, T> classFunction,
-      Function<StartupMethod<C, M>, T> methodFunction) {
+      Function<StartupClass, T> classFunction,
+      Function<StartupMethod, T> methodFunction,
+      Function<SyntheticStartupMethod, T> syntheticMethodFunction) {
     return classFunction.apply(this);
   }
 
+  public DexType getReference() {
+    return type;
+  }
+
   @Override
   public boolean isStartupClass() {
     return true;
   }
 
   @Override
-  public StartupClass<C, M> asStartupClass() {
+  public StartupClass asStartupClass() {
     return this;
   }
 
   @Override
-  public void serializeToString(
-      StringBuilder builder,
-      Function<C, String> classSerializer,
-      Function<M, String> methodSerializer) {
-    if (isSynthetic()) {
-      builder.append('S');
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
     }
-    builder.append(classSerializer.apply(getReference()));
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    StartupClass that = (StartupClass) o;
+    return type == that.type;
   }
 
-  public static class Builder<C, M> extends StartupItem.Builder<C, M, Builder<C, M>> {
+  @Override
+  public int hashCode() {
+    return type.hashCode();
+  }
 
-    @Override
-    public Builder<C, M> setMethodReference(M reference) {
-      throw new Unreachable();
+  public static class Builder implements StartupClassBuilder {
+
+    private final DexItemFactory dexItemFactory;
+
+    private DexType type;
+
+    Builder() {
+      this(null);
+    }
+
+    Builder(DexItemFactory dexItemFactory) {
+      this.dexItemFactory = dexItemFactory;
     }
 
     @Override
-    public StartupClass<C, M> build() {
-      return new StartupClass<>(flags, classReference);
+    public Builder setClassReference(ClassReference classReference) {
+      assert dexItemFactory != null;
+      return setClassReference(ClassReferenceUtils.toDexType(classReference, dexItemFactory));
+    }
+
+    public Builder setClassReference(DexType type) {
+      this.type = type;
+      return this;
+    }
+
+    public StartupClass build() {
+      return new StartupClass(type);
     }
   }
 }

src/main/java/com/android/tools/r8/experimental/startup/profile/StartupItem.java

diff --git a/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupItem.java b/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupItem.java
index 4590a3f..1854c07 100644
--- a/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupItem.java
+++ b/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupItem.java
@@ -4,35 +4,27 @@
 
 package com.android.tools.r8.experimental.startup.profile;
 
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
-public abstract class StartupItem<C, M, R> {
-
-  private static final int FLAG_SYNTHETIC = 1;
-
-  protected final int flags;
-  protected final R reference;
-
-  public StartupItem(int flags, R reference) {
-    this.flags = flags;
-    this.reference = reference;
-  }
+public abstract class StartupItem {
 
   public abstract void accept(
-      Consumer<StartupClass<C, M>> classConsumer, Consumer<StartupMethod<C, M>> methodConsumer);
+      Consumer<StartupClass> classConsumer,
+      Consumer<StartupMethod> methodConsumer,
+      Consumer<SyntheticStartupMethod> syntheticMethodConsumer);
 
   public abstract <T> T apply(
-      Function<StartupClass<C, M>, T> classFunction,
-      Function<StartupMethod<C, M>, T> methodFunction);
+      Function<StartupClass, T> classFunction,
+      Function<StartupMethod, T> methodFunction,
+      Function<SyntheticStartupMethod, T> syntheticMethodFunction);
 
   public boolean isStartupClass() {
     return false;
   }
 
-  public StartupClass<C, M> asStartupClass() {
+  public StartupClass asStartupClass() {
+    assert false;
     return null;
   }
 
@@ -40,126 +32,17 @@
     return false;
   }
 
-  public StartupMethod<C, M> asStartupMethod() {
+  public StartupMethod asStartupMethod() {
+    assert false;
     return null;
   }
 
-  public static <C, M> Builder<C, M, ?> builder() {
-    return new Builder<>();
+  public boolean isSyntheticStartupMethod() {
+    return false;
   }
 
-  public static Builder<DexType, DexMethod, ?> dexBuilder() {
-    return new Builder<>();
-  }
-
-  public int getFlags() {
-    return flags;
-  }
-
-  public R getReference() {
-    return reference;
-  }
-
-  public boolean isSynthetic() {
-    return (flags & FLAG_SYNTHETIC) != 0;
-  }
-
-  public abstract void serializeToString(
-      StringBuilder builder,
-      Function<C, String> classSerializer,
-      Function<M, String> methodSerializer);
-
-  @Override
-  public boolean equals(Object obj) {
-    if (this == obj) {
-      return true;
-    }
-    if (obj == null || getClass() != obj.getClass()) {
-      return false;
-    }
-    StartupItem<?, ?, ?> startupItem = (StartupItem<?, ?, ?>) obj;
-    return flags == startupItem.flags && reference.equals(startupItem.reference);
-  }
-
-  @Override
-  public int hashCode() {
-    return (reference.hashCode() << 1) | flags;
-  }
-
-  @Override
-  public String toString() {
-    StringBuilder builder = new StringBuilder();
-    if (isSynthetic()) {
-      builder.append('S');
-    }
-    builder.append(reference);
-    return builder.toString();
-  }
-
-  public static class Builder<C, M, B extends Builder<C, M, B>> {
-
-    protected int flags;
-    protected C classReference;
-    protected M methodReference;
-
-    public B applyIf(boolean condition, Consumer<B> thenConsumer, Consumer<B> elseConsumer) {
-      if (condition) {
-        thenConsumer.accept(self());
-      } else {
-        elseConsumer.accept(self());
-      }
-      return self();
-    }
-
-    public B setFlags(int flags) {
-      this.flags = flags;
-      return self();
-    }
-
-    public B setClassReference(C reference) {
-      this.classReference = reference;
-      return self();
-    }
-
-    public B setMethodReference(M reference) {
-      this.methodReference = reference;
-      return self();
-    }
-
-    public B setSynthetic() {
-      this.flags |= FLAG_SYNTHETIC;
-      return self();
-    }
-
-    public B setSynthetic(boolean synthetic) {
-      if (synthetic) {
-        return setSynthetic();
-      }
-      assert (flags & FLAG_SYNTHETIC) == 0;
-      return self();
-    }
-
-    public StartupItem<C, M, ?> build() {
-      if (classReference != null) {
-        return buildStartupClass();
-      } else {
-        return buildStartupMethod();
-      }
-    }
-
-    public StartupClass<C, M> buildStartupClass() {
-      assert classReference != null;
-      return new StartupClass<>(flags, classReference);
-    }
-
-    public StartupMethod<C, M> buildStartupMethod() {
-      assert methodReference != null;
-      return new StartupMethod<>(flags, methodReference);
-    }
-
-    @SuppressWarnings("unchecked")
-    public B self() {
-      return (B) this;
-    }
+  public SyntheticStartupMethod asSyntheticStartupMethod() {
+    assert false;
+    return null;
   }
 }

src/main/java/com/android/tools/r8/experimental/startup/profile/StartupMethod.java

diff --git a/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupMethod.java b/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupMethod.java
index b6eb04b..9e45798 100644
--- a/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupMethod.java
+++ b/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupMethod.java
@@ -4,66 +4,104 @@
 
 package com.android.tools.r8.experimental.startup.profile;
 
-import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.startup.StartupMethodBuilder;
+import com.android.tools.r8.utils.MethodReferenceUtils;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
-public class StartupMethod<C, M> extends StartupItem<C, M, M> {
+public class StartupMethod extends StartupItem {
 
-  public StartupMethod(int flags, M reference) {
-    super(flags, reference);
+  private final DexMethod method;
+
+  StartupMethod(DexMethod method) {
+    this.method = method;
   }
 
-  public static Builder<ClassReference, MethodReference> referenceBuilder() {
-    return new Builder<>();
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static Builder builder(DexItemFactory dexItemFactory) {
+    return new Builder(dexItemFactory);
   }
 
   @Override
   public void accept(
-      Consumer<StartupClass<C, M>> classConsumer, Consumer<StartupMethod<C, M>> methodConsumer) {
+      Consumer<StartupClass> classConsumer,
+      Consumer<StartupMethod> methodConsumer,
+      Consumer<SyntheticStartupMethod> syntheticMethodConsumer) {
     methodConsumer.accept(this);
   }
 
   @Override
   public <T> T apply(
-      Function<StartupClass<C, M>, T> classFunction,
-      Function<StartupMethod<C, M>, T> methodFunction) {
+      Function<StartupClass, T> classFunction,
+      Function<StartupMethod, T> methodFunction,
+      Function<SyntheticStartupMethod, T> syntheticMethodFunction) {
     return methodFunction.apply(this);
   }
 
+  public DexMethod getReference() {
+    return method;
+  }
+
   @Override
   public boolean isStartupMethod() {
     return true;
   }
 
   @Override
-  public StartupMethod<C, M> asStartupMethod() {
+  public StartupMethod asStartupMethod() {
     return this;
   }
 
   @Override
-  public void serializeToString(
-      StringBuilder builder,
-      Function<C, String> classSerializer,
-      Function<M, String> methodSerializer) {
-    if (isSynthetic()) {
-      builder.append('S');
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
     }
-    builder.append(methodSerializer.apply(getReference()));
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    StartupMethod that = (StartupMethod) o;
+    return method == that.method;
   }
 
-  public static class Builder<C, M> extends StartupItem.Builder<C, M, Builder<C, M>> {
+  @Override
+  public int hashCode() {
+    return method.hashCode();
+  }
 
-    @Override
-    public Builder<C, M> setClassReference(C reference) {
-      throw new Unreachable();
+  public static class Builder implements StartupMethodBuilder {
+
+    private final DexItemFactory dexItemFactory;
+
+    private DexMethod method;
+
+    Builder() {
+      this(null);
+    }
+
+    Builder(DexItemFactory dexItemFactory) {
+      this.dexItemFactory = dexItemFactory;
     }
 
     @Override
-    public StartupMethod<C, M> build() {
-      return new StartupMethod<>(flags, methodReference);
+    public Builder setMethodReference(MethodReference classReference) {
+      assert dexItemFactory != null;
+      return setMethodReference(MethodReferenceUtils.toDexMethod(classReference, dexItemFactory));
+    }
+
+    public Builder setMethodReference(DexMethod method) {
+      this.method = method;
+      return this;
+    }
+
+    public StartupMethod build() {
+      return new StartupMethod(method);
     }
   }
 }

src/main/java/com/android/tools/r8/experimental/startup/profile/StartupProfile.java

diff --git a/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupProfile.java b/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupProfile.java
index c2e65b7..a0d6204 100644
--- a/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupProfile.java
+++ b/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupProfile.java
@@ -4,22 +4,23 @@
 
 package com.android.tools.r8.experimental.startup.profile;
 
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.startup.StartupClassBuilder;
+import com.android.tools.r8.startup.StartupMethodBuilder;
+import com.android.tools.r8.startup.StartupProfileBuilder;
 import com.android.tools.r8.startup.StartupProfileProvider;
+import com.android.tools.r8.startup.SyntheticStartupMethodBuilder;
 import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.StringDiagnostic;
-import com.android.tools.r8.utils.StringUtils;
 import com.google.common.collect.ImmutableList;
-import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.function.Consumer;
 
 public class StartupProfile {
 
-  private final List<StartupItem<DexType, DexMethod, ?>> startupItems;
+  private final List<StartupItem> startupItems;
 
-  public StartupProfile(List<StartupItem<DexType, DexMethod, ?>> startupItems) {
+  public StartupProfile(List<StartupItem> startupItems) {
     this.startupItems = startupItems;
   }
 
@@ -27,6 +28,10 @@
     return new Builder();
   }
 
+  public static Builder builder(DexItemFactory dexItemFactory) {
+    return new Builder(dexItemFactory);
+  }
+
   /**
    * Parses the supplied startup configuration, if any. The startup configuration is a list of class
    * and method descriptors.
@@ -43,60 +48,63 @@
    * </pre>
    */
   public static StartupProfile parseStartupProfile(InternalOptions options) {
-    if (!options.getStartupOptions().hasStartupProfileProvider()) {
+    if (!options.getStartupOptions().hasStartupProfileProviders()) {
       return null;
     }
-    StartupProfileProvider resource = options.getStartupOptions().getStartupProfileProvider();
-    List<String> startupDescriptors = StringUtils.splitLines(resource.get());
-    return createStartupConfigurationFromLines(options, startupDescriptors);
+    Collection<StartupProfileProvider> startupProfileProviders =
+        options.getStartupOptions().getStartupProfileProviders();
+    StartupProfile.Builder startupProfileBuilder = StartupProfile.builder(options.dexItemFactory());
+    for (StartupProfileProvider startupProfileProvider : startupProfileProviders) {
+      startupProfileProvider.getStartupProfile(startupProfileBuilder);
+    }
+    return startupProfileBuilder.build();
   }
 
-  public static StartupProfile createStartupConfigurationFromLines(
-      InternalOptions options, List<String> startupDescriptors) {
-    List<StartupItem<DexType, DexMethod, ?>> startupItems = new ArrayList<>();
-    StartupProfileParser.createDexParser(options.dexItemFactory())
-        .parseLines(
-            startupDescriptors,
-            startupItems::add,
-            startupItems::add,
-            error ->
-                options.reporter.warning(
-                    new StringDiagnostic(
-                        "Invalid descriptor for startup class or method: " + error)));
-    return new StartupProfile(startupItems);
-  }
-
-  public List<StartupItem<DexType, DexMethod, ?>> getStartupItems() {
+  public List<StartupItem> getStartupItems() {
     return startupItems;
   }
 
-  public String serializeToString() {
-    StringBuilder builder = new StringBuilder();
-    for (StartupItem<DexType, DexMethod, ?> startupItem : startupItems) {
-      startupItem.serializeToString(builder, DexType::toSmaliString, DexMethod::toSmaliString);
-      builder.append('\n');
+  public static class Builder implements StartupProfileBuilder {
+
+    private final DexItemFactory dexItemFactory;
+    private final ImmutableList.Builder<StartupItem> startupItemsBuilder = ImmutableList.builder();
+
+    Builder() {
+      this(null);
     }
-    return builder.toString();
-  }
 
-  public static class Builder {
+    Builder(DexItemFactory dexItemFactory) {
+      this.dexItemFactory = dexItemFactory;
+    }
 
-    private final ImmutableList.Builder<StartupItem<DexType, DexMethod, ?>> startupItemsBuilder =
-        ImmutableList.builder();
+    @Override
+    public Builder addStartupClass(Consumer<StartupClassBuilder> startupClassBuilderConsumer) {
+      StartupClass.Builder startupClassBuilder = StartupClass.builder(dexItemFactory);
+      startupClassBuilderConsumer.accept(startupClassBuilder);
+      return addStartupItem(startupClassBuilder.build());
+    }
 
-    public Builder addStartupItem(StartupItem<DexType, DexMethod, ?> startupItem) {
+    @Override
+    public Builder addStartupMethod(Consumer<StartupMethodBuilder> startupMethodBuilderConsumer) {
+      StartupMethod.Builder startupMethodBuilder = StartupMethod.builder(dexItemFactory);
+      startupMethodBuilderConsumer.accept(startupMethodBuilder);
+      return addStartupItem(startupMethodBuilder.build());
+    }
+
+    @Override
+    public StartupProfileBuilder addSyntheticStartupMethod(
+        Consumer<SyntheticStartupMethodBuilder> syntheticStartupMethodBuilderConsumer) {
+      SyntheticStartupMethod.Builder syntheticStartupMethodBuilder =
+          SyntheticStartupMethod.builder(dexItemFactory);
+      syntheticStartupMethodBuilderConsumer.accept(syntheticStartupMethodBuilder);
+      return addStartupItem(syntheticStartupMethodBuilder.build());
+    }
+
+    private Builder addStartupItem(StartupItem startupItem) {
       this.startupItemsBuilder.add(startupItem);
       return this;
     }
 
-    public Builder addStartupClass(StartupClass<DexType, DexMethod> startupClass) {
-      return addStartupItem(startupClass);
-    }
-
-    public Builder addStartupMethod(StartupMethod<DexType, DexMethod> startupMethod) {
-      return addStartupItem(startupMethod);
-    }
-
     public Builder apply(Consumer<Builder> consumer) {
       consumer.accept(this);
       return this;

src/main/java/com/android/tools/r8/experimental/startup/profile/StartupProfileParser.java

diff --git a/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupProfileParser.java b/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupProfileParser.java
index a386c31..cc205bf 100644
--- a/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupProfileParser.java
+++ b/src/main/java/com/android/tools/r8/experimental/startup/profile/StartupProfileParser.java
@@ -4,90 +4,49 @@
 
 package com.android.tools.r8.experimental.startup.profile;
 
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.startup.StartupProfileBuilder;
+import com.android.tools.r8.utils.BooleanBox;
 import com.android.tools.r8.utils.DescriptorUtils;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
-import java.util.function.Function;
+import java.util.stream.Stream;
 
-public class StartupProfileParser<C, M, T> {
+public class StartupProfileParser {
 
-  interface MethodFactory<C, M, T> {
-
-    M createMethod(
-        C methodHolder, String methodName, List<T> methodParameterTypes, T methodReturnType);
-  }
-
-  private final Function<String, C> classFactory;
-  private final MethodFactory<C, M, T> methodFactory;
-  private final Function<String, T> typeFactory;
-
-  StartupProfileParser(
-      Function<String, C> classFactory,
-      MethodFactory<C, M, T> methodFactory,
-      Function<String, T> typeFactory) {
-    this.classFactory = classFactory;
-    this.methodFactory = methodFactory;
-    this.typeFactory = typeFactory;
-  }
-
-  public static StartupProfileParser<DexType, DexMethod, DexType> createDexParser(
-      DexItemFactory dexItemFactory) {
-    return new StartupProfileParser<>(
-        dexItemFactory::createType,
-        (methodHolder, methodName, methodParameters, methodReturnType) ->
-            dexItemFactory.createMethod(
-                methodHolder,
-                dexItemFactory.createProto(methodReturnType, methodParameters),
-                dexItemFactory.createString(methodName)),
-        dexItemFactory::createType);
-  }
-
-  public static StartupProfileParser<ClassReference, MethodReference, TypeReference>
-      createReferenceParser() {
-    return new StartupProfileParser<>(
-        Reference::classFromDescriptor, Reference::method, Reference::returnTypeFromDescriptor);
+  public static StartupProfileParser create() {
+    return new StartupProfileParser();
   }
 
   public void parseLines(
-      List<String> startupDescriptors,
-      Consumer<? super StartupClass<C, M>> startupClassConsumer,
-      Consumer<? super StartupMethod<C, M>> startupMethodConsumer,
+      Stream<String> startupDescriptors,
+      StartupProfileBuilder startupProfileBuilder,
       Consumer<String> parseErrorHandler) {
-    for (String startupDescriptor : startupDescriptors) {
-      if (!startupDescriptor.isEmpty()) {
-        parseLine(
-            startupDescriptor, startupClassConsumer, startupMethodConsumer, parseErrorHandler);
-      }
-    }
+    startupDescriptors.forEach(
+        startupDescriptor -> {
+          if (!startupDescriptor.isEmpty()) {
+            parseLine(startupDescriptor, startupProfileBuilder, parseErrorHandler);
+          }
+        });
   }
 
   public void parseLine(
       String startupDescriptor,
-      Consumer<? super StartupClass<C, M>> startupClassConsumer,
-      Consumer<? super StartupMethod<C, M>> startupMethodConsumer,
+      StartupProfileBuilder startupProfileBuilder,
       Consumer<String> parseErrorHandler) {
-    StartupItem.Builder<C, M, ?> startupItemBuilder = StartupItem.builder();
-    startupDescriptor = parseSyntheticFlag(startupDescriptor, startupItemBuilder);
+    BooleanBox syntheticFlag = new BooleanBox();
+    startupDescriptor = parseSyntheticFlag(startupDescriptor, syntheticFlag);
     parseStartupClassOrMethod(
-        startupDescriptor,
-        startupItemBuilder,
-        startupClassConsumer,
-        startupMethodConsumer,
-        parseErrorHandler);
+        startupDescriptor, startupProfileBuilder, syntheticFlag, parseErrorHandler);
   }
 
-  private static String parseSyntheticFlag(
-      String startupDescriptor, StartupItem.Builder<?, ?, ?> startupItemBuilder) {
+  private static String parseSyntheticFlag(String startupDescriptor, BooleanBox syntheticFlag) {
     if (!startupDescriptor.isEmpty() && startupDescriptor.charAt(0) == 'S') {
-      startupItemBuilder.setSynthetic();
+      syntheticFlag.set();
       return startupDescriptor.substring(1);
     }
     return startupDescriptor;
@@ -95,24 +54,34 @@
 
   private void parseStartupClassOrMethod(
       String startupDescriptor,
-      StartupItem.Builder<C, M, ?> startupItemBuilder,
-      Consumer<? super StartupClass<C, M>> startupClassConsumer,
-      Consumer<? super StartupMethod<C, M>> startupMethodConsumer,
+      StartupProfileBuilder startupProfileBuilder,
+      BooleanBox syntheticFlag,
       Consumer<String> parseErrorHandler) {
     int arrowStartIndex = getArrowStartIndex(startupDescriptor);
     if (arrowStartIndex >= 0) {
-      M startupMethod = parseStartupMethodDescriptor(startupDescriptor, arrowStartIndex);
-      if (startupMethod != null) {
-        startupMethodConsumer.accept(
-            startupItemBuilder.setMethodReference(startupMethod).buildStartupMethod());
+      if (syntheticFlag.isFalse()) {
+        MethodReference startupMethod =
+            parseStartupMethodDescriptor(startupDescriptor, arrowStartIndex);
+        if (startupMethod != null) {
+          startupProfileBuilder.addStartupMethod(
+              startupMethodBuilder -> startupMethodBuilder.setMethodReference(startupMethod));
+        } else {
+          parseErrorHandler.accept(startupDescriptor);
+        }
       } else {
         parseErrorHandler.accept(startupDescriptor);
       }
     } else {
-      C startupClass = parseStartupClassDescriptor(startupDescriptor);
+      ClassReference startupClass = parseStartupClassDescriptor(startupDescriptor);
       if (startupClass != null) {
-        startupClassConsumer.accept(
-            startupItemBuilder.setClassReference(startupClass).buildStartupClass());
+        if (syntheticFlag.isFalse()) {
+          startupProfileBuilder.addStartupClass(
+              startupClassBuilder -> startupClassBuilder.setClassReference(startupClass));
+        } else {
+          startupProfileBuilder.addSyntheticStartupMethod(
+              syntheticStartupMethodBuilder ->
+                  syntheticStartupMethodBuilder.setSyntheticContextReference(startupClass));
+        }
       } else {
         parseErrorHandler.accept(startupDescriptor);
       }
@@ -123,17 +92,18 @@
     return startupDescriptor.indexOf("->");
   }
 
-  private C parseStartupClassDescriptor(String startupClassDescriptor) {
+  private ClassReference parseStartupClassDescriptor(String startupClassDescriptor) {
     if (DescriptorUtils.isClassDescriptor(startupClassDescriptor)) {
-      return classFactory.apply(startupClassDescriptor);
+      return Reference.classFromDescriptor(startupClassDescriptor);
     } else {
       return null;
     }
   }
 
-  private M parseStartupMethodDescriptor(String startupMethodDescriptor, int arrowStartIndex) {
+  private MethodReference parseStartupMethodDescriptor(
+      String startupMethodDescriptor, int arrowStartIndex) {
     String classDescriptor = startupMethodDescriptor.substring(0, arrowStartIndex);
-    C methodHolder = parseStartupClassDescriptor(classDescriptor);
+    ClassReference methodHolder = parseStartupClassDescriptor(classDescriptor);
     if (methodHolder == null) {
       return null;
     }
@@ -150,14 +120,15 @@
     return parseStartupMethodProto(methodHolder, methodName, protoDescriptor);
   }
 
-  private M parseStartupMethodProto(C methodHolder, String methodName, String protoDescriptor) {
-    List<T> parameterTypes = new ArrayList<>();
+  private MethodReference parseStartupMethodProto(
+      ClassReference methodHolder, String methodName, String protoDescriptor) {
+    List<TypeReference> parameterTypes = new ArrayList<>();
     for (String parameterTypeDescriptor :
         DescriptorUtils.getArgumentTypeDescriptors(protoDescriptor)) {
-      parameterTypes.add(typeFactory.apply(parameterTypeDescriptor));
+      parameterTypes.add(Reference.typeFromDescriptor(parameterTypeDescriptor));
     }
     String returnTypeDescriptor = DescriptorUtils.getReturnTypeDescriptor(protoDescriptor);
-    T returnType = typeFactory.apply(returnTypeDescriptor);
-    return methodFactory.createMethod(methodHolder, methodName, parameterTypes, returnType);
+    TypeReference returnType = Reference.returnTypeFromDescriptor(returnTypeDescriptor);
+    return Reference.method(methodHolder, methodName, parameterTypes, returnType);
   }
 }

src/main/java/com/android/tools/r8/experimental/startup/profile/SyntheticStartupMethod.java

diff --git a/src/main/java/com/android/tools/r8/experimental/startup/profile/SyntheticStartupMethod.java b/src/main/java/com/android/tools/r8/experimental/startup/profile/SyntheticStartupMethod.java
new file mode 100644
index 0000000..eedcadd
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/experimental/startup/profile/SyntheticStartupMethod.java
@@ -0,0 +1,108 @@
+// Copyright (c) 2022, the R8 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.
+
+package com.android.tools.r8.experimental.startup.profile;
+
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.startup.SyntheticStartupMethodBuilder;
+import com.android.tools.r8.utils.ClassReferenceUtils;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public class SyntheticStartupMethod extends StartupItem {
+
+  private final DexType syntheticContextType;
+
+  SyntheticStartupMethod(DexType syntheticContextType) {
+    this.syntheticContextType = syntheticContextType;
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static Builder builder(DexItemFactory dexItemFactory) {
+    return new Builder(dexItemFactory);
+  }
+
+  @Override
+  public void accept(
+      Consumer<StartupClass> classConsumer,
+      Consumer<StartupMethod> methodConsumer,
+      Consumer<SyntheticStartupMethod> syntheticMethodConsumer) {
+    syntheticMethodConsumer.accept(this);
+  }
+
+  @Override
+  public <T> T apply(
+      Function<StartupClass, T> classFunction,
+      Function<StartupMethod, T> methodFunction,
+      Function<SyntheticStartupMethod, T> syntheticMethodFunction) {
+    return syntheticMethodFunction.apply(this);
+  }
+
+  public DexType getSyntheticContextType() {
+    return syntheticContextType;
+  }
+
+  @Override
+  public boolean isSyntheticStartupMethod() {
+    return true;
+  }
+
+  @Override
+  public SyntheticStartupMethod asSyntheticStartupMethod() {
+    return this;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    SyntheticStartupMethod that = (SyntheticStartupMethod) o;
+    return syntheticContextType == that.syntheticContextType;
+  }
+
+  @Override
+  public int hashCode() {
+    return syntheticContextType.hashCode();
+  }
+
+  public static class Builder implements SyntheticStartupMethodBuilder {
+
+    private final DexItemFactory dexItemFactory;
+
+    private DexType syntheticContextReference;
+
+    Builder() {
+      this(null);
+    }
+
+    Builder(DexItemFactory dexItemFactory) {
+      this.dexItemFactory = dexItemFactory;
+    }
+
+    @Override
+    public Builder setSyntheticContextReference(ClassReference syntheticContextReference) {
+      assert dexItemFactory != null;
+      return setSyntheticContextReference(
+          ClassReferenceUtils.toDexType(syntheticContextReference, dexItemFactory));
+    }
+
+    public Builder setSyntheticContextReference(DexType syntheticContextReference) {
+      this.syntheticContextReference = syntheticContextReference;
+      return this;
+    }
+
+    public SyntheticStartupMethod build() {
+      return new SyntheticStartupMethod(syntheticContextReference);
+    }
+  }
+}

src/main/java/com/android/tools/r8/startup/StartupProfileProvider.java

diff --git a/src/main/java/com/android/tools/r8/startup/StartupProfileProvider.java b/src/main/java/com/android/tools/r8/startup/StartupProfileProvider.java
index 4d98373..39ad8fc 100644
--- a/src/main/java/com/android/tools/r8/startup/StartupProfileProvider.java
+++ b/src/main/java/com/android/tools/r8/startup/StartupProfileProvider.java
@@ -11,10 +11,6 @@
 @Keep
 public interface StartupProfileProvider extends Resource {
 
-  // TODO(b/238173796): Change the implementation to use the new API below.
-  /** Return the startup profile. */
-  String get();
-
   /** Provides the startup profile by callbacks to the given {@param startupProfileBuilder}. */
   void getStartupProfile(StartupProfileBuilder startupProfileBuilder);
 }

src/main/java/com/android/tools/r8/utils/InternalOptions.java

diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index f02405c..78c17ec 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -816,7 +816,7 @@
       new KotlinOptimizationOptions();
   private final ApiModelTestingOptions apiModelTestingOptions = new ApiModelTestingOptions();
   private final DesugarSpecificOptions desugarSpecificOptions = new DesugarSpecificOptions();
-  private final StartupOptions startupOptions = new StartupOptions();
+  private final StartupOptions startupOptions = new StartupOptions(this);
   private final StartupInstrumentationOptions startupInstrumentationOptions =
       new StartupInstrumentationOptions();
   public final TestingOptions testing = new TestingOptions();

src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingWithStartupClassesTest.java

diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingWithStartupClassesTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingWithStartupClassesTest.java
index 9ab1f03..f9b2f74 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingWithStartupClassesTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingWithStartupClassesTest.java
@@ -7,11 +7,9 @@
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.errors.Unimplemented;
-import com.android.tools.r8.experimental.startup.profile.StartupClass;
-import com.android.tools.r8.experimental.startup.profile.StartupProfile;
-import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.startup.StartupProfileBuilder;
 import com.android.tools.r8.startup.StartupProfileProvider;
 import com.android.tools.r8.utils.BooleanUtils;
@@ -52,30 +50,18 @@
         .addKeepClassAndMembersRules(Main.class)
         .addOptionsModification(
             options -> {
-              DexItemFactory dexItemFactory = options.dexItemFactory();
-              StartupProfile startupProfile =
-                  StartupProfile.builder()
-                      .apply(
-                          builder ->
-                              getStartupClasses()
-                                  .forEach(
-                                      startupClass ->
-                                          builder.addStartupClass(
-                                              StartupClass.dexBuilder()
-                                                  .setClassReference(
-                                                      toDexType(startupClass, dexItemFactory))
-                                                  .build())))
-                      .build();
               StartupProfileProvider startupProfileProvider =
                   new StartupProfileProvider() {
-                    @Override
-                    public String get() {
-                      return startupProfile.serializeToString();
-                    }
 
                     @Override
                     public void getStartupProfile(StartupProfileBuilder startupProfileBuilder) {
-                      throw new Unimplemented();
+                      for (Class<?> startupClass : getStartupClasses()) {
+                        ClassReference startupClassReference =
+                            Reference.classFromClass(startupClass);
+                        startupProfileBuilder.addStartupClass(
+                            startupClassBuilder ->
+                                startupClassBuilder.setClassReference(startupClassReference));
+                      }
                     }
 
                     @Override
@@ -83,7 +69,9 @@
                       return Origin.unknown();
                     }
                   };
-              options.getStartupOptions().setStartupProfileProvider(startupProfileProvider);
+              options
+                  .getStartupOptions()
+                  .setStartupProfileProviders(Collections.singleton(startupProfileProvider));
             })
         .addHorizontallyMergedClassesInspector(
             inspector ->

src/test/java/com/android/tools/r8/compilerapi/startupprofile/StartupProfileApiTest.java

diff --git a/src/test/java/com/android/tools/r8/compilerapi/startupprofile/StartupProfileApiTest.java b/src/test/java/com/android/tools/r8/compilerapi/startupprofile/StartupProfileApiTest.java
index f8bc404..b6572fc 100644
--- a/src/test/java/com/android/tools/r8/compilerapi/startupprofile/StartupProfileApiTest.java
+++ b/src/test/java/com/android/tools/r8/compilerapi/startupprofile/StartupProfileApiTest.java
@@ -82,9 +82,8 @@
     testRunner.accept(new DexIndexedConsumer.DirectoryConsumer(output));
     assertThat(
         new CodeInspector(output.resolve("classes.dex")).clazz(test.getMockClass()), isPresent());
-    // TODO(b/238173796): The PostStartupMockClass should be in classes2.dex.
     assertThat(
-        new CodeInspector(output.resolve("classes.dex")).clazz(test.getPostStartupMockClass()),
+        new CodeInspector(output.resolve("classes2.dex")).clazz(test.getPostStartupMockClass()),
         isPresent());
   }
 
@@ -96,11 +95,6 @@
 
     private StartupProfileProvider getStartupProfileProvider() {
       return new StartupProfileProvider() {
-        @Override
-        public String get() {
-          // Intentionally empty. All uses of this API should be rewritten to use getStartupProfile.
-          return "";
-        }
 
         @Override
         public void getStartupProfile(StartupProfileBuilder startupProfileBuilder) {

src/test/java/com/android/tools/r8/internal/YouTubeV1719Test.java

diff --git a/src/test/java/com/android/tools/r8/internal/YouTubeV1719Test.java b/src/test/java/com/android/tools/r8/internal/YouTubeV1719Test.java
index a44f221..35ef96e 100644
--- a/src/test/java/com/android/tools/r8/internal/YouTubeV1719Test.java
+++ b/src/test/java/com/android/tools/r8/internal/YouTubeV1719Test.java
@@ -38,6 +38,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.Collections;
 import java.util.concurrent.ExecutionException;
 import org.junit.After;
 import org.junit.Test;
@@ -149,7 +150,8 @@
                       if (startupProfileProvider != null) {
                         options
                             .getStartupOptions()
-                            .setStartupProfileProvider(startupProfileProvider)
+                            .setStartupProfileProviders(
+                                Collections.singleton(startupProfileProvider))
                             .setEnableMinimalStartupDex(enableMinimalStartupDex)
                             .setEnableStartupBoundaryOptimizations(
                                 enableStartupBoundaryOptimizations);

src/test/java/com/android/tools/r8/internal/startup/ChromeStartupTest.java

diff --git a/src/test/java/com/android/tools/r8/internal/startup/ChromeStartupTest.java b/src/test/java/com/android/tools/r8/internal/startup/ChromeStartupTest.java
index c7211db..0af6a45 100644
--- a/src/test/java/com/android/tools/r8/internal/startup/ChromeStartupTest.java
+++ b/src/test/java/com/android/tools/r8/internal/startup/ChromeStartupTest.java
@@ -13,23 +13,22 @@
 import com.android.tools.r8.ArchiveProgramResourceProvider;
 import com.android.tools.r8.DexIndexedConsumer;
 import com.android.tools.r8.R8FullTestBuilder;
-import com.android.tools.r8.StringResource;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.ThrowableConsumer;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.errors.Unimplemented;
-import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.startup.StartupProfileBuilder;
+import com.android.tools.r8.experimental.startup.StartupProfileProviderUtils;
 import com.android.tools.r8.startup.StartupProfileProvider;
 import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.Reporter;
 import com.android.tools.r8.utils.ZipUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.Collections;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -238,25 +237,10 @@
       boolean enableStartupBoundaryOptimizations,
       Path outDirectory)
       throws Exception {
+    Reporter reporter = new Reporter();
     StartupProfileProvider startupProfileProvider =
-        new StartupProfileProvider() {
-          @Override
-          public String get() {
-            return StringResource.fromFile(chromeDirectory.resolve("startup.txt"))
-                .getStringWithRuntimeException();
-          }
-
-          @Override
-          public void getStartupProfile(StartupProfileBuilder startupProfileBuilder) {
-            throw new Unimplemented();
-          }
-
-          @Override
-          public Origin getOrigin() {
-            return Origin.unknown();
-          }
-        };
-
+        StartupProfileProviderUtils.createFromFile(
+            chromeDirectory.resolve("startup.txt"), reporter);
     buildR8(
         testBuilder ->
             testBuilder.addOptionsModification(
@@ -265,7 +249,7 @@
                         .getStartupOptions()
                         .setEnableMinimalStartupDex(enableMinimalStartupDex)
                         .setEnableStartupBoundaryOptimizations(enableStartupBoundaryOptimizations)
-                        .setStartupProfileProvider(startupProfileProvider)),
+                        .setStartupProfileProviders(Collections.singleton(startupProfileProvider))),
         outDirectory);
   }
 

src/test/java/com/android/tools/r8/startup/InliningOutOfStartupPartitionTest.java

diff --git a/src/test/java/com/android/tools/r8/startup/InliningOutOfStartupPartitionTest.java b/src/test/java/com/android/tools/r8/startup/InliningOutOfStartupPartitionTest.java
index b26ff87..b171421 100644
--- a/src/test/java/com/android/tools/r8/startup/InliningOutOfStartupPartitionTest.java
+++ b/src/test/java/com/android/tools/r8/startup/InliningOutOfStartupPartitionTest.java
@@ -11,12 +11,10 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.experimental.startup.profile.StartupClass;
-import com.android.tools.r8.experimental.startup.profile.StartupItem;
-import com.android.tools.r8.experimental.startup.profile.StartupMethod;
-import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.startup.profile.ExternalStartupClass;
+import com.android.tools.r8.startup.profile.ExternalStartupItem;
+import com.android.tools.r8.startup.profile.ExternalStartupMethod;
 import com.android.tools.r8.startup.utils.StartupTestingUtils;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -41,12 +39,12 @@
 
   @Test
   public void test() throws Exception {
-    List<StartupItem<ClassReference, MethodReference, ?>> startupItems =
+    List<ExternalStartupItem> startupItems =
         ImmutableList.of(
-            StartupClass.referenceBuilder()
+            ExternalStartupClass.builder()
                 .setClassReference(Reference.classFromClass(Main.class))
                 .build(),
-            StartupMethod.referenceBuilder()
+            ExternalStartupMethod.builder()
                 .setMethodReference(MethodReferenceUtils.mainMethod(Main.class))
                 .build());
     testForR8(parameters.getBackend())

src/test/java/com/android/tools/r8/startup/MinimalStartupDexTest.java

diff --git a/src/test/java/com/android/tools/r8/startup/MinimalStartupDexTest.java b/src/test/java/com/android/tools/r8/startup/MinimalStartupDexTest.java
index eda0c51..d6d12a8 100644
--- a/src/test/java/com/android/tools/r8/startup/MinimalStartupDexTest.java
+++ b/src/test/java/com/android/tools/r8/startup/MinimalStartupDexTest.java
@@ -12,9 +12,7 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.experimental.startup.profile.StartupItem;
-import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.startup.profile.ExternalStartupItem;
 import com.android.tools.r8.startup.utils.StartupTestingUtils;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -45,7 +43,7 @@
 
   @Test
   public void test() throws Exception {
-    List<StartupItem<ClassReference, MethodReference, ?>> startupList = new ArrayList<>();
+    List<ExternalStartupItem> startupList = new ArrayList<>();
     testForD8(parameters.getBackend())
         .addInnerClasses(getClass())
         .apply(

src/test/java/com/android/tools/r8/startup/StartupInstrumentationTest.java

diff --git a/src/test/java/com/android/tools/r8/startup/StartupInstrumentationTest.java b/src/test/java/com/android/tools/r8/startup/StartupInstrumentationTest.java
index 13257e1..faa893b 100644
--- a/src/test/java/com/android/tools/r8/startup/StartupInstrumentationTest.java
+++ b/src/test/java/com/android/tools/r8/startup/StartupInstrumentationTest.java
@@ -9,12 +9,10 @@
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.experimental.startup.profile.StartupClass;
-import com.android.tools.r8.experimental.startup.profile.StartupItem;
-import com.android.tools.r8.experimental.startup.profile.StartupMethod;
-import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.startup.profile.ExternalStartupClass;
+import com.android.tools.r8.startup.profile.ExternalStartupItem;
+import com.android.tools.r8.startup.profile.ExternalStartupMethod;
 import com.android.tools.r8.startup.utils.StartupTestingUtils;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.MethodReferenceUtils;
@@ -48,7 +46,7 @@
   @Test
   public void test() throws Exception {
     Path out = temp.newFolder().toPath().resolve("out.txt").toAbsolutePath();
-    List<StartupItem<ClassReference, MethodReference, ?>> startupList = new ArrayList<>();
+    List<ExternalStartupItem> startupList = new ArrayList<>();
     testForD8(parameters.getBackend())
         .addInnerClasses(getClass())
         .applyIf(
@@ -75,19 +73,18 @@
     return ImmutableList.of("foo");
   }
 
-  private List<StartupItem<ClassReference, MethodReference, ?>> getExpectedStartupList()
-      throws NoSuchMethodException {
+  private List<ExternalStartupItem> getExpectedStartupList() throws NoSuchMethodException {
     return ImmutableList.of(
-        StartupClass.referenceBuilder()
+        ExternalStartupClass.builder()
             .setClassReference(Reference.classFromClass(Main.class))
             .build(),
-        StartupMethod.referenceBuilder()
+        ExternalStartupMethod.builder()
             .setMethodReference(MethodReferenceUtils.mainMethod(Main.class))
             .build(),
-        StartupClass.referenceBuilder()
+        ExternalStartupClass.builder()
             .setClassReference(Reference.classFromClass(AStartupClass.class))
             .build(),
-        StartupMethod.referenceBuilder()
+        ExternalStartupMethod.builder()
             .setMethodReference(
                 Reference.methodFromMethod(AStartupClass.class.getDeclaredMethod("foo")))
             .build());

src/test/java/com/android/tools/r8/startup/StartupSyntheticPlacementTest.java

diff --git a/src/test/java/com/android/tools/r8/startup/StartupSyntheticPlacementTest.java b/src/test/java/com/android/tools/r8/startup/StartupSyntheticPlacementTest.java
index 64c4c56..e9c4224 100644
--- a/src/test/java/com/android/tools/r8/startup/StartupSyntheticPlacementTest.java
+++ b/src/test/java/com/android/tools/r8/startup/StartupSyntheticPlacementTest.java
@@ -16,14 +16,14 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestCompilerBuilder;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.experimental.startup.profile.StartupClass;
-import com.android.tools.r8.experimental.startup.profile.StartupItem;
-import com.android.tools.r8.experimental.startup.profile.StartupMethod;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.ir.desugar.LambdaClass;
 import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.startup.profile.ExternalStartupClass;
+import com.android.tools.r8.startup.profile.ExternalStartupItem;
+import com.android.tools.r8.startup.profile.ExternalStartupMethod;
+import com.android.tools.r8.startup.profile.ExternalSyntheticStartupMethod;
 import com.android.tools.r8.startup.utils.MixedSectionLayoutInspector;
 import com.android.tools.r8.startup.utils.StartupTestingUtils;
 import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
@@ -90,7 +90,7 @@
     Path optimizedApp = r8CompileResult.writeToZip();
 
     // Then instrument the app to generate a startup list for the minified app.
-    List<StartupItem<ClassReference, MethodReference, ?>> startupList = new ArrayList<>();
+    List<ExternalStartupItem> startupList = new ArrayList<>();
     testForD8(parameters.getBackend())
         .addProgramFiles(optimizedApp)
         .apply(
@@ -125,7 +125,7 @@
   @Test
   public void testLayoutUsingR8() throws Exception {
     // First generate a startup list for the original app.
-    List<StartupItem<ClassReference, MethodReference, ?>> startupList = new ArrayList<>();
+    List<ExternalStartupItem> startupList = new ArrayList<>();
     D8TestCompileResult instrumentationCompileResult =
         testForD8(parameters.getBackend())
             .addInnerClasses(getClass())
@@ -167,7 +167,7 @@
   private void configureStartupOptions(
       TestCompilerBuilder<?, ?, ?, ?, ?> testBuilder,
       CodeInspector inspector,
-      List<StartupItem<ClassReference, MethodReference, ?>> startupList) {
+      List<ExternalStartupItem> startupList) {
     testBuilder
         .addOptionsModification(
             options -> {
@@ -188,36 +188,30 @@
   }
 
   @SuppressWarnings("unchecked")
-  private List<StartupItem<ClassReference, MethodReference, ?>> getExpectedStartupList(
+  private List<ExternalStartupItem> getExpectedStartupList(
       CodeInspector inspector, boolean isStartupListForOriginalApp) throws NoSuchMethodException {
-    ImmutableList.Builder<StartupItem<ClassReference, MethodReference, ?>> builder =
-        ImmutableList.builder();
+    ImmutableList.Builder<ExternalStartupItem> builder = ImmutableList.builder();
     builder.add(
-        StartupClass.referenceBuilder()
+        ExternalStartupClass.builder()
             .setClassReference(Reference.classFromClass(Main.class))
             .build(),
-        StartupMethod.referenceBuilder()
+        ExternalStartupMethod.builder()
             .setMethodReference(MethodReferenceUtils.mainMethod(Main.class))
             .build(),
-        StartupClass.referenceBuilder()
-            .setClassReference(Reference.classFromClass(A.class))
-            .build(),
-        StartupMethod.referenceBuilder()
+        ExternalStartupClass.builder().setClassReference(Reference.classFromClass(A.class)).build(),
+        ExternalStartupMethod.builder()
             .setMethodReference(Reference.methodFromMethod(A.class.getDeclaredMethod("a")))
             .build(),
-        StartupClass.referenceBuilder()
-            .setClassReference(Reference.classFromClass(B.class))
-            .build(),
-        StartupMethod.referenceBuilder()
+        ExternalStartupClass.builder().setClassReference(Reference.classFromClass(B.class)).build(),
+        ExternalStartupMethod.builder()
             .setMethodReference(
                 Reference.methodFromMethod(B.class.getDeclaredMethod("b", boolean.class)))
             .build());
     if (useLambda) {
       if (isStartupListForOriginalApp) {
         builder.add(
-            StartupClass.referenceBuilder()
-                .setClassReference(Reference.classFromClass(B.class))
-                .setSynthetic()
+            ExternalSyntheticStartupMethod.builder()
+                .setSyntheticContextReference(Reference.classFromClass(B.class))
                 .build());
       } else {
         ClassSubject bClassSubject = inspector.clazz(B.class);
@@ -238,14 +232,14 @@
             externalSyntheticLambdaClassSubject.getFinalReference();
 
         builder.add(
-            StartupClass.referenceBuilder()
+            ExternalStartupClass.builder()
                 .setClassReference(externalSyntheticLambdaClassReference)
                 .build(),
-            StartupMethod.referenceBuilder()
+            ExternalStartupMethod.builder()
                 .setMethodReference(
                     MethodReferenceUtils.instanceConstructor(externalSyntheticLambdaClassReference))
                 .build(),
-            StartupMethod.referenceBuilder()
+            ExternalStartupMethod.builder()
                 .setMethodReference(
                     Reference.method(
                         externalSyntheticLambdaClassReference,
@@ -253,7 +247,7 @@
                         ImmutableList.of(Reference.classFromClass(Object.class)),
                         null))
                 .build(),
-            StartupMethod.referenceBuilder()
+            ExternalStartupMethod.builder()
                 .setMethodReference(
                     Reference.method(
                         Reference.classFromClass(B.class),
@@ -263,16 +257,14 @@
                 .build());
       }
       builder.add(
-          StartupMethod.referenceBuilder()
+          ExternalStartupMethod.builder()
               .setMethodReference(
                   Reference.methodFromMethod(B.class.getDeclaredMethod("lambda$b$0", Object.class)))
               .build());
     }
     builder.add(
-        StartupClass.referenceBuilder()
-            .setClassReference(Reference.classFromClass(C.class))
-            .build(),
-        StartupMethod.referenceBuilder()
+        ExternalStartupClass.builder().setClassReference(Reference.classFromClass(C.class)).build(),
+        ExternalStartupMethod.builder()
             .setMethodReference(Reference.methodFromMethod(C.class.getDeclaredMethod("c")))
             .build());
     return builder.build();

src/test/java/com/android/tools/r8/startup/StartupSyntheticWithoutContextTest.java

diff --git a/src/test/java/com/android/tools/r8/startup/StartupSyntheticWithoutContextTest.java b/src/test/java/com/android/tools/r8/startup/StartupSyntheticWithoutContextTest.java
index 5b30a0a..a824cc4 100644
--- a/src/test/java/com/android/tools/r8/startup/StartupSyntheticWithoutContextTest.java
+++ b/src/test/java/com/android/tools/r8/startup/StartupSyntheticWithoutContextTest.java
@@ -14,13 +14,13 @@
 
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.experimental.startup.profile.StartupClass;
-import com.android.tools.r8.experimental.startup.profile.StartupItem;
-import com.android.tools.r8.experimental.startup.profile.StartupMethod;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.startup.profile.ExternalStartupClass;
+import com.android.tools.r8.startup.profile.ExternalStartupItem;
+import com.android.tools.r8.startup.profile.ExternalStartupMethod;
+import com.android.tools.r8.startup.profile.ExternalSyntheticStartupMethod;
 import com.android.tools.r8.startup.utils.MixedSectionLayoutInspector;
 import com.android.tools.r8.startup.utils.StartupTestingUtils;
 import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
@@ -61,7 +61,7 @@
 
   @Test
   public void test() throws Exception {
-    List<StartupItem<ClassReference, MethodReference, ?>> startupList = new ArrayList<>();
+    List<ExternalStartupItem> startupList = new ArrayList<>();
     testForD8(parameters.getBackend())
         .addInnerClasses(getClass())
         .apply(
@@ -101,38 +101,30 @@
     return ImmutableList.of("A", "B", "C");
   }
 
-  private List<StartupItem<ClassReference, MethodReference, ?>> getExpectedStartupList()
-      throws NoSuchMethodException {
+  private List<ExternalStartupItem> getExpectedStartupList() throws NoSuchMethodException {
     return ImmutableList.of(
-        StartupClass.referenceBuilder()
+        ExternalStartupClass.builder()
             .setClassReference(Reference.classFromClass(Main.class))
             .build(),
-        StartupMethod.referenceBuilder()
+        ExternalStartupMethod.builder()
             .setMethodReference(MethodReferenceUtils.mainMethod(Main.class))
             .build(),
-        StartupClass.referenceBuilder()
-            .setClassReference(Reference.classFromClass(A.class))
-            .build(),
-        StartupMethod.referenceBuilder()
+        ExternalStartupClass.builder().setClassReference(Reference.classFromClass(A.class)).build(),
+        ExternalStartupMethod.builder()
             .setMethodReference(Reference.methodFromMethod(A.class.getDeclaredMethod("a")))
             .build(),
-        StartupClass.referenceBuilder()
-            .setClassReference(Reference.classFromClass(B.class))
-            .build(),
-        StartupMethod.referenceBuilder()
+        ExternalStartupClass.builder().setClassReference(Reference.classFromClass(B.class)).build(),
+        ExternalStartupMethod.builder()
             .setMethodReference(Reference.methodFromMethod(B.class.getDeclaredMethod("b")))
             .build(),
-        StartupClass.referenceBuilder()
-            .setClassReference(Reference.classFromClass(B.class))
-            .setSynthetic()
+        ExternalSyntheticStartupMethod.builder()
+            .setSyntheticContextReference(Reference.classFromClass(B.class))
             .build(),
-        StartupMethod.referenceBuilder()
+        ExternalStartupMethod.builder()
             .setMethodReference(Reference.methodFromMethod(B.class.getDeclaredMethod("lambda$b$0")))
             .build(),
-        StartupClass.referenceBuilder()
-            .setClassReference(Reference.classFromClass(C.class))
-            .build(),
-        StartupMethod.referenceBuilder()
+        ExternalStartupClass.builder().setClassReference(Reference.classFromClass(C.class)).build(),
+        ExternalStartupMethod.builder()
             .setMethodReference(Reference.methodFromMethod(C.class.getDeclaredMethod("c")))
             .build());
   }

src/test/java/com/android/tools/r8/startup/profile/ExternalStartupClass.java

diff --git a/src/test/java/com/android/tools/r8/startup/profile/ExternalStartupClass.java b/src/test/java/com/android/tools/r8/startup/profile/ExternalStartupClass.java
new file mode 100644
index 0000000..c6caccf
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/startup/profile/ExternalStartupClass.java
@@ -0,0 +1,66 @@
+// Copyright (c) 2022, the R8 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.
+
+package com.android.tools.r8.startup.profile;
+
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.startup.StartupClassBuilder;
+import java.util.function.Function;
+
+public class ExternalStartupClass extends ExternalStartupItem {
+
+  private final ClassReference classReference;
+
+  ExternalStartupClass(ClassReference classReference) {
+    this.classReference = classReference;
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  @Override
+  public <T> T apply(
+      Function<ExternalStartupClass, T> classFunction,
+      Function<ExternalStartupMethod, T> methodFunction,
+      Function<ExternalSyntheticStartupMethod, T> syntheticMethodFunction) {
+    return classFunction.apply(this);
+  }
+
+  public ClassReference getReference() {
+    return classReference;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    ExternalStartupClass that = (ExternalStartupClass) o;
+    return classReference.equals(that.classReference);
+  }
+
+  @Override
+  public int hashCode() {
+    return classReference.hashCode();
+  }
+
+  public static class Builder implements StartupClassBuilder {
+
+    private ClassReference classReference;
+
+    @Override
+    public Builder setClassReference(ClassReference classReference) {
+      this.classReference = classReference;
+      return this;
+    }
+
+    public ExternalStartupClass build() {
+      return new ExternalStartupClass(classReference);
+    }
+  }
+}

src/test/java/com/android/tools/r8/startup/profile/ExternalStartupItem.java

diff --git a/src/test/java/com/android/tools/r8/startup/profile/ExternalStartupItem.java b/src/test/java/com/android/tools/r8/startup/profile/ExternalStartupItem.java
new file mode 100644
index 0000000..e3aa745
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/startup/profile/ExternalStartupItem.java
@@ -0,0 +1,15 @@
+// Copyright (c) 2022, the R8 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.
+
+package com.android.tools.r8.startup.profile;
+
+import java.util.function.Function;
+
+public abstract class ExternalStartupItem {
+
+  public abstract <T> T apply(
+      Function<ExternalStartupClass, T> classFunction,
+      Function<ExternalStartupMethod, T> methodFunction,
+      Function<ExternalSyntheticStartupMethod, T> syntheticMethodFunction);
+}

src/test/java/com/android/tools/r8/startup/profile/ExternalStartupMethod.java

diff --git a/src/test/java/com/android/tools/r8/startup/profile/ExternalStartupMethod.java b/src/test/java/com/android/tools/r8/startup/profile/ExternalStartupMethod.java
new file mode 100644
index 0000000..0d73a7a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/startup/profile/ExternalStartupMethod.java
@@ -0,0 +1,67 @@
+// Copyright (c) 2022, the R8 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.
+
+package com.android.tools.r8.startup.profile;
+
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.startup.StartupMethodBuilder;
+import com.android.tools.r8.startup.profile.ExternalStartupClass.Builder;
+import java.util.function.Function;
+
+public class ExternalStartupMethod extends ExternalStartupItem {
+
+  private final MethodReference methodReference;
+
+  ExternalStartupMethod(MethodReference methodReference) {
+    this.methodReference = methodReference;
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  @Override
+  public <T> T apply(
+      Function<ExternalStartupClass, T> classFunction,
+      Function<ExternalStartupMethod, T> methodFunction,
+      Function<ExternalSyntheticStartupMethod, T> syntheticMethodFunction) {
+    return methodFunction.apply(this);
+  }
+
+  public MethodReference getReference() {
+    return methodReference;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    ExternalStartupMethod that = (ExternalStartupMethod) o;
+    return methodReference.equals(that.methodReference);
+  }
+
+  @Override
+  public int hashCode() {
+    return methodReference.hashCode();
+  }
+
+  public static class Builder implements StartupMethodBuilder {
+
+    private MethodReference methodReference;
+
+    @Override
+    public Builder setMethodReference(MethodReference methodReference) {
+      this.methodReference = methodReference;
+      return this;
+    }
+
+    public ExternalStartupMethod build() {
+      return new ExternalStartupMethod(methodReference);
+    }
+  }
+}

src/test/java/com/android/tools/r8/startup/profile/ExternalSyntheticStartupMethod.java

diff --git a/src/test/java/com/android/tools/r8/startup/profile/ExternalSyntheticStartupMethod.java b/src/test/java/com/android/tools/r8/startup/profile/ExternalSyntheticStartupMethod.java
new file mode 100644
index 0000000..628cdec
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/startup/profile/ExternalSyntheticStartupMethod.java
@@ -0,0 +1,66 @@
+// Copyright (c) 2022, the R8 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.
+
+package com.android.tools.r8.startup.profile;
+
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.startup.SyntheticStartupMethodBuilder;
+import java.util.function.Function;
+
+public class ExternalSyntheticStartupMethod extends ExternalStartupItem {
+
+  private final ClassReference syntheticContextReference;
+
+  ExternalSyntheticStartupMethod(ClassReference syntheticContextReference) {
+    this.syntheticContextReference = syntheticContextReference;
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  @Override
+  public <T> T apply(
+      Function<ExternalStartupClass, T> classFunction,
+      Function<ExternalStartupMethod, T> methodFunction,
+      Function<ExternalSyntheticStartupMethod, T> syntheticMethodFunction) {
+    return syntheticMethodFunction.apply(this);
+  }
+
+  public ClassReference getSyntheticContextReference() {
+    return syntheticContextReference;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    ExternalSyntheticStartupMethod that = (ExternalSyntheticStartupMethod) o;
+    return syntheticContextReference.equals(that.syntheticContextReference);
+  }
+
+  @Override
+  public int hashCode() {
+    return syntheticContextReference.hashCode();
+  }
+
+  public static class Builder implements SyntheticStartupMethodBuilder {
+
+    private ClassReference syntheticContextReference;
+
+    @Override
+    public Builder setSyntheticContextReference(ClassReference syntheticContextReference) {
+      this.syntheticContextReference = syntheticContextReference;
+      return this;
+    }
+
+    public ExternalSyntheticStartupMethod build() {
+      return new ExternalSyntheticStartupMethod(syntheticContextReference);
+    }
+  }
+}

src/test/java/com/android/tools/r8/startup/utils/StartupTestingUtils.java

diff --git a/src/test/java/com/android/tools/r8/startup/utils/StartupTestingUtils.java b/src/test/java/com/android/tools/r8/startup/utils/StartupTestingUtils.java
index 2011ff1..a9ca8c5 100644
--- a/src/test/java/com/android/tools/r8/startup/utils/StartupTestingUtils.java
+++ b/src/test/java/com/android/tools/r8/startup/utils/StartupTestingUtils.java
@@ -14,28 +14,25 @@
 import com.android.tools.r8.TestCompilerBuilder;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.errors.Unimplemented;
 import com.android.tools.r8.experimental.startup.instrumentation.StartupInstrumentationOptions;
-import com.android.tools.r8.experimental.startup.profile.StartupItem;
-import com.android.tools.r8.experimental.startup.profile.StartupProfile;
 import com.android.tools.r8.experimental.startup.profile.StartupProfileParser;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.startup.StartupClassBuilder;
+import com.android.tools.r8.startup.StartupMethodBuilder;
 import com.android.tools.r8.startup.StartupProfileBuilder;
 import com.android.tools.r8.startup.StartupProfileProvider;
+import com.android.tools.r8.startup.SyntheticStartupMethodBuilder;
+import com.android.tools.r8.startup.profile.ExternalStartupClass;
+import com.android.tools.r8.startup.profile.ExternalStartupItem;
+import com.android.tools.r8.startup.profile.ExternalStartupMethod;
+import com.android.tools.r8.startup.profile.ExternalSyntheticStartupMethod;
 import com.android.tools.r8.utils.AndroidApiLevel;
-import com.android.tools.r8.utils.ClassReferenceUtils;
-import com.android.tools.r8.utils.MethodReferenceUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.ThrowingConsumer;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Collections;
 import java.util.List;
 import java.util.function.Consumer;
 import org.junit.rules.TemporaryFolder;
@@ -53,6 +50,39 @@
     }
   }
 
+  private static StartupProfileBuilder createStartupItemFactory(
+      Consumer<ExternalStartupItem> startupItemConsumer) {
+    return new StartupProfileBuilder() {
+      @Override
+      public StartupProfileBuilder addStartupClass(
+          Consumer<StartupClassBuilder> startupClassBuilderConsumer) {
+        ExternalStartupClass.Builder startupClassBuilder = ExternalStartupClass.builder();
+        startupClassBuilderConsumer.accept(startupClassBuilder);
+        startupItemConsumer.accept(startupClassBuilder.build());
+        return this;
+      }
+
+      @Override
+      public StartupProfileBuilder addStartupMethod(
+          Consumer<StartupMethodBuilder> startupMethodBuilderConsumer) {
+        ExternalStartupMethod.Builder startupMethodBuilder = ExternalStartupMethod.builder();
+        startupMethodBuilderConsumer.accept(startupMethodBuilder);
+        startupItemConsumer.accept(startupMethodBuilder.build());
+        return this;
+      }
+
+      @Override
+      public StartupProfileBuilder addSyntheticStartupMethod(
+          Consumer<SyntheticStartupMethodBuilder> syntheticStartupMethodBuilderConsumer) {
+        ExternalSyntheticStartupMethod.Builder syntheticStartupMethodBuilder =
+            ExternalSyntheticStartupMethod.builder();
+        syntheticStartupMethodBuilderConsumer.accept(syntheticStartupMethodBuilder);
+        startupItemConsumer.accept(syntheticStartupMethodBuilder.build());
+        return this;
+      }
+    };
+  }
+
   public static ThrowableConsumer<D8TestBuilder>
       enableStartupInstrumentationForOriginalAppUsingFile(TestParameters parameters) {
     return testBuilder ->
@@ -66,12 +96,6 @@
   }
 
   public static ThrowableConsumer<D8TestBuilder>
-      enableStartupInstrumentationForOptimizedAppUsingFile(TestParameters parameters) {
-    return testBuilder ->
-        enableStartupInstrumentation(testBuilder, parameters, AppVariant.OPTIMIZED, false);
-  }
-
-  public static ThrowableConsumer<D8TestBuilder>
       enableStartupInstrumentationForOptimizedAppUsingLogcat(TestParameters parameters) {
     return testBuilder ->
         enableStartupInstrumentation(testBuilder, parameters, AppVariant.OPTIMIZED, true);
@@ -108,26 +132,22 @@
   }
 
   public static void readStartupListFromFile(
-      Path path, Consumer<StartupItem<ClassReference, MethodReference, ?>> startupItemConsumer)
-      throws IOException {
-    StartupProfileParser.createReferenceParser()
+      Path path, Consumer<ExternalStartupItem> startupItemConsumer) throws IOException {
+    StartupProfileParser.create()
         .parseLines(
-            Files.readAllLines(path),
-            startupItemConsumer,
-            startupItemConsumer,
+            Files.readAllLines(path).stream(),
+            createStartupItemFactory(startupItemConsumer),
             error -> fail("Unexpected parse error: " + error));
   }
 
   public static ThrowingConsumer<D8TestRunResult, RuntimeException> removeStartupListFromStdout(
-      Consumer<StartupItem<ClassReference, MethodReference, ?>> startupItemConsumer) {
+      Consumer<ExternalStartupItem> startupItemConsumer) {
     return runResult -> removeStartupListFromStdout(runResult, startupItemConsumer);
   }
 
   public static void removeStartupListFromStdout(
-      D8TestRunResult runResult,
-      Consumer<StartupItem<ClassReference, MethodReference, ?>> startupItemConsumer) {
-    StartupProfileParser<ClassReference, MethodReference, TypeReference> parser =
-        StartupProfileParser.createReferenceParser();
+      D8TestRunResult runResult, Consumer<ExternalStartupItem> startupItemConsumer) {
+    StartupProfileParser parser = StartupProfileParser.create();
     StringBuilder stdoutBuilder = new StringBuilder();
     String startupDescriptorPrefix = "[" + startupInstrumentationTag + "] ";
     for (String line : StringUtils.splitLines(runResult.getStdOut(), true)) {
@@ -135,8 +155,7 @@
         String message = line.substring(startupDescriptorPrefix.length());
         parser.parseLine(
             message,
-            startupItemConsumer,
-            startupItemConsumer,
+            createStartupItemFactory(startupItemConsumer),
             error -> fail("Unexpected parse error: " + error));
       } else {
         stdoutBuilder.append(line).append(System.lineSeparator());
@@ -146,30 +165,31 @@
   }
 
   public static void setStartupConfiguration(
-      TestCompilerBuilder<?, ?, ?, ?, ?> testBuilder,
-      List<StartupItem<ClassReference, MethodReference, ?>> startupItems) {
+      TestCompilerBuilder<?, ?, ?, ?, ?> testBuilder, List<ExternalStartupItem> startupItems) {
     testBuilder.addOptionsModification(
         options -> {
-          DexItemFactory dexItemFactory = options.dexItemFactory();
-          StartupProfile startupProfile =
-              StartupProfile.builder()
-                  .apply(
-                      builder ->
-                          startupItems.forEach(
-                              startupItem ->
-                                  builder.addStartupItem(
-                                      convertStartupItemToDex(startupItem, dexItemFactory))))
-                  .build();
           StartupProfileProvider startupProfileProvider =
               new StartupProfileProvider() {
                 @Override
-                public String get() {
-                  return startupProfile.serializeToString();
-                }
-
-                @Override
                 public void getStartupProfile(StartupProfileBuilder startupProfileBuilder) {
-                  throw new Unimplemented();
+                  for (ExternalStartupItem startupItem : startupItems) {
+                    startupItem.apply(
+                        startupClass ->
+                            startupProfileBuilder.addStartupClass(
+                                startupClassBuilder ->
+                                    startupClassBuilder.setClassReference(
+                                        startupClass.getReference())),
+                        startupMethod ->
+                            startupProfileBuilder.addStartupMethod(
+                                startupMethodBuilder ->
+                                    startupMethodBuilder.setMethodReference(
+                                        startupMethod.getReference())),
+                        syntheticStartupMethod ->
+                            startupProfileBuilder.addSyntheticStartupMethod(
+                                syntheticStartupMethodBuilder ->
+                                    syntheticStartupMethodBuilder.setSyntheticContextReference(
+                                        syntheticStartupMethod.getSyntheticContextReference())));
+                  }
                 }
 
                 @Override
@@ -177,27 +197,12 @@
                   return Origin.unknown();
                 }
               };
-          options.getStartupOptions().setStartupProfileProvider(startupProfileProvider);
+          options
+              .getStartupOptions()
+              .setStartupProfileProviders(Collections.singleton(startupProfileProvider));
         });
   }
 
-  private static StartupItem<DexType, DexMethod, ?> convertStartupItemToDex(
-      StartupItem<ClassReference, MethodReference, ?> startupItem, DexItemFactory dexItemFactory) {
-    return StartupItem.dexBuilder()
-        .applyIf(
-            startupItem.isStartupClass(),
-            builder ->
-                builder.setClassReference(
-                    ClassReferenceUtils.toDexType(
-                        startupItem.asStartupClass().getReference(), dexItemFactory)),
-            builder ->
-                builder.setMethodReference(
-                    MethodReferenceUtils.toDexMethod(
-                        startupItem.asStartupMethod().getReference(), dexItemFactory)))
-        .setFlags(startupItem.getFlags())
-        .build();
-  }
-
   private static byte[] getTransformedAndroidUtilLog() throws IOException {
     return transformer(Log.class).setClassDescriptor("Landroid/util/Log;").transform();
   }

third_party/binary_compatibility_tests/compiler_api_tests.tar.gz.sha1

diff --git a/third_party/binary_compatibility_tests/compiler_api_tests.tar.gz.sha1 b/third_party/binary_compatibility_tests/compiler_api_tests.tar.gz.sha1
index 040d696..4753c76 100644
--- a/third_party/binary_compatibility_tests/compiler_api_tests.tar.gz.sha1
+++ b/third_party/binary_compatibility_tests/compiler_api_tests.tar.gz.sha1
@@ -1 +1 @@
-98dc48c246bd0855133e138c2cd2b5835cf862cf
\ No newline at end of file
+46ac3bedbdba8732e48d13fcc94967f43ae1d91b
\ No newline at end of file