diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/MergeGroupBase.java b/src/main/java/com/android/tools/r8/classmerging/MergeGroup.java
similarity index 72%
rename from src/main/java/com/android/tools/r8/horizontalclassmerging/MergeGroupBase.java
rename to src/main/java/com/android/tools/r8/classmerging/MergeGroup.java
index 8d96410..a811666 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/MergeGroupBase.java
+++ b/src/main/java/com/android/tools/r8/classmerging/MergeGroup.java
@@ -1,9 +1,9 @@
 // Copyright (c) 2023, 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;
+package com.android.tools.r8.classmerging;
 
-public abstract class MergeGroupBase {
+public abstract class MergeGroup {
 
   public abstract int size();
 }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/Policy.java b/src/main/java/com/android/tools/r8/classmerging/Policy.java
similarity index 73%
rename from src/main/java/com/android/tools/r8/horizontalclassmerging/Policy.java
rename to src/main/java/com/android/tools/r8/classmerging/Policy.java
index 530a642..3eac536 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/Policy.java
+++ b/src/main/java/com/android/tools/r8/classmerging/Policy.java
@@ -2,15 +2,19 @@
 // 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;
+package com.android.tools.r8.classmerging;
 
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
+import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
+import com.android.tools.r8.horizontalclassmerging.MultiClassPolicyWithPreprocessing;
+import com.android.tools.r8.horizontalclassmerging.SingleClassPolicy;
 import com.android.tools.r8.verticalclassmerging.VerticalClassMergerPolicy;
 import java.util.ArrayList;
 import java.util.Collection;
 
 /**
- * The super class of all horizontal class merging policies. Most classes will either implement
- * {@link SingleClassPolicy} or {@link MultiClassPolicy}.
+ * The super class of all class merging policies. Most classes will either implement {@link
+ * SingleClassPolicy} or {@link MultiClassPolicy}.
  */
 public abstract class Policy {
 
@@ -66,18 +70,19 @@
   /**
    * Remove all groups containing no or only a single class, as there is no point in merging these.
    */
-  protected Collection<MergeGroup> removeTrivialGroups(Collection<MergeGroup> groups) {
+  protected Collection<HorizontalMergeGroup> removeTrivialGroups(
+      Collection<HorizontalMergeGroup> groups) {
     assert !(groups instanceof ArrayList);
-    groups.removeIf(MergeGroup::isTrivial);
+    groups.removeIf(HorizontalMergeGroup::isTrivial);
     return groups;
   }
 
-  boolean recordRemovedClassesForDebugging(
-      boolean isInterfaceGroup, int previousGroupSize, Collection<MergeGroup> newGroups) {
+  public boolean recordRemovedClassesForDebugging(
+      boolean isInterfaceGroup, int previousGroupSize, Collection<HorizontalMergeGroup> newGroups) {
     assert previousGroupSize >= 2;
     int previousNumberOfRemovedClasses = previousGroupSize - 1;
     int newNumberOfRemovedClasses = 0;
-    for (MergeGroup newGroup : newGroups) {
+    for (HorizontalMergeGroup newGroup : newGroups) {
       if (newGroup.isNonTrivial()) {
         newNumberOfRemovedClasses += newGroup.size() - 1;
       }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyExecutor.java b/src/main/java/com/android/tools/r8/classmerging/PolicyExecutor.java
similarity index 94%
rename from src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyExecutor.java
rename to src/main/java/com/android/tools/r8/classmerging/PolicyExecutor.java
index 0495ce2..fb199e0 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyExecutor.java
+++ b/src/main/java/com/android/tools/r8/classmerging/PolicyExecutor.java
@@ -2,7 +2,7 @@
 // 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;
+package com.android.tools.r8.classmerging;
 
 import com.android.tools.r8.utils.Timing;
 import java.util.Collection;
@@ -15,7 +15,7 @@
  * primarily be readable and correct. The SimplePolicyExecutor should be a reference implementation,
  * against which more efficient policy executors can be compared.
  */
-public abstract class PolicyExecutor<MG extends MergeGroupBase> {
+public abstract class PolicyExecutor<MG extends MergeGroup> {
 
   /**
    * Given an initial collection of class groups which can potentially be merged, run all of the
diff --git a/src/main/java/com/android/tools/r8/classmerging/SyntheticArgumentClass.java b/src/main/java/com/android/tools/r8/classmerging/SyntheticArgumentClass.java
index a8dcd49..54cdd43 100644
--- a/src/main/java/com/android/tools/r8/classmerging/SyntheticArgumentClass.java
+++ b/src/main/java/com/android/tools/r8/classmerging/SyntheticArgumentClass.java
@@ -7,7 +7,7 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.synthesis.SyntheticItems.SyntheticKindSelector;
 import com.google.common.base.Suppliers;
@@ -60,7 +60,7 @@
           .createFixedClass(syntheticKindSelector, context, appView, builder -> {});
     }
 
-    public SyntheticArgumentClass build(Collection<MergeGroup> mergeGroups) {
+    public SyntheticArgumentClass build(Collection<HorizontalMergeGroup> mergeGroups) {
       return build(getDeterministicContext(mergeGroups));
     }
 
@@ -87,9 +87,10 @@
       return new SyntheticArgumentClass(syntheticArgumentTypes);
     }
 
-    private static DexProgramClass getDeterministicContext(Collection<MergeGroup> mergeGroups) {
+    private static DexProgramClass getDeterministicContext(
+        Collection<HorizontalMergeGroup> mergeGroups) {
       // Relies on the determinism of the merge groups.
-      MergeGroup mergeGroup = mergeGroups.iterator().next();
+      HorizontalMergeGroup mergeGroup = mergeGroups.iterator().next();
       assert mergeGroup.hasTarget();
       return mergeGroup.getTarget();
     }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassInstanceFieldsMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassInstanceFieldsMerger.java
index 8edf836..778132e 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassInstanceFieldsMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassInstanceFieldsMerger.java
@@ -33,7 +33,9 @@
   DexEncodedField[] merge();
 
   static ClassInstanceFieldsMerger create(
-      AppView<?> appView, HorizontalClassMergerGraphLens.Builder lensBuilder, MergeGroup group) {
+      AppView<?> appView,
+      HorizontalClassMergerGraphLens.Builder lensBuilder,
+      HorizontalMergeGroup group) {
     if (appView.hasClassHierarchy()) {
       return new ClassInstanceFieldsMergerImpl(appView.withClassHierarchy(), lensBuilder, group);
     } else {
@@ -137,7 +139,7 @@
   class ClassInstanceFieldsMergerImpl implements ClassInstanceFieldsMerger {
 
     private final AppView<? extends AppInfoWithClassHierarchy> appView;
-    private final MergeGroup group;
+    private final HorizontalMergeGroup group;
 
     @SuppressWarnings("BadImport")
     private final Builder lensBuilder;
@@ -149,7 +151,7 @@
     private ClassInstanceFieldsMergerImpl(
         AppView<? extends AppInfoWithClassHierarchy> appView,
         HorizontalClassMergerGraphLens.Builder lensBuilder,
-        MergeGroup group) {
+        HorizontalMergeGroup group) {
       this.appView = appView;
       this.group = group;
       this.lensBuilder = lensBuilder;
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 ecbf167..2097c3a 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
@@ -60,7 +60,7 @@
 
   private final AppView<?> appView;
   private final Mode mode;
-  private final MergeGroup group;
+  private final HorizontalMergeGroup group;
   private final DexItemFactory dexItemFactory;
   private final HorizontalClassMergerGraphLens.Builder lensBuilder;
 
@@ -81,7 +81,7 @@
       IRCodeProvider codeProvider,
       Mode mode,
       HorizontalClassMergerGraphLens.Builder lensBuilder,
-      MergeGroup group,
+      HorizontalMergeGroup group,
       Collection<VirtualMethodMerger> virtualMethodMergers) {
     this.appView = appView;
     this.dexItemFactory = appView.dexItemFactory();
@@ -376,9 +376,10 @@
     private final AppView<?> appView;
     private final IRCodeProvider codeProvider;
     private final Mode mode;
-    private final MergeGroup group;
+    private final HorizontalMergeGroup group;
 
-    public Builder(AppView<?> appView, IRCodeProvider codeProvider, MergeGroup group, Mode mode) {
+    public Builder(
+        AppView<?> appView, IRCodeProvider codeProvider, HorizontalMergeGroup group, Mode mode) {
       this.appView = appView;
       this.codeProvider = codeProvider;
       this.group = group;
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassStaticFieldsMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassStaticFieldsMerger.java
index 81ec45e..dd6ddf2 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassStaticFieldsMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassStaticFieldsMerger.java
@@ -17,7 +17,7 @@
 
   private final AppView<?> appView;
   private final DexItemFactory dexItemFactory;
-  private final MergeGroup group;
+  private final HorizontalMergeGroup group;
 
   @SuppressWarnings("BadImport")
   private final Builder lensBuilder;
@@ -25,7 +25,9 @@
   private final Map<DexField, DexEncodedField> targetFields = new LinkedHashMap<>();
 
   public ClassStaticFieldsMerger(
-      AppView<?> appView, HorizontalClassMergerGraphLens.Builder lensBuilder, MergeGroup group) {
+      AppView<?> appView,
+      HorizontalClassMergerGraphLens.Builder lensBuilder,
+      HorizontalMergeGroup group) {
     this.appView = appView;
     this.dexItemFactory = appView.dexItemFactory();
     this.group = group;
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 3bc0655..d7c99ba 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
@@ -6,6 +6,7 @@
 
 import static com.android.tools.r8.graph.DexClassAndMethod.asProgramMethodOrNull;
 
+import com.android.tools.r8.classmerging.Policy;
 import com.android.tools.r8.classmerging.SyntheticArgumentClass;
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
@@ -126,7 +127,7 @@
     // Run the policies on all program classes to produce a final grouping.
     List<Policy> policies =
         PolicyScheduler.getPolicies(appView, codeProvider, mode, runtimeTypeCheckInfo);
-    Collection<MergeGroup> groups =
+    Collection<HorizontalMergeGroup> groups =
         new HorizontalClassMergerPolicyExecutor()
             .run(getInitialGroups(), policies, executorService, timing);
 
@@ -187,7 +188,7 @@
     if (mode.isInitial()) {
       fieldAccessInfoCollectionModifier = createFieldAccessInfoCollectionModifier(groups);
     } else {
-      assert groups.stream().noneMatch(MergeGroup::hasClassIdField);
+      assert groups.stream().noneMatch(HorizontalMergeGroup::hasClassIdField);
     }
 
     // Set the new graph lens before finalizing any synthetic code.
@@ -272,11 +273,11 @@
   }
 
   private FieldAccessInfoCollectionModifier createFieldAccessInfoCollectionModifier(
-      Collection<MergeGroup> groups) {
+      Collection<HorizontalMergeGroup> groups) {
     assert mode.isInitial();
     FieldAccessInfoCollectionModifier.Builder builder =
         new FieldAccessInfoCollectionModifier.Builder();
-    for (MergeGroup group : groups) {
+    for (HorizontalMergeGroup group : groups) {
       if (group.hasClassIdField()) {
         DexProgramClass target = group.getTarget();
         target.forEachProgramInstanceInitializerMatching(
@@ -292,7 +293,7 @@
   }
 
   private void transformIncompleteCode(
-      Collection<MergeGroup> groups,
+      Collection<HorizontalMergeGroup> groups,
       HorizontalClassMergerGraphLens horizontalClassMergerGraphLens,
       ExecutorService executorService)
       throws ExecutionException {
@@ -322,7 +323,8 @@
   }
 
   private boolean verifyNoIncompleteCode(
-      Collection<MergeGroup> groups, ExecutorService executorService) throws ExecutionException {
+      Collection<HorizontalMergeGroup> groups, ExecutorService executorService)
+      throws ExecutionException {
     ThreadUtils.processItems(
         groups,
         group -> {
@@ -357,9 +359,9 @@
 
   // TODO(b/270398965): Replace LinkedList.
   @SuppressWarnings("JdkObsolete")
-  private List<MergeGroup> getInitialGroups() {
-    MergeGroup initialClassGroup = new MergeGroup();
-    MergeGroup initialInterfaceGroup = new MergeGroup();
+  private List<HorizontalMergeGroup> getInitialGroups() {
+    HorizontalMergeGroup initialClassGroup = new HorizontalMergeGroup();
+    HorizontalMergeGroup initialInterfaceGroup = new HorizontalMergeGroup();
     for (DexProgramClass clazz : appView.appInfo().classesWithDeterministicOrder()) {
       if (clazz.isInterface()) {
         initialInterfaceGroup.add(clazz);
@@ -367,10 +369,10 @@
         initialClassGroup.add(clazz);
       }
     }
-    List<MergeGroup> initialGroups = new LinkedList<>();
+    List<HorizontalMergeGroup> initialGroups = new LinkedList<>();
     initialGroups.add(initialClassGroup);
     initialGroups.add(initialInterfaceGroup);
-    initialGroups.removeIf(MergeGroup::isTrivial);
+    initialGroups.removeIf(HorizontalMergeGroup::isTrivial);
     return initialGroups;
   }
 
@@ -381,9 +383,9 @@
   private List<ClassMerger> initializeClassMergers(
       IRCodeProvider codeProvider,
       HorizontalClassMergerGraphLens.Builder lensBuilder,
-      Collection<MergeGroup> groups) {
+      Collection<HorizontalMergeGroup> groups) {
     List<ClassMerger> classMergers = new ArrayList<>(groups.size());
-    for (MergeGroup group : groups) {
+    for (HorizontalMergeGroup group : groups) {
       assert group.isNonTrivial();
       assert group.hasInstanceFieldMap();
       assert group.hasTarget();
@@ -439,8 +441,8 @@
 
   @SuppressWarnings("ReferenceEquality")
   private static boolean verifyNoCyclesInInterfaceHierarchies(
-      AppView<?> appView, Collection<MergeGroup> groups) {
-    for (MergeGroup group : groups) {
+      AppView<?> appView, Collection<HorizontalMergeGroup> groups) {
+    for (HorizontalMergeGroup group : groups) {
       if (group.isClassGroup()) {
         continue;
       }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerPolicyExecutor.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerPolicyExecutor.java
index f207cbc..be9f787 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerPolicyExecutor.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerPolicyExecutor.java
@@ -3,6 +3,8 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.horizontalclassmerging;
 
+import com.android.tools.r8.classmerging.Policy;
+import com.android.tools.r8.classmerging.PolicyExecutor;
 import com.google.common.collect.ImmutableList;
 import java.util.Collection;
 import java.util.Iterator;
@@ -10,11 +12,11 @@
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 
-public class HorizontalClassMergerPolicyExecutor extends PolicyExecutor<MergeGroup> {
+public class HorizontalClassMergerPolicyExecutor extends PolicyExecutor<HorizontalMergeGroup> {
 
   @Override
-  protected LinkedList<MergeGroup> apply(
-      Policy policy, LinkedList<MergeGroup> linkedGroups, ExecutorService executorService)
+  protected LinkedList<HorizontalMergeGroup> apply(
+      Policy policy, LinkedList<HorizontalMergeGroup> linkedGroups, ExecutorService executorService)
       throws ExecutionException {
     if (policy.isSingleClassPolicy()) {
       applySingleClassPolicy(policy.asSingleClassPolicy(), linkedGroups);
@@ -31,10 +33,10 @@
     return linkedGroups;
   }
 
-  void applySingleClassPolicy(SingleClassPolicy policy, LinkedList<MergeGroup> groups) {
-    Iterator<MergeGroup> i = groups.iterator();
+  void applySingleClassPolicy(SingleClassPolicy policy, LinkedList<HorizontalMergeGroup> groups) {
+    Iterator<HorizontalMergeGroup> i = groups.iterator();
     while (i.hasNext()) {
-      MergeGroup group = i.next();
+      HorizontalMergeGroup group = i.next();
       boolean isInterfaceGroup = group.isInterfaceGroup();
       int previousGroupSize = group.size();
       group.removeIf(clazz -> !policy.canMerge(clazz));
@@ -48,15 +50,15 @@
 
   // TODO(b/270398965): Replace LinkedList.
   @SuppressWarnings("JdkObsolete")
-  private LinkedList<MergeGroup> applyMultiClassPolicy(
-      MultiClassPolicy policy, LinkedList<MergeGroup> groups) {
+  private LinkedList<HorizontalMergeGroup> applyMultiClassPolicy(
+      MultiClassPolicy policy, LinkedList<HorizontalMergeGroup> groups) {
     // For each group apply the multi class policy and add all the new groups together.
-    LinkedList<MergeGroup> newGroups = new LinkedList<>();
+    LinkedList<HorizontalMergeGroup> newGroups = new LinkedList<>();
     groups.forEach(
         group -> {
           boolean isInterfaceGroup = group.isInterfaceGroup();
           int previousGroupSize = group.size();
-          Collection<MergeGroup> policyGroups = policy.apply(group);
+          Collection<HorizontalMergeGroup> policyGroups = policy.apply(group);
           policyGroups.forEach(newGroup -> newGroup.applyMetadataFrom(group));
           assert policy.recordRemovedClassesForDebugging(
               isInterfaceGroup, previousGroupSize, policyGroups);
@@ -67,19 +69,19 @@
 
   // TODO(b/270398965): Replace LinkedList.
   @SuppressWarnings("JdkObsolete")
-  private <T> LinkedList<MergeGroup> applyMultiClassPolicyWithPreprocessing(
+  private <T> LinkedList<HorizontalMergeGroup> applyMultiClassPolicyWithPreprocessing(
       MultiClassPolicyWithPreprocessing<T> policy,
-      LinkedList<MergeGroup> groups,
+      LinkedList<HorizontalMergeGroup> groups,
       ExecutorService executorService)
       throws ExecutionException {
     // For each group apply the multi class policy and add all the new groups together.
     T data = policy.preprocess(groups, executorService);
-    LinkedList<MergeGroup> newGroups = new LinkedList<>();
+    LinkedList<HorizontalMergeGroup> newGroups = new LinkedList<>();
     groups.forEach(
         group -> {
           boolean isInterfaceGroup = group.isInterfaceGroup();
           int previousGroupSize = group.size();
-          Collection<MergeGroup> policyGroups = policy.apply(group, data);
+          Collection<HorizontalMergeGroup> policyGroups = policy.apply(group, data);
           policyGroups.forEach(newGroup -> newGroup.applyMetadataFrom(group));
           assert policy.recordRemovedClassesForDebugging(
               isInterfaceGroup, previousGroupSize, policyGroups);
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/MergeGroup.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalMergeGroup.java
similarity index 94%
rename from src/main/java/com/android/tools/r8/horizontalclassmerging/MergeGroup.java
rename to src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalMergeGroup.java
index 06b3ab6..9210ef9 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/MergeGroup.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalMergeGroup.java
@@ -6,6 +6,7 @@
 
 package com.android.tools.r8.horizontalclassmerging;
 
+import com.android.tools.r8.classmerging.MergeGroup;
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClass;
@@ -26,7 +27,7 @@
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 
-public class MergeGroup extends MergeGroupBase implements Collection<DexProgramClass> {
+public class HorizontalMergeGroup extends MergeGroup implements Collection<DexProgramClass> {
 
   public static class Metadata {}
 
@@ -42,21 +43,21 @@
 
   // TODO(b/270398965): Replace LinkedList.
   @SuppressWarnings("JdkObsolete")
-  public MergeGroup() {
+  public HorizontalMergeGroup() {
     this.classes = new LinkedList<>();
   }
 
-  public MergeGroup(DexProgramClass clazz) {
+  public HorizontalMergeGroup(DexProgramClass clazz) {
     this();
     add(clazz);
   }
 
-  public MergeGroup(Iterable<DexProgramClass> classes) {
+  public HorizontalMergeGroup(Iterable<DexProgramClass> classes) {
     this();
     Iterables.addAll(this.classes, classes);
   }
 
-  public void applyMetadataFrom(MergeGroup group) {
+  public void applyMetadataFrom(HorizontalMergeGroup group) {
     if (metadata == null) {
       metadata = group.metadata;
     }
@@ -67,7 +68,7 @@
     return classes.add(clazz);
   }
 
-  public boolean add(MergeGroup group) {
+  public boolean add(HorizontalMergeGroup group) {
     return classes.addAll(group.getClasses());
   }
 
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontallyMergedClasses.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontallyMergedClasses.java
index f832f3a..197f2b8 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontallyMergedClasses.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontallyMergedClasses.java
@@ -112,11 +112,11 @@
       mergedClasses.put(source, target);
     }
 
-    void addMergeGroup(MergeGroup group) {
+    void addMergeGroup(HorizontalMergeGroup group) {
       group.forEachSource(clazz -> add(clazz.getType(), group.getTarget().getType()));
     }
 
-    Builder addMergeGroups(Iterable<MergeGroup> groups) {
+    Builder addMergeGroups(Iterable<HorizontalMergeGroup> groups) {
       groups.forEach(this::addMergeGroup);
       return this;
     }
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 67022ed..f49af82 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerAnalysis.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerAnalysis.java
@@ -40,7 +40,7 @@
   public static InstanceInitializerDescription analyze(
       AppView<? extends AppInfoWithClassHierarchy> appView,
       IRCodeProvider codeProvider,
-      MergeGroup group,
+      HorizontalMergeGroup group,
       InstanceInitializer instanceInitializer) {
     if (instanceInitializer.isAbsent()) {
       InstanceInitializerDescription.Builder builder =
@@ -69,7 +69,7 @@
   public static InstanceInitializerDescription analyze(
       AppView<? extends AppInfoWithClassHierarchy> appView,
       IRCodeProvider codeProvider,
-      MergeGroup group,
+      HorizontalMergeGroup group,
       ProgramMethod instanceInitializer) {
     InstanceInitializerDescription.Builder builder =
         InstanceInitializerDescription.builder(appView, instanceInitializer);
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 2360c368..dc5f15e 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerDescription.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerDescription.java
@@ -74,7 +74,7 @@
    */
   public IncompleteMergedInstanceInitializerCode createCfCode(
       DexMethod originalMethodReference,
-      MergeGroup group,
+      HorizontalMergeGroup group,
       boolean hasClassId,
       int extraNulls) {
     return new IncompleteMergedInstanceInitializerCode(
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 54f4898..b522877 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMerger.java
@@ -45,7 +45,7 @@
   private final AppView<? extends AppInfoWithClassHierarchy> appView;
   private final Reference2IntMap<DexType> classIdentifiers;
   private final DexItemFactory dexItemFactory;
-  private final MergeGroup group;
+  private final HorizontalMergeGroup group;
   private final List<ProgramMethod> instanceInitializers;
   private final InstanceInitializerDescription instanceInitializerDescription;
   private final HorizontalClassMergerGraphLens.Builder lensBuilder;
@@ -54,7 +54,7 @@
   InstanceInitializerMerger(
       AppView<? extends AppInfoWithClassHierarchy> appView,
       Reference2IntMap<DexType> classIdentifiers,
-      MergeGroup group,
+      HorizontalMergeGroup group,
       List<ProgramMethod> instanceInitializers,
       HorizontalClassMergerGraphLens.Builder lensBuilder,
       Mode mode) {
@@ -64,7 +64,7 @@
   InstanceInitializerMerger(
       AppView<? extends AppInfoWithClassHierarchy> appView,
       Reference2IntMap<DexType> classIdentifiers,
-      MergeGroup group,
+      HorizontalMergeGroup group,
       List<ProgramMethod> instanceInitializers,
       HorizontalClassMergerGraphLens.Builder lensBuilder,
       Mode mode,
@@ -214,7 +214,7 @@
       return this;
     }
 
-    public List<InstanceInitializerMerger> build(MergeGroup group) {
+    public List<InstanceInitializerMerger> build(HorizontalMergeGroup group) {
       assert instanceInitializerGroups.stream().noneMatch(List::isEmpty);
       return ListUtils.map(
           instanceInitializerGroups,
@@ -224,7 +224,7 @@
     }
 
     public InstanceInitializerMerger buildSingle(
-        MergeGroup group, InstanceInitializerDescription instanceInitializerDescription) {
+        HorizontalMergeGroup group, InstanceInitializerDescription instanceInitializerDescription) {
       assert instanceInitializerGroups.stream().noneMatch(List::isEmpty);
       assert instanceInitializerGroups.size() == 1;
       List<ProgramMethod> instanceInitializers = ListUtils.first(instanceInitializerGroups);
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMergerCollection.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMergerCollection.java
index 50a0f23..62d7522 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMergerCollection.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/InstanceInitializerMergerCollection.java
@@ -42,7 +42,7 @@
       AppView<?> appView,
       Reference2IntMap<DexType> classIdentifiers,
       IRCodeProvider codeProvider,
-      MergeGroup group,
+      HorizontalMergeGroup group,
       HorizontalClassMergerGraphLens.Builder lensBuilder,
       Mode mode) {
     if (!appView.hasClassHierarchy()) {
@@ -130,7 +130,7 @@
         instanceInitializerMergers, equivalentInstanceInitializerMergers);
   }
 
-  private static boolean verifyNoInstanceInitializers(MergeGroup group) {
+  private static boolean verifyNoInstanceInitializers(HorizontalMergeGroup group) {
     group.forEach(
         clazz -> {
           assert !clazz.programInstanceInitializers().iterator().hasNext();
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassPolicy.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassPolicy.java
index 63420fe..8bad6ec 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassPolicy.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassPolicy.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.horizontalclassmerging;
 
+import com.android.tools.r8.classmerging.Policy;
 import java.util.Collection;
 
 public abstract class MultiClassPolicy extends Policy {
@@ -16,7 +17,7 @@
    *     merged. If the policy detects no issues then `group` will be returned unchanged. If classes
    *     cannot be merged with any other classes they are returned as singleton lists.
    */
-  public abstract Collection<MergeGroup> apply(MergeGroup group);
+  public abstract Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group);
 
   @Override
   public boolean isMultiClassPolicy() {
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassPolicyWithPreprocessing.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassPolicyWithPreprocessing.java
index d634479..416164b 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassPolicyWithPreprocessing.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassPolicyWithPreprocessing.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.horizontalclassmerging;
 
+import com.android.tools.r8.classmerging.Policy;
 import java.util.Collection;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
@@ -19,9 +20,10 @@
    *     merged. If the policy detects no issues then `group` will be returned unchanged. If classes
    *     cannot be merged with any other classes they are returned as singleton lists.
    */
-  public abstract Collection<MergeGroup> apply(MergeGroup group, T data);
+  public abstract Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group, T data);
 
-  public abstract T preprocess(Collection<MergeGroup> groups, ExecutorService executorService)
+  public abstract T preprocess(
+      Collection<HorizontalMergeGroup> groups, ExecutorService executorService)
       throws ExecutionException;
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassSameReferencePolicy.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassSameReferencePolicy.java
index aa3ca62..40399c0 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassSameReferencePolicy.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/MultiClassSameReferencePolicy.java
@@ -12,12 +12,12 @@
 public abstract class MultiClassSameReferencePolicy<T> extends MultiClassPolicy {
 
   @Override
-  public final Collection<MergeGroup> apply(MergeGroup group) {
-    Map<T, MergeGroup> groups = new LinkedHashMap<>();
+  public final Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
+    Map<T, HorizontalMergeGroup> groups = new LinkedHashMap<>();
     for (DexProgramClass clazz : group) {
       T mergeKey = getMergeKey(clazz);
       if (mergeKey != null) {
-        groups.computeIfAbsent(mergeKey, ignore -> new MergeGroup()).add(clazz);
+        groups.computeIfAbsent(mergeKey, ignore -> new HorizontalMergeGroup()).add(clazz);
       }
     }
     removeTrivialGroups(groups.values());
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 da96bcf..fa18dbb 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyScheduler.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyScheduler.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.horizontalclassmerging;
 
+import com.android.tools.r8.classmerging.Policy;
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/SingleClassPolicy.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/SingleClassPolicy.java
index db2d8eb..7c9aedb 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/SingleClassPolicy.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/SingleClassPolicy.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.horizontalclassmerging;
 
+import com.android.tools.r8.classmerging.Policy;
 import com.android.tools.r8.graph.DexProgramClass;
 
 public abstract class SingleClassPolicy extends Policy {
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/VirtualMethodMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/VirtualMethodMerger.java
index 5b1ee78..6175c5a 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/VirtualMethodMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/VirtualMethodMerger.java
@@ -49,13 +49,13 @@
 
   private final AppView<? extends AppInfoWithClassHierarchy> appView;
   private final DexItemFactory dexItemFactory;
-  private final MergeGroup group;
+  private final HorizontalMergeGroup group;
   private final List<ProgramMethod> methods;
   private final SuperMethodReference superMethod;
 
   public VirtualMethodMerger(
       AppView<? extends AppInfoWithClassHierarchy> appView,
-      MergeGroup group,
+      HorizontalMergeGroup group,
       List<ProgramMethod> methods,
       SuperMethodReference superMethod) {
     this.appView = appView;
@@ -75,7 +75,7 @@
 
     /** Get the super method handle if this method overrides a parent method. */
     private SuperMethodReference superMethod(
-        AppView<? extends AppInfoWithClassHierarchy> appView, MergeGroup group) {
+        AppView<? extends AppInfoWithClassHierarchy> appView, HorizontalMergeGroup group) {
       DexMethod template = methods.iterator().next().getReference();
       SingleResolutionResult<?> resolutionResult =
           appView
@@ -98,7 +98,7 @@
     }
 
     public VirtualMethodMerger build(
-        AppView<? extends AppInfoWithClassHierarchy> appView, MergeGroup group) {
+        AppView<? extends AppInfoWithClassHierarchy> appView, HorizontalMergeGroup group) {
       // If not all the classes are in the merge group, find the fallback super method to call.
       SuperMethodReference superMethod =
           methods.size() < group.size() ? superMethod(appView, group) : null;
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/code/ClassInitializerMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/code/ClassInitializerMerger.java
index a0b8b9b..19efa91 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/code/ClassInitializerMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/code/ClassInitializerMerger.java
@@ -24,7 +24,7 @@
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.UseRegistry;
 import com.android.tools.r8.graph.proto.RewrittenPrototypeDescription;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.ir.code.BasicBlock;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.IRMetadata;
@@ -59,7 +59,7 @@
     this.classInitializers = classInitializers;
   }
 
-  public static ClassInitializerMerger create(MergeGroup group) {
+  public static ClassInitializerMerger create(HorizontalMergeGroup group) {
     ClassInitializerMerger.Builder builder = new ClassInitializerMerger.Builder();
     group.forEach(
         clazz -> {
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/AtMostOneClassThatMatchesPolicy.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/AtMostOneClassThatMatchesPolicy.java
index 17bb034..82cc1b5 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/AtMostOneClassThatMatchesPolicy.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/AtMostOneClassThatMatchesPolicy.java
@@ -7,7 +7,7 @@
 import static com.android.tools.r8.utils.IteratorUtils.createCircularIterator;
 
 import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
 import com.google.common.collect.ImmutableList;
 import java.util.Collection;
@@ -20,12 +20,12 @@
   // TODO(b/270398965): Replace LinkedList.
   @SuppressWarnings("JdkObsolete")
   @Override
-  public Collection<MergeGroup> apply(MergeGroup group) {
+  public Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
     // Create a new merge group for each class that we want at most one of.
-    List<MergeGroup> newGroups = new LinkedList<>();
+    List<HorizontalMergeGroup> newGroups = new LinkedList<>();
     for (DexProgramClass clazz : group) {
       if (atMostOneOf(clazz)) {
-        newGroups.add(new MergeGroup(clazz));
+        newGroups.add(new HorizontalMergeGroup(clazz));
       }
     }
 
@@ -36,7 +36,7 @@
     }
 
     // Otherwise, fill up the new merge groups with the remaining classes.
-    Iterator<MergeGroup> newGroupsIterator = createCircularIterator(newGroups);
+    Iterator<HorizontalMergeGroup> newGroupsIterator = createCircularIterator(newGroups);
     for (DexProgramClass clazz : group) {
       if (!atMostOneOf(clazz)) {
         newGroupsIterator.next().add(clazz);
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 b9c4c3c..16e17f0 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
@@ -7,7 +7,7 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger.Mode;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+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;
@@ -34,7 +34,7 @@
   }
 
   @Override
-  public Collection<MergeGroup> apply(MergeGroup group) {
+  public Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
     if (appView.enableWholeProgramOptimizations()) {
       if (mode.isInitial() || group.isInterfaceGroup()) {
         group.selectTarget(appView);
@@ -63,7 +63,7 @@
     return true;
   }
 
-  private boolean verifyAlreadyFinalized(MergeGroup group) {
+  private boolean verifyAlreadyFinalized(HorizontalMergeGroup group) {
     assert group.hasTarget();
     assert group.getClasses().contains(group.getTarget());
     assert group.hasInstanceFieldMap();
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/LimitClassGroups.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/LimitClassGroups.java
index d271464..728cf5e 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/LimitClassGroups.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/LimitClassGroups.java
@@ -6,7 +6,7 @@
 
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
 import java.util.Collection;
 import java.util.Collections;
@@ -27,13 +27,13 @@
   // TODO(b/270398965): Replace LinkedList.
   @Override
   @SuppressWarnings({"JdkObsolete", "MixedMutabilityReturnType"})
-  public Collection<MergeGroup> apply(MergeGroup group) {
+  public Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
     if (group.size() <= maxGroupSize || group.isInterfaceGroup()) {
       return Collections.singletonList(group);
     }
 
-    LinkedList<MergeGroup> newGroups = new LinkedList<>();
-    MergeGroup newGroup = createNewGroup(newGroups);
+    LinkedList<HorizontalMergeGroup> newGroups = new LinkedList<>();
+    HorizontalMergeGroup newGroup = createNewGroup(newGroups);
     for (DexProgramClass clazz : group) {
       if (newGroup.size() == maxGroupSize) {
         newGroup = createNewGroup(newGroups);
@@ -42,7 +42,7 @@
     }
     if (newGroup.size() == 1) {
       if (maxGroupSize == 2) {
-        MergeGroup removedGroup = newGroups.removeLast();
+        HorizontalMergeGroup removedGroup = newGroups.removeLast();
         assert removedGroup == newGroup;
       } else {
         newGroup.add(newGroups.getFirst().removeLast());
@@ -51,8 +51,8 @@
     return newGroups;
   }
 
-  private MergeGroup createNewGroup(LinkedList<MergeGroup> newGroups) {
-    MergeGroup newGroup = new MergeGroup();
+  private HorizontalMergeGroup createNewGroup(LinkedList<HorizontalMergeGroup> newGroups) {
+    HorizontalMergeGroup newGroup = new HorizontalMergeGroup();
     newGroups.add(newGroup);
     return newGroup;
   }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/LimitInterfaceGroups.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/LimitInterfaceGroups.java
index adee1f4..414003a 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/LimitInterfaceGroups.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/LimitInterfaceGroups.java
@@ -7,7 +7,7 @@
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
 import java.util.Collection;
 import java.util.Collections;
@@ -25,24 +25,24 @@
   }
 
   @Override
-  public Collection<MergeGroup> apply(MergeGroup group) {
+  public Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
     if (group.isClassGroup()) {
       return Collections.singletonList(group);
     }
     // Mapping from new merge groups to their size.
-    Map<MergeGroup, Integer> newGroups = new LinkedHashMap<>();
+    Map<HorizontalMergeGroup, Integer> newGroups = new LinkedHashMap<>();
     for (DexProgramClass clazz : group) {
       processClass(clazz, newGroups);
     }
     return removeTrivialGroups(newGroups.keySet());
   }
 
-  private void processClass(DexProgramClass clazz, Map<MergeGroup, Integer> newGroups) {
+  private void processClass(DexProgramClass clazz, Map<HorizontalMergeGroup, Integer> newGroups) {
     int increment = clazz.getMethodCollection().size();
 
     // Find an existing group.
-    for (Entry<MergeGroup, Integer> entry : newGroups.entrySet()) {
-      MergeGroup candidateGroup = entry.getKey();
+    for (Entry<HorizontalMergeGroup, Integer> entry : newGroups.entrySet()) {
+      HorizontalMergeGroup candidateGroup = entry.getKey();
       int candidateGroupSize = entry.getValue();
       int newCandidateGroupSize = candidateGroupSize + increment;
       if (newCandidateGroupSize <= maxGroupSize) {
@@ -53,7 +53,7 @@
     }
 
     // Failed to find an existing group.
-    newGroups.put(new MergeGroup(clazz), increment);
+    newGroups.put(new HorizontalMergeGroup(clazz), increment);
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/MinimizeInstanceFieldCasts.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/MinimizeInstanceFieldCasts.java
index 0242766..bfd431f 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/MinimizeInstanceFieldCasts.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/MinimizeInstanceFieldCasts.java
@@ -7,7 +7,7 @@
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
 import com.google.common.collect.HashMultiset;
 import com.google.common.collect.Multiset;
@@ -20,13 +20,13 @@
 public class MinimizeInstanceFieldCasts extends MultiClassPolicy {
 
   @Override
-  public final Collection<MergeGroup> apply(MergeGroup group) {
+  public final Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
     // First find all classes that can be merged without changing field types.
-    Map<Multiset<DexType>, MergeGroup> newGroups = new LinkedHashMap<>();
+    Map<Multiset<DexType>, HorizontalMergeGroup> newGroups = new LinkedHashMap<>();
     group.forEach(clazz -> addExact(clazz, newGroups));
 
     // Create a single group from all trivial groups.
-    MergeGroup pendingGroup = new MergeGroup();
+    HorizontalMergeGroup pendingGroup = new HorizontalMergeGroup();
     newGroups
         .values()
         .removeIf(
@@ -43,13 +43,14 @@
     }
 
     if (!pendingGroup.isTrivial()) {
-      List<MergeGroup> newGroupsIncludingRelaxedGroup = new ArrayList<>(newGroups.values());
+      List<HorizontalMergeGroup> newGroupsIncludingRelaxedGroup =
+          new ArrayList<>(newGroups.values());
       newGroupsIncludingRelaxedGroup.add(pendingGroup);
       return newGroupsIncludingRelaxedGroup;
     }
 
-    MergeGroup smallestNewGroup = null;
-    for (MergeGroup newGroup : newGroups.values()) {
+    HorizontalMergeGroup smallestNewGroup = null;
+    for (HorizontalMergeGroup newGroup : newGroups.values()) {
       if (smallestNewGroup == null || newGroup.size() < smallestNewGroup.size()) {
         smallestNewGroup = newGroup;
       }
@@ -59,8 +60,11 @@
     return newGroups.values();
   }
 
-  private void addExact(DexProgramClass clazz, Map<Multiset<DexType>, MergeGroup> groups) {
-    groups.computeIfAbsent(getExactMergeKey(clazz), ignore -> new MergeGroup()).add(clazz);
+  private void addExact(
+      DexProgramClass clazz, Map<Multiset<DexType>, HorizontalMergeGroup> groups) {
+    groups
+        .computeIfAbsent(getExactMergeKey(clazz), ignore -> new HorizontalMergeGroup())
+        .add(clazz);
   }
 
   private Multiset<DexType> getExactMergeKey(DexProgramClass clazz) {
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoClassInitializerCycles.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoClassInitializerCycles.java
index bb60289..9addf2f 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoClassInitializerCycles.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoClassInitializerCycles.java
@@ -20,7 +20,7 @@
 import com.android.tools.r8.graph.MethodResolutionResult;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.lens.GraphLens;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicyWithPreprocessing;
 import com.android.tools.r8.horizontalclassmerging.policies.deadlock.SingleCallerInformation;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
@@ -97,7 +97,7 @@
   final AppView<AppInfoWithLiveness> appView;
 
   // Mapping from each merge candidate to its merge group.
-  final Map<DexProgramClass, MergeGroup> allGroups = new IdentityHashMap<>();
+  final Map<DexProgramClass, HorizontalMergeGroup> allGroups = new IdentityHashMap<>();
 
   private SingleCallerInformation singleCallerInformation;
 
@@ -112,24 +112,25 @@
   // TODO(b/270398965): Replace LinkedList.
   @SuppressWarnings("JdkObsolete")
   @Override
-  public Collection<MergeGroup> apply(MergeGroup group, Void nothing) {
+  public Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group, Void nothing) {
     // Partition the merge group into smaller groups that may be merged. If the class initialization
     // of a parent class may initialize a member of the merge group, then this member is not
     // eligible for class merging, unless the only way to class initialize this member is from the
     // class initialization of the parent class. In this case, the member may be merged with other
     // group members that are also guaranteed to only be class initialized from the class
     // initialization of the parent class.
-    List<MergeGroup> partitioning = partitionClassesWithPossibleClassInitializerDeadlock(group);
-    List<MergeGroup> newGroups = new LinkedList<>();
+    List<HorizontalMergeGroup> partitioning =
+        partitionClassesWithPossibleClassInitializerDeadlock(group);
+    List<HorizontalMergeGroup> newGroups = new LinkedList<>();
 
     // Revisit each partition. If the class initialization of a group member may initialize another
     // class (not necessarily a group member), and vice versa, then class initialization could
     // deadlock if the group member is merged with another class that is initialized concurrently.
-    for (MergeGroup partition : partitioning) {
-      List<MergeGroup> newGroupsFromPartition = new LinkedList<>();
+    for (HorizontalMergeGroup partition : partitioning) {
+      List<HorizontalMergeGroup> newGroupsFromPartition = new LinkedList<>();
       Tracer tracer = new Tracer(partition);
       for (DexProgramClass clazz : partition) {
-        MergeGroup newGroup = getOrCreateGroupFor(clazz, newGroupsFromPartition, tracer);
+        HorizontalMergeGroup newGroup = getOrCreateGroupFor(clazz, newGroupsFromPartition, tracer);
         if (newGroup != null) {
           newGroup.add(clazz);
         } else {
@@ -143,22 +144,22 @@
     return newGroups;
   }
 
-  private void commit(MergeGroup oldGroup, List<MergeGroup> newGroups) {
-    for (MergeGroup newGroup : newGroups) {
+  private void commit(HorizontalMergeGroup oldGroup, List<HorizontalMergeGroup> newGroups) {
+    for (HorizontalMergeGroup newGroup : newGroups) {
       for (DexProgramClass member : newGroup) {
         allGroups.put(member, newGroup);
       }
     }
     for (DexProgramClass member : oldGroup) {
-      MergeGroup newGroup = allGroups.get(member);
+      HorizontalMergeGroup newGroup = allGroups.get(member);
       if (newGroup == oldGroup) {
         allGroups.remove(member);
       }
     }
   }
 
-  private MergeGroup getOrCreateGroupFor(
-      DexProgramClass clazz, List<MergeGroup> groups, Tracer tracer) {
+  private HorizontalMergeGroup getOrCreateGroupFor(
+      DexProgramClass clazz, List<HorizontalMergeGroup> groups, Tracer tracer) {
     assert !tracer.hasPossibleClassInitializerDeadlock(clazz);
 
     if (clazz.hasClassInitializer()) {
@@ -174,18 +175,18 @@
       }
     }
 
-    for (MergeGroup group : groups) {
+    for (HorizontalMergeGroup group : groups) {
       if (canMerge(clazz, group, tracer)) {
         return group;
       }
     }
 
-    MergeGroup newGroup = new MergeGroup();
+    HorizontalMergeGroup newGroup = new HorizontalMergeGroup();
     groups.add(newGroup);
     return newGroup;
   }
 
-  private boolean canMerge(DexProgramClass clazz, MergeGroup group, Tracer tracer) {
+  private boolean canMerge(DexProgramClass clazz, HorizontalMergeGroup group, Tracer tracer) {
     for (DexProgramClass member : group) {
       // Check that the class initialization of the given class cannot reach the class initializer
       // of the current group member.
@@ -206,7 +207,8 @@
    * If the class initializer of one of the classes in the merge group is reached, then that class
    * is not eligible for merging.
    */
-  private List<MergeGroup> partitionClassesWithPossibleClassInitializerDeadlock(MergeGroup group) {
+  private List<HorizontalMergeGroup> partitionClassesWithPossibleClassInitializerDeadlock(
+      HorizontalMergeGroup group) {
     Set<DexProgramClass> superclasses = Sets.newIdentityHashSet();
     appView
         .appInfo()
@@ -230,13 +232,15 @@
     }
     tracer.trace();
 
-    MergeGroup notInitializedByInitializationOfParent = new MergeGroup();
-    Map<DexProgramClass, MergeGroup> partitioning = new LinkedHashMap<>();
+    HorizontalMergeGroup notInitializedByInitializationOfParent = new HorizontalMergeGroup();
+    Map<DexProgramClass, HorizontalMergeGroup> partitioning = new LinkedHashMap<>();
     for (DexProgramClass member : group) {
       if (tracer.hasPossibleClassInitializerDeadlock(member)) {
         DexProgramClass nearestLock = getNearestLock(member, superclasses);
         if (nearestLock != null) {
-          partitioning.computeIfAbsent(nearestLock, ignoreKey(MergeGroup::new)).add(member);
+          partitioning
+              .computeIfAbsent(nearestLock, ignoreKey(HorizontalMergeGroup::new))
+              .add(member);
         } else {
           // Ineligible for merging.
         }
@@ -245,7 +249,7 @@
       }
     }
 
-    return ImmutableList.<MergeGroup>builder()
+    return ImmutableList.<HorizontalMergeGroup>builder()
         .add(notInitializedByInitializationOfParent)
         .addAll(partitioning.values())
         .build();
@@ -276,9 +280,9 @@
   }
 
   @Override
-  public Void preprocess(Collection<MergeGroup> groups, ExecutorService executorService)
+  public Void preprocess(Collection<HorizontalMergeGroup> groups, ExecutorService executorService)
       throws ExecutionException {
-    for (MergeGroup group : groups) {
+    for (HorizontalMergeGroup group : groups) {
       for (DexProgramClass clazz : group) {
         allGroups.put(clazz, group);
       }
@@ -296,7 +300,7 @@
 
   private class Tracer {
 
-    final MergeGroup group;
+    final HorizontalMergeGroup group;
 
     // The members of the existing merge group, for efficient membership querying.
     final Set<DexProgramClass> groupMembers;
@@ -314,7 +318,7 @@
     // group).
     private Collection<DexProgramClass> tracingRoots;
 
-    Tracer(MergeGroup group) {
+    Tracer(HorizontalMergeGroup group) {
       this.group = group;
       this.groupMembers = SetUtils.newIdentityHashSet(group);
     }
@@ -469,7 +473,7 @@
             worklist.addIfNotSeen(superClass);
           }
 
-          MergeGroup other = allGroups.get(clazz);
+          HorizontalMergeGroup other = allGroups.get(clazz);
           if (other != null && other != group) {
             worklist.addIfNotSeen(other);
           }
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
index 6d83173..f4b929d 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoConstructorCollisions.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoConstructorCollisions.java
@@ -12,7 +12,7 @@
 import com.android.tools.r8.graph.DexProto;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger.Mode;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+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;
@@ -55,9 +55,10 @@
    * filtered group.
    */
   @Override
-  public Collection<MergeGroup> apply(MergeGroup group, Set<DexType> collisionResolution) {
-    MergeGroup newGroup =
-        new MergeGroup(
+  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);
   }
@@ -67,10 +68,11 @@
    * lead to constructor collisions.
    */
   @Override
-  public Set<DexType> preprocess(Collection<MergeGroup> groups, ExecutorService executorService) {
+  public Set<DexType> preprocess(
+      Collection<HorizontalMergeGroup> groups, ExecutorService executorService) {
     // Build a mapping from types to groups.
-    Map<DexType, MergeGroup> groupsByType = new IdentityHashMap<>();
-    for (MergeGroup group : groups) {
+    Map<DexType, HorizontalMergeGroup> groupsByType = new IdentityHashMap<>();
+    for (HorizontalMergeGroup group : groups) {
       for (DexProgramClass clazz : group) {
         groupsByType.put(clazz.getType(), group);
       }
@@ -109,7 +111,7 @@
     return collisionResolution;
   }
 
-  private DexProto rewriteProto(DexProto proto, Map<DexType, MergeGroup> groups) {
+  private DexProto rewriteProto(DexProto proto, Map<DexType, HorizontalMergeGroup> groups) {
     DexType[] parameters =
         ArrayUtils.map(
             proto.getParameters().values,
@@ -118,7 +120,7 @@
     return dexItemFactory.createProto(rewriteType(proto.getReturnType(), groups), parameters);
   }
 
-  private DexMethod rewriteReference(DexMethod method, Map<DexType, MergeGroup> groups) {
+  private DexMethod rewriteReference(DexMethod method, Map<DexType, HorizontalMergeGroup> groups) {
     return dexItemFactory.createMethod(
         rewriteType(method.getHolderType(), groups),
         rewriteProto(method.getProto(), groups),
@@ -126,7 +128,7 @@
   }
 
   @SuppressWarnings("ReferenceEquality")
-  private DexType rewriteType(DexType type, Map<DexType, MergeGroup> groups) {
+  private DexType rewriteType(DexType type, Map<DexType, HorizontalMergeGroup> groups) {
     if (type.isArrayType()) {
       DexType baseType = type.toBaseType(dexItemFactory);
       DexType rewrittenBaseType = rewriteType(baseType, groups);
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoDeadLocks.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoDeadLocks.java
index 7e32fd3..ee9f3a7 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoDeadLocks.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoDeadLocks.java
@@ -6,7 +6,7 @@
 
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import java.util.Collection;
@@ -28,14 +28,14 @@
   // TODO(b/270398965): Replace LinkedList.
   @Override
   @SuppressWarnings({"JdkObsolete", "MixedMutabilityReturnType"})
-  public Collection<MergeGroup> apply(MergeGroup group) {
+  public Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
     // Gather all synchronized classes.
-    Collection<MergeGroup> synchronizedGroups = new LinkedList<>();
+    Collection<HorizontalMergeGroup> synchronizedGroups = new LinkedList<>();
     group.removeIf(
         clazz -> {
           boolean synchronizationClass = isSynchronizationClass(clazz);
           if (synchronizationClass) {
-            MergeGroup synchronizedGroup = new MergeGroup();
+            HorizontalMergeGroup synchronizedGroup = new HorizontalMergeGroup();
             synchronizedGroup.add(clazz);
             synchronizedGroups.add(synchronizedGroup);
           }
@@ -46,7 +46,7 @@
       return Collections.singletonList(group);
     }
 
-    Iterator<MergeGroup> synchronizedGroupIterator = synchronizedGroups.iterator();
+    Iterator<HorizontalMergeGroup> synchronizedGroupIterator = synchronizedGroups.iterator();
     for (DexProgramClass clazz : group) {
       if (!synchronizedGroupIterator.hasNext()) {
         synchronizedGroupIterator = synchronizedGroups.iterator();
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoDefaultInterfaceMethodCollisions.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoDefaultInterfaceMethodCollisions.java
index e8494a3..f330807 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoDefaultInterfaceMethodCollisions.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoDefaultInterfaceMethodCollisions.java
@@ -19,7 +19,7 @@
 import com.android.tools.r8.graph.SubtypingInfo;
 import com.android.tools.r8.graph.TopDownClassHierarchyTraversal;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger.Mode;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicyWithPreprocessing;
 import com.android.tools.r8.horizontalclassmerging.policies.NoDefaultInterfaceMethodCollisions.InterfaceInfo;
 import com.android.tools.r8.utils.IterableUtils;
@@ -82,7 +82,8 @@
   }
 
   @Override
-  public Collection<MergeGroup> apply(MergeGroup group, Map<DexType, InterfaceInfo> infos) {
+  public Collection<HorizontalMergeGroup> apply(
+      HorizontalMergeGroup group, Map<DexType, InterfaceInfo> infos) {
     if (!group.isInterfaceGroup()) {
       return ImmutableList.of(group);
     }
@@ -95,7 +96,7 @@
     // TODO(b/173990042): Consider forming multiple groups instead of just filtering. In practice,
     //  this rarely leads to much filtering, though, since the use of default methods is somewhat
     //  limited.
-    MergeGroup newGroup = new MergeGroup();
+    HorizontalMergeGroup newGroup = new HorizontalMergeGroup();
     for (DexProgramClass clazz : group) {
       Set<DexMethod> newDefaultMethodsAddedToClassByMerge =
           computeNewDefaultMethodsAddedToClassByMerge(clazz, group, infos);
@@ -107,7 +108,7 @@
   }
 
   private Set<DexMethod> computeNewDefaultMethodsAddedToClassByMerge(
-      DexProgramClass clazz, MergeGroup group, Map<DexType, InterfaceInfo> infos) {
+      DexProgramClass clazz, HorizontalMergeGroup group, Map<DexType, InterfaceInfo> infos) {
     // Run through the other classes in the merge group, and add the default interface methods that
     // they declare (or inherit from a super interface) to a set.
     Set<DexMethod> newDefaultMethodsAddedToClassByMerge = Sets.newIdentityHashSet();
@@ -146,7 +147,7 @@
 
   @Override
   public Map<DexType, InterfaceInfo> preprocess(
-      Collection<MergeGroup> groups, ExecutorService executorService) {
+      Collection<HorizontalMergeGroup> groups, ExecutorService executorService) {
     SubtypingInfo subtypingInfo = SubtypingInfo.create(appView);
     Collection<DexProgramClass> classesOfInterest = computeClassesOfInterest(subtypingInfo);
     Map<DexType, DexMethodSignatureSet> inheritedClassMethodsPerClass =
@@ -163,7 +164,7 @@
 
     // Store the computed information for each interface that is subject to merging.
     Map<DexType, InterfaceInfo> infos = new IdentityHashMap<>();
-    for (MergeGroup group : groups) {
+    for (HorizontalMergeGroup group : groups) {
       if (group.isInterfaceGroup()) {
         for (DexProgramClass clazz : group) {
           infos.put(
@@ -277,13 +278,13 @@
       computeDefaultMethodsInheritedBySubclassesPerProgramClass(
           Collection<DexProgramClass> classesOfInterest,
           Map<DexType, Map<DexMethodSignature, Set<DexMethod>>> inheritedDefaultMethodsPerClass,
-          Collection<MergeGroup> groups,
+          Collection<HorizontalMergeGroup> groups,
           SubtypingInfo subtypingInfo) {
     // Build a mapping from class types to their merge group.
     Map<DexType, Iterable<DexProgramClass>> classGroupsByType =
         MapUtils.newIdentityHashMap(
             builder ->
-                Iterables.filter(groups, MergeGroup::isClassGroup)
+                Iterables.filter(groups, HorizontalMergeGroup::isClassGroup)
                     .forEach(group -> group.forEach(clazz -> builder.put(clazz.getType(), group))));
 
     // Copy the map from classes to their inherited default methods.
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoDefaultInterfaceMethodMerging.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoDefaultInterfaceMethodMerging.java
index e466650..318a2af 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoDefaultInterfaceMethodMerging.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoDefaultInterfaceMethodMerging.java
@@ -10,7 +10,7 @@
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger.Mode;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
 import com.android.tools.r8.utils.WorkList;
 import com.android.tools.r8.utils.collections.DexMethodSignatureMap;
@@ -43,11 +43,11 @@
   }
 
   @Override
-  public Collection<MergeGroup> apply(MergeGroup group) {
+  public Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
     // Split the group into smaller groups such that no default methods collide.
     // TODO(b/229951607): This fixes the ICCE issue for synthetic lambda classes, but a more
     //  general solution possibly extending the policy NoDefaultInterfaceMethodCollisions.
-    Map<MergeGroup, DexMethodSignatureMap<DexType>> newGroups = new LinkedHashMap<>();
+    Map<HorizontalMergeGroup, DexMethodSignatureMap<DexType>> newGroups = new LinkedHashMap<>();
     for (DexProgramClass clazz : group) {
       addClassToGroup(
           clazz,
@@ -63,14 +63,14 @@
   @SuppressWarnings("ReferenceEquality")
   private void addClassToGroup(
       DexProgramClass clazz,
-      Map<MergeGroup, DexMethodSignatureMap<DexType>> newGroups,
+      Map<HorizontalMergeGroup, DexMethodSignatureMap<DexType>> newGroups,
       Function<DexProgramClass, DexMethodSignatureMap<DexType>> fn) {
     DexMethodSignatureMap<DexType> classSignatures = fn.apply(clazz);
 
     // Find a group that does not have any collisions with `clazz`.
     nextGroup:
-    for (Entry<MergeGroup, DexMethodSignatureMap<DexType>> entry : newGroups.entrySet()) {
-      MergeGroup group = entry.getKey();
+    for (Entry<HorizontalMergeGroup, DexMethodSignatureMap<DexType>> entry : newGroups.entrySet()) {
+      HorizontalMergeGroup group = entry.getKey();
       DexMethodSignatureMap<DexType> groupSignatures = entry.getValue();
       if (!groupSignatures.containsAnyKeyOf(classSignatures.keySet())) {
         groupSignatures.putAll(classSignatures);
@@ -92,7 +92,7 @@
     }
 
     // Else create a new group.
-    newGroups.put(new MergeGroup(clazz), classSignatures);
+    newGroups.put(new HorizontalMergeGroup(clazz), classSignatures);
   }
 
   @SuppressWarnings("ReferenceEquality")
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
index aef65d3..b792e84 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInstanceInitializerMerging.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInstanceInitializerMerging.java
@@ -19,13 +19,13 @@
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.horizontalclassmerging.ClassInstanceFieldsMerger;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger.Mode;
+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.MergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicyWithPreprocessing;
 import com.android.tools.r8.utils.IterableUtils;
 import com.android.tools.r8.utils.ListUtils;
@@ -73,7 +73,7 @@
   @Override
   @SuppressWarnings("MixedMutabilityReturnType")
   public Map<DexProgramClass, Set<DexMethod>> preprocess(
-      Collection<MergeGroup> groups, ExecutorService executorService) {
+      Collection<HorizontalMergeGroup> groups, ExecutorService executorService) {
     if (!appView.options().canHaveNonReboundConstructorInvoke()) {
       return Collections.emptyMap();
     }
@@ -118,8 +118,8 @@
 
   @Override
   @SuppressWarnings("MixedMutabilityReturnType")
-  public Collection<MergeGroup> apply(
-      MergeGroup group, Map<DexProgramClass, Set<DexMethod>> absentInstanceInitializers) {
+  public Collection<HorizontalMergeGroup> apply(
+      HorizontalMergeGroup group, Map<DexProgramClass, Set<DexMethod>> absentInstanceInitializers) {
     assert !group.hasTarget();
     assert !group.hasInstanceFieldMap();
 
@@ -148,7 +148,8 @@
     group.selectTarget(appView);
     group.selectInstanceFieldMap(appView);
 
-    Map<MergeGroup, Map<DexMethodSignature, InstanceInitializer>> newGroups = new LinkedHashMap<>();
+    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
@@ -164,12 +165,12 @@
     // Partition group into smaller groups where there are no (non-equivalent) instance initializer
     // collisions.
     for (DexProgramClass clazz : group) {
-      MergeGroup newGroup = null;
+      HorizontalMergeGroup newGroup = null;
       Map<DexMethodSignature, InstanceInitializer> classInstanceInitializers =
           getInstanceInitializersByRelaxedSignature(clazz, absentInstanceInitializers);
-      for (Entry<MergeGroup, Map<DexMethodSignature, InstanceInitializer>> entry :
+      for (Entry<HorizontalMergeGroup, Map<DexMethodSignature, InstanceInitializer>> entry :
           newGroups.entrySet()) {
-        MergeGroup candidateGroup = entry.getKey();
+        HorizontalMergeGroup candidateGroup = entry.getKey();
         Map<DexMethodSignature, InstanceInitializer> groupInstanceInitializers = entry.getValue();
         if (canAddClassToGroup(
             classInstanceInitializers,
@@ -183,12 +184,12 @@
       if (newGroup != null) {
         newGroup.add(clazz);
       } else {
-        newGroups.put(new MergeGroup(clazz), classInstanceInitializers);
+        newGroups.put(new HorizontalMergeGroup(clazz), classInstanceInitializers);
       }
     }
 
     // Remove trivial groups and finalize the newly created groups.
-    Collection<MergeGroup> newNonTrivialGroups = removeTrivialGroups(newGroups.keySet());
+    Collection<HorizontalMergeGroup> newNonTrivialGroups = removeTrivialGroups(newGroups.keySet());
     setInstanceFieldMaps(newNonTrivialGroups, group);
     return newNonTrivialGroups;
   }
@@ -265,7 +266,7 @@
   }
 
   private Optional<InstanceInitializerDescription> getOrComputeInstanceInitializerDescription(
-      MergeGroup group,
+      HorizontalMergeGroup group,
       InstanceInitializer instanceInitializer,
       Map<DexMethod, Optional<InstanceInitializerDescription>> instanceInitializerDescriptions) {
     return instanceInitializerDescriptions.computeIfAbsent(
@@ -296,8 +297,9 @@
         : instanceInitializerReference;
   }
 
-  private void setInstanceFieldMaps(Iterable<MergeGroup> newGroups, MergeGroup group) {
-    for (MergeGroup newGroup : newGroups) {
+  private void setInstanceFieldMaps(
+      Iterable<HorizontalMergeGroup> newGroups, HorizontalMergeGroup group) {
+    for (HorizontalMergeGroup newGroup : newGroups) {
       // Set target.
       newGroup.selectTarget(appView);
 
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
index 07b2fc7..21283e1 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoVirtualMethodMerging.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoVirtualMethodMerging.java
@@ -14,7 +14,7 @@
 import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger.Mode;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+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;
@@ -40,17 +40,19 @@
   }
 
   @Override
-  public Collection<MergeGroup> apply(MergeGroup group) {
-    Map<MergeGroup, Map<DexMethodSignature, ProgramMethod>> newGroups = new LinkedHashMap<>();
+  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));
 
-      MergeGroup newGroup = null;
-      for (Entry<MergeGroup, Map<DexMethodSignature, ProgramMethod>> entry : newGroups.entrySet()) {
-        MergeGroup candidateGroup = entry.getKey();
+      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)) {
@@ -63,7 +65,7 @@
       if (newGroup != null) {
         newGroup.add(clazz);
       } else {
-        newGroups.put(new MergeGroup(clazz), classMethods);
+        newGroups.put(new HorizontalMergeGroup(clazz), classMethods);
       }
     }
     return removeTrivialGroups(newGroups.keySet());
@@ -72,7 +74,7 @@
   private boolean canAddNonAbstractVirtualMethodsToGroup(
       DexProgramClass clazz,
       Collection<ProgramMethod> methods,
-      MergeGroup group,
+      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.
@@ -92,7 +94,8 @@
     return true;
   }
 
-  private boolean hasNonAbstractDefinitionInHierarchy(MergeGroup group, ProgramMethod method) {
+  private boolean hasNonAbstractDefinitionInHierarchy(
+      HorizontalMergeGroup group, ProgramMethod method) {
     return hasNonAbstractDefinitionInSuperClass(group.getSuperType(), method)
         || hasNonAbstractDefinitionInSuperInterface(
             SetUtils.newIdentityHashSet(IterableUtils.flatMap(group, DexClass::getInterfaces)),
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoWeakerAccessPrivileges.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoWeakerAccessPrivileges.java
index 2305438..3daa113 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoWeakerAccessPrivileges.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoWeakerAccessPrivileges.java
@@ -10,7 +10,7 @@
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.ImmediateProgramSubtypingInfo;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
 import com.android.tools.r8.optimize.argumentpropagation.utils.ProgramClassesBidirectedGraph;
 import com.android.tools.r8.utils.collections.DexMethodSignatureSet;
@@ -46,14 +46,14 @@
   // TODO(b/270398965): Replace LinkedList.
   @SuppressWarnings("JdkObsolete")
   @Override
-  public Collection<MergeGroup> apply(MergeGroup group) {
-    List<MergeGroup> newMergeGroups = new LinkedList<>();
-    Map<MergeGroup, DexMethodSignatureSet> inheritedInterfaceMethodsPerGroup =
+  public Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
+    List<HorizontalMergeGroup> newMergeGroups = new LinkedList<>();
+    Map<HorizontalMergeGroup, DexMethodSignatureSet> inheritedInterfaceMethodsPerGroup =
         new IdentityHashMap<>();
     for (DexProgramClass clazz : group) {
       // Find an existing merge group that the current class can be added to.
-      MergeGroup newMergeGroup = null;
-      for (MergeGroup candidateMergeGroup : newMergeGroups) {
+      HorizontalMergeGroup newMergeGroup = null;
+      for (HorizontalMergeGroup candidateMergeGroup : newMergeGroups) {
         DexMethodSignatureSet inheritedInterfaceMethodsInGroup =
             inheritedInterfaceMethodsPerGroup.get(candidateMergeGroup);
         if (canAddToGroup(clazz, candidateMergeGroup, inheritedInterfaceMethodsInGroup)) {
@@ -65,7 +65,7 @@
       DexMethodSignatureSet inheritedInterfaceMethodsInGroup;
       if (newMergeGroup == null) {
         // Form a new singleton merge group from the current class.
-        newMergeGroup = new MergeGroup(clazz);
+        newMergeGroup = new HorizontalMergeGroup(clazz);
         newMergeGroups.add(newMergeGroup);
         inheritedInterfaceMethodsInGroup = DexMethodSignatureSet.create();
         inheritedInterfaceMethodsPerGroup.put(newMergeGroup, inheritedInterfaceMethodsInGroup);
@@ -86,7 +86,7 @@
 
   private boolean canAddToGroup(
       DexProgramClass clazz,
-      MergeGroup group,
+      HorizontalMergeGroup group,
       DexMethodSignatureSet inheritedInterfaceMethodsInGroup) {
     // We need to ensure that adding class to the group is OK.
     DexMethodSignatureSet nonPublicVirtualMethodSignaturesInClassComponent =
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/OnlyDirectlyConnectedOrUnrelatedInterfaces.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/OnlyDirectlyConnectedOrUnrelatedInterfaces.java
index 9812a26..db74f25 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/OnlyDirectlyConnectedOrUnrelatedInterfaces.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/OnlyDirectlyConnectedOrUnrelatedInterfaces.java
@@ -13,7 +13,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.SubtypingInfo;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger.Mode;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicyWithPreprocessing;
 import com.android.tools.r8.utils.SetUtils;
 import com.android.tools.r8.utils.WorkList;
@@ -62,7 +62,7 @@
   private final Mode mode;
 
   // The interface merge groups that this policy has committed to so far.
-  private final Map<DexProgramClass, MergeGroup> committed = new IdentityHashMap<>();
+  private final Map<DexProgramClass, HorizontalMergeGroup> committed = new IdentityHashMap<>();
 
   public OnlyDirectlyConnectedOrUnrelatedInterfaces(
       AppView<? extends AppInfoWithClassHierarchy> appView, Mode mode) {
@@ -73,7 +73,8 @@
   // TODO(b/270398965): Replace LinkedList.
   @Override
   @SuppressWarnings({"JdkObsolete", "MixedMutabilityReturnType"})
-  public Collection<MergeGroup> apply(MergeGroup group, SubtypingInfo subtypingInfo) {
+  public Collection<HorizontalMergeGroup> apply(
+      HorizontalMergeGroup group, SubtypingInfo subtypingInfo) {
     if (!group.isInterfaceGroup()) {
       return ImmutableList.of(group);
     }
@@ -104,9 +105,9 @@
       committed.put(clazz, newGroup.getGroup());
     }
 
-    List<MergeGroup> newGroups = new LinkedList<>();
+    List<HorizontalMergeGroup> newGroups = new LinkedList<>();
     for (MergeGroupWithInfo newGroupWithInfo : newGroupsWithInfo) {
-      MergeGroup newGroup = newGroupWithInfo.getGroup();
+      HorizontalMergeGroup newGroup = newGroupWithInfo.getGroup();
       if (newGroup.isTrivial()) {
         assert !newGroup.isEmpty();
         committed.remove(newGroup.getClasses().getFirst());
@@ -135,7 +136,7 @@
     workList.addIgnoringSeenSet(clazz);
     workList.process(
         interfaceDefinition -> {
-          MergeGroup group = committed.get(interfaceDefinition);
+          HorizontalMergeGroup group = committed.get(interfaceDefinition);
           if (group != null) {
             workList.addIfNotSeen(group);
           }
@@ -163,7 +164,8 @@
   }
 
   @Override
-  public SubtypingInfo preprocess(Collection<MergeGroup> groups, ExecutorService executorService) {
+  public SubtypingInfo preprocess(
+      Collection<HorizontalMergeGroup> groups, ExecutorService executorService) {
     return SubtypingInfo.create(appView);
   }
 
@@ -174,7 +176,7 @@
 
   static class MergeGroupWithInfo {
 
-    private final MergeGroup group;
+    private final HorizontalMergeGroup group;
     private final Set<DexProgramClass> members;
     private final Set<DexProgramClass> superInterfaces;
     private final Set<DexProgramClass> subInterfaces;
@@ -183,7 +185,7 @@
         DexProgramClass clazz,
         Set<DexProgramClass> superInterfaces,
         Set<DexProgramClass> subInterfaces) {
-      this.group = new MergeGroup(clazz);
+      this.group = new HorizontalMergeGroup(clazz);
       this.members = SetUtils.newIdentityHashSet(clazz);
       this.superInterfaces = superInterfaces;
       this.subInterfaces = subInterfaces;
@@ -206,7 +208,7 @@
       subInterfaces.remove(clazz);
     }
 
-    MergeGroup getGroup() {
+    HorizontalMergeGroup getGroup() {
       return group;
     }
 
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 63e334b..b891bcd 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
@@ -10,7 +10,7 @@
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger.Mode;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.OptionalBool;
@@ -101,10 +101,10 @@
 
   public static class TargetGroup {
 
-    private final MergeGroup group = new MergeGroup();
+    private final HorizontalMergeGroup group = new HorizontalMergeGroup();
     private final Map<DexMethodSignature, MethodCharacteristics> methodMap = new HashMap<>();
 
-    public MergeGroup getGroup() {
+    public HorizontalMergeGroup getGroup() {
       return group;
     }
 
@@ -139,7 +139,7 @@
   // TODO(b/270398965): Replace LinkedList.
   @SuppressWarnings("JdkObsolete")
   @Override
-  public Collection<MergeGroup> apply(MergeGroup group) {
+  public Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
     List<TargetGroup> groups = new ArrayList<>();
 
     for (DexProgramClass clazz : group) {
@@ -152,7 +152,7 @@
       }
     }
 
-    LinkedList<MergeGroup> newGroups = new LinkedList<>();
+    LinkedList<HorizontalMergeGroup> newGroups = new LinkedList<>();
     for (TargetGroup newGroup : groups) {
       if (!newGroup.getGroup().isTrivial()) {
         newGroups.add(newGroup.getGroup());
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreventClassMethodAndDefaultMethodCollisions.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreventClassMethodAndDefaultMethodCollisions.java
index 2a3602c..06e39d7 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreventClassMethodAndDefaultMethodCollisions.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreventClassMethodAndDefaultMethodCollisions.java
@@ -14,7 +14,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ImmediateProgramSubtypingInfo;
 import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
 import com.android.tools.r8.utils.collections.DexMethodSignatureSet;
 import com.google.common.collect.ImmutableList;
@@ -151,7 +151,7 @@
   }
 
   @Override
-  public Collection<MergeGroup> apply(MergeGroup group) {
+  public Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
     // This policy is specific to issues that may arise from merging (non-interface) classes.
     if (group.isInterfaceGroup()) {
       return ImmutableList.of(group);
@@ -162,7 +162,7 @@
       signatures.addAllMethods(clazz.methods());
     }
 
-    Map<DispatchSignature, MergeGroup> newGroups = new LinkedHashMap<>();
+    Map<DispatchSignature, HorizontalMergeGroup> newGroups = new LinkedHashMap<>();
     for (DexProgramClass clazz : group) {
       DexMethodSignatureSet clazzReserved = computeReservedSignaturesForClass(clazz);
       DispatchSignature dispatchSignature = new DispatchSignature();
@@ -178,7 +178,7 @@
         }
         dispatchSignature.addSignature(signature, category);
       }
-      newGroups.computeIfAbsent(dispatchSignature, ignore -> new MergeGroup()).add(clazz);
+      newGroups.computeIfAbsent(dispatchSignature, ignore -> new HorizontalMergeGroup()).add(clazz);
     }
     return removeTrivialGroups(newGroups.values());
   }
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 29a9147..bfc4cd1 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
@@ -15,7 +15,7 @@
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger.Mode;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
 import com.android.tools.r8.utils.TraversalContinuation;
 import com.android.tools.r8.verticalclassmerging.IllegalAccessDetector;
@@ -122,10 +122,12 @@
 
   /** Sort unrestricted classes into restricted classes if they are in the same package. */
   void tryFindRestrictedPackage(
-      MergeGroup unrestrictedClasses, Map<String, MergeGroup> restrictedClasses) {
+      HorizontalMergeGroup unrestrictedClasses,
+      Map<String, HorizontalMergeGroup> restrictedClasses) {
     unrestrictedClasses.removeIf(
         clazz -> {
-          MergeGroup restrictedPackage = restrictedClasses.get(clazz.type.getPackageDescriptor());
+          HorizontalMergeGroup restrictedPackage =
+              restrictedClasses.get(clazz.type.getPackageDescriptor());
           if (restrictedPackage != null) {
             restrictedPackage.add(clazz);
             return true;
@@ -135,15 +137,16 @@
   }
 
   @Override
-  public Collection<MergeGroup> apply(MergeGroup group) {
-    Map<String, MergeGroup> restrictedClasses = new LinkedHashMap<>();
-    MergeGroup unrestrictedClasses = new MergeGroup();
+  public Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
+    Map<String, HorizontalMergeGroup> restrictedClasses = new LinkedHashMap<>();
+    HorizontalMergeGroup unrestrictedClasses = new HorizontalMergeGroup();
 
     // Sort all restricted classes into packages.
     for (DexProgramClass clazz : group) {
       if (shouldRestrictMergingAcrossPackageBoundary(clazz)) {
         restrictedClasses
-            .computeIfAbsent(clazz.getType().getPackageDescriptor(), ignore -> new MergeGroup())
+            .computeIfAbsent(
+                clazz.getType().getPackageDescriptor(), ignore -> new HorizontalMergeGroup())
             .add(clazz);
       } else {
         unrestrictedClasses.add(clazz);
@@ -155,7 +158,7 @@
 
     // TODO(b/166577694): Add the unrestricted classes to restricted groups, but ensure they aren't
     // the merge target.
-    Collection<MergeGroup> groups = new ArrayList<>(restrictedClasses.size() + 1);
+    Collection<HorizontalMergeGroup> groups = new ArrayList<>(restrictedClasses.size() + 1);
     if (unrestrictedClasses.size() > 1) {
       groups.add(unrestrictedClasses);
     }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/SamePackageForNonGlobalMergeSynthetic.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/SamePackageForNonGlobalMergeSynthetic.java
index db6d282..a95bafe 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/SamePackageForNonGlobalMergeSynthetic.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/SamePackageForNonGlobalMergeSynthetic.java
@@ -9,7 +9,7 @@
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
 import com.android.tools.r8.synthesis.SyntheticItems;
 import com.google.common.collect.Iterables;
@@ -28,10 +28,12 @@
 
   /** Sort unrestricted classes into restricted classes if they are in the same package. */
   private void tryFindRestrictedPackage(
-      MergeGroup unrestrictedClasses, Map<String, MergeGroup> restrictedClasses) {
+      HorizontalMergeGroup unrestrictedClasses,
+      Map<String, HorizontalMergeGroup> restrictedClasses) {
     unrestrictedClasses.removeIf(
         clazz -> {
-          MergeGroup restrictedPackage = restrictedClasses.get(clazz.type.getPackageDescriptor());
+          HorizontalMergeGroup restrictedPackage =
+              restrictedClasses.get(clazz.type.getPackageDescriptor());
           if (restrictedPackage != null) {
             restrictedPackage.add(clazz);
             return true;
@@ -41,9 +43,9 @@
   }
 
   @Override
-  public Collection<MergeGroup> apply(MergeGroup group) {
-    Map<String, MergeGroup> restrictedClasses = new LinkedHashMap<>();
-    MergeGroup unrestrictedClasses = new MergeGroup();
+  public Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
+    Map<String, HorizontalMergeGroup> restrictedClasses = new LinkedHashMap<>();
+    HorizontalMergeGroup unrestrictedClasses = new HorizontalMergeGroup();
     SyntheticItems syntheticItems = appView.getSyntheticItems();
 
     // Sort all restricted classes into packages.
@@ -56,7 +58,7 @@
                   || !kind.asSyntheticMethodKind().isAllowGlobalMerging())) {
         restrictedClasses
             .computeIfAbsent(
-                clazz.getType().getPackageDescriptor(), ignoreArgument(MergeGroup::new))
+                clazz.getType().getPackageDescriptor(), ignoreArgument(HorizontalMergeGroup::new))
             .add(clazz);
       } else {
         unrestrictedClasses.add(clazz);
@@ -66,7 +68,7 @@
     tryFindRestrictedPackage(unrestrictedClasses, restrictedClasses);
     removeTrivialGroups(restrictedClasses.values());
 
-    Collection<MergeGroup> groups = new ArrayList<>(restrictedClasses.size() + 1);
+    Collection<HorizontalMergeGroup> groups = new ArrayList<>(restrictedClasses.size() + 1);
     if (unrestrictedClasses.size() > 1) {
       groups.add(unrestrictedClasses);
     }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/VerifyMultiClassPolicyAlwaysSatisfied.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/VerifyMultiClassPolicyAlwaysSatisfied.java
index 7ad1e60..e62195b 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/VerifyMultiClassPolicyAlwaysSatisfied.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/VerifyMultiClassPolicyAlwaysSatisfied.java
@@ -4,7 +4,7 @@
 
 package com.android.tools.r8.horizontalclassmerging.policies;
 
-import com.android.tools.r8.horizontalclassmerging.MergeGroup;
+import com.android.tools.r8.horizontalclassmerging.HorizontalMergeGroup;
 import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
 import com.android.tools.r8.utils.InternalOptions;
 import java.util.Collection;
@@ -29,15 +29,15 @@
   }
 
   @Override
-  public Collection<MergeGroup> apply(MergeGroup group) {
+  public Collection<HorizontalMergeGroup> apply(HorizontalMergeGroup group) {
     assert verifySameAppliedGroup(group);
     return Collections.singletonList(group);
   }
 
-  private boolean verifySameAppliedGroup(MergeGroup group) {
-    Collection<MergeGroup> applied = policy.apply(group);
+  private boolean verifySameAppliedGroup(HorizontalMergeGroup group) {
+    Collection<HorizontalMergeGroup> applied = policy.apply(group);
     assert applied.size() == 1;
-    MergeGroup appliedGroup = applied.iterator().next();
+    HorizontalMergeGroup appliedGroup = applied.iterator().next();
     assert appliedGroup.size() == group.size() && group.containsAll(appliedGroup);
     return true;
   }
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index e069c30..24a5e7e 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -26,6 +26,7 @@
 import com.android.tools.r8.Version;
 import com.android.tools.r8.androidapi.ComputedApiLevel;
 import com.android.tools.r8.cf.CfVersion;
+import com.android.tools.r8.classmerging.Policy;
 import com.android.tools.r8.debuginfo.DebugRepresentation;
 import com.android.tools.r8.dex.ApplicationReader.ProgramClassConflictResolver;
 import com.android.tools.r8.dex.Constants;
@@ -66,7 +67,6 @@
 import com.android.tools.r8.graph.lens.GraphLens;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger;
 import com.android.tools.r8.horizontalclassmerging.HorizontallyMergedClasses;
-import com.android.tools.r8.horizontalclassmerging.Policy;
 import com.android.tools.r8.inspector.internal.InspectorImpl;
 import com.android.tools.r8.ir.analysis.proto.ProtoReferences;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerPolicy.java b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerPolicy.java
index 9635b3c..5ecda24 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerPolicy.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerPolicy.java
@@ -7,6 +7,7 @@
 
 import com.android.tools.r8.androidapi.AndroidApiLevelCompute;
 import com.android.tools.r8.androidapi.ComputedApiLevel;
+import com.android.tools.r8.classmerging.Policy;
 import com.android.tools.r8.features.FeatureSplitBoundaryOptimizationUtils;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.CfCode;
@@ -20,7 +21,6 @@
 import com.android.tools.r8.graph.LookupResult.LookupResultSuccess;
 import com.android.tools.r8.graph.ObjectAllocationInfoCollection;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.horizontalclassmerging.Policy;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
 import com.android.tools.r8.profile.startup.optimization.StartupBoundaryOptimizationUtils;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerPolicyExecutor.java b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerPolicyExecutor.java
index e55dacb..6a0438c 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerPolicyExecutor.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerPolicyExecutor.java
@@ -3,11 +3,11 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.verticalclassmerging;
 
+import com.android.tools.r8.classmerging.Policy;
+import com.android.tools.r8.classmerging.PolicyExecutor;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.ImmediateProgramSubtypingInfo;
-import com.android.tools.r8.horizontalclassmerging.Policy;
-import com.android.tools.r8.horizontalclassmerging.PolicyExecutor;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.Timing;
@@ -18,7 +18,6 @@
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 
-// TODO(b/315252934): Parallelize policy execution over connected program components.
 public class VerticalClassMergerPolicyExecutor extends PolicyExecutor<VerticalMergeGroup> {
 
   private final AppView<AppInfoWithLiveness> appView;
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalMergeGroup.java b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalMergeGroup.java
index 28b2a82..1b434ea 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalMergeGroup.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalMergeGroup.java
@@ -3,10 +3,10 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.verticalclassmerging;
 
+import com.android.tools.r8.classmerging.MergeGroup;
 import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.horizontalclassmerging.MergeGroupBase;
 
-public class VerticalMergeGroup extends MergeGroupBase {
+public class VerticalMergeGroup extends MergeGroup {
 
   private final DexProgramClass source;
   private final DexProgramClass target;
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClinitDeadlockAfterMergingMultipleGroupsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClinitDeadlockAfterMergingMultipleGroupsTest.java
index 635ff0e..b2dc326 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClinitDeadlockAfterMergingMultipleGroupsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClinitDeadlockAfterMergingMultipleGroupsTest.java
@@ -7,9 +7,9 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.classmerging.Policy;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.horizontalclassmerging.MultiClassSameReferencePolicy;
-import com.android.tools.r8.horizontalclassmerging.Policy;
 import com.google.common.collect.ImmutableList;
 import org.junit.Test;
 import org.junit.runner.RunWith;