diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 2717f8a..eb4825c 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -78,6 +78,7 @@
 import com.android.tools.r8.optimize.interfaces.analysis.CfOpenClosedInterfacesAnalysis;
 import com.android.tools.r8.optimize.proto.ProtoNormalizer;
 import com.android.tools.r8.optimize.redundantbridgeremoval.RedundantBridgeRemover;
+import com.android.tools.r8.optimize.singlecaller.SingleCallerInliner;
 import com.android.tools.r8.origin.CommandLineOrigin;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.profile.art.ArtProfileCompletenessChecker;
@@ -769,6 +770,7 @@
               .runIfNecessary(executorService, timing);
           assert appView.dexItemFactory().verifyNoCachedTypeElements();
 
+          new SingleCallerInliner(appViewWithLiveness).runIfNecessary(executorService, timing);
           new ProtoNormalizer(appViewWithLiveness).run(executorService, timing);
         }
       }
diff --git a/src/main/java/com/android/tools/r8/classmerging/ClassMergerGraphLens.java b/src/main/java/com/android/tools/r8/classmerging/ClassMergerGraphLens.java
index 300d399..7408427 100644
--- a/src/main/java/com/android/tools/r8/classmerging/ClassMergerGraphLens.java
+++ b/src/main/java/com/android/tools/r8/classmerging/ClassMergerGraphLens.java
@@ -9,10 +9,8 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.classmerging.MergedClasses;
 import com.android.tools.r8.graph.lens.NestedGraphLens;
-import com.android.tools.r8.ir.conversion.ExtraParameter;
 import com.android.tools.r8.utils.collections.BidirectionalManyToManyRepresentativeMap;
 import com.android.tools.r8.utils.collections.BidirectionalManyToOneRepresentativeMap;
-import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
@@ -30,9 +28,6 @@
   public abstract static class BuilderBase<
       GL extends ClassMergerGraphLens, MC extends MergedClasses> {
 
-    public abstract void addExtraParameters(
-        DexMethod from, DexMethod to, List<? extends ExtraParameter> extraParameters);
-
     public abstract void commitPendingUpdates();
 
     public abstract void fixupField(DexField from, DexField to);
diff --git a/src/main/java/com/android/tools/r8/classmerging/ClassMergerMode.java b/src/main/java/com/android/tools/r8/classmerging/ClassMergerMode.java
index 9c459af..bb9a37b 100644
--- a/src/main/java/com/android/tools/r8/classmerging/ClassMergerMode.java
+++ b/src/main/java/com/android/tools/r8/classmerging/ClassMergerMode.java
@@ -14,17 +14,4 @@
   public boolean isFinal() {
     return this == FINAL;
   }
-
-  public boolean isRestrictedToAlphaRenaming() {
-    return isFinal();
-  }
-
-  // Similar to isRestrictedToAlphaRenaming(), but used on paths that are R8 specific. All usages of
-  // this method should be removed as a result of running a full final round of horizontal class
-  // merging.
-  @Deprecated
-  @SuppressWarnings("InlineMeSuggester")
-  public boolean isRestrictedToAlphaRenamingInR8() {
-    return isRestrictedToAlphaRenaming();
-  }
 }
diff --git a/src/main/java/com/android/tools/r8/classmerging/ClassMergerTreeFixer.java b/src/main/java/com/android/tools/r8/classmerging/ClassMergerTreeFixer.java
index 6f58680..c1e27ad 100644
--- a/src/main/java/com/android/tools/r8/classmerging/ClassMergerTreeFixer.java
+++ b/src/main/java/com/android/tools/r8/classmerging/ClassMergerTreeFixer.java
@@ -3,7 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.classmerging;
 
-import static com.android.tools.r8.ir.conversion.ExtraUnusedParameter.computeExtraUnusedParameters;
+import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
 
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppView;
@@ -18,9 +18,9 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.DexTypeList;
 import com.android.tools.r8.graph.EnclosingMethodAttribute;
+import com.android.tools.r8.graph.ImmediateProgramSubtypingInfo;
 import com.android.tools.r8.graph.classmerging.MergedClasses;
 import com.android.tools.r8.graph.fixup.TreeFixerBase;
-import com.android.tools.r8.horizontalclassmerging.SubtypingForrestForClasses;
 import com.android.tools.r8.shaking.AnnotationFixer;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.ArrayUtils;
@@ -32,8 +32,10 @@
 import com.android.tools.r8.utils.collections.MutableBidirectionalOneToOneMap;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Sets;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.IdentityHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
@@ -46,9 +48,10 @@
         MC extends MergedClasses>
     extends TreeFixerBase {
 
+  private final ClassMergerSharedData classMergerSharedData;
+  private final ImmediateProgramSubtypingInfo immediateSubtypingInfo;
   protected final LB lensBuilder;
   protected final MC mergedClasses;
-  private final ClassMergerSharedData classMergerSharedData;
 
   private final Map<DexProgramClass, DexType> originalSuperTypes = new IdentityHashMap<>();
 
@@ -59,10 +62,12 @@
   public ClassMergerTreeFixer(
       AppView<?> appView,
       ClassMergerSharedData classMergerSharedData,
+      ImmediateProgramSubtypingInfo immediateSubtypingInfo,
       LB lensBuilder,
       MC mergedClasses) {
     super(appView);
     this.classMergerSharedData = classMergerSharedData;
+    this.immediateSubtypingInfo = immediateSubtypingInfo;
     this.lensBuilder = lensBuilder;
     this.mergedClasses = mergedClasses;
   }
@@ -78,12 +83,10 @@
     Iterables.filter(classes, DexProgramClass::isInterface).forEach(this::fixupInterfaceClass);
     classes.forEach(this::fixupAttributes);
     classes.forEach(this::fixupProgramClassSuperTypes);
-    SubtypingForrestForClasses subtypingForrest =
-        new SubtypingForrestForClasses(appView.withClassHierarchy());
+
     // TODO(b/170078037): parallelize this code segment.
-    for (DexProgramClass root : subtypingForrest.getProgramRoots()) {
-      subtypingForrest.traverseNodeDepthFirst(
-          root, new DexMethodSignatureBiMap<>(), this::fixupProgramClass);
+    for (DexProgramClass root : getRoots()) {
+      traverseProgramClassesDepthFirst(root, new DexMethodSignatureBiMap<>());
     }
     postprocess();
     GL lens = lensBuilder.build(appViewWithLiveness, mergedClasses);
@@ -92,6 +95,38 @@
     return lens;
   }
 
+  private List<DexProgramClass> getRoots() {
+    List<DexProgramClass> roots = new ArrayList<>();
+    for (DexProgramClass clazz : appView.appInfo().classes()) {
+      if (!clazz.isInterface() && !mergedClasses.isMergeSource(clazz.getType())) {
+        DexProgramClass superClass =
+            asProgramClassOrNull(appView.definitionFor(clazz.getSuperType(), clazz));
+        if (superClass == null) {
+          roots.add(clazz);
+        }
+      }
+    }
+    return roots;
+  }
+
+  private void traverseProgramClassesDepthFirst(
+      DexProgramClass clazz, DexMethodSignatureBiMap<DexMethodSignature> state) {
+    DexMethodSignatureBiMap<DexMethodSignature> newState = fixupProgramClass(clazz, state);
+    for (DexProgramClass subclass : immediateSubtypingInfo.getSubclasses(clazz)) {
+      traverseProgramClassesDepthFirst(subclass, newState);
+    }
+    if (mergedClasses.isMergeTarget(clazz.getType())) {
+      for (DexType sourceType : mergedClasses.getSourcesFor(clazz.getType())) {
+        DexProgramClass sourceClass = appView.definitionFor(sourceType).asProgramClass();
+        for (DexProgramClass subclass : immediateSubtypingInfo.getSubclasses(sourceClass)) {
+          if (subclass != clazz) {
+            traverseProgramClassesDepthFirst(subclass, newState);
+          }
+        }
+      }
+    }
+  }
+
   public void preprocess() {
     // Intentionally empty.
   }
@@ -289,10 +324,6 @@
                     newMethodReference,
                     classMergerSharedData.getExtraUnusedArgumentTypes(),
                     tryMethod -> !newMethodSignatures.containsValue(tryMethod.getSignature()));
-            lensBuilder.addExtraParameters(
-                originalMethodReference,
-                newMethodReference,
-                computeExtraUnusedParameters(originalMethodReference, newMethodReference));
           } else {
             newMethodReference =
                 dexItemFactory.createFreshMethodNameWithoutHolder(
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
index 5d0b33c..9618cd6 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
@@ -242,7 +242,6 @@
 
   void appendClassIdField() {
     assert appView.hasLiveness();
-    assert !mode.isRestrictedToAlphaRenamingInR8();
 
     DexEncodedField classIdField =
         DexEncodedField.syntheticBuilder()
@@ -373,11 +372,14 @@
   }
 
   public static class Builder {
+
     private final AppView<?> appView;
     private final IRCodeProvider codeProvider;
     private final ClassMergerMode mode;
     private final HorizontalMergeGroup group;
 
+    private List<VirtualMethodMerger> virtualMethodMergers;
+
     public Builder(
         AppView<?> appView,
         IRCodeProvider codeProvider,
@@ -389,19 +391,19 @@
       this.mode = mode;
     }
 
-    @SuppressWarnings("MixedMutabilityReturnType")
-    private List<VirtualMethodMerger> createVirtualMethodMergers() {
+    public Builder initializeVirtualMethodMergers() {
       if (!appView.hasClassHierarchy()) {
         assert getVirtualMethodMergerBuilders().isEmpty();
-        return Collections.emptyList();
+        virtualMethodMergers = Collections.emptyList();
+        return this;
       }
       Map<DexMethodSignature, VirtualMethodMerger.Builder> virtualMethodMergerBuilders =
           getVirtualMethodMergerBuilders();
       if (virtualMethodMergerBuilders.isEmpty()) {
-        return Collections.emptyList();
+        virtualMethodMergers = Collections.emptyList();
+        return this;
       }
-      List<VirtualMethodMerger> virtualMethodMergers =
-          new ArrayList<>(virtualMethodMergerBuilders.size());
+      virtualMethodMergers = new ArrayList<>(virtualMethodMergerBuilders.size());
       List<VirtualMethodMerger> nonNopOrTrivialVirtualMethodMergers =
           new ArrayList<>(virtualMethodMergerBuilders.size());
       for (VirtualMethodMerger.Builder builder : virtualMethodMergerBuilders.values()) {
@@ -418,7 +420,7 @@
       // first, then the non trivial mergers are processed and correctly deal with conflicting
       // signatures.
       assert verifyNopOrTrivialAreFirst(virtualMethodMergers);
-      return virtualMethodMergers;
+      return this;
     }
 
     private boolean verifyNopOrTrivialAreFirst(List<VirtualMethodMerger> virtualMethodMergers) {
@@ -450,6 +452,16 @@
       return virtualMethodMergerBuilders;
     }
 
+    public void initializeClassIdField() {
+      boolean requiresClassIdField =
+          virtualMethodMergers.stream()
+              .anyMatch(virtualMethodMerger -> !virtualMethodMerger.isNopOrTrivial());
+      if (requiresClassIdField) {
+        assert appView.enableWholeProgramOptimizations();
+        createClassIdField();
+      }
+    }
+
     private void createClassIdField() {
       DexField field =
           appView
@@ -467,16 +479,6 @@
 
     public ClassMerger build(
         HorizontalClassMergerGraphLens.Builder lensBuilder) {
-      List<VirtualMethodMerger> virtualMethodMergers = createVirtualMethodMergers();
-
-      boolean requiresClassIdField =
-          virtualMethodMergers.stream()
-              .anyMatch(virtualMethodMerger -> !virtualMethodMerger.isNopOrTrivial());
-      if (requiresClassIdField) {
-        assert !mode.isRestrictedToAlphaRenaming();
-        createClassIdField();
-      }
-
       return new ClassMerger(appView, codeProvider, mode, lensBuilder, group, virtualMethodMergers);
     }
   }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
index 18f1d1a..849e67a 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
@@ -16,6 +16,7 @@
 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.ImmediateProgramSubtypingInfo;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.PrunedItems;
 import com.android.tools.r8.horizontalclassmerging.code.SyntheticInitializerConverter;
@@ -116,8 +117,7 @@
       Timing timing)
       throws ExecutionException {
     // Run the policies on all program classes to produce a final grouping.
-    List<Policy> policies =
-        PolicyScheduler.getPolicies(appView, codeProvider, mode, runtimeTypeCheckInfo);
+    List<Policy> policies = PolicyScheduler.getPolicies(appView, mode, runtimeTypeCheckInfo);
     Collection<HorizontalMergeGroup> groups =
         new HorizontalClassMergerPolicyExecutor()
             .run(getInitialGroups(), policies, executorService, timing);
@@ -128,12 +128,26 @@
       return;
     }
 
+    ClassMergerSharedData classMergerSharedData = new ClassMergerSharedData(appView);
     HorizontalClassMergerGraphLens.Builder lensBuilder =
         new HorizontalClassMergerGraphLens.Builder();
 
-    // Merge the classes.
-    List<ClassMerger> classMergers = initializeClassMergers(codeProvider, lensBuilder, groups);
-    ClassMergerSharedData classMergerSharedData = new ClassMergerSharedData(appView);
+    // Determine which classes need a class id field.
+    List<ClassMerger.Builder> classMergerBuilders = createClassMergerBuilders(codeProvider, groups);
+    initializeClassIdFields(classMergerBuilders);
+
+    // Ensure that all allocations of classes that end up needing a class id use a constructor on
+    // the class itself.
+    ImmediateProgramSubtypingInfo immediateSubtypingInfo =
+        appView.enableWholeProgramOptimizations()
+            ? ImmediateProgramSubtypingInfo.createWithDeterministicOrder(
+                appView.withClassHierarchy())
+            : null;
+    new UndoConstructorInlining(appView, classMergerSharedData, immediateSubtypingInfo)
+        .runIfNecessary(groups, mode, executorService, timing);
+
+    // Merge classes.
+    List<ClassMerger> classMergers = createClassMergers(classMergerBuilders, lensBuilder);
     ProfileCollectionAdditions profileCollectionAdditions =
         ProfileCollectionAdditions.create(appView);
     SyntheticInitializerConverter.Builder syntheticInitializerConverterBuilder =
@@ -158,7 +172,13 @@
     appView.setHorizontallyMergedClasses(mergedClasses, mode);
 
     HorizontalClassMergerGraphLens horizontalClassMergerGraphLens =
-        createLens(classMergerSharedData, mergedClasses, lensBuilder, executorService, timing);
+        createLens(
+            classMergerSharedData,
+            immediateSubtypingInfo,
+            mergedClasses,
+            lensBuilder,
+            executorService,
+            timing);
     profileCollectionAdditions =
         profileCollectionAdditions.rewriteMethodReferences(
             horizontalClassMergerGraphLens::getNextMethodToInvoke);
@@ -166,10 +186,10 @@
     assert verifyNoCyclesInInterfaceHierarchies(appView, groups);
 
     FieldAccessInfoCollectionModifier fieldAccessInfoCollectionModifier = null;
-    if (mode.isRestrictedToAlphaRenaming()) {
-      assert groups.stream().noneMatch(HorizontalMergeGroup::hasClassIdField);
-    } else {
+    if (appView.enableWholeProgramOptimizations()) {
       fieldAccessInfoCollectionModifier = createFieldAccessInfoCollectionModifier(groups);
+    } else {
+      assert groups.stream().noneMatch(HorizontalMergeGroup::hasClassIdField);
     }
 
     // Set the new graph lens before finalizing any synthetic code.
@@ -381,21 +401,34 @@
     return initialGroups;
   }
 
-  /**
-   * Prepare horizontal class merging by determining which virtual methods and constructors need to
-   * be merged and how the merging should be performed.
-   */
-  private List<ClassMerger> initializeClassMergers(
-      IRCodeProvider codeProvider,
-      HorizontalClassMergerGraphLens.Builder lensBuilder,
-      Collection<HorizontalMergeGroup> groups) {
-    List<ClassMerger> classMergers = new ArrayList<>(groups.size());
+  private List<ClassMerger.Builder> createClassMergerBuilders(
+      IRCodeProvider codeProvider, Collection<HorizontalMergeGroup> groups) {
+    List<ClassMerger.Builder> classMergerBuilders = new ArrayList<>(groups.size());
     for (HorizontalMergeGroup group : groups) {
       assert group.isNonTrivial();
       assert group.hasInstanceFieldMap();
       assert group.hasTarget();
-      classMergers.add(
-          new ClassMerger.Builder(appView, codeProvider, group, mode).build(lensBuilder));
+      classMergerBuilders.add(new ClassMerger.Builder(appView, codeProvider, group, mode));
+    }
+    return classMergerBuilders;
+  }
+
+  private void initializeClassIdFields(List<ClassMerger.Builder> classMergerBuilders) {
+    for (ClassMerger.Builder classMergerBuilder : classMergerBuilders) {
+      classMergerBuilder.initializeVirtualMethodMergers().initializeClassIdField();
+    }
+  }
+
+  /**
+   * Prepare horizontal class merging by determining which virtual methods and constructors need to
+   * be merged and how the merging should be performed.
+   */
+  private List<ClassMerger> createClassMergers(
+      List<ClassMerger.Builder> classMergerBuilders,
+      HorizontalClassMergerGraphLens.Builder lensBuilder) {
+    List<ClassMerger> classMergers = new ArrayList<>(classMergerBuilders.size());
+    for (ClassMerger.Builder classMergerBuilder : classMergerBuilders) {
+      classMergers.add(classMergerBuilder.build(lensBuilder));
     }
     appView.dexItemFactory().clearTypeElementsCache();
     return classMergers;
@@ -427,13 +460,14 @@
    */
   private HorizontalClassMergerGraphLens createLens(
       ClassMergerSharedData classMergerSharedData,
+      ImmediateProgramSubtypingInfo immediateSubtypingInfo,
       HorizontallyMergedClasses mergedClasses,
       HorizontalClassMergerGraphLens.Builder lensBuilder,
       ExecutorService executorService,
       Timing timing)
       throws ExecutionException {
     return new HorizontalClassMergerTreeFixer(
-            appView, classMergerSharedData, mergedClasses, lensBuilder)
+            appView, classMergerSharedData, immediateSubtypingInfo, mergedClasses, lensBuilder)
         .run(executorService, timing);
   }
 
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java
index 81d95ee..17bfc2b 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java
@@ -4,6 +4,8 @@
 
 package com.android.tools.r8.horizontalclassmerging;
 
+import static com.android.tools.r8.ir.conversion.ExtraUnusedParameter.computeExtraUnusedParameters;
+
 import com.android.tools.r8.classmerging.ClassMergerGraphLens;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexEncodedMember;
@@ -15,7 +17,9 @@
 import com.android.tools.r8.graph.lens.FieldLookupResult;
 import com.android.tools.r8.graph.lens.GraphLens;
 import com.android.tools.r8.graph.lens.MethodLookupResult;
+import com.android.tools.r8.graph.proto.RewrittenPrototypeDescription;
 import com.android.tools.r8.ir.code.InvokeType;
+import com.android.tools.r8.ir.conversion.ExtraConstantIntParameter;
 import com.android.tools.r8.ir.conversion.ExtraParameter;
 import com.android.tools.r8.utils.IterableUtils;
 import com.android.tools.r8.utils.collections.BidirectionalManyToOneHashMap;
@@ -26,7 +30,6 @@
 import com.android.tools.r8.utils.collections.MutableBidirectionalManyToOneRepresentativeMap;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Streams;
-import java.util.ArrayList;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
@@ -34,13 +37,13 @@
 
 public class HorizontalClassMergerGraphLens extends ClassMergerGraphLens {
 
-  private final Map<DexMethod, List<ExtraParameter>> methodExtraParameters;
+  private final Map<DexMethod, ExtraConstantIntParameter> methodExtraParameters;
   private final HorizontallyMergedClasses mergedClasses;
 
   private HorizontalClassMergerGraphLens(
       AppView<?> appView,
       HorizontallyMergedClasses mergedClasses,
-      Map<DexMethod, List<ExtraParameter>> methodExtraParameters,
+      Map<DexMethod, ExtraConstantIntParameter> methodExtraParameters,
       BidirectionalManyToOneRepresentativeMap<DexField, DexField> fieldMap,
       BidirectionalManyToOneMap<DexMethod, DexMethod> methodMap,
       BidirectionalManyToOneRepresentativeMap<DexMethod, DexMethod> newMethodSignatures) {
@@ -116,18 +119,7 @@
       return super.internalDescribeLookupMethod(previous, context, codeLens);
     }
     assert previous.hasReboundReference();
-    List<ExtraParameter> extraParameters =
-        methodExtraParameters.get(previous.getReboundReference());
-    MethodLookupResult lookup = super.internalDescribeLookupMethod(previous, context, codeLens);
-    if (extraParameters == null) {
-      return lookup;
-    }
-    return MethodLookupResult.builder(this, codeLens)
-        .setReboundReference(lookup.getReboundReference())
-        .setReference(lookup.getReference())
-        .setPrototypeChanges(lookup.getPrototypeChanges().withExtraParameters(extraParameters))
-        .setType(lookup.getType())
-        .build();
+    return super.internalDescribeLookupMethod(previous, context, codeLens);
   }
 
   @Override
@@ -147,6 +139,47 @@
         .build();
   }
 
+  @Override
+  protected RewrittenPrototypeDescription internalDescribePrototypeChanges(
+      RewrittenPrototypeDescription prototypeChanges,
+      DexMethod previousMethod,
+      DexMethod newMethod) {
+    if (newMethod.getArity() > previousMethod.getArity()) {
+      assert dexItemFactory().isConstructor(previousMethod);
+      RewrittenPrototypeDescription collisionResolution =
+          RewrittenPrototypeDescription.createForExtraParameters(
+              computeExtraUnusedParameters(previousMethod, newMethod));
+      ExtraConstantIntParameter extraParameter = methodExtraParameters.get(previousMethod);
+      if (extraParameter != null) {
+        List<ExtraParameter> extraParameters =
+            (List<ExtraParameter>) collisionResolution.getExtraParameters();
+        extraParameters.set(0, extraParameter);
+      }
+      return prototypeChanges.combine(collisionResolution);
+    }
+    assert newMethod.getArity() == previousMethod.getArity();
+    return prototypeChanges;
+  }
+
+  @Override
+  public RewrittenPrototypeDescription lookupPrototypeChangesForMethodDefinition(
+      DexMethod newMethod, GraphLens codeLens) {
+    if (this == codeLens) {
+      return getIdentityLens().lookupPrototypeChangesForMethodDefinition(newMethod, codeLens);
+    }
+    DexMethod previousMethod = getPreviousMethodSignature(newMethod);
+    RewrittenPrototypeDescription lookup =
+        getPrevious().lookupPrototypeChangesForMethodDefinition(previousMethod, codeLens);
+    if (newMethod.getArity() > previousMethod.getArity()) {
+      assert dexItemFactory().isConstructor(previousMethod);
+      RewrittenPrototypeDescription collisionResolution =
+          RewrittenPrototypeDescription.createForExtraParameters(
+              computeExtraUnusedParameters(previousMethod, newMethod));
+      return lookup.combine(collisionResolution);
+    }
+    return lookup;
+  }
+
   public static class Builder
       extends BuilderBase<HorizontalClassMergerGraphLens, HorizontallyMergedClasses> {
 
@@ -156,7 +189,7 @@
         BidirectionalManyToOneHashMap.newIdentityHashMap();
     private final MutableBidirectionalManyToOneRepresentativeMap<DexMethod, DexMethod>
         newMethodSignatures = BidirectionalManyToOneRepresentativeHashMap.newIdentityHashMap();
-    private final Map<DexMethod, List<ExtraParameter>> methodExtraParameters =
+    private final Map<DexMethod, ExtraConstantIntParameter> methodExtraParameters =
         new IdentityHashMap<>();
 
     private final MutableBidirectionalManyToOneMap<DexMethod, DexMethod> pendingMethodMapUpdates =
@@ -329,28 +362,11 @@
      * where many constructors are merged into a single constructor. The synthesized constructor
      * therefore does not have a unique reverse constructor.
      */
-    void mapMergedConstructor(DexMethod from, DexMethod to, List<ExtraParameter> extraParameters) {
+    void mapMergedConstructor(
+        DexMethod from, DexMethod to, ExtraConstantIntParameter extraParameter) {
       mapMethod(from, to);
-      if (!extraParameters.isEmpty()) {
-        methodExtraParameters.put(from, extraParameters);
-      }
-    }
-
-    @Override
-    public void addExtraParameters(
-        DexMethod from, DexMethod to, List<? extends ExtraParameter> extraParameters) {
-      Set<DexMethod> originalMethodSignatures = methodMap.getKeys(from);
-      if (originalMethodSignatures.isEmpty()) {
-        methodExtraParameters
-            .computeIfAbsent(from, ignore -> new ArrayList<>(extraParameters.size()))
-            .addAll(extraParameters);
-      } else {
-        for (DexMethod originalMethodSignature : originalMethodSignatures) {
-          methodExtraParameters
-              .computeIfAbsent(
-                  originalMethodSignature, ignore -> new ArrayList<>(extraParameters.size()))
-              .addAll(extraParameters);
-        }
+      if (extraParameter != null) {
+        methodExtraParameters.put(from, extraParameter);
       }
     }
   }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerTreeFixer.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerTreeFixer.java
index b1859ae..794ca05 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerTreeFixer.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerTreeFixer.java
@@ -7,6 +7,7 @@
 import com.android.tools.r8.classmerging.ClassMergerSharedData;
 import com.android.tools.r8.classmerging.ClassMergerTreeFixer;
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.ImmediateProgramSubtypingInfo;
 import com.android.tools.r8.utils.Timing;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
@@ -25,9 +26,10 @@
   public HorizontalClassMergerTreeFixer(
       AppView<?> appView,
       ClassMergerSharedData classMergerSharedData,
+      ImmediateProgramSubtypingInfo immediateSubtypingInfo,
       HorizontallyMergedClasses mergedClasses,
       HorizontalClassMergerGraphLens.Builder lensBuilder) {
-    super(appView, classMergerSharedData, lensBuilder, mergedClasses);
+    super(appView, classMergerSharedData, immediateSubtypingInfo, lensBuilder, mergedClasses);
   }
 
   /**
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/IncompleteVirtuallyMergedMethodCode.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/IncompleteVirtuallyMergedMethodCode.java
index 05088a9..75deda3 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/IncompleteVirtuallyMergedMethodCode.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/IncompleteVirtuallyMergedMethodCode.java
@@ -4,6 +4,8 @@
 
 package com.android.tools.r8.horizontalclassmerging;
 
+import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
+
 import com.android.tools.r8.cf.code.CfFrame;
 import com.android.tools.r8.cf.code.CfInstanceFieldRead;
 import com.android.tools.r8.cf.code.CfInstruction;
@@ -15,7 +17,6 @@
 import com.android.tools.r8.cf.code.CfSwitch;
 import com.android.tools.r8.cf.code.CfSwitch.Kind;
 import com.android.tools.r8.cf.code.frame.FrameType;
-import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.CfCode;
@@ -24,9 +25,16 @@
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.lens.GraphLens;
 import com.android.tools.r8.horizontalclassmerging.VirtualMethodMerger.SuperMethodReference;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.code.IRMetadata;
+import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.code.ValueType;
+import com.android.tools.r8.lightir.LirBuilder;
 import com.android.tools.r8.lightir.LirCode;
+import com.android.tools.r8.lightir.LirEncodingStrategy;
+import com.android.tools.r8.lightir.LirStrategy;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.IterableUtils;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceSortedMap;
@@ -164,7 +172,117 @@
       AppView<? extends AppInfoWithClassHierarchy> appView,
       ProgramMethod method,
       HorizontalClassMergerGraphLens lens) {
-    throw new Unreachable();
+    LirEncodingStrategy<Value, Integer> strategy =
+        LirStrategy.getDefaultStrategy().getEncodingStrategy();
+    LirBuilder<Value, Integer> lirBuilder =
+        LirCode.builder(
+                method.getReference(),
+                method.getDefinition().isD8R8Synthesized(),
+                strategy,
+                appView.options())
+            .setMetadata(IRMetadata.unknown());
+
+    int instructionIndex = 0;
+    List<Value> argumentValues = new ArrayList<>();
+    TypeElement returnType =
+        method.getReturnType().isVoidType() ? null : method.getReturnType().toTypeElement(appView);
+
+    // Add receiver argument.
+    DexType receiverType = method.getHolderType();
+    TypeElement receiverTypeElement = receiverType.toTypeElement(appView, definitelyNotNull());
+    Value receiverValue = Value.createNoDebugLocal(instructionIndex, receiverTypeElement);
+    argumentValues.add(receiverValue);
+    strategy.defineValue(receiverValue, receiverValue.getNumber());
+    lirBuilder.addArgument(receiverValue.getNumber(), false);
+    instructionIndex++;
+
+    // Add non-receiver arguments.
+    for (; instructionIndex < method.getDefinition().getNumberOfArguments(); instructionIndex++) {
+      DexType argumentType = method.getArgumentType(instructionIndex);
+      TypeElement argumentTypeElement = argumentType.toTypeElement(appView);
+      Value argumentValue = Value.createNoDebugLocal(instructionIndex, argumentTypeElement);
+      argumentValues.add(argumentValue);
+      strategy.defineValue(argumentValue, argumentValue.getNumber());
+      lirBuilder.addArgument(argumentValue.getNumber(), argumentType.isBooleanType());
+    }
+
+    // Read class id field from receiver.
+    TypeElement classIdValueType = TypeElement.getInt();
+    Value classIdValue = Value.createNoDebugLocal(instructionIndex, classIdValueType);
+    strategy.defineValue(classIdValue, classIdValue.getNumber());
+    lirBuilder.addInstanceGet(classIdField, receiverValue);
+    instructionIndex++;
+
+    // Emit switch.
+    IntBidirectionalIterator classIdIterator = mappedMethods.keySet().iterator();
+    int[] keys = new int[mappedMethods.size() - BooleanUtils.intValue(superMethod == null)];
+    int[] targets = new int[keys.length];
+    int nextTarget = instructionIndex - argumentValues.size() + 3;
+    for (int i = 0; i < keys.length; i++) {
+      keys[i] = classIdIterator.nextInt();
+      targets[i] = nextTarget;
+      nextTarget += 2;
+    }
+    lirBuilder.addIntSwitch(classIdValue, keys, targets);
+    instructionIndex++;
+
+    // Emit switch fallthrough.
+    if (superMethod == null) {
+      DexMethod fallthroughTarget =
+          lens.getNextMethodSignature(mappedMethods.get(mappedMethods.lastIntKey()));
+      if (method.getHolder().isInterface()) {
+        lirBuilder.addInvokeInterface(fallthroughTarget, argumentValues);
+      } else {
+        lirBuilder.addInvokeVirtual(fallthroughTarget, argumentValues);
+      }
+    } else {
+      DexMethod reboundFallthroughTarget =
+          lens.lookupInvokeSuper(superMethod.getReboundReference(), method).getReference();
+      DexMethod fallthroughTarget =
+          reboundFallthroughTarget.withHolder(
+              lens.getNextClassType(superMethod.getReference().getHolderType()),
+              appView.dexItemFactory());
+      lirBuilder.addInvokeSuper(fallthroughTarget, argumentValues, false);
+    }
+    if (method.getReturnType().isVoidType()) {
+      lirBuilder.addReturnVoid();
+    } else {
+      Value returnValue = Value.createNoDebugLocal(instructionIndex, returnType);
+      strategy.defineValue(returnValue, returnValue.getNumber());
+      lirBuilder.addReturn(returnValue);
+    }
+    instructionIndex += 2;
+
+    // Emit switch cases.
+    for (int classId : keys) {
+      DexMethod target = lens.getNextMethodSignature(mappedMethods.get(classId));
+      if (method.getHolder().isInterface()) {
+        lirBuilder.addInvokeInterface(target, argumentValues);
+      } else {
+        lirBuilder.addInvokeVirtual(target, argumentValues);
+      }
+      if (method.getReturnType().isVoidType()) {
+        lirBuilder.addReturnVoid();
+      } else {
+        Value returnValue = Value.createNoDebugLocal(instructionIndex, returnType);
+        strategy.defineValue(returnValue, returnValue.getNumber());
+        lirBuilder.addReturn(returnValue);
+      }
+      instructionIndex += 2;
+    }
+
+    return new LirCode<>(lirBuilder.build()) {
+
+      @Override
+      public boolean hasExplicitCodeLens() {
+        return true;
+      }
+
+      @Override
+      public GraphLens getCodeLens(AppView<?> appView) {
+        return lens;
+      }
+    };
   }
 
   private static CfFrame createCfFrameForSwitchCase(ProgramMethod representative, int localsSize) {
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerAnalysis.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerAnalysis.java
index f49af82..96aeb10 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerAnalysis.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerAnalysis.java
@@ -150,7 +150,10 @@
 
               // TODO(b/189296638): Consider allowing constructor forwarding.
               if (!lensRewrittenInvokedMethod.isInstanceInitializer(appView.dexItemFactory())
-                  || lensRewrittenInvokedMethod.getHolderType() != group.getSuperType()) {
+                  || !appView
+                      .appInfo()
+                      .isSubtype(
+                          group.getSuperType(), lensRewrittenInvokedMethod.getHolderType())) {
                 return invalid();
               }
 
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerDescription.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerDescription.java
index dc5f15e..a543580 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerDescription.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerDescription.java
@@ -72,7 +72,7 @@
    *
    * @param originalMethodReference the original reference of the representative method
    */
-  public IncompleteMergedInstanceInitializerCode createCfCode(
+  public IncompleteMergedInstanceInitializerCode createCode(
       DexMethod originalMethodReference,
       HorizontalMergeGroup group,
       boolean hasClassId,
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMerger.java
index 2a87bb4..7f25de0 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMerger.java
@@ -22,7 +22,6 @@
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.horizontalclassmerging.code.ConstructorEntryPointSynthesizedCode;
 import com.android.tools.r8.ir.conversion.ExtraConstantIntParameter;
-import com.android.tools.r8.ir.conversion.ExtraParameter;
 import com.android.tools.r8.ir.conversion.ExtraUnusedParameter;
 import com.android.tools.r8.profile.rewriting.ProfileCollectionAdditions;
 import com.android.tools.r8.utils.ArrayUtils;
@@ -30,7 +29,6 @@
 import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.SetUtils;
 import com.android.tools.r8.utils.structural.Ordered;
-import com.google.common.collect.ImmutableList;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceAVLTreeMap;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceSortedMap;
 import it.unimi.dsi.fastutil.objects.Reference2IntMap;
@@ -275,11 +273,8 @@
       boolean needsClassId,
       int extraNulls) {
     if (hasInstanceInitializerDescription()) {
-      return instanceInitializerDescription.createCfCode(
-          getOriginalMethodReference(),
-          group,
-          needsClassId,
-          extraNulls);
+      return instanceInitializerDescription.createCode(
+          getOriginalMethodReference(), group, needsClassId, extraNulls);
     }
     assert useSyntheticMethod();
     return new ConstructorEntryPointSynthesizedCode(
@@ -305,28 +300,19 @@
     boolean needsClassId =
         instanceInitializers.size() > 1
             && (!hasInstanceInitializerDescription() || group.hasClassIdField());
-    assert !mode.isRestrictedToAlphaRenamingInR8() || !needsClassId;
 
     DexMethod newMethodReferenceTemplate = getNewMethodReference(representative, needsClassId);
-    assert !mode.isRestrictedToAlphaRenamingInR8()
-        || classMethodsBuilder.isFresh(newMethodReferenceTemplate);
 
     DexMethod newMethodReference =
         dexItemFactory.createInstanceInitializerWithFreshProto(
             newMethodReferenceTemplate,
-            mode.isRestrictedToAlphaRenamingInR8()
-                ? ImmutableList.of()
-                : classMergerSharedData.getExtraUnusedArgumentTypes(),
+            classMergerSharedData.getExtraUnusedArgumentTypes(),
             classMethodsBuilder::isFresh);
 
     // Compute the extra unused null parameters.
     List<ExtraUnusedParameter> extraUnusedParameters =
         computeExtraUnusedParameters(newMethodReferenceTemplate, newMethodReference);
 
-    // Verify that the merge is a simple renaming in the final round of merging.
-    assert !mode.isRestrictedToAlphaRenamingInR8()
-        || newMethodReference == newMethodReferenceTemplate;
-
     // Move instance initializers to target class.
     if (hasInstanceInitializerDescription()) {
       lensBuilder.moveMethods(instanceInitializers, newMethodReference);
@@ -360,14 +346,13 @@
 
     // Map each of the instance initializers to the new instance initializer in the graph lens.
     for (ProgramMethod instanceInitializer : instanceInitializers) {
-      List<ExtraParameter> extraParameters = new ArrayList<>();
-      if (needsClassId) {
-        int classIdentifier = classIdentifiers.getInt(instanceInitializer.getHolderType());
-        extraParameters.add(new ExtraConstantIntParameter(classIdentifier));
-      }
-      extraParameters.addAll(extraUnusedParameters);
+      ExtraConstantIntParameter extraParameter =
+          needsClassId
+              ? new ExtraConstantIntParameter(
+                  classIdentifiers.getInt(instanceInitializer.getHolderType()))
+              : null;
       lensBuilder.mapMergedConstructor(
-          instanceInitializer.getReference(), newMethodReference, extraParameters);
+          instanceInitializer.getReference(), newMethodReference, extraParameter);
     }
 
     DexEncodedMethod representativeMethod = representative.getDefinition();
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyScheduler.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyScheduler.java
index 5ea7df7..75cc55c 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyScheduler.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyScheduler.java
@@ -23,7 +23,6 @@
 import com.android.tools.r8.horizontalclassmerging.policies.NoClassAnnotationCollisions;
 import com.android.tools.r8.horizontalclassmerging.policies.NoClassInitializerCycles;
 import com.android.tools.r8.horizontalclassmerging.policies.NoClassInitializerWithObservableSideEffects;
-import com.android.tools.r8.horizontalclassmerging.policies.NoConstructorCollisions;
 import com.android.tools.r8.horizontalclassmerging.policies.NoDeadEnumLiteMaps;
 import com.android.tools.r8.horizontalclassmerging.policies.NoDeadLocks;
 import com.android.tools.r8.horizontalclassmerging.policies.NoDefaultInterfaceMethodCollisions;
@@ -35,7 +34,6 @@
 import com.android.tools.r8.horizontalclassmerging.policies.NoIndirectRuntimeTypeChecks;
 import com.android.tools.r8.horizontalclassmerging.policies.NoInnerClasses;
 import com.android.tools.r8.horizontalclassmerging.policies.NoInstanceFieldAnnotations;
-import com.android.tools.r8.horizontalclassmerging.policies.NoInstanceInitializerMerging;
 import com.android.tools.r8.horizontalclassmerging.policies.NoInterfaces;
 import com.android.tools.r8.horizontalclassmerging.policies.NoKeepRules;
 import com.android.tools.r8.horizontalclassmerging.policies.NoKotlinMetadata;
@@ -44,7 +42,6 @@
 import com.android.tools.r8.horizontalclassmerging.policies.NoResourceClasses;
 import com.android.tools.r8.horizontalclassmerging.policies.NoServiceLoaders;
 import com.android.tools.r8.horizontalclassmerging.policies.NoVerticallyMergedClasses;
-import com.android.tools.r8.horizontalclassmerging.policies.NoVirtualMethodMerging;
 import com.android.tools.r8.horizontalclassmerging.policies.NoWeakerAccessPrivileges;
 import com.android.tools.r8.horizontalclassmerging.policies.NotMatchedByNoHorizontalClassMerging;
 import com.android.tools.r8.horizontalclassmerging.policies.NotTwoInitsWithMonitors;
@@ -74,12 +71,10 @@
 
   public static List<Policy> getPolicies(
       AppView<?> appView,
-      IRCodeProvider codeProvider,
       ClassMergerMode mode,
       RuntimeTypeCheckInfo runtimeTypeCheckInfo) {
     if (appView.hasClassHierarchy()) {
-      return getPoliciesForR8(
-          appView.withClassHierarchy(), codeProvider, mode, runtimeTypeCheckInfo);
+      return getPoliciesForR8(appView.withClassHierarchy(), mode, runtimeTypeCheckInfo);
     } else {
       return getPoliciesForD8(appView.withoutClassHierarchy(), mode);
     }
@@ -99,13 +94,12 @@
 
   private static List<Policy> getPoliciesForR8(
       AppView<? extends AppInfoWithClassHierarchy> appView,
-      IRCodeProvider codeProvider,
       ClassMergerMode mode,
       RuntimeTypeCheckInfo runtimeTypeCheckInfo) {
     List<Policy> policies =
         ImmutableList.<Policy>builder()
             .addAll(getSingleClassPolicies(appView, mode, runtimeTypeCheckInfo))
-            .addAll(getMultiClassPolicies(appView, codeProvider, mode, runtimeTypeCheckInfo))
+            .addAll(getMultiClassPolicies(appView, mode, runtimeTypeCheckInfo))
             .build();
     policies = appView.options().testing.horizontalClassMergingPolicyRewriter.apply(policies);
     assert verifyPolicyOrderingConstraints(policies);
@@ -221,44 +215,24 @@
 
   private static List<Policy> getMultiClassPolicies(
       AppView<? extends AppInfoWithClassHierarchy> appView,
-      IRCodeProvider codeProvider,
       ClassMergerMode mode,
       RuntimeTypeCheckInfo runtimeTypeCheckInfo) {
     ImmutableList.Builder<Policy> builder = ImmutableList.builder();
-
     addRequiredMultiClassPolicies(appView, mode, runtimeTypeCheckInfo, builder);
-
     if (!appView.options().horizontalClassMergerOptions().isRestrictedToSynthetics()) {
       AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
       addMultiClassPoliciesForMergingNonSyntheticClasses(appViewWithLiveness, builder);
     }
-
-    if (mode.isRestrictedToAlphaRenamingInR8()) {
-      builder.add(
-          new NoVirtualMethodMerging(appView, mode), new NoConstructorCollisions(appView, mode));
-    } else {
-      AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
-      if (mode.isInitial()) {
-        builder.add(new AllInstantiatedOrUninstantiated(appViewWithLiveness, mode));
-      }
-      builder.add(
-          new PreserveMethodCharacteristics(appViewWithLiveness, mode),
-          new MinimizeInstanceFieldCasts());
+    if (mode.isInitial()) {
+      assert appView.hasLiveness();
+      builder.add(new AllInstantiatedOrUninstantiated(appView.withLiveness()));
     }
-
+    if (appView.hasLiveness()) {
+      builder.add(new PreserveMethodCharacteristics(appView.withLiveness(), mode));
+    }
+    builder.add(new MinimizeInstanceFieldCasts());
     addMultiClassPoliciesForInterfaceMerging(appView, mode, builder);
-
-    builder.add(new LimitClassGroups(appView));
-
-    if (mode.isRestrictedToAlphaRenamingInR8()) {
-      // This needs to reason about equivalence of instance initializers, which relies on the
-      // mapping from instance fields on source classes to the instance fields on target classes.
-      // This policy therefore selects a target for each merge group and creates the mapping for
-      // instance fields. For this reason we run this policy in the very end.
-      builder.add(new NoInstanceInitializerMerging(appView, codeProvider, mode));
-    }
-
-    return builder.add(new FinalizeMergeGroup(appView, mode)).build();
+    return builder.add(new LimitClassGroups(appView), new FinalizeMergeGroup(appView)).build();
   }
 
   private static List<? extends Policy> getMultiClassPoliciesForD8(
@@ -275,7 +249,7 @@
         new NoDifferentApiReferenceLevel(appView),
         new LimitClassGroups(appView));
     assert verifyMultiClassPoliciesIrrelevantForMergingSyntheticsInD8(appView, mode, builder);
-    builder.add(new FinalizeMergeGroup(appView, mode));
+    builder.add(new FinalizeMergeGroup(appView));
     return builder.build();
   }
 
@@ -292,12 +266,12 @@
         new NoClassAnnotationCollisions(),
         new SameFeatureSplit(appView),
         new SameStartupPartition(appView),
-        new SameInstanceFields(appView, mode),
+        new SameInstanceFields(appView),
         new SameMainDexGroup(appView),
         new SameNestHost(appView),
         new SameParentClass(),
         new SyntheticItemsPolicy(appView, mode),
-        new RespectPackageBoundaries(appView, mode),
+        new RespectPackageBoundaries(appView),
         new NoDifferentApiReferenceLevel(appView),
         new NoIndirectRuntimeTypeChecks(appView, runtimeTypeCheckInfo),
         new NoWeakerAccessPrivileges(appView, immediateSubtypingInfo),
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/SubtypingForrestForClasses.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/SubtypingForrestForClasses.java
deleted file mode 100644
index afb02cd..0000000
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/SubtypingForrestForClasses.java
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright (c) 2020, 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.horizontalclassmerging;
-
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexProgramClass;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.IdentityHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.function.BiFunction;
-
-/**
- * Calculates the subtyping forrest for all classes. Unlike {@link
- * com.android.tools.r8.graph.SubtypingInfo}, interfaces are not included in this subtyping
- * information and only the immediate parents are stored (i.e. the transitive parents are not
- * calculated). In the following example graph, the roots are A, E and G, and each edge indicates an
- * entry in {@link SubtypingForrestForClasses#subtypeMap} going from the parent to an entry in the
- * collection of children. <code>
- *     A      E     G
- *    / \     |
- *   B  C     F
- *   |
- *   D
- * </code>
- */
-public class SubtypingForrestForClasses {
-
-  private final AppView<? extends AppInfoWithClassHierarchy> appView;
-  private final Collection<DexProgramClass> roots = new ArrayList<>();
-  private final Map<DexProgramClass, List<DexProgramClass>> subtypeMap = new IdentityHashMap<>();
-
-  public SubtypingForrestForClasses(AppView<? extends AppInfoWithClassHierarchy> appView) {
-    this.appView = appView;
-    calculateSubtyping(appView.appInfo().classes());
-  }
-
-  private DexProgramClass superClass(DexProgramClass clazz) {
-    return appView.programDefinitionFor(clazz.superType, clazz);
-  }
-
-  private void calculateSubtyping(Iterable<DexProgramClass> classes) {
-    classes.forEach(this::calculateSubtyping);
-  }
-
-  private void calculateSubtyping(DexProgramClass clazz) {
-    if (clazz.isInterface()) {
-      return;
-    }
-    DexProgramClass superClass = superClass(clazz);
-    if (superClass == null) {
-      roots.add(clazz);
-    } else {
-      subtypeMap.computeIfAbsent(superClass, ignore -> new ArrayList<>()).add(clazz);
-    }
-  }
-
-  public Collection<DexProgramClass> getProgramRoots() {
-    return roots;
-  }
-
-  public Collection<DexProgramClass> getSubtypesFor(DexProgramClass clazz) {
-    return subtypeMap.getOrDefault(clazz, Collections.emptyList());
-  }
-
-  public <T> T traverseNodeDepthFirst(
-      DexProgramClass clazz, T state, BiFunction<DexProgramClass, T, T> consumer) {
-    T newState = consumer.apply(clazz, state);
-    getSubtypesFor(clazz).forEach(subClazz -> traverseNodeDepthFirst(subClazz, newState, consumer));
-    return newState;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/code/ConstructorEntryPointSynthesizedCode.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/code/ConstructorEntryPointSynthesizedCode.java
index 6b87383..d872901 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/code/ConstructorEntryPointSynthesizedCode.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/code/ConstructorEntryPointSynthesizedCode.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.UseRegistry;
+import com.android.tools.r8.graph.bytecodemetadata.BytecodeMetadataProvider;
 import com.android.tools.r8.graph.lens.GraphLens;
 import com.android.tools.r8.graph.proto.RewrittenPrototypeDescription;
 import com.android.tools.r8.horizontalclassmerging.ConstructorEntryPoint;
@@ -24,11 +25,13 @@
 import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.Position.SyntheticPosition;
 import com.android.tools.r8.ir.conversion.IRBuilder;
+import com.android.tools.r8.ir.conversion.IRToLirFinalizer;
 import com.android.tools.r8.ir.conversion.MethodConversionOptions;
 import com.android.tools.r8.ir.conversion.MethodConversionOptions.MutableMethodConversionOptions;
 import com.android.tools.r8.ir.conversion.SourceCode;
 import com.android.tools.r8.lightir.LirCode;
 import com.android.tools.r8.utils.RetracerForCodePrinting;
+import com.android.tools.r8.utils.Timing;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceSortedMap;
 
@@ -94,7 +97,25 @@
       AppView<? extends AppInfoWithClassHierarchy> appView,
       ProgramMethod method,
       HorizontalClassMergerGraphLens lens) {
-    throw new Unreachable();
+    for (Int2ReferenceMap.Entry<DexMethod> entry : typeConstructors.int2ReferenceEntrySet()) {
+      entry.setValue(lens.getNextMethodSignature(entry.getValue()));
+    }
+    IRCode irCode = buildIR(method, appView);
+    LirCode<Integer> lirCode =
+        new IRToLirFinalizer(appView)
+            .finalizeCode(irCode, BytecodeMetadataProvider.empty(), Timing.empty());
+    return new LirCode<>(lirCode) {
+
+      @Override
+      public boolean hasExplicitCodeLens() {
+        return true;
+      }
+
+      @Override
+      public GraphLens getCodeLens(AppView<?> appView) {
+        return lens;
+      }
+    };
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/AllInstantiatedOrUninstantiated.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/AllInstantiatedOrUninstantiated.java
index e5839b6..d118b1d 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/AllInstantiatedOrUninstantiated.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/AllInstantiatedOrUninstantiated.java
@@ -4,22 +4,18 @@
 
 package com.android.tools.r8.horizontalclassmerging.policies;
 
-import com.android.tools.r8.classmerging.ClassMergerMode;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.horizontalclassmerging.MultiClassSameReferencePolicy;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 
+// This policy is only used to prevent that horizontal class merging regresses the
+// uninstantiated type optimization.
 public class AllInstantiatedOrUninstantiated extends MultiClassSameReferencePolicy<Boolean> {
 
   private final AppView<AppInfoWithLiveness> appView;
 
-  public AllInstantiatedOrUninstantiated(
-      AppView<AppInfoWithLiveness> appView, ClassMergerMode mode) {
-    // This policy is only used to prevent that horizontal class merging regresses the
-    // uninstantiated type optimization. Since there won't be any IR processing after the final
-    // round of horizontal class merging, there is no need to use the policy.
-    assert mode.isInitial();
+  public AllInstantiatedOrUninstantiated(AppView<AppInfoWithLiveness> appView) {
     this.appView = appView;
   }
 
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/FinalizeMergeGroup.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/FinalizeMergeGroup.java
index c70a156..0d32b98 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/FinalizeMergeGroup.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/FinalizeMergeGroup.java
@@ -4,16 +4,12 @@
 
 package com.android.tools.r8.horizontalclassmerging.policies;
 
-import com.android.tools.r8.classmerging.ClassMergerMode;
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
 import com.android.tools.r8.utils.ListUtils;
-import com.android.tools.r8.utils.SetUtils;
 import com.android.tools.r8.utils.collections.EmptyBidirectionalOneToOneMap;
 import java.util.Collection;
-import java.util.Set;
 
 /**
  * Identifies when instance initializer merging is required and bails out. This is needed to ensure
@@ -26,24 +22,16 @@
 public class FinalizeMergeGroup extends MultiClassPolicy {
 
   private final AppView<?> appView;
-  private final ClassMergerMode mode;
 
-  public FinalizeMergeGroup(AppView<?> appView, ClassMergerMode mode) {
+  public FinalizeMergeGroup(AppView<?> appView) {
     this.appView = appView;
-    this.mode = mode;
   }
 
   @Override
   public Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
     if (appView.enableWholeProgramOptimizations()) {
-      if (group.isInterfaceGroup() || !mode.isRestrictedToAlphaRenamingInR8()) {
-        group.selectTarget(appView);
-        group.selectInstanceFieldMap(appView.withClassHierarchy());
-      } else {
-        // In the final round of merging each group should be finalized by the
-        // NoInstanceInitializerMerging policy.
-        assert verifyAlreadyFinalized(group);
-      }
+      group.selectTarget(appView);
+      group.selectInstanceFieldMap(appView.withClassHierarchy());
     } else {
       assert !group.hasTarget();
       assert !group.hasInstanceFieldMap();
@@ -62,21 +50,4 @@
   public boolean isIdentityForInterfaceGroups() {
     return true;
   }
-
-  private boolean verifyAlreadyFinalized(HorizontalMergeGroup group) {
-    assert group.hasTarget();
-    assert group.getClasses().contains(group.getTarget());
-    assert group.hasInstanceFieldMap();
-    Set<DexType> types =
-        SetUtils.newIdentityHashSet(
-            builder -> group.forEach(clazz -> builder.accept(clazz.getType())));
-    group
-        .getInstanceFieldMap()
-        .forEach(
-            (sourceField, targetField) -> {
-              assert types.contains(sourceField.getHolderType());
-              assert types.contains(targetField.getHolderType());
-            });
-    return true;
-  }
 }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoConstructorCollisions.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoConstructorCollisions.java
deleted file mode 100644
index c1d9320..0000000
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoConstructorCollisions.java
+++ /dev/null
@@ -1,156 +0,0 @@
-// Copyright (c) 2020, 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.horizontalclassmerging.policies;
-
-import com.android.tools.r8.classmerging.ClassMergerMode;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexProto;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
-import com.android.tools.r8.horizontalclassmerging.MultiClassPolicyWithPreprocessing;
-import com.android.tools.r8.utils.ArrayUtils;
-import com.android.tools.r8.utils.IterableUtils;
-import com.android.tools.r8.utils.ListUtils;
-import com.android.tools.r8.utils.WorkList;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Sets;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.IdentityHashMap;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ExecutorService;
-
-/**
- * In the final round, we're not allowed to resolve constructor collisions by appending null
- * arguments to constructor calls.
- *
- * <p>As an example, if a class in the program declares the constructors {@code <init>(A)} and
- * {@code <init>(B)}, the classes A and B must not be merged.
- *
- * <p>To avoid collisions of this kind, we run over all the classes in the program, and apply the
- * current set of merge groups to the constructor signatures of each class. Then, in case of a
- * collision, we extract all the mapped types from the constructor signatures, and prevent merging
- * of these types.
- */
-public class NoConstructorCollisions extends MultiClassPolicyWithPreprocessing<Set<DexType>> {
-
-  private final AppView<? extends AppInfoWithClassHierarchy> appView;
-  private final DexItemFactory dexItemFactory;
-
-  public NoConstructorCollisions(
-      AppView<? extends AppInfoWithClassHierarchy> appView, ClassMergerMode mode) {
-    assert mode.isRestrictedToAlphaRenamingInR8();
-    this.appView = appView;
-    this.dexItemFactory = appView.dexItemFactory();
-  }
-
-  /**
-   * Removes the classes in {@param collisionResolution} from {@param group}, and returns the new
-   * filtered group.
-   */
-  @Override
-  public Collection<HorizontalMergeGroup> apply(
-      HorizontalMergeGroup group, Set<DexType> collisionResolution) {
-    HorizontalMergeGroup newGroup =
-        new HorizontalMergeGroup(
-            Iterables.filter(group, clazz -> !collisionResolution.contains(clazz.getType())));
-    return newGroup.isTrivial() ? Collections.emptyList() : ListUtils.newLinkedList(newGroup);
-  }
-
-  /**
-   * Computes the set of classes that must not be merged, because the merging of these classes could
-   * lead to constructor collisions.
-   */
-  @Override
-  public Set<DexType> preprocess(
-      Collection<HorizontalMergeGroup> groups, ExecutorService executorService) {
-    // Build a mapping from types to groups.
-    Map<DexType, HorizontalMergeGroup> groupsByType = new IdentityHashMap<>();
-    for (HorizontalMergeGroup group : groups) {
-      for (DexProgramClass clazz : group) {
-        groupsByType.put(clazz.getType(), group);
-      }
-    }
-
-    // Find the set of types that must not be merged, because they could lead to a constructor
-    // collision.
-    Set<DexType> collisionResolution = Sets.newIdentityHashSet();
-    // Iterate over all the instance initializers of the current class. If the current class is in
-    // a merge group, we must include all constructors of the entire merge group.
-    WorkList.newIdentityWorkList(appView.appInfo().classes())
-        .process(
-            (current, workList) -> {
-              Iterable<DexProgramClass> group =
-                  groupsByType.containsKey(current.getType())
-                      ? groupsByType.get(current.getType())
-                      : IterableUtils.singleton(current);
-              Set<DexMethod> seen = Sets.newIdentityHashSet();
-              for (DexProgramClass clazz : group) {
-                for (DexEncodedMethod method :
-                    clazz.directMethods(DexEncodedMethod::isInstanceInitializer)) {
-                  // Rewrite the constructor reference using the current merge groups.
-                  DexMethod newReference = rewriteReference(method.getReference(), groupsByType);
-                  if (!seen.add(newReference)) {
-                    // Found a collision. Block all referenced types from being merged.
-                    for (DexType type : method.getProto().getBaseTypes(dexItemFactory)) {
-                      if (type.isClassType() && groupsByType.containsKey(type)) {
-                        collisionResolution.add(type);
-                      }
-                    }
-                  }
-                }
-              }
-              workList.markAsSeen(group);
-            });
-    return collisionResolution;
-  }
-
-  private DexProto rewriteProto(DexProto proto, Map<DexType, HorizontalMergeGroup> groups) {
-    DexType[] parameters =
-        ArrayUtils.map(
-            proto.getParameters().values,
-            parameter -> rewriteType(parameter, groups),
-            DexType.EMPTY_ARRAY);
-    return dexItemFactory.createProto(rewriteType(proto.getReturnType(), groups), parameters);
-  }
-
-  private DexMethod rewriteReference(DexMethod method, Map<DexType, HorizontalMergeGroup> groups) {
-    return dexItemFactory.createMethod(
-        rewriteType(method.getHolderType(), groups),
-        rewriteProto(method.getProto(), groups),
-        method.getName());
-  }
-
-  @SuppressWarnings("ReferenceEquality")
-  private DexType rewriteType(DexType type, Map<DexType, HorizontalMergeGroup> groups) {
-    if (type.isArrayType()) {
-      DexType baseType = type.toBaseType(dexItemFactory);
-      DexType rewrittenBaseType = rewriteType(baseType, groups);
-      if (rewrittenBaseType == baseType) {
-        return type;
-      }
-      return type.replaceBaseType(rewrittenBaseType, dexItemFactory);
-    }
-    if (type.isClassType()) {
-      if (!groups.containsKey(type)) {
-        return type;
-      }
-      return groups.get(type).getClasses().getFirst().getType();
-    }
-    assert type.isPrimitiveType() || type.isVoidType();
-    return type;
-  }
-
-  @Override
-  public String getName() {
-    return "NoConstructorCollisions";
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInstanceInitializerMerging.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInstanceInitializerMerging.java
deleted file mode 100644
index dffdc02..0000000
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInstanceInitializerMerging.java
+++ /dev/null
@@ -1,346 +0,0 @@
-// Copyright (c) 2020, 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.horizontalclassmerging.policies;
-
-import static com.android.tools.r8.utils.MapUtils.ignoreKey;
-
-import com.android.tools.r8.classmerging.ClassMergerMode;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexEncodedField;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexMethodSignature;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexTypeList;
-import com.android.tools.r8.graph.MethodAccessInfoCollection;
-import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.horizontalclassmerging.ClassInstanceFieldsMerger;
-import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
-import com.android.tools.r8.horizontalclassmerging.IRCodeProvider;
-import com.android.tools.r8.horizontalclassmerging.InstanceInitializerAnalysis;
-import com.android.tools.r8.horizontalclassmerging.InstanceInitializerAnalysis.AbsentInstanceInitializer;
-import com.android.tools.r8.horizontalclassmerging.InstanceInitializerAnalysis.InstanceInitializer;
-import com.android.tools.r8.horizontalclassmerging.InstanceInitializerAnalysis.PresentInstanceInitializer;
-import com.android.tools.r8.horizontalclassmerging.InstanceInitializerDescription;
-import com.android.tools.r8.horizontalclassmerging.MultiClassPolicyWithPreprocessing;
-import com.android.tools.r8.utils.IterableUtils;
-import com.android.tools.r8.utils.ListUtils;
-import com.android.tools.r8.utils.MapUtils;
-import com.android.tools.r8.utils.SetUtils;
-import com.android.tools.r8.utils.collections.BidirectionalManyToOneHashMap;
-import com.android.tools.r8.utils.collections.MutableBidirectionalManyToOneMap;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Sets;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.IdentityHashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Optional;
-import java.util.Set;
-import java.util.concurrent.ExecutorService;
-import java.util.function.Function;
-
-/**
- * Identifies when instance initializer merging is required and bails out. This is needed to ensure
- * that we don't need to append extra null arguments at constructor call sites, such that the result
- * of the final round of class merging can be described as a renaming only.
- *
- * <p>This policy requires that all instance initializers with the same signature (relaxed, by
- * converting references types to java.lang.Object) have the same behavior.
- */
-public class NoInstanceInitializerMerging
-    extends MultiClassPolicyWithPreprocessing<Map<DexProgramClass, Set<DexMethod>>> {
-
-  private final AppView<? extends AppInfoWithClassHierarchy> appView;
-  private final IRCodeProvider codeProvider;
-
-  public NoInstanceInitializerMerging(
-      AppView<? extends AppInfoWithClassHierarchy> appView,
-      IRCodeProvider codeProvider,
-      ClassMergerMode mode) {
-    assert mode.isRestrictedToAlphaRenamingInR8();
-    this.appView = appView;
-    this.codeProvider = codeProvider;
-  }
-
-  @Override
-  @SuppressWarnings("MixedMutabilityReturnType")
-  public Map<DexProgramClass, Set<DexMethod>> preprocess(
-      Collection<HorizontalMergeGroup> groups, ExecutorService executorService) {
-    if (!appView.options().canHaveNonReboundConstructorInvoke()) {
-      return Collections.emptyMap();
-    }
-
-    if (appView.hasLiveness()) {
-      DexItemFactory dexItemFactory = appView.dexItemFactory();
-      MethodAccessInfoCollection methodAccessInfoCollection =
-          appView.appInfoWithLiveness().getMethodAccessInfoCollection();
-
-      // Compute a mapping for the merge candidates to efficiently determine if a given type is a
-      // merge candidate.
-      Map<DexType, DexProgramClass> mergeCandidates =
-          MapUtils.newImmutableMap(
-              builder ->
-                  IterableUtils.flatten(groups)
-                      .forEach(
-                          mergeCandidate -> builder.put(mergeCandidate.getType(), mergeCandidate)));
-
-      // Compute a mapping from merge candidates to the constructors that have been removed by
-      // constructor shrinking.
-      return MapUtils.newIdentityHashMap(
-          builder ->
-              methodAccessInfoCollection.forEachDirectInvoke(
-                  (method, contexts) -> {
-                    DexProgramClass mergeCandidateHolder =
-                        mergeCandidates.get(method.getHolderType());
-                    if (mergeCandidateHolder != null
-                        && method.isInstanceInitializer(dexItemFactory)
-                        && mergeCandidateHolder.getMethodCollection().getMethod(method) == null) {
-                      builder
-                          .computeIfAbsent(
-                              mergeCandidateHolder, ignoreKey(Sets::newIdentityHashSet))
-                          .add(method);
-                    }
-                  }));
-    }
-
-    // Constructor shrinking is disabled when shrinking is disabled.
-    assert !appView.options().isShrinking();
-    return Collections.emptyMap();
-  }
-
-  @Override
-  @SuppressWarnings("MixedMutabilityReturnType")
-  public Collection<HorizontalMergeGroup> apply(
-      HorizontalMergeGroup group, Map<DexProgramClass, Set<DexMethod>> absentInstanceInitializers) {
-    assert !group.hasTarget();
-    assert !group.hasInstanceFieldMap();
-
-    if (group.isInterfaceGroup()) {
-      return ListUtils.newLinkedList(group);
-    }
-
-    // When we merge equivalent instance initializers with different protos, we find the least upper
-    // bound of each parameter type. As a result of this, the final instance initializer signatures
-    // are not known until all instance initializers in the group are known. Therefore, we disallow
-    // merging of classes that have multiple methods with the same relaxed method signature (where
-    // reference parameters are converted to java.lang.Object), to ensure that merging will result
-    // in a simple renaming (specifically, we must not need to append null arguments to constructor
-    // calls due to constructor collisions).
-    group.removeIf(
-        clazz ->
-            hasMultipleInstanceInitializersWithSameRelaxedSignature(
-                clazz, absentInstanceInitializers));
-
-    if (group.isEmpty()) {
-      return Collections.emptyList();
-    }
-
-    // We want to allow merging of equivalent instance initializers. Equivalence depends on the
-    // mapping of instance fields, so we must compute this mapping now.
-    group.selectTarget(appView);
-    group.selectInstanceFieldMap(appView);
-
-    Map<HorizontalMergeGroup, Map<DexMethodSignature, InstanceInitializer>> newGroups =
-        new LinkedHashMap<>();
-
-    // Caching of instance initializer descriptions, which are used to determine equivalence.
-    // TODO(b/181846319): Make this cache available to the instance initializer merger so that we
-    //  don't reanalyze instance initializers.
-    Map<DexMethod, Optional<InstanceInitializerDescription>> instanceInitializerDescriptions =
-        new IdentityHashMap<>();
-    Function<InstanceInitializer, Optional<InstanceInitializerDescription>>
-        instanceInitializerDescriptionProvider =
-            instanceInitializer ->
-                getOrComputeInstanceInitializerDescription(
-                    group, instanceInitializer, instanceInitializerDescriptions);
-
-    // Partition group into smaller groups where there are no (non-equivalent) instance initializer
-    // collisions.
-    for (DexProgramClass clazz : group) {
-      HorizontalMergeGroup newGroup = null;
-      Map<DexMethodSignature, InstanceInitializer> classInstanceInitializers =
-          getInstanceInitializersByRelaxedSignature(clazz, absentInstanceInitializers);
-      for (Entry<HorizontalMergeGroup, Map<DexMethodSignature, InstanceInitializer>> entry :
-          newGroups.entrySet()) {
-        HorizontalMergeGroup candidateGroup = entry.getKey();
-        Map<DexMethodSignature, InstanceInitializer> groupInstanceInitializers = entry.getValue();
-        if (canAddClassToGroup(
-            classInstanceInitializers,
-            groupInstanceInitializers,
-            instanceInitializerDescriptionProvider)) {
-          newGroup = candidateGroup;
-          classInstanceInitializers.forEach(groupInstanceInitializers::put);
-          break;
-        }
-      }
-      if (newGroup != null) {
-        newGroup.add(clazz);
-      } else {
-        newGroups.put(new HorizontalMergeGroup(clazz), classInstanceInitializers);
-      }
-    }
-
-    // Remove trivial groups and finalize the newly created groups.
-    Collection<HorizontalMergeGroup> newNonTrivialGroups = removeTrivialGroups(newGroups.keySet());
-    setInstanceFieldMaps(newNonTrivialGroups, group);
-    return newNonTrivialGroups;
-  }
-
-  private boolean canAddClassToGroup(
-      Map<DexMethodSignature, InstanceInitializer> classInstanceInitializers,
-      Map<DexMethodSignature, InstanceInitializer> groupInstanceInitializers,
-      Function<InstanceInitializer, Optional<InstanceInitializerDescription>>
-          instanceInitializerDescriptionProvider) {
-    for (Entry<DexMethodSignature, InstanceInitializer> entry :
-        classInstanceInitializers.entrySet()) {
-      DexMethodSignature relaxedSignature = entry.getKey();
-      InstanceInitializer classInstanceInitializer = entry.getValue();
-      InstanceInitializer groupInstanceInitializer =
-          groupInstanceInitializers.get(relaxedSignature);
-      if (groupInstanceInitializer == null) {
-        continue;
-      }
-
-      Optional<InstanceInitializerDescription> classInstanceInitializerDescription =
-          instanceInitializerDescriptionProvider.apply(classInstanceInitializer);
-      if (!classInstanceInitializerDescription.isPresent()) {
-        return false;
-      }
-
-      Optional<InstanceInitializerDescription> groupInstanceInitializerDescription =
-          instanceInitializerDescriptionProvider.apply(groupInstanceInitializer);
-      if (!groupInstanceInitializerDescription.isPresent()
-          || !classInstanceInitializerDescription.equals(groupInstanceInitializerDescription)) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  private boolean hasMultipleInstanceInitializersWithSameRelaxedSignature(
-      DexProgramClass clazz, Map<DexProgramClass, Set<DexMethod>> absentInstanceInitializers) {
-    Set<DexMethod> instanceInitializerReferences =
-        SetUtils.unionIdentityHashSet(
-            SetUtils.newIdentityHashSet(
-                IterableUtils.transform(
-                    clazz.programInstanceInitializers(), ProgramMethod::getReference)),
-            absentInstanceInitializers.getOrDefault(clazz, Collections.emptySet()));
-    if (instanceInitializerReferences.size() <= 1) {
-      return false;
-    }
-
-    Set<DexMethod> seen = SetUtils.newIdentityHashSet();
-    return Iterables.any(
-        instanceInitializerReferences,
-        instanceInitializerReference ->
-            !seen.add(getRelaxedSignature(instanceInitializerReference)));
-  }
-
-  private Map<DexMethodSignature, InstanceInitializer> getInstanceInitializersByRelaxedSignature(
-      DexProgramClass clazz, Map<DexProgramClass, Set<DexMethod>> absentInstanceInitializers) {
-    Map<DexMethodSignature, InstanceInitializer> result = new HashMap<>();
-    for (ProgramMethod presentInstanceInitializer : clazz.programInstanceInitializers()) {
-      DexMethodSignature relaxedSignature =
-          getRelaxedSignature(presentInstanceInitializer).getSignature();
-      InstanceInitializer previous =
-          result.put(relaxedSignature, new PresentInstanceInitializer(presentInstanceInitializer));
-      assert previous == null;
-    }
-    for (DexMethod absentInstanceInitializer :
-        absentInstanceInitializers.getOrDefault(clazz, Collections.emptySet())) {
-      DexMethodSignature relaxedSignature =
-          getRelaxedSignature(absentInstanceInitializer).getSignature();
-      InstanceInitializer previous =
-          result.put(relaxedSignature, new AbsentInstanceInitializer(absentInstanceInitializer));
-      assert previous == null;
-    }
-    return result;
-  }
-
-  private Optional<InstanceInitializerDescription> getOrComputeInstanceInitializerDescription(
-      HorizontalMergeGroup group,
-      InstanceInitializer instanceInitializer,
-      Map<DexMethod, Optional<InstanceInitializerDescription>> instanceInitializerDescriptions) {
-    return instanceInitializerDescriptions.computeIfAbsent(
-        instanceInitializer.getReference(),
-        key -> {
-          InstanceInitializerDescription instanceInitializerDescription =
-              InstanceInitializerAnalysis.analyze(
-                  appView, codeProvider, group, instanceInitializer);
-          return Optional.ofNullable(instanceInitializerDescription);
-        });
-  }
-
-  private DexMethod getRelaxedSignature(ProgramMethod instanceInitializer) {
-    return getRelaxedSignature(instanceInitializer.getReference());
-  }
-
-  @SuppressWarnings("ReferenceEquality")
-  private DexMethod getRelaxedSignature(DexMethod instanceInitializerReference) {
-    DexType objectType = appView.dexItemFactory().objectType;
-    DexTypeList parameters = instanceInitializerReference.getParameters();
-    DexTypeList relaxedParameters =
-        parameters.map(parameter -> parameter.isPrimitiveType() ? parameter : objectType);
-    return parameters != relaxedParameters
-        ? appView
-            .dexItemFactory()
-            .createInstanceInitializer(
-                instanceInitializerReference.getHolderType(), relaxedParameters)
-        : instanceInitializerReference;
-  }
-
-  private void setInstanceFieldMaps(
-      Iterable<HorizontalMergeGroup> newGroups, HorizontalMergeGroup group) {
-    for (HorizontalMergeGroup newGroup : newGroups) {
-      // Set target.
-      newGroup.selectTarget(appView);
-
-      // Construct mapping from instance fields on old target to instance fields on new target.
-      // Note the importance of this: If we create a fresh mapping from the instance fields of each
-      // source class to the new target class, we could invalidate the constructor equivalence.
-      Map<DexEncodedField, DexEncodedField> oldTargetToNewTargetInstanceFieldMap =
-          new IdentityHashMap<>();
-      if (newGroup.getTarget() != group.getTarget()) {
-        ClassInstanceFieldsMerger.mapFields(
-            appView,
-            group.getTarget(),
-            newGroup.getTarget(),
-            oldTargetToNewTargetInstanceFieldMap::put);
-      }
-
-      // Construct mapping from source to target fields.
-      MutableBidirectionalManyToOneMap<DexEncodedField, DexEncodedField> instanceFieldMap =
-          BidirectionalManyToOneHashMap.newLinkedHashMap();
-      newGroup.forEachSource(
-          source ->
-              source.forEachProgramInstanceField(
-                  sourceField -> {
-                    DexEncodedField oldTargetInstanceField =
-                        group.getTargetInstanceField(sourceField).getDefinition();
-                    DexEncodedField newTargetInstanceField =
-                        oldTargetToNewTargetInstanceFieldMap.getOrDefault(
-                            oldTargetInstanceField, oldTargetInstanceField);
-                    instanceFieldMap.put(sourceField.getDefinition(), newTargetInstanceField);
-                  }));
-      newGroup.setInstanceFieldMap(instanceFieldMap);
-    }
-  }
-
-  @Override
-  public String getName() {
-    return "NoInstanceInitializerMerging";
-  }
-
-  @Override
-  public boolean isIdentityForInterfaceGroups() {
-    return true;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoVirtualMethodMerging.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoVirtualMethodMerging.java
deleted file mode 100644
index 3320310..0000000
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoVirtualMethodMerging.java
+++ /dev/null
@@ -1,138 +0,0 @@
-// Copyright (c) 2020, 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.horizontalclassmerging.policies;
-
-import com.android.tools.r8.classmerging.ClassMergerMode;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexMethodSignature;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult;
-import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
-import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
-import com.android.tools.r8.utils.IterableUtils;
-import com.android.tools.r8.utils.SetUtils;
-import com.google.common.collect.Iterables;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-
-/**
- * Identifies when virtual method merging is required and bails out. This is needed to ensure that
- * we don't need to synthesize any $r8$classId fields, such that the result of the final round of
- * class merging can be described as a renaming only.
- */
-public class NoVirtualMethodMerging extends MultiClassPolicy {
-
-  private final AppView<? extends AppInfoWithClassHierarchy> appView;
-
-  public NoVirtualMethodMerging(
-      AppView<? extends AppInfoWithClassHierarchy> appView, ClassMergerMode mode) {
-    assert mode.isRestrictedToAlphaRenamingInR8();
-    this.appView = appView;
-  }
-
-  @Override
-  public Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
-    Map<HorizontalMergeGroup, Map<DexMethodSignature, ProgramMethod>> newGroups =
-        new LinkedHashMap<>();
-    for (DexProgramClass clazz : group) {
-      Map<DexMethodSignature, ProgramMethod> classMethods = new HashMap<>();
-      clazz.forEachProgramVirtualMethodMatching(
-          DexEncodedMethod::isNonAbstractVirtualMethod,
-          method -> classMethods.put(method.getMethodSignature(), method));
-
-      HorizontalMergeGroup newGroup = null;
-      for (Entry<HorizontalMergeGroup, Map<DexMethodSignature, ProgramMethod>> entry :
-          newGroups.entrySet()) {
-        HorizontalMergeGroup candidateGroup = entry.getKey();
-        Map<DexMethodSignature, ProgramMethod> groupMethods = entry.getValue();
-        if (canAddNonAbstractVirtualMethodsToGroup(
-            clazz, classMethods.values(), candidateGroup, groupMethods)) {
-          newGroup = candidateGroup;
-          groupMethods.putAll(classMethods);
-          break;
-        }
-      }
-
-      if (newGroup != null) {
-        newGroup.add(clazz);
-      } else {
-        newGroups.put(new HorizontalMergeGroup(clazz), classMethods);
-      }
-    }
-    return removeTrivialGroups(newGroups.keySet());
-  }
-
-  private boolean canAddNonAbstractVirtualMethodsToGroup(
-      DexProgramClass clazz,
-      Collection<ProgramMethod> methods,
-      HorizontalMergeGroup group,
-      Map<DexMethodSignature, ProgramMethod> groupMethods) {
-    // For each of clazz' virtual methods, check that adding these methods to the group does not
-    // require method merging.
-    for (ProgramMethod method : methods) {
-      ProgramMethod groupMethod = groupMethods.get(method.getMethodSignature());
-      if (groupMethod != null || hasNonAbstractDefinitionInHierarchy(group, method)) {
-        return false;
-      }
-    }
-    // For each of the group's virtual methods, check that adding these methods clazz does not
-    // require method merging.
-    for (ProgramMethod method : groupMethods.values()) {
-      if (hasNonAbstractDefinitionInHierarchy(clazz, method)) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  private boolean hasNonAbstractDefinitionInHierarchy(
-      HorizontalMergeGroup group, ProgramMethod method) {
-    return hasNonAbstractDefinitionInSuperClass(group.getSuperType(), method)
-        || hasNonAbstractDefinitionInSuperInterface(
-            SetUtils.newIdentityHashSet(IterableUtils.flatMap(group, DexClass::getInterfaces)),
-            method);
-  }
-
-  private boolean hasNonAbstractDefinitionInHierarchy(DexProgramClass clazz, ProgramMethod method) {
-    return hasNonAbstractDefinitionInSuperClass(clazz.getSuperType(), method)
-        || hasNonAbstractDefinitionInSuperInterface(clazz.getInterfaces(), method);
-  }
-
-  private boolean hasNonAbstractDefinitionInSuperClass(DexType superType, ProgramMethod method) {
-    SingleResolutionResult<?> resolutionResult =
-        appView
-            .appInfo()
-            .resolveMethodOnClassLegacy(superType, method.getReference())
-            .asSingleResolution();
-    return resolutionResult != null && !resolutionResult.getResolvedMethod().isAbstract();
-  }
-
-  private boolean hasNonAbstractDefinitionInSuperInterface(
-      Iterable<DexType> interfaceTypes, ProgramMethod method) {
-    return Iterables.any(
-        interfaceTypes,
-        interfaceType -> {
-          SingleResolutionResult<?> resolutionResult =
-              appView
-                  .appInfo()
-                  .resolveMethodOnInterfaceLegacy(interfaceType, method.getReference())
-                  .asSingleResolution();
-          return resolutionResult != null && !resolutionResult.getResolvedMethod().isAbstract();
-        });
-  }
-
-  @Override
-  public String getName() {
-    return "NoVirtualMethodMerging";
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreserveMethodCharacteristics.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreserveMethodCharacteristics.java
index caf75a0..1486c2f 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreserveMethodCharacteristics.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreserveMethodCharacteristics.java
@@ -39,10 +39,10 @@
     private final MethodAccessFlags accessFlags;
     private final boolean isAssumeNoSideEffectsMethod;
     private final OptionalBool isLibraryMethodOverride;
-    private final boolean isMainDexRoot;
+    private final OptionalBool isMainDexRoot;
 
     private MethodCharacteristics(
-        DexEncodedMethod method, boolean isAssumeNoSideEffectsMethod, boolean isMainDexRoot) {
+        DexEncodedMethod method, boolean isAssumeNoSideEffectsMethod, OptionalBool isMainDexRoot) {
       this.accessFlags =
           MethodAccessFlags.builder()
               .setPrivate(method.getAccessFlags().isPrivate())
@@ -57,11 +57,14 @@
     }
 
     static MethodCharacteristics create(
-        AppView<AppInfoWithLiveness> appView, DexEncodedMethod method) {
+        AppView<AppInfoWithLiveness> appView, ClassMergerMode mode, DexEncodedMethod method) {
       return new MethodCharacteristics(
           method,
           appView.getAssumeInfoCollection().isSideEffectFree(method.getReference()),
-          appView.appInfo().getMainDexInfo().isTracedMethodRoot(method.getReference()));
+          mode.isInitial()
+              ? OptionalBool.of(
+                  appView.appInfo().getMainDexInfo().isTracedMethodRoot(method.getReference()))
+              : OptionalBool.unknown());
     }
 
     @Override
@@ -91,12 +94,12 @@
   }
 
   private final AppView<AppInfoWithLiveness> appView;
+  private final ClassMergerMode mode;
 
   public PreserveMethodCharacteristics(AppView<AppInfoWithLiveness> appView, ClassMergerMode mode) {
-    // This policy checks that method merging does invalidate various properties. Thus there is no
-    // reason to run this policy if method merging is not allowed.
-    assert !mode.isRestrictedToAlphaRenamingInR8();
+    // This policy checks that method merging does invalidate various properties.
     this.appView = appView;
+    this.mode = mode;
   }
 
   public static class TargetGroup {
@@ -108,12 +111,14 @@
       return group;
     }
 
-    public boolean tryAdd(AppView<AppInfoWithLiveness> appView, DexProgramClass clazz) {
+    public boolean tryAdd(
+        AppView<AppInfoWithLiveness> appView, ClassMergerMode mode, DexProgramClass clazz) {
       Map<DexMethodSignature, MethodCharacteristics> newMethods = new HashMap<>();
       for (DexEncodedMethod method : clazz.methods(this::isSubjectToMethodMerging)) {
         DexMethodSignature signature = method.getSignature();
         MethodCharacteristics existingCharacteristics = methodMap.get(signature);
-        MethodCharacteristics methodCharacteristics = MethodCharacteristics.create(appView, method);
+        MethodCharacteristics methodCharacteristics =
+            MethodCharacteristics.create(appView, mode, method);
         if (existingCharacteristics == null) {
           newMethods.put(signature, methodCharacteristics);
           continue;
@@ -143,10 +148,11 @@
     List<TargetGroup> groups = new ArrayList<>();
 
     for (DexProgramClass clazz : group) {
-      boolean added = Iterables.any(groups, targetGroup -> targetGroup.tryAdd(appView, clazz));
+      boolean added =
+          Iterables.any(groups, targetGroup -> targetGroup.tryAdd(appView, mode, clazz));
       if (!added) {
         TargetGroup newGroup = new TargetGroup();
-        added = newGroup.tryAdd(appView, clazz);
+        added = newGroup.tryAdd(appView, mode, clazz);
         assert added;
         groups.add(newGroup);
       }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/RespectPackageBoundaries.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/RespectPackageBoundaries.java
index 9b8306d..892c40c 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/RespectPackageBoundaries.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/RespectPackageBoundaries.java
@@ -4,7 +4,6 @@
 
 package com.android.tools.r8.horizontalclassmerging.policies;
 
-import com.android.tools.r8.classmerging.ClassMergerMode;
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClass;
@@ -28,12 +27,9 @@
 public class RespectPackageBoundaries extends MultiClassPolicy {
 
   private final AppView<? extends AppInfoWithClassHierarchy> appView;
-  private final ClassMergerMode mode;
 
-  public RespectPackageBoundaries(
-      AppView<? extends AppInfoWithClassHierarchy> appView, ClassMergerMode mode) {
+  public RespectPackageBoundaries(AppView<? extends AppInfoWithClassHierarchy> appView) {
     this.appView = appView;
-    this.mode = mode;
   }
 
   boolean shouldRestrictMergingAcrossPackageBoundary(DexProgramClass clazz) {
@@ -93,20 +89,15 @@
 
                         @Override
                         protected boolean checkRewrittenFieldType(DexClassAndField field) {
-                          if (mode.isRestrictedToAlphaRenamingInR8()) {
-                            // No relaxing of field types, hence no insertion of casts where we need
-                            // to guarantee visibility.
-                          } else {
-                            // If the type of the field is package private, we need to keep the
-                            // current class in its package in case we end up synthesizing a
-                            // check-cast for the field type after relaxing the type of the field
-                            // after instance field merging.
-                            DexType fieldBaseType = field.getType().toBaseType(dexItemFactory());
-                            if (fieldBaseType.isClassType()) {
-                              DexClass fieldBaseClass = appView.definitionFor(fieldBaseType);
-                              if (fieldBaseClass == null || !fieldBaseClass.isPublic()) {
-                                return setFoundPackagePrivateAccess();
-                              }
+                          // If the type of the field is package private, we need to keep the
+                          // current class in its package in case we end up synthesizing a
+                          // check-cast for the field type after relaxing the type of the field
+                          // after instance field merging.
+                          DexType fieldBaseType = field.getType().toBaseType(dexItemFactory());
+                          if (fieldBaseType.isClassType()) {
+                            DexClass fieldBaseClass = appView.definitionFor(fieldBaseType);
+                            if (fieldBaseClass == null || !fieldBaseClass.isPublic()) {
+                              return setFoundPackagePrivateAccess();
                             }
                           }
                           return continueSearchForPackagePrivateAccess();
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/SameInstanceFields.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/SameInstanceFields.java
index 73ff6fc..d3cb879 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/SameInstanceFields.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/SameInstanceFields.java
@@ -4,7 +4,6 @@
 
 package com.android.tools.r8.horizontalclassmerging.policies;
 
-import com.android.tools.r8.classmerging.ClassMergerMode;
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexEncodedField;
@@ -21,25 +20,16 @@
 public class SameInstanceFields extends MultiClassSameReferencePolicy<Multiset<InstanceFieldInfo>> {
 
   private final DexItemFactory dexItemFactory;
-  private final ClassMergerMode mode;
 
-  public SameInstanceFields(
-      AppView<? extends AppInfoWithClassHierarchy> appView, ClassMergerMode mode) {
+  public SameInstanceFields(AppView<? extends AppInfoWithClassHierarchy> appView) {
     this.dexItemFactory = appView.dexItemFactory();
-    this.mode = mode;
   }
 
   @Override
   public Multiset<InstanceFieldInfo> getMergeKey(DexProgramClass clazz) {
     Multiset<InstanceFieldInfo> fields = HashMultiset.create();
     for (DexEncodedField field : clazz.instanceFields()) {
-      // We do not allow merging fields with different types in the final round of horizontal class
-      // merging, since that requires inserting check-cast instructions at reads.
-      InstanceFieldInfo instanceFieldInfo =
-          mode.isRestrictedToAlphaRenamingInR8()
-              ? InstanceFieldInfo.createExact(field)
-              : InstanceFieldInfo.createRelaxed(field, dexItemFactory);
-      fields.add(instanceFieldInfo);
+      fields.add(InstanceFieldInfo.createRelaxed(field, dexItemFactory));
     }
     return fields;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index 048460e..31577fc 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -709,7 +709,7 @@
     }
 
     if (!isDebugMode) {
-      new StringOptimizer(appView).run(code, timing);
+      new StringOptimizer(appView).run(code, methodProcessor, methodProcessingContext, timing);
       timing.begin("Optimize library methods");
       appView
           .libraryMethodOptimizer()
@@ -821,7 +821,8 @@
       constantCanonicalizer.canonicalize();
       timing.end();
       previous = printMethod(code, "IR after constant canonicalization (SSA)", previous);
-      new DexConstantOptimizer(appView, constantCanonicalizer).run(code, timing);
+      new DexConstantOptimizer(appView, constantCanonicalizer)
+          .run(code, methodProcessor, methodProcessingContext, timing);
       previous = printMethod(code, "IR after dex constant optimization (SSA)", previous);
     }
 
@@ -847,7 +848,8 @@
 
     deadCodeRemover.run(code, timing);
 
-    new ParentConstructorHoistingCodeRewriter(appView).run(code, timing);
+    new ParentConstructorHoistingCodeRewriter(appView)
+        .run(code, methodProcessor, methodProcessingContext, timing);
 
     BytecodeMetadataProvider.Builder bytecodeMetadataProviderBuilder =
         BytecodeMetadataProvider.builder();
@@ -877,7 +879,7 @@
       assert code.isConsistentSSA(appView);
 
       // TODO(b/214496607): Remove when dynamic types are safe w.r.t. interface assignment rules.
-      new MoveResultRewriter(appView).run(code, timing);
+      new MoveResultRewriter(appView).run(code, methodProcessor, methodProcessingContext, timing);
     }
 
     // Assert that we do not have unremoved non-sense code in the output, e.g., v <- non-null NULL.
diff --git a/src/main/java/com/android/tools/r8/lightir/LirBuilder.java b/src/main/java/com/android/tools/r8/lightir/LirBuilder.java
index 6f68845..a35a20f 100644
--- a/src/main/java/com/android/tools/r8/lightir/LirBuilder.java
+++ b/src/main/java/com/android/tools/r8/lightir/LirBuilder.java
@@ -810,6 +810,10 @@
     for (int i = 0; i < keys.length; i++) {
       targets[i] = getBlockIndex(keyToTargetMap.get(keys[i]));
     }
+    return addIntSwitch(value, keys, targets);
+  }
+
+  public LirBuilder<V, EV> addIntSwitch(V value, int[] keys, int[] targets) {
     IntSwitchPayload payload = new IntSwitchPayload(keys, targets);
     return addInstructionTemplate(
         LirOpcodes.TABLESWITCH,
diff --git a/src/main/java/com/android/tools/r8/lightir/LirCode.java b/src/main/java/com/android/tools/r8/lightir/LirCode.java
index 0158379..6f93b21 100644
--- a/src/main/java/com/android/tools/r8/lightir/LirCode.java
+++ b/src/main/java/com/android/tools/r8/lightir/LirCode.java
@@ -534,8 +534,11 @@
       ProgramMethod method,
       AppView<?> appView,
       MutableMethodConversionOptions conversionOptions) {
+    GraphLens codeLens = method.getDefinition().getCode().getCodeLens(appView);
     RewrittenPrototypeDescription protoChanges =
-        appView.graphLens().lookupPrototypeChangesForMethodDefinition(method.getReference());
+        appView
+            .graphLens()
+            .lookupPrototypeChangesForMethodDefinition(method.getReference(), codeLens);
     return internalBuildIR(
         method, appView, new NumberGenerator(), null, protoChanges, conversionOptions);
   }
diff --git a/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java b/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java
index 26a4261..a610af6 100644
--- a/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java
@@ -138,6 +138,9 @@
 
   private boolean hasPotentialNonTrivialInvokeRewriting(
       DexMethod method, InvokeType type, MethodLookupResult result) {
+    if (graphLens.isHorizontalClassMergerGraphLens()) {
+      return !result.getPrototypeChanges().isEmpty();
+    }
     if (graphLens.isProtoNormalizerLens()) {
       return result.getPrototypeChanges().getArgumentInfoCollection().hasArgumentPermutation();
     }
@@ -315,25 +318,29 @@
   }
 
   private boolean hasNonTrivialMethodChanges() {
+    if (graphLens.isClassMergerLens()) {
+      RewrittenPrototypeDescription prototypeChanges =
+          graphLens.lookupPrototypeChangesForMethodDefinition(context.getReference(), codeLens);
+      assert prototypeChanges.getArgumentInfoCollection().isEmpty();
+      assert !prototypeChanges.hasRewrittenReturnInfo();
+      if (prototypeChanges.hasExtraParameters()) {
+        return true;
+      }
+      VerticalClassMergerGraphLens verticalClassMergerLens = graphLens.asVerticalClassMergerLens();
+      if (verticalClassMergerLens != null) {
+        DexMethod previousReference =
+            verticalClassMergerLens.getPreviousMethodSignature(contextReference);
+        return verticalClassMergerLens.hasInterfaceBeenMergedIntoClass(
+            previousReference.getReturnType());
+      }
+    }
     if (graphLens.isProtoNormalizerLens()) {
       RewrittenPrototypeDescription prototypeChanges =
           graphLens.lookupPrototypeChangesForMethodDefinition(context.getReference(), codeLens);
+      assert !prototypeChanges.hasExtraParameters();
+      assert !prototypeChanges.hasRewrittenReturnInfo();
       return prototypeChanges.getArgumentInfoCollection().hasArgumentPermutation();
     }
-    VerticalClassMergerGraphLens verticalClassMergerLens = graphLens.asVerticalClassMergerLens();
-    if (verticalClassMergerLens != null) {
-      DexMethod previousReference =
-          verticalClassMergerLens.getPreviousMethodSignature(contextReference);
-      if (verticalClassMergerLens.hasInterfaceBeenMergedIntoClass(
-          previousReference.getReturnType())) {
-        return true;
-      }
-      RewrittenPrototypeDescription prototypeChanges =
-          graphLens.lookupPrototypeChangesForMethodDefinition(context.getReference(), codeLens);
-      if (!prototypeChanges.isEmpty()) {
-        return true;
-      }
-    }
     return false;
   }
 
diff --git a/src/main/java/com/android/tools/r8/naming/Minifier.java b/src/main/java/com/android/tools/r8/naming/Minifier.java
index 937d6a3..376c969 100644
--- a/src/main/java/com/android/tools/r8/naming/Minifier.java
+++ b/src/main/java/com/android/tools/r8/naming/Minifier.java
@@ -277,7 +277,6 @@
         InternalNamingState internalState,
         BiPredicate<DexString, DexMethod> isAvailable) {
       if (!method.isProgramMethod()) {
-        assert isAvailable.test(method.getName(), method.getReference());
         return method.getName();
       }
       assert allowMemberRenaming(method);
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMerger.java b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMerger.java
index b19cfe0..dfdd31b 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMerger.java
@@ -97,7 +97,7 @@
   private void run(ExecutorService executorService, Timing timing) throws ExecutionException {
     timing.begin("Setup");
     ImmediateProgramSubtypingInfo immediateSubtypingInfo =
-        ImmediateProgramSubtypingInfo.create(appView);
+        ImmediateProgramSubtypingInfo.createWithDeterministicOrder(appView);
 
     // Compute the disjoint class hierarchies for parallel processing.
     List<Set<DexProgramClass>> connectedComponents =
@@ -123,7 +123,12 @@
       return;
     }
     VerticalClassMergerGraphLens lens =
-        runFixup(classMergerSharedData, verticalClassMergerResult, executorService, timing);
+        runFixup(
+            classMergerSharedData,
+            immediateSubtypingInfo,
+            verticalClassMergerResult,
+            executorService,
+            timing);
     assert verifyGraphLens(lens, verticalClassMergerResult);
 
     // Update keep info and art profiles.
@@ -230,12 +235,13 @@
 
   private VerticalClassMergerGraphLens runFixup(
       ClassMergerSharedData classMergerSharedData,
+      ImmediateProgramSubtypingInfo immediateSubtypingInfo,
       VerticalClassMergerResult verticalClassMergerResult,
       ExecutorService executorService,
       Timing timing)
       throws ExecutionException {
     return new VerticalClassMergerTreeFixer(
-            appView, classMergerSharedData, verticalClassMergerResult)
+            appView, classMergerSharedData, immediateSubtypingInfo, verticalClassMergerResult)
         .run(executorService, timing);
   }
 
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerGraphLens.java b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerGraphLens.java
index 783b3d2..8d0ad13 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerGraphLens.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerGraphLens.java
@@ -23,7 +23,6 @@
 import com.android.tools.r8.graph.proto.ArgumentInfoCollection;
 import com.android.tools.r8.graph.proto.RewrittenPrototypeDescription;
 import com.android.tools.r8.ir.code.InvokeType;
-import com.android.tools.r8.ir.conversion.ExtraParameter;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.shaking.KeepInfoCollection;
 import com.android.tools.r8.utils.InternalOptions;
@@ -40,7 +39,6 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.IdentityHashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
@@ -372,12 +370,6 @@
     }
 
     @Override
-    public void addExtraParameters(
-        DexMethod from, DexMethod to, List<? extends ExtraParameter> extraParameters) {
-      // Intentionally empty.
-    }
-
-    @Override
     public void commitPendingUpdates() {
       // Commit new field signatures.
       newFieldSignatures.putAll(pendingNewFieldSignatureUpdates);
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerTreeFixer.java b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerTreeFixer.java
index ff87a99..b601485 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerTreeFixer.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerTreeFixer.java
@@ -6,6 +6,7 @@
 import com.android.tools.r8.classmerging.ClassMergerSharedData;
 import com.android.tools.r8.classmerging.ClassMergerTreeFixer;
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.ImmediateProgramSubtypingInfo;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.Timing;
 import java.util.List;
@@ -23,10 +24,12 @@
   VerticalClassMergerTreeFixer(
       AppView<AppInfoWithLiveness> appView,
       ClassMergerSharedData classMergerSharedData,
+      ImmediateProgramSubtypingInfo immediateSubtypingInfo,
       VerticalClassMergerResult verticalClassMergerResult) {
     super(
         appView,
         classMergerSharedData,
+        immediateSubtypingInfo,
         VerticalClassMergerGraphLens.Builder.createBuilderForFixup(verticalClassMergerResult),
         verticalClassMergerResult.getVerticallyMergedClasses());
     this.synthesizedBridges = verticalClassMergerResult.getSynthesizedBridges();
diff --git a/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
index e2beb9e..93a9889 100644
--- a/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
@@ -128,7 +128,7 @@
         .withOptionConsumer(opts -> opts.enableClassInlining = false)
         .withBuilderTransformation(
             b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
-        .withDexCheck(inspector -> checkLambdaCount(inspector, 11, "lambdadesugaring"))
+        .withDexCheck(inspector -> checkLambdaCount(inspector, 6, "lambdadesugaring"))
         .run(Paths.get(ToolHelper.THIRD_PARTY_DIR, "examplesAndroidOLegacy"));
 
     test("lambdadesugaring", "lambdadesugaring", "LambdaDesugaring")
@@ -167,7 +167,7 @@
         .withOptionConsumer(opts -> opts.enableClassInlining = false)
         .withBuilderTransformation(
             b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
-        .withDexCheck(inspector -> checkLambdaCount(inspector, 11, "lambdadesugaring"))
+        .withDexCheck(inspector -> checkLambdaCount(inspector, 6, "lambdadesugaring"))
         .run(Paths.get(ToolHelper.THIRD_PARTY_DIR, "examplesAndroidOLegacy"));
 
     test("lambdadesugaring", "lambdadesugaring", "LambdaDesugaring")
@@ -202,7 +202,7 @@
             b ->
                 b.addProguardConfiguration(
                     getProguardOptionsNPlus(enableProguardCompatibilityMode), Origin.unknown()))
-        .withDexCheck(inspector -> checkLambdaCount(inspector, 6, "lambdadesugaringnplus"))
+        .withDexCheck(inspector -> checkLambdaCount(inspector, 3, "lambdadesugaringnplus"))
         .run();
 
     test("lambdadesugaringnplus", "lambdadesugaringnplus", "LambdasWithStaticAndDefaultMethods")
@@ -214,7 +214,7 @@
             b ->
                 b.addProguardConfiguration(
                     getProguardOptionsNPlus(enableProguardCompatibilityMode), Origin.unknown()))
-        .withDexCheck(inspector -> checkLambdaCount(inspector, 3, "lambdadesugaringnplus"))
+        .withDexCheck(inspector -> checkLambdaCount(inspector, 2, "lambdadesugaringnplus"))
         .run();
   }
 
@@ -244,7 +244,7 @@
             b ->
                 b.addProguardConfiguration(
                     getProguardOptionsNPlus(enableProguardCompatibilityMode), Origin.unknown()))
-        .withDexCheck(inspector -> checkLambdaCount(inspector, 6, "lambdadesugaringnplus"))
+        .withDexCheck(inspector -> checkLambdaCount(inspector, 3, "lambdadesugaringnplus"))
         .run();
 
     test("lambdadesugaringnplus", "lambdadesugaringnplus", "LambdasWithStaticAndDefaultMethods")
@@ -256,7 +256,7 @@
             b ->
                 b.addProguardConfiguration(
                     getProguardOptionsNPlus(enableProguardCompatibilityMode), Origin.unknown()))
-        .withDexCheck(inspector -> checkLambdaCount(inspector, 3, "lambdadesugaringnplus"))
+        .withDexCheck(inspector -> checkLambdaCount(inspector, 2, "lambdadesugaringnplus"))
         .run();
   }
 
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoVerticalMergingSubReferenceApiTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoVerticalMergingSubReferenceApiTest.java
index dff5d14..4f6282a 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoVerticalMergingSubReferenceApiTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoVerticalMergingSubReferenceApiTest.java
@@ -6,7 +6,7 @@
 
 import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForMethod;
 import static com.android.tools.r8.utils.AndroidApiLevel.L_MR1;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsentIf;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static junit.framework.TestCase.assertEquals;
 import static org.hamcrest.CoreMatchers.not;
@@ -14,7 +14,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NoInliningOfDefaultInitializer;
 import com.android.tools.r8.NoMethodStaticizing;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
@@ -26,22 +25,20 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
 import org.junit.runners.Parameterized.Parameters;
 
 @RunWith(Parameterized.class)
 public class ApiModelNoVerticalMergingSubReferenceApiTest extends TestBase {
 
-  private final TestParameters parameters;
+  @Parameter(0)
+  public TestParameters parameters;
 
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
     return getTestParameters().withAllRuntimesAndApiLevels().build();
   }
 
-  public ApiModelNoVerticalMergingSubReferenceApiTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
   @Test()
   public void testR8() throws Exception {
     Method apiMethod = Api.class.getDeclaredMethod("apiLevel22");
@@ -57,7 +54,6 @@
         .apply(ApiModelingTestHelper::disableOutliningAndStubbing)
         .enableInliningAnnotations()
         .enableNeverClassInliningAnnotations()
-        .enableNoInliningOfDefaultInitializerAnnotations()
         .enableNoMethodStaticizingAnnotations()
         .addVerticallyMergedClassesInspector(
             inspector -> {
@@ -78,9 +74,7 @@
                 assertThat(base, not(isPresent()));
                 ClassSubject sub = inspector.clazz(Sub.class);
                 assertThat(sub, isPresent());
-                assertThat(
-                    sub.uniqueInstanceInitializer(),
-                    isAbsentIf(parameters.canHaveNonReboundConstructorInvoke()));
+                assertThat(sub.uniqueInstanceInitializer(), isAbsent());
                 assertEquals(1, sub.virtualMethods().size());
                 FoundMethodSubject callCallApi = sub.virtualMethods().get(0);
                 assertEquals("callCallApi", callCallApi.getOriginalName());
@@ -109,7 +103,6 @@
   }
 
   @NeverClassInline
-  @NoInliningOfDefaultInitializer
   public static class Sub extends Base {
 
     @NeverInline
diff --git a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoVerticalMergingTest.java b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoVerticalMergingTest.java
index 2e368e9..3f93300 100644
--- a/src/test/java/com/android/tools/r8/apimodel/ApiModelNoVerticalMergingTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/ApiModelNoVerticalMergingTest.java
@@ -6,7 +6,7 @@
 
 import static com.android.tools.r8.apimodel.ApiModelingTestHelper.setMockApiLevelForMethod;
 import static com.android.tools.r8.utils.AndroidApiLevel.L_MR1;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsentIf;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static junit.framework.TestCase.assertEquals;
 import static org.hamcrest.CoreMatchers.not;
@@ -14,7 +14,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NoInliningOfDefaultInitializer;
 import com.android.tools.r8.NoMethodStaticizing;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
@@ -26,22 +25,20 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
 import org.junit.runners.Parameterized.Parameters;
 
 @RunWith(Parameterized.class)
 public class ApiModelNoVerticalMergingTest extends TestBase {
 
-  private final TestParameters parameters;
+  @Parameter(0)
+  public TestParameters parameters;
 
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
     return getTestParameters().withAllRuntimesAndApiLevels().build();
   }
 
-  public ApiModelNoVerticalMergingTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
   @Test()
   public void testR8() throws Exception {
     Method apiMethod = Api.class.getDeclaredMethod("apiLevel22");
@@ -57,7 +54,6 @@
         .apply(ApiModelingTestHelper::disableOutliningAndStubbing)
         .enableInliningAnnotations()
         .enableNeverClassInliningAnnotations()
-        .enableNoInliningOfDefaultInitializerAnnotations()
         .enableNoMethodStaticizingAnnotations()
         .addVerticallyMergedClassesInspector(
             inspector -> {
@@ -77,9 +73,7 @@
                 assertThat(base, not(isPresent()));
                 ClassSubject sub = inspector.clazz(Sub.class);
                 assertThat(sub, isPresent());
-                assertThat(
-                    sub.uniqueInstanceInitializer(),
-                    isAbsentIf(parameters.canHaveNonReboundConstructorInvoke()));
+                assertThat(sub.uniqueInstanceInitializer(), isAbsent());
                 assertEquals(1, sub.virtualMethods().size());
                 FoundMethodSubject callCallApi = sub.virtualMethods().get(0);
                 assertEquals("callCallApi", callCallApi.getOriginalName());
@@ -109,7 +103,6 @@
   }
 
   @NeverClassInline
-  @NoInliningOfDefaultInitializer
   public static class Sub extends Base {
 
     @NeverInline
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/BridgeWithInvokeSuperOnInterfaceTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/BridgeWithInvokeSuperOnInterfaceTest.java
index 4c6af25..e6d8721 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/BridgeWithInvokeSuperOnInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/BridgeWithInvokeSuperOnInterfaceTest.java
@@ -4,9 +4,9 @@
 
 package com.android.tools.r8.bridgeremoval;
 
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static org.hamcrest.CoreMatchers.not;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.NoVerticalClassMerging;
@@ -16,7 +16,7 @@
 import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.transformers.ClassFileTransformer.MethodPredicate;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -60,9 +60,12 @@
               // Check that we are removing the bridge if we support default methods.
               if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
                 ClassSubject J = inspector.clazz(J.class);
-                assertThat(J, isPresent());
-                MethodSubject fooMethod = J.uniqueMethodWithOriginalName("foo");
-                assertThat(fooMethod, not(isPresent()));
+                assertThat(J, isAbsent());
+                assertTrue(
+                    inspector.allClasses().stream()
+                        .allMatch(
+                            classSubject ->
+                                classSubject.allMethods(FoundMethodSubject::isBridge).isEmpty()));
               }
             })
         .run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingAfterConstructorShrinkingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingAfterConstructorShrinkingTest.java
index 4c390c7..f13a1a1 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingAfterConstructorShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingAfterConstructorShrinkingTest.java
@@ -54,7 +54,8 @@
             options -> options.horizontalClassMergerOptions().disableInitialRoundOfClassMerging())
         .addHorizontallyMergedClassesInspector(
             i -> {
-              if (enableRetargetingOfConstructorBridgeCalls) {
+              if (enableRetargetingOfConstructorBridgeCalls
+                  || parameters.canInitNewInstanceUsingSuperclassConstructor()) {
                 i.assertClassesMerged(A.class, B.class);
               } else {
                 i.assertNoClassesMerged();
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingAfterConstructorShrinkingWithRepackagingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingAfterConstructorShrinkingWithRepackagingTest.java
index 1dab3a8..9ac51d6 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingAfterConstructorShrinkingWithRepackagingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingAfterConstructorShrinkingWithRepackagingTest.java
@@ -5,6 +5,7 @@
 package com.android.tools.r8.classmerging.horizontal;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsentIf;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
@@ -77,7 +78,8 @@
             options -> options.horizontalClassMergerOptions().disableInitialRoundOfClassMerging())
         .addHorizontallyMergedClassesInspector(
             i -> {
-              if (enableRetargetingOfConstructorBridgeCalls) {
+              if (enableRetargetingOfConstructorBridgeCalls
+                  || parameters.canInitNewInstanceUsingSuperclassConstructor()) {
                 // Repackaging will have moved both classes to top-level package, so rename them.
                 i.assertClassReferencesMerged(
                     moveToTopLevelPackage(A.class), moveToTopLevelPackage(B.class));
@@ -96,29 +98,45 @@
               // Verify Parent and Parent.<init>(Parent) are present and that Parent has been
               // repackaged into the default package.
               ClassSubject parentClassSubject = inspector.clazz(Parent.class);
-              assertThat(parentClassSubject, isPresent());
-              assertEquals("", parentClassSubject.getDexProgramClass().getType().getPackageName());
+              assertThat(
+                  parentClassSubject,
+                  isAbsentIf(parameters.canInitNewInstanceUsingSuperclassConstructor()));
+              if (parentClassSubject.isPresent()) {
+                assertEquals(
+                    "", parentClassSubject.getDexProgramClass().getType().getPackageName());
 
-              MethodSubject parentInstanceInitializerSubject =
-                  parentClassSubject.uniqueInstanceInitializer();
-              assertThat(parentInstanceInitializerSubject, isPresent());
-              assertEquals(
-                  parentClassSubject.asTypeSubject(),
-                  parentInstanceInitializerSubject.getParameter(0));
+                MethodSubject parentInstanceInitializerSubject =
+                    parentClassSubject.uniqueInstanceInitializer();
+                assertThat(parentInstanceInitializerSubject, isPresent());
+                assertEquals(
+                    parentClassSubject.asTypeSubject(),
+                    parentInstanceInitializerSubject.getParameter(0));
+              }
 
               // Verify that A and A.<init>(Parent) are present.
               ClassSubject aClassSubject = inspector.clazz(A.class);
               assertThat(aClassSubject, isPresent());
               assertEquals("", aClassSubject.getDexProgramClass().getType().getPackageName());
 
-              MethodSubject aInstanceInitializerSubject = aClassSubject.uniqueInstanceInitializer();
+              MethodSubject aInstanceInitializerSubject =
+                  aClassSubject.uniqueMethodThatMatches(
+                      method ->
+                          method.isInstanceInitializer()
+                              && method
+                                  .streamInstructions()
+                                  .anyMatch(instruction -> instruction.isConstString("Ouch!")));
               assertThat(aInstanceInitializerSubject, isPresent());
+
               assertEquals(
-                  parentClassSubject.asTypeSubject(), aInstanceInitializerSubject.getParameter(0));
+                  parentClassSubject.isPresent()
+                      ? parentClassSubject.asTypeSubject()
+                      : aClassSubject.asTypeSubject(),
+                  aInstanceInitializerSubject.getParameter(0));
 
               // Verify that B or B's initializer was removed.
               ClassSubject bClassSubject = inspector.clazz(B.class);
-              if (enableRetargetingOfConstructorBridgeCalls) {
+              if (enableRetargetingOfConstructorBridgeCalls
+                  || parameters.canInitNewInstanceUsingSuperclassConstructor()) {
                 assertThat(bClassSubject, isAbsent());
               } else {
                 assertThat(bClassSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerConstructorCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerConstructorCollisionTest.java
index 79b5725..67c2d49 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerConstructorCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerConstructorCollisionTest.java
@@ -12,6 +12,10 @@
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.NoHorizontalClassMerging;
 import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
+import com.android.tools.r8.utils.Box;
 import org.junit.Test;
 
 public class TreeFixerConstructorCollisionTest extends HorizontalClassMergingTestBase {
@@ -21,14 +25,28 @@
 
   @Test
   public void testR8() throws Exception {
+    Box<ClassReference> aClassReferenceAfterRepackaging = new Box<>();
     testForR8(parameters.getBackend())
         .addInnerClasses(getClass())
         .addKeepMainRule(Main.class)
         .addHorizontallyMergedClassesInspector(
-            inspector ->
-                inspector.assertIsCompleteMergeGroup(A.class, B.class).assertNoOtherClassesMerged())
+            inspector -> {
+              ClassReference aClassReference = aClassReferenceAfterRepackaging.get();
+              inspector
+                  .assertIsCompleteMergeGroup(A.class, B.class)
+                  .assertIsCompleteMergeGroup(
+                      SyntheticItemsTestUtils.syntheticInitializerArgumentType(aClassReference, 0),
+                      SyntheticItemsTestUtils.syntheticInitializerArgumentType(aClassReference, 1),
+                      SyntheticItemsTestUtils.syntheticInitializerArgumentType(aClassReference, 2),
+                      SyntheticItemsTestUtils.syntheticInitializerArgumentType(aClassReference, 3))
+                  .assertNoOtherClassesMerged();
+            })
         .addOptionsModification(
             options -> options.inlinerOptions().setEnableConstructorInlining(false))
+        .addRepackagingInspector(
+            inspector ->
+                aClassReferenceAfterRepackaging.set(
+                    inspector.getTarget(Reference.classFromClass(A.class))))
         .enableInliningAnnotations()
         .enableNeverClassInliningAnnotations()
         .enableNoHorizontalClassMergingAnnotations()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java
index abff6e4..c9b170b 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java
@@ -32,10 +32,10 @@
                 inspector
                     .applyIf(
                         parameters.canUseDefaultAndStaticInterfaceMethods(),
-                        i -> i.assertIsCompleteMergeGroup(I.class, J.class))
-                    .applyIf(
-                        !parameters.canUseDefaultAndStaticInterfaceMethods(),
-                        i -> i.assertIsCompleteMergeGroup(B1.class, B2.class))
+                        i -> i.assertIsCompleteMergeGroup(I.class, J.class),
+                        i ->
+                            i.assertIsCompleteMergeGroup(B1.class, B2.class)
+                                .assertIsCompleteMergeGroup(C1.class, C2.class))
                     .assertNoOtherClassesMerged())
         .enableInliningAnnotations()
         .enableNeverClassInliningAnnotations()
@@ -55,7 +55,9 @@
                   codeInspector.clazz(B2.class),
                   isPresentIf(parameters.canUseDefaultAndStaticInterfaceMethods()));
               assertThat(codeInspector.clazz(C1.class), isPresent());
-              assertThat(codeInspector.clazz(C2.class), isPresent());
+              assertThat(
+                  codeInspector.clazz(C2.class),
+                  isPresentIf(parameters.canUseDefaultAndStaticInterfaceMethods()));
             });
   }
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/whyareyounotinlining/WhyAreYouNotInliningInvokeWithUnknownTargetTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/whyareyounotinlining/WhyAreYouNotInliningInvokeWithUnknownTargetTest.java
index 5baa779..06f5aa2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/whyareyounotinlining/WhyAreYouNotInliningInvokeWithUnknownTargetTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/whyareyounotinlining/WhyAreYouNotInliningInvokeWithUnknownTargetTest.java
@@ -8,6 +8,7 @@
 import static org.hamcrest.CoreMatchers.is;
 
 import com.android.tools.r8.DiagnosticsMatcher;
+import com.android.tools.r8.NeverReprocessMethod;
 import com.android.tools.r8.NoHorizontalClassMerging;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
@@ -39,6 +40,7 @@
         .addKeepRules("-whyareyounotinlining class " + A.class.getTypeName() + " { void m(); }")
         .enableExperimentalWhyAreYouNotInlining()
         .enableNoHorizontalClassMergingAnnotations()
+        .enableNeverReprocessMethodAnnotations()
         .setMinApi(parameters)
         .allowDiagnosticInfoMessages()
         .compile()
@@ -59,6 +61,7 @@
 
   static class TestClass {
 
+    @NeverReprocessMethod
     public static void main(String[] args) {
       (System.currentTimeMillis() >= 0 ? new A() : new B()).m();
     }
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java
index c9c9e05..0a52142 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java
@@ -66,8 +66,8 @@
                 inspector -> {
                   HorizontalClassMergerOptions defaultHorizontalClassMergerOptions =
                       new InternalOptions().horizontalClassMergerOptions();
-                  assertEquals(4833, inspector.getSources().size());
-                  assertEquals(167, inspector.getTargets().size());
+                  assertEquals(4994, inspector.getSources().size());
+                  assertEquals(173, inspector.getTargets().size());
                   assertTrue(
                       inspector.getMergeGroups().stream()
                           .allMatch(
diff --git a/src/test/java/com/android/tools/r8/kotlin/sealed/SealedInterfaceSubClassesHorizontalMergeTest.java b/src/test/java/com/android/tools/r8/kotlin/sealed/SealedInterfaceSubClassesHorizontalMergeTest.java
index 238099b..a206c4a 100644
--- a/src/test/java/com/android/tools/r8/kotlin/sealed/SealedInterfaceSubClassesHorizontalMergeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/sealed/SealedInterfaceSubClassesHorizontalMergeTest.java
@@ -13,8 +13,10 @@
 import com.android.tools.r8.KotlinTestBase;
 import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.BooleanUtils;
-import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
+import com.android.tools.r8.utils.Box;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.Collection;
@@ -86,6 +88,8 @@
 
   @Test
   public void testR8() throws ExecutionException, CompilationFailedException, IOException {
+    Box<ClassReference> aClassReferenceAfterRepackaging = new Box<>();
+    Box<ClassReference> bClassReferenceAfterRepackaging = new Box<>();
     testForR8(parameters.getBackend())
         .addProgramFiles(compilationResults.getForConfiguration(kotlinc, targetVersion))
         .addProgramFiles(kotlinc.getKotlinStdlibJar())
@@ -103,11 +107,21 @@
                             inspector
                                 .assertIsCompleteMergeGroup(A, B)
                                 .assertNoOtherClassesMerged()),
-            // TODO(b/296852026): Updates to horizintal class merging can cause this to start
-            // failing as the classes can actually bne merged without -assumenosideeffects rules.
             b ->
                 b.addHorizontallyMergedClassesInspector(
-                    HorizontallyMergedClassesInspector::assertNoClassesMerged))
+                        inspector ->
+                            inspector
+                                .assertIsCompleteMergeGroup(
+                                    aClassReferenceAfterRepackaging.get(),
+                                    bClassReferenceAfterRepackaging.get())
+                                .assertNoOtherClassesMerged())
+                    .addRepackagingInspector(
+                        inspector -> {
+                          aClassReferenceAfterRepackaging.set(
+                              inspector.getTarget(Reference.classFromTypeName(A)));
+                          bClassReferenceAfterRepackaging.set(
+                              inspector.getTarget(Reference.classFromTypeName(B)));
+                        }))
         .compile()
         .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
         .run(parameters.getRuntime(), MAIN)
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveVirtualBridgeTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveVirtualBridgeTest.java
index 4013b58..7e99f86 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveVirtualBridgeTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveVirtualBridgeTest.java
@@ -62,12 +62,10 @@
             inspector -> {
               ClassSubject clazz = inspector.clazz(B.class);
               assertThat(clazz, isPresent());
-              if (parameters.canHaveNonReboundConstructorInvoke()) {
-                assertEquals(0, clazz.allMethods().size());
-              } else {
-                assertEquals(1, clazz.allMethods().size());
-                assertThat(clazz.allMethods().get(0), isInstanceInitializer());
-              }
+              // TODO(b/324527514): Initializer should be removed when
+              //  canHaveNonReboundConstructorInvoke().
+              assertEquals(1, clazz.allMethods().size());
+              assertThat(clazz.allMethods().get(0), isInstanceInitializer());
             });
   }
 
diff --git a/src/test/java/com/android/tools/r8/profile/art/completeness/LambdaStaticLibraryMethodImplementationProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/completeness/LambdaStaticLibraryMethodImplementationProfileRewritingTest.java
index c83d81d..6eac7c2 100644
--- a/src/test/java/com/android/tools/r8/profile/art/completeness/LambdaStaticLibraryMethodImplementationProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/completeness/LambdaStaticLibraryMethodImplementationProfileRewritingTest.java
@@ -103,9 +103,7 @@
     assertThat(lambdaClassSubject, notIf(isPresent(), canUseLambdas));
 
     MethodSubject lambdaInitializerSubject = lambdaClassSubject.uniqueInstanceInitializer();
-    assertThat(
-        lambdaInitializerSubject,
-        notIf(isPresent(), canHaveNonReboundConstructorInvoke || canUseLambdas));
+    assertThat(lambdaInitializerSubject, notIf(isPresent(), canUseLambdas));
 
     MethodSubject lambdaMainMethodSubject =
         lambdaClassSubject.uniqueMethodThatMatches(FoundMethodSubject::isVirtual);
@@ -116,10 +114,8 @@
     } else {
       profileInspector
           .assertContainsClassRules(lambdaClassSubject)
-          .assertContainsMethodRules(mainMethodSubject, lambdaMainMethodSubject)
-          .applyIf(
-              !canHaveNonReboundConstructorInvoke,
-              i -> i.assertContainsMethodRule(lambdaInitializerSubject));
+          .assertContainsMethodRules(
+              mainMethodSubject, lambdaInitializerSubject, lambdaMainMethodSubject);
     }
 
     profileInspector.assertContainsNoOtherRules();
diff --git a/src/test/java/com/android/tools/r8/profile/art/completeness/NestBasedAccessBridgesProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/completeness/NestBasedAccessBridgesProfileRewritingTest.java
index 577518d..f296a71 100644
--- a/src/test/java/com/android/tools/r8/profile/art/completeness/NestBasedAccessBridgesProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/completeness/NestBasedAccessBridgesProfileRewritingTest.java
@@ -133,7 +133,8 @@
         syntheticConstructorArgumentClassSubject, notIf(isPresent(), canUseNestBasedAccesses));
 
     MethodSubject instanceInitializer = nestMemberClassSubject.init();
-    assertThat(instanceInitializer, notIf(isPresent(), canHaveNonReboundConstructorInvoke));
+    // TODO(b/324527514): Should be absent when canHaveNonReboundConstructorInvoke is true.
+    assertThat(instanceInitializer, isPresent());
 
     MethodSubject instanceInitializerWithSyntheticArgumentSubject =
         syntheticConstructorArgumentClassSubject.isPresent()
diff --git a/src/test/java/com/android/tools/r8/profile/art/completeness/RecordProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/completeness/RecordProfileRewritingTest.java
index cd72b73..cbab790 100644
--- a/src/test/java/com/android/tools/r8/profile/art/completeness/RecordProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/completeness/RecordProfileRewritingTest.java
@@ -199,8 +199,7 @@
     ClassSubject recordTagClassSubject = inspector.clazz(recordClassReference);
     assertThat(recordTagClassSubject, isAbsentIf(canMergeRecordTag || canUseRecords));
     if (recordTagClassSubject.isPresent()) {
-      assertEquals(
-          canHaveNonReboundConstructorInvoke ? 0 : 1, recordTagClassSubject.allMethods().size());
+      assertEquals(1, recordTagClassSubject.allMethods().size());
     }
 
     MethodSubject recordTagInstanceInitializerSubject = recordTagClassSubject.init();
@@ -216,13 +215,12 @@
                 : recordTagClassSubject.asTypeSubject(),
         personRecordClassSubject.getSuperType());
     assertEquals(
-        canUseRecords ? 6 : canHaveNonReboundConstructorInvoke || !canMergeRecordTag ? 10 : 11,
+        canUseRecords ? 6 : canMergeRecordTag ? 11 : 10,
         personRecordClassSubject.allMethods().size());
 
     MethodSubject personDefaultInstanceInitializerSubject = personRecordClassSubject.init();
     assertThat(
-        personDefaultInstanceInitializerSubject,
-        isPresentIf(!canHaveNonReboundConstructorInvoke && canMergeRecordTag && !canUseRecords));
+        personDefaultInstanceInitializerSubject, isPresentIf(canMergeRecordTag && !canUseRecords));
 
     MethodSubject personInstanceInitializerSubject =
         canMergeRecordTag
@@ -317,7 +315,7 @@
                 i.assertContainsMethodRules(
                     nameNestAccessorMethodSubject, ageNestAccessorMethodSubject))
         .applyIf(
-            !canHaveNonReboundConstructorInvoke && canMergeRecordTag && !canUseRecords,
+            canMergeRecordTag && !canUseRecords,
             i -> i.assertContainsMethodRule(personDefaultInstanceInitializerSubject))
         .applyIf(
             !canUseRecords,
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageWithOverridesOfPackagePrivateMethodsTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageWithOverridesOfPackagePrivateMethodsTest.java
index 2f7657a..d3b2371 100644
--- a/src/test/java/com/android/tools/r8/repackage/RepackageWithOverridesOfPackagePrivateMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageWithOverridesOfPackagePrivateMethodsTest.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.repackage;
 
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 import static org.hamcrest.MatcherAssert.assertThat;
 
 import com.android.tools.r8.NeverClassInline;
@@ -30,6 +31,12 @@
     testForR8(parameters.getBackend())
         .addInnerClasses(getClass())
         .addKeepMainRule(TestClass.class)
+        .addHorizontallyMergedClassesInspector(
+            inspector ->
+                inspector
+                    .assertIsCompleteMergeGroup(HelloGreeterBase.class, WorldGreeterBase.class)
+                    .assertIsCompleteMergeGroup(HelloGreeter.class, WorldGreeter.class)
+                    .assertNoOtherClassesMerged())
         .apply(this::configureRepackaging)
         .enableInliningAnnotations()
         .enableNeverClassInliningAnnotations()
@@ -45,7 +52,7 @@
 
   private void inspect(CodeInspector inspector) {
     assertThat(HelloGreeter.class, isNotRepackaged(inspector));
-    assertThat(WorldGreeter.class, isNotRepackaged(inspector));
+    assertThat(inspector.clazz(WorldGreeter.class), isAbsent());
   }
 
   public static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageWithOverridesOfProtectedMethodsTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageWithOverridesOfProtectedMethodsTest.java
index 356bf73..bebcdba 100644
--- a/src/test/java/com/android/tools/r8/repackage/RepackageWithOverridesOfProtectedMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageWithOverridesOfProtectedMethodsTest.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.repackage;
 
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 import static org.hamcrest.MatcherAssert.assertThat;
 
 import com.android.tools.r8.NeverClassInline;
@@ -11,6 +12,9 @@
 import com.android.tools.r8.NoParameterTypeStrengthening;
 import com.android.tools.r8.NoVerticalClassMerging;
 import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.Box;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -26,9 +30,25 @@
 
   @Test
   public void test() throws Exception {
+    Box<ClassReference> helloGreeterAfterRepackaging = new Box<>();
+    Box<ClassReference> worldGreeterAfterRepackaging = new Box<>();
     testForR8(parameters.getBackend())
         .addInnerClasses(getClass())
         .addKeepMainRule(TestClass.class)
+        .addHorizontallyMergedClassesInspector(
+            inspector ->
+                inspector
+                    .assertIsCompleteMergeGroup(HelloGreeterBase.class, WorldGreeterBase.class)
+                    .assertIsCompleteMergeGroup(
+                        helloGreeterAfterRepackaging.get(), worldGreeterAfterRepackaging.get())
+                    .assertNoOtherClassesMerged())
+        .addRepackagingInspector(
+            inspector -> {
+              helloGreeterAfterRepackaging.set(
+                  inspector.getTarget(Reference.classFromClass(HelloGreeter.class)));
+              worldGreeterAfterRepackaging.set(
+                  inspector.getTarget(Reference.classFromClass(WorldGreeter.class)));
+            })
         .apply(this::configureRepackaging)
         .enableInliningAnnotations()
         .enableNeverClassInliningAnnotations()
@@ -43,7 +63,7 @@
 
   private void inspect(CodeInspector inspector) {
     assertThat(HelloGreeter.class, isRepackaged(inspector));
-    assertThat(WorldGreeter.class, isRepackaged(inspector));
+    assertThat(inspector.clazz(WorldGreeter.class), isAbsent());
   }
 
   public static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/shaking/RetainIndirectlyReferencedConstructorShakingOnDexTest.java b/src/test/java/com/android/tools/r8/shaking/RetainIndirectlyReferencedConstructorShakingOnDexTest.java
index a3d1fef..102603a 100644
--- a/src/test/java/com/android/tools/r8/shaking/RetainIndirectlyReferencedConstructorShakingOnDexTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/RetainIndirectlyReferencedConstructorShakingOnDexTest.java
@@ -76,19 +76,17 @@
 
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
-    assertEquals(
-        parameters.canHaveNonReboundConstructorInvoke() ? 0 : 1,
-        bClassSubject.allMethods(FoundMethodSubject::isInstanceInitializer).size());
+    // TODO(b/324527514): Should be `1 - intValue(parameters.canHaveNonReboundConstructorInvoke())`.
+    assertEquals(1, bClassSubject.allMethods(FoundMethodSubject::isInstanceInitializer).size());
 
     MethodSubject mainMethodSubject = mainClassSubject.mainMethod();
+    // TODO(b/324527514): Should invoke A.<init> when canHaveNonReboundConstructorInvoke()
+    //  && enableRetargetingOfConstructorBridgeCalls.
     assertThat(
         mainMethodSubject,
         invokesMethod(
             MethodReferenceUtils.instanceConstructor(
-                parameters.canHaveNonReboundConstructorInvoke()
-                        && enableRetargetingOfConstructorBridgeCalls
-                    ? Reference.classFromDescriptor(aClassSubject.getFinalDescriptor())
-                    : Reference.classFromDescriptor(bClassSubject.getFinalDescriptor()))));
+                Reference.classFromDescriptor(bClassSubject.getFinalDescriptor()))));
   }
 
   static class Main {
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/AllowHorizontalClassMergingWithIfRuleTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/AllowHorizontalClassMergingWithIfRuleTest.java
index af28109..f8ca87c 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/AllowHorizontalClassMergingWithIfRuleTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/AllowHorizontalClassMergingWithIfRuleTest.java
@@ -31,7 +31,9 @@
         .addKeepRules("-if class * { void foo(); } -keep class " + Main.class.getTypeName())
         .addHorizontallyMergedClassesInspector(
             inspector ->
-                inspector.assertIsCompleteMergeGroup(B.class, C.class).assertNoOtherClassesMerged())
+                inspector
+                    .assertIsCompleteMergeGroup(A.class, B.class, C.class)
+                    .assertNoOtherClassesMerged())
         .setMinApi(parameters)
         .compile()
         .run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java b/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
index 47d969c..a5e5f19 100644
--- a/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
+++ b/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
@@ -152,6 +152,11 @@
         originalMethod.getMethodDescriptor());
   }
 
+  public static ClassReference syntheticInitializerArgumentType(
+      ClassReference classReference, int id) {
+    return syntheticClass(classReference, naming.NON_FIXED_INIT_TYPE_ARGUMENT, id);
+  }
+
   public static ClassReference syntheticNestConstructorArgumentClass(
       ClassReference classReference) {
     return Reference.classFromDescriptor(