diff --git a/src/library_desugar/desugar_jdk_libs.json b/src/library_desugar/desugar_jdk_libs.json
index dc7ac7b..3a9c0b4 100644
--- a/src/library_desugar/desugar_jdk_libs.json
+++ b/src/library_desugar/desugar_jdk_libs.json
@@ -2,7 +2,7 @@
   "configuration_format_version": 3,
   "group_id" : "com.tools.android",
   "artifact_id" : "desugar_jdk_libs",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "required_compilation_api_level": 26,
   "synthesized_library_classes_package_prefix": "j$.",
   "support_all_callbacks_from_library": true,
@@ -77,12 +77,6 @@
         "java.time.": "j$.time.",
         "java.util.Desugar": "j$.util.Desugar"
       },
-      "backport": {
-        "java.lang.Double8": "java.lang.Double",
-        "java.lang.Integer8": "java.lang.Integer",
-        "java.lang.Long8": "java.lang.Long",
-        "java.lang.Math8": "java.lang.Math"
-      },
       "retarget_lib_member": {
         "java.util.Date#toInstant": "java.util.DesugarDate",
         "java.util.GregorianCalendar#toZonedDateTime": "java.util.DesugarGregorianCalendar",
diff --git a/src/main/java/com/android/tools/r8/L8Command.java b/src/main/java/com/android/tools/r8/L8Command.java
index b552bb2..4c235d9 100644
--- a/src/main/java/com/android/tools/r8/L8Command.java
+++ b/src/main/java/com/android/tools/r8/L8Command.java
@@ -21,6 +21,7 @@
 import com.android.tools.r8.utils.Reporter;
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.android.tools.r8.utils.ThreadUtils;
+import com.google.common.collect.ImmutableList;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -315,6 +316,9 @@
         }
         r8Builder.addProguardConfiguration(
             libraryConfiguration.getExtraKeepRules(), Origin.unknown());
+        // TODO(b/180903899): Remove rule when -dontwarn sun.misc.Unsafe is part of config.
+        r8Builder.addProguardConfiguration(
+            ImmutableList.of("-dontwarn sun.misc.Unsafe"), Origin.unknown());
         r8Builder.addProguardConfigurationFiles(proguardConfigFiles);
         r8Builder.setDisableDesugaring(true);
         r8Builder.skipDump();
diff --git a/src/main/java/com/android/tools/r8/annotations/SynthesizedClassMap.java b/src/main/java/com/android/tools/r8/annotations/SynthesizedClassMap.java
deleted file mode 100644
index b46a2ba..0000000
--- a/src/main/java/com/android/tools/r8/annotations/SynthesizedClassMap.java
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright (c) 2017, 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.annotations;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-@Retention(RetentionPolicy.CLASS)
-@Target(ElementType.TYPE)
-public @interface SynthesizedClassMap {
-  Class<?>[] value() default {};
-}
diff --git a/src/main/java/com/android/tools/r8/dex/VirtualFile.java b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
index 8f56827..614ac4d 100644
--- a/src/main/java/com/android/tools/r8/dex/VirtualFile.java
+++ b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
@@ -467,7 +467,7 @@
 
       // Pull out the classes that should go into feature splits.
       Map<FeatureSplit, Set<DexProgramClass>> featureSplitClasses =
-          classToFeatureSplitMap.getFeatureSplitClasses(classes);
+          classToFeatureSplitMap.getFeatureSplitClasses(classes, appView.getSyntheticItems());
       if (featureSplitClasses.size() > 0) {
         for (Set<DexProgramClass> featureClasses : featureSplitClasses.values()) {
           classes.removeAll(featureClasses);
@@ -475,14 +475,17 @@
       }
       List<DexProgramClass> toRemove = new ArrayList<>();
       for (DexProgramClass dexProgramClass : classes) {
-        Collection<DexProgramClass> synthesizedFrom = dexProgramClass.getSynthesizedFrom();
-        if (!synthesizedFrom.isEmpty()) {
-          DexProgramClass from = Iterables.getFirst(synthesizedFrom, null);
-          FeatureSplit featureSplit = classToFeatureSplitMap.getFeatureSplit(from);
-          if (!featureSplit.isBase()) {
-            Set<DexProgramClass> dexProgramClasses = featureSplitClasses.get(featureSplit);
-            dexProgramClasses.add(dexProgramClass);
-            toRemove.add(dexProgramClass);
+        if (appView.getSyntheticItems().isLegacySyntheticClass(dexProgramClass)) {
+          Collection<DexProgramClass> synthesizedFrom = dexProgramClass.getSynthesizedFrom();
+          if (!synthesizedFrom.isEmpty()) {
+            DexProgramClass from = Iterables.getFirst(synthesizedFrom, null);
+            FeatureSplit featureSplit =
+                classToFeatureSplitMap.getFeatureSplit(from, appView.getSyntheticItems());
+            if (!featureSplit.isBase()) {
+              Set<DexProgramClass> dexProgramClasses = featureSplitClasses.get(featureSplit);
+              dexProgramClasses.add(dexProgramClass);
+              toRemove.add(dexProgramClass);
+            }
           }
         }
       }
diff --git a/src/main/java/com/android/tools/r8/features/ClassToFeatureSplitMap.java b/src/main/java/com/android/tools/r8/features/ClassToFeatureSplitMap.java
index 1ea1595..d96643d 100644
--- a/src/main/java/com/android/tools/r8/features/ClassToFeatureSplitMap.java
+++ b/src/main/java/com/android/tools/r8/features/ClassToFeatureSplitMap.java
@@ -17,11 +17,15 @@
 import com.android.tools.r8.graph.ProgramDefinition;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.PrunedItems;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.synthesis.SyntheticItems;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.Reporter;
 import com.google.common.collect.Sets;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.IdentityHashMap;
+import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 
@@ -88,9 +92,9 @@
     return result;
   }
 
-  public int compareFeatureSplitsForDexTypes(DexType a, DexType b) {
-    FeatureSplit featureSplitA = getFeatureSplit(a);
-    FeatureSplit featureSplitB = getFeatureSplit(b);
+  public int compareFeatureSplitsForDexTypes(DexType a, DexType b, SyntheticItems syntheticItems) {
+    FeatureSplit featureSplitA = getFeatureSplit(a, syntheticItems);
+    FeatureSplit featureSplitB = getFeatureSplit(b, syntheticItems);
     assert featureSplitA != null;
     assert featureSplitB != null;
     if (featureSplitA == featureSplitB) {
@@ -109,10 +113,10 @@
   }
 
   public Map<FeatureSplit, Set<DexProgramClass>> getFeatureSplitClasses(
-      Set<DexProgramClass> classes) {
+      Set<DexProgramClass> classes, SyntheticItems syntheticItems) {
     Map<FeatureSplit, Set<DexProgramClass>> result = new IdentityHashMap<>();
     for (DexProgramClass clazz : classes) {
-      FeatureSplit featureSplit = getFeatureSplit(clazz);
+      FeatureSplit featureSplit = getFeatureSplit(clazz, syntheticItems);
       if (featureSplit != null && !featureSplit.isBase()) {
         result.computeIfAbsent(featureSplit, ignore -> Sets.newIdentityHashSet()).add(clazz);
       }
@@ -120,41 +124,61 @@
     return result;
   }
 
-  public FeatureSplit getFeatureSplit(ProgramDefinition clazz) {
-    return getFeatureSplit(clazz.getContextType());
+  public FeatureSplit getFeatureSplit(ProgramDefinition clazz, SyntheticItems syntheticItems) {
+    return getFeatureSplit(clazz.getContextType(), syntheticItems);
   }
 
-  public FeatureSplit getFeatureSplit(DexType type) {
+  public FeatureSplit getFeatureSplit(DexType type, SyntheticItems syntheticItems) {
+    Collection<DexType> contexts = syntheticItems.getSynthesizingContexts(type);
+    if (!contexts.isEmpty()) {
+      Iterator<DexType> iterator = contexts.iterator();
+      DexType context = iterator.next();
+      FeatureSplit feature = classToFeatureSplitMap.getOrDefault(context, FeatureSplit.BASE);
+      assert verifyConsistentFeatureContexts(iterator, feature);
+      return feature;
+    }
     return classToFeatureSplitMap.getOrDefault(type, FeatureSplit.BASE);
   }
 
+  private boolean verifyConsistentFeatureContexts(
+      Iterator<DexType> contextIterator, FeatureSplit feature) {
+    while (contextIterator.hasNext()) {
+      assert feature
+          == classToFeatureSplitMap.getOrDefault(contextIterator.next(), FeatureSplit.BASE);
+    }
+    return true;
+  }
+
   public boolean isEmpty() {
     return classToFeatureSplitMap.isEmpty();
   }
 
-  public boolean isInBase(DexProgramClass clazz) {
-    return getFeatureSplit(clazz).isBase();
+  public boolean isInBase(DexProgramClass clazz, SyntheticItems syntheticItems) {
+    return getFeatureSplit(clazz, syntheticItems).isBase();
   }
 
-  public boolean isInBaseOrSameFeatureAs(DexProgramClass clazz, ProgramDefinition context) {
-    FeatureSplit split = getFeatureSplit(clazz);
-    return split.isBase() || split == getFeatureSplit(context);
+  public boolean isInBaseOrSameFeatureAs(
+      DexProgramClass clazz, ProgramDefinition context, SyntheticItems syntheticItems) {
+    FeatureSplit split = getFeatureSplit(clazz, syntheticItems);
+    return split.isBase() || split == getFeatureSplit(context, syntheticItems);
   }
 
-  public boolean isInFeature(DexProgramClass clazz) {
-    return !isInBase(clazz);
+  public boolean isInFeature(DexProgramClass clazz, SyntheticItems syntheticItems) {
+    return !isInBase(clazz, syntheticItems);
   }
 
-  public boolean isInSameFeatureOrBothInBase(ProgramMethod a, ProgramMethod b) {
-    return isInSameFeatureOrBothInBase(a.getHolder(), b.getHolder());
+  public boolean isInSameFeatureOrBothInBase(
+      ProgramMethod a, ProgramMethod b, SyntheticItems syntheticItems) {
+    return isInSameFeatureOrBothInBase(a.getHolder(), b.getHolder(), syntheticItems);
   }
 
-  public boolean isInSameFeatureOrBothInBase(DexProgramClass a, DexProgramClass b) {
-    return getFeatureSplit(a) == getFeatureSplit(b);
+  public boolean isInSameFeatureOrBothInBase(
+      DexProgramClass a, DexProgramClass b, SyntheticItems syntheticItems) {
+    return getFeatureSplit(a, syntheticItems) == getFeatureSplit(b, syntheticItems);
   }
 
-  public boolean isInSameFeatureOrBothInBase(DexType a, DexType b) {
-    return getFeatureSplit(a) == getFeatureSplit(b);
+  public boolean isInSameFeatureOrBothInBase(DexType a, DexType b, SyntheticItems syntheticItems) {
+    return getFeatureSplit(a, syntheticItems) == getFeatureSplit(b, syntheticItems);
   }
 
   public ClassToFeatureSplitMap rewrittenWithLens(GraphLens lens) {
@@ -187,4 +211,14 @@
         });
     return classToFeatureSplitMapAfterPruning;
   }
+
+  // Static helpers to avoid verbose predicates.
+
+  private static ClassToFeatureSplitMap getMap(AppView<AppInfoWithLiveness> appView) {
+    return appView.appInfo().getClassToFeatureSplitMap();
+  }
+
+  public static boolean isInFeature(DexProgramClass clazz, AppView<AppInfoWithLiveness> appView) {
+    return getMap(appView).isInFeature(clazz, appView.getSyntheticItems());
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/graph/AccessControl.java b/src/main/java/com/android/tools/r8/graph/AccessControl.java
index f872a56..51ff1e2 100644
--- a/src/main/java/com/android/tools/r8/graph/AccessControl.java
+++ b/src/main/java/com/android/tools/r8/graph/AccessControl.java
@@ -4,6 +4,7 @@
 package com.android.tools.r8.graph;
 
 import com.android.tools.r8.features.ClassToFeatureSplitMap;
+import com.android.tools.r8.synthesis.SyntheticItems;
 import com.android.tools.r8.utils.OptionalBool;
 
 /**
@@ -18,16 +19,21 @@
       DexClass clazz,
       ProgramDefinition context,
       AppView<? extends AppInfoWithClassHierarchy> appView) {
-    return isClassAccessible(clazz, context, appView.appInfo().getClassToFeatureSplitMap());
+    return isClassAccessible(
+        clazz, context, appView.appInfo().getClassToFeatureSplitMap(), appView.getSyntheticItems());
   }
 
   public static OptionalBool isClassAccessible(
-      DexClass clazz, ProgramDefinition context, ClassToFeatureSplitMap classToFeatureSplitMap) {
+      DexClass clazz,
+      ProgramDefinition context,
+      ClassToFeatureSplitMap classToFeatureSplitMap,
+      SyntheticItems syntheticItems) {
     if (!clazz.isPublic() && !clazz.getType().isSamePackage(context.getContextType())) {
       return OptionalBool.FALSE;
     }
     if (clazz.isProgramClass()
-        && !classToFeatureSplitMap.isInBaseOrSameFeatureAs(clazz.asProgramClass(), context)) {
+        && !classToFeatureSplitMap.isInBaseOrSameFeatureAs(
+            clazz.asProgramClass(), context, syntheticItems)) {
       return OptionalBool.UNKNOWN;
     }
     return OptionalBool.TRUE;
@@ -60,7 +66,11 @@
       AppInfoWithClassHierarchy appInfo) {
     AccessFlags<?> memberFlags = member.getDefinition().getAccessFlags();
     OptionalBool classAccessibility =
-        isClassAccessible(initialResolutionHolder, context, appInfo.getClassToFeatureSplitMap());
+        isClassAccessible(
+            initialResolutionHolder,
+            context,
+            appInfo.getClassToFeatureSplitMap(),
+            appInfo.getSyntheticItems());
     if (classAccessibility.isFalse()) {
       return OptionalBool.FALSE;
     }
diff --git a/src/main/java/com/android/tools/r8/graph/AppServices.java b/src/main/java/com/android/tools/r8/graph/AppServices.java
index bb61928..2cfb4d9 100644
--- a/src/main/java/com/android/tools/r8/graph/AppServices.java
+++ b/src/main/java/com/android/tools/r8/graph/AppServices.java
@@ -105,12 +105,14 @@
     }
     // Check if service is defined feature
     DexProgramClass serviceClass = appView.definitionForProgramType(serviceType);
-    if (serviceClass != null && classToFeatureSplitMap.isInFeature(serviceClass)) {
+    if (serviceClass != null
+        && classToFeatureSplitMap.isInFeature(serviceClass, appView.getSyntheticItems())) {
       return true;
     }
     for (DexType implementationType : featureImplementations.get(FeatureSplit.BASE)) {
       DexProgramClass implementationClass = appView.definitionForProgramType(implementationType);
-      if (implementationClass != null && classToFeatureSplitMap.isInFeature(implementationClass)) {
+      if (implementationClass != null
+          && classToFeatureSplitMap.isInFeature(implementationClass, appView.getSyntheticItems())) {
         return true;
       }
     }
diff --git a/src/main/java/com/android/tools/r8/graph/DexAnnotation.java b/src/main/java/com/android/tools/r8/graph/DexAnnotation.java
index 3483fbb..f2959bb 100644
--- a/src/main/java/com/android/tools/r8/graph/DexAnnotation.java
+++ b/src/main/java/com/android/tools/r8/graph/DexAnnotation.java
@@ -5,7 +5,6 @@
 
 import com.android.tools.r8.dex.IndexedItemCollection;
 import com.android.tools.r8.dex.MixedSectionCollection;
-import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.graph.DexValue.DexValueAnnotation;
 import com.android.tools.r8.graph.DexValue.DexValueArray;
 import com.android.tools.r8.graph.DexValue.DexValueInt;
@@ -22,10 +21,7 @@
 import com.android.tools.r8.utils.structural.StructuralMapping;
 import com.android.tools.r8.utils.structural.StructuralSpecification;
 import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
-import java.util.TreeSet;
 import java.util.function.Function;
 
 public class DexAnnotation extends DexItem implements StructuralItem<DexAnnotation> {
@@ -96,8 +92,7 @@
     }
     if (annotation == options.itemFactory.dalvikFastNativeAnnotation
         || annotation == options.itemFactory.dalvikCriticalNativeAnnotation
-        || annotation == options.itemFactory.annotationSynthesizedClass
-        || annotation == options.itemFactory.annotationSynthesizedClassMap) {
+        || annotation == options.itemFactory.annotationSynthesizedClass) {
       return true;
     }
     if (options.processCovariantReturnTypeAnnotations) {
@@ -363,43 +358,6 @@
     return new DexValueString(factory.createString(string));
   }
 
-  public static Collection<DexType> readAnnotationSynthesizedClassMap(
-      DexProgramClass clazz, DexItemFactory dexItemFactory) {
-    DexAnnotation foundAnnotation =
-        clazz.annotations().getFirstMatching(dexItemFactory.annotationSynthesizedClassMap);
-    if (foundAnnotation != null) {
-      if (foundAnnotation.annotation.elements.length != 1) {
-        throw new CompilationError(getInvalidSynthesizedClassMapMessage(clazz, foundAnnotation));
-      }
-      DexAnnotationElement value = foundAnnotation.annotation.elements[0];
-      if (value.name != dexItemFactory.valueString) {
-        throw new CompilationError(getInvalidSynthesizedClassMapMessage(clazz, foundAnnotation));
-      }
-      DexValueArray existingList = value.value.asDexValueArray();
-      if (existingList == null) {
-        throw new CompilationError(getInvalidSynthesizedClassMapMessage(clazz, foundAnnotation));
-      }
-      Collection<DexType> synthesized = new ArrayList<>(existingList.values.length);
-      for (DexValue element : existingList.getValues()) {
-        if (!element.isDexValueType()) {
-          throw new CompilationError(getInvalidSynthesizedClassMapMessage(clazz, foundAnnotation));
-        }
-        synthesized.add(element.asDexValueType().value);
-      }
-      return synthesized;
-    }
-    return Collections.emptyList();
-  }
-
-  private static String getInvalidSynthesizedClassMapMessage(
-      DexProgramClass annotatedClass,
-      DexAnnotation invalidAnnotation) {
-    return annotatedClass.toSourceString()
-        + " is annotated with invalid "
-        + invalidAnnotation.annotation.type.toString()
-        + ": " + invalidAnnotation.toString();
-  }
-
   public static DexAnnotation createAnnotationSynthesizedClass(
       SyntheticKind kind, DexType synthesizingContext, DexItemFactory dexItemFactory) {
     DexAnnotationElement kindElement =
@@ -456,26 +414,6 @@
     return new Pair<>(kind, valueElement.value.asDexValueType().getValue());
   }
 
-  public static DexAnnotation createAnnotationSynthesizedClassMap(
-      TreeSet<DexType> synthesized,
-      DexItemFactory dexItemFactory) {
-    DexValueType[] values = synthesized.stream()
-        .map(DexValueType::new)
-        .toArray(DexValueType[]::new);
-    DexValueArray array = new DexValueArray(values);
-    DexAnnotationElement pair =
-        new DexAnnotationElement(dexItemFactory.createString("value"), array);
-    return new DexAnnotation(
-        VISIBILITY_BUILD,
-        new DexEncodedAnnotation(
-            dexItemFactory.annotationSynthesizedClassMap, new DexAnnotationElement[]{pair}));
-  }
-
-  public static boolean isSynthesizedClassMapAnnotation(DexAnnotation annotation,
-      DexItemFactory factory) {
-    return annotation.annotation.type == factory.annotationSynthesizedClassMap;
-  }
-
   public DexAnnotation rewrite(Function<DexEncodedAnnotation, DexEncodedAnnotation> rewriter) {
     DexEncodedAnnotation rewritten = rewriter.apply(annotation);
     if (rewritten == annotation) {
diff --git a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
index 0752d20..3f6eff3 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -605,8 +605,6 @@
   public final DexType annotationThrows = createStaticallyKnownType("Ldalvik/annotation/Throws;");
   public final DexType annotationSynthesizedClass =
       createStaticallyKnownType("Lcom/android/tools/r8/annotations/SynthesizedClass;");
-  public final DexType annotationSynthesizedClassMap =
-      createStaticallyKnownType("Lcom/android/tools/r8/annotations/SynthesizedClassMap;");
   public final DexType annotationCovariantReturnType =
       createStaticallyKnownType("Ldalvik/annotation/codegen/CovariantReturnType;");
   public final DexType annotationCovariantReturnTypes =
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/SameFeatureSplit.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/SameFeatureSplit.java
index 9e4dd2b..20caa50 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/SameFeatureSplit.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/SameFeatureSplit.java
@@ -19,6 +19,9 @@
 
   @Override
   public FeatureSplit getMergeKey(DexProgramClass clazz) {
-    return appView.appInfo().getClassToFeatureSplitMap().getFeatureSplit(clazz);
+    return appView
+        .appInfo()
+        .getClassToFeatureSplitMap()
+        .getFeatureSplit(clazz, appView.getSyntheticItems());
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
index 969b5d5..33e414f 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
@@ -38,6 +38,7 @@
 import com.android.tools.r8.ir.optimize.inliner.WhyAreYouNotInliningReporter;
 import com.android.tools.r8.logging.Log;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.synthesis.SyntheticItems;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.Timing;
@@ -152,10 +153,11 @@
       return false;
     }
 
+    SyntheticItems syntheticItems = appView.getSyntheticItems();
     ClassToFeatureSplitMap classToFeatureSplitMap = appView.appInfo().getClassToFeatureSplitMap();
-    if (!classToFeatureSplitMap.isInSameFeatureOrBothInBase(singleTarget, method)) {
+    if (!classToFeatureSplitMap.isInSameFeatureOrBothInBase(singleTarget, method, syntheticItems)) {
       // Still allow inlining if we inline from the base into a feature.
-      if (!classToFeatureSplitMap.isInBase(singleTarget.getHolder())) {
+      if (!classToFeatureSplitMap.isInBase(singleTarget.getHolder(), syntheticItems)) {
         whyAreYouNotInliningReporter.reportInliningAcrossFeatureSplit();
         return false;
       }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
index 8dc0dd3..0f12d78 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
@@ -11,6 +11,7 @@
 import com.android.tools.r8.contexts.CompilationContext.ProcessorContext;
 import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.features.ClassToFeatureSplitMap;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.ClasspathMethod;
 import com.android.tools.r8.graph.Code;
@@ -1287,7 +1288,7 @@
         code -> {
           ProgramMethod context = code.context();
           assert !context.getDefinition().getCode().isOutlineCode();
-          if (appView.appInfo().getClassToFeatureSplitMap().isInFeature(context.getHolder())) {
+          if (ClassToFeatureSplitMap.isInFeature(context.getHolder(), appView)) {
             return;
           }
           for (BasicBlock block : code.blocks) {
@@ -1306,7 +1307,7 @@
   public void identifyOutlineSites(IRCode code) {
     ProgramMethod context = code.context();
     assert !context.getDefinition().getCode().isOutlineCode();
-    assert !appView.appInfo().getClassToFeatureSplitMap().isInFeature(context.getHolder());
+    assert !ClassToFeatureSplitMap.isInFeature(context.getHolder(), appView);
     for (BasicBlock block : code.blocks) {
       new OutlineSiteIdentifier(context, block).process();
     }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ReflectionOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/ReflectionOptimizer.java
index afdf56a..289b2ba 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ReflectionOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ReflectionOptimizer.java
@@ -246,7 +246,8 @@
 
     // Make sure the (base) type is visible.
     ClassToFeatureSplitMap classToFeatureSplitMap = appView.appInfo().getClassToFeatureSplitMap();
-    if (AccessControl.isClassAccessible(baseClass, context, classToFeatureSplitMap)
+    if (AccessControl.isClassAccessible(
+            baseClass, context, classToFeatureSplitMap, appView.getSyntheticItems())
         .isPossiblyFalse()) {
       return;
     }
@@ -254,7 +255,8 @@
     // If the type is guaranteed to be visible, it must be in the same feature as the current method
     // or in the base.
     assert !baseClass.isProgramClass()
-        || classToFeatureSplitMap.isInBaseOrSameFeatureAs(baseClass.asProgramClass(), context);
+        || classToFeatureSplitMap.isInBaseOrSameFeatureAs(
+            baseClass.asProgramClass(), context, appView.getSyntheticItems());
 
     consumer.accept(type, baseClass);
   }
diff --git a/src/main/java/com/android/tools/r8/ir/synthetic/ForwardMethodBuilder.java b/src/main/java/com/android/tools/r8/ir/synthetic/ForwardMethodBuilder.java
index 0b340af..84acf70 100644
--- a/src/main/java/com/android/tools/r8/ir/synthetic/ForwardMethodBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/synthetic/ForwardMethodBuilder.java
@@ -177,6 +177,7 @@
       DexType parameter = sourceParameters[i];
       ValueType parameterType = ValueType.fromDexType(parameter);
       instructions.add(new CfLoad(parameterType, maxLocals));
+      maxStack += parameterType.requiredRegisters();
       maxLocals += parameterType.requiredRegisters();
       maybeInsertArgumentCast(i, parameter, instructions);
     }
diff --git a/src/main/java/com/android/tools/r8/shaking/AnnotationRemover.java b/src/main/java/com/android/tools/r8/shaking/AnnotationRemover.java
index 762617e..057a80f 100644
--- a/src/main/java/com/android/tools/r8/shaking/AnnotationRemover.java
+++ b/src/main/java/com/android/tools/r8/shaking/AnnotationRemover.java
@@ -115,10 +115,6 @@
         return isAnnotationTypeLive;
 
       case DexAnnotation.VISIBILITY_BUILD:
-        if (DexAnnotation.isSynthesizedClassMapAnnotation(annotation, dexItemFactory)) {
-          // TODO(sgjesse) When should these be removed?
-          return true;
-        }
         if (!config.runtimeInvisibleAnnotations) {
           return false;
         }
diff --git a/src/main/java/com/android/tools/r8/shaking/MainDexInfo.java b/src/main/java/com/android/tools/r8/shaking/MainDexInfo.java
index 58315d4..a60967f 100644
--- a/src/main/java/com/android/tools/r8/shaking/MainDexInfo.java
+++ b/src/main/java/com/android/tools/r8/shaking/MainDexInfo.java
@@ -91,6 +91,11 @@
     return this == NONE;
   }
 
+  public boolean isMainDexTypeThatShouldIncludeDependencies(DexType type) {
+    // Dependencies of 'type' are only needed if 'type' is a direct/executed main-dex type.
+    return classList.contains(type) || tracedRoots.contains(type);
+  }
+
   public boolean isMainDex(ProgramDefinition definition) {
     return isFromList(definition) || isTracedRoot(definition) || isDependency(definition);
   }
diff --git a/src/main/java/com/android/tools/r8/shaking/MissingClasses.java b/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
index c2d6a7c..ba25312 100644
--- a/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
+++ b/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
@@ -73,10 +73,6 @@
     // if the same type is in newMissingClasses in which case it is reported regardless.
     private final Set<DexType> newIgnoredMissingClasses = Sets.newIdentityHashSet();
 
-    private Builder() {
-      this(Sets.newIdentityHashSet());
-    }
-
     private Builder(Set<DexType> alreadyMissingClasses) {
       this.alreadyMissingClasses = alreadyMissingClasses;
     }
@@ -133,9 +129,7 @@
           getMissingClassesToBeReported(appView, synthesizingContextOracle);
       if (!missingClassesToBeReported.isEmpty()) {
         MissingDefinitionsDiagnostic diagnostic = createDiagnostic(missingClassesToBeReported);
-        InternalOptions options = appView.options();
-        // TODO(b/180903899): Remove L8 special handling when -dontwarn sun.misc.Unsafe is in place.
-        if (options.ignoreMissingClasses || options.isDesugaredLibraryCompilation()) {
+        if (appView.options().ignoreMissingClasses) {
           appView.reporter().warning(diagnostic);
         } else {
           throw appView.reporter().fatalError(diagnostic);
@@ -270,7 +264,6 @@
               dexItemFactory.annotationMethodParameters,
               dexItemFactory.annotationSourceDebugExtension,
               dexItemFactory.annotationSynthesizedClass,
-              dexItemFactory.annotationSynthesizedClassMap,
               dexItemFactory.annotationThrows,
               dexItemFactory.serializedLambdaType)
           .addAll(dexItemFactory.getJavaConversionTypes())
diff --git a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
index 4963f21..afc9e50 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
@@ -357,7 +357,7 @@
 
     if (!appInfo
         .getClassToFeatureSplitMap()
-        .isInSameFeatureOrBothInBase(sourceClass, targetClass)) {
+        .isInSameFeatureOrBothInBase(sourceClass, targetClass, appView.getSyntheticItems())) {
       return false;
     }
     if (appView.appServices().allServiceTypes().contains(sourceClass.type)
diff --git a/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java b/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
index 82f3204..bff9202 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
@@ -15,7 +15,6 @@
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.shaking.MainDexInfo;
 import java.util.Comparator;
-import java.util.Set;
 
 /**
  * A synthesizing context is a description of the context that gives rise to a synthetic item.
@@ -123,14 +122,15 @@
     appView.rewritePrefix.rewriteType(hygienicType, rewrittenType);
   }
 
+  // TODO(b/180074885): Remove this once main-dex is traced at the end of of compilation.
   void addIfDerivedFromMainDexClass(
-      DexProgramClass externalSyntheticClass,
-      MainDexInfo mainDexInfo,
-      Set<DexType> allMainDexTypes) {
+      DexProgramClass externalSyntheticClass, MainDexInfo mainDexInfo) {
+    if (mainDexInfo.isMainDex(externalSyntheticClass)) {
+      return;
+    }
     // The input context type (not the annotated context) determines if the derived class is to be
-    // in main dex.
-    // TODO(b/168584485): Once resolved allMainDexTypes == mainDexClasses.
-    if (allMainDexTypes.contains(inputContextType)) {
+    // in main dex, as it is the input context type that is traced as part of main-dex tracing.
+    if (mainDexInfo.isMainDexTypeThatShouldIncludeDependencies(inputContextType)) {
       mainDexInfo.addSyntheticClass(externalSyntheticClass);
     }
   }
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
index 9520d57..f6577d3 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
@@ -66,7 +66,10 @@
   public abstract C getHolder();
 
   final HashCode computeHash(
-      RepresentativeMap map, boolean intermediate, ClassToFeatureSplitMap classToFeatureSplitMap) {
+      RepresentativeMap map,
+      boolean intermediate,
+      ClassToFeatureSplitMap classToFeatureSplitMap,
+      SyntheticItems syntheticItems) {
     Hasher hasher = Hashing.murmur3_128().newHasher();
     if (getKind().isFixedSuffixSynthetic) {
       // Fixed synthetics are non-shareable. Its unique type is used as the hash key.
@@ -81,7 +84,7 @@
     if (!classToFeatureSplitMap.isEmpty()) {
       hasher.putInt(
           classToFeatureSplitMap
-              .getFeatureSplit(getContext().getSynthesizingContextType())
+              .getFeatureSplit(getContext().getSynthesizingContextType(), syntheticItems)
               .hashCode());
     }
 
@@ -95,15 +98,17 @@
       D other,
       boolean includeContext,
       GraphLens graphLens,
-      ClassToFeatureSplitMap classToFeatureSplitMap) {
-    return compareTo(other, includeContext, graphLens, classToFeatureSplitMap) == 0;
+      ClassToFeatureSplitMap classToFeatureSplitMap,
+      SyntheticItems syntheticItems) {
+    return compareTo(other, includeContext, graphLens, classToFeatureSplitMap, syntheticItems) == 0;
   }
 
   int compareTo(
       D other,
       boolean includeContext,
       GraphLens graphLens,
-      ClassToFeatureSplitMap classToFeatureSplitMap) {
+      ClassToFeatureSplitMap classToFeatureSplitMap,
+      SyntheticItems syntheticItems) {
     DexType thisType = getHolder().getType();
     DexType otherType = other.getHolder().getType();
     if (getKind().isFixedSuffixSynthetic) {
@@ -120,10 +125,10 @@
       DexType synthesizingContextType = this.getContext().getSynthesizingContextType();
       DexType otherSynthesizingContextType = other.getContext().getSynthesizingContextType();
       if (!classToFeatureSplitMap.isInSameFeatureOrBothInBase(
-          synthesizingContextType, otherSynthesizingContextType)) {
+          synthesizingContextType, otherSynthesizingContextType, syntheticItems)) {
         int order =
             classToFeatureSplitMap.compareFeatureSplitsForDexTypes(
-                synthesizingContextType, otherSynthesizingContextType);
+                synthesizingContextType, otherSynthesizingContextType, syntheticItems);
         assert order != 0;
         return order;
       }
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
index 60dca8f..2e70db6 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
@@ -7,7 +7,6 @@
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexAnnotation;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedMethod;
@@ -32,11 +31,9 @@
 import com.android.tools.r8.utils.collections.BidirectionalManyToOneRepresentativeMap;
 import com.android.tools.r8.utils.collections.BidirectionalOneToOneHashMap;
 import com.android.tools.r8.utils.structural.RepresentativeMap;
-import com.google.common.collect.ArrayListMultimap;
 import com.google.common.collect.ImmutableCollection;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ListMultimap;
 import com.google.common.collect.Sets;
 import com.google.common.hash.HashCode;
 import java.util.ArrayList;
@@ -48,7 +45,6 @@
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
-import java.util.TreeSet;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
 
@@ -203,9 +199,11 @@
     public int compareToIncludingContext(
         EquivalenceGroup<T> other,
         GraphLens graphLens,
-        ClassToFeatureSplitMap classToFeatureSplitMap) {
+        ClassToFeatureSplitMap classToFeatureSplitMap,
+        SyntheticItems syntheticItems) {
       return getRepresentative()
-          .compareTo(other.getRepresentative(), true, graphLens, classToFeatureSplitMap);
+          .compareTo(
+              other.getRepresentative(), true, graphLens, classToFeatureSplitMap, syntheticItems);
     }
 
     @Override
@@ -219,11 +217,14 @@
   }
 
   private final InternalOptions options;
-  private final CommittedSyntheticsCollection synthetics;
+  private final SyntheticItems synthetics;
+  private final CommittedSyntheticsCollection committed;
 
-  SyntheticFinalization(InternalOptions options, CommittedSyntheticsCollection synthetics) {
+  SyntheticFinalization(
+      InternalOptions options, SyntheticItems synthetics, CommittedSyntheticsCollection committed) {
     this.options = options;
     this.synthetics = synthetics;
+    this.committed = committed;
   }
 
   public static void finalize(AppView<AppInfo> appView) {
@@ -257,7 +258,6 @@
   Result computeFinalSynthetics(AppView<?> appView) {
     assert verifyNoNestedSynthetics();
     DexApplication application;
-    MainDexInfo mainDexInfo = appView.appInfo().getMainDexInfo();
     Builder lensBuilder = new Builder();
     ImmutableMap.Builder<DexType, SyntheticMethodReference> finalMethodsBuilder =
         ImmutableMap.builder();
@@ -269,8 +269,8 @@
       application =
           buildLensAndProgram(
               appView,
-              computeEquivalences(appView, synthetics.getNonLegacyMethods().values(), generators),
-              computeEquivalences(appView, synthetics.getNonLegacyClasses().values(), generators),
+              computeEquivalences(appView, committed.getNonLegacyMethods().values(), generators),
+              computeEquivalences(appView, committed.getNonLegacyClasses().values(), generators),
               lensBuilder,
               (clazz, reference) -> {
                 finalSyntheticProgramDefinitions.add(clazz);
@@ -285,13 +285,8 @@
     ImmutableMap<DexType, SyntheticProgramClassReference> finalClasses =
         finalClassesBuilder.build();
 
-    handleSynthesizedClassMapping(
-        finalSyntheticProgramDefinitions, application, options, mainDexInfo, lensBuilder.typeMap);
-
-    assert appView.appInfo().getMainDexInfo() == mainDexInfo;
-
     Set<DexType> prunedSynthetics = Sets.newIdentityHashSet();
-    synthetics.forEachNonLegacyItem(
+    committed.forEachNonLegacyItem(
         reference -> {
           DexType type = reference.getHolder();
           if (!finalMethods.containsKey(type) && !finalClasses.containsKey(type)) {
@@ -304,7 +299,7 @@
             SyntheticItems.INVALID_ID_AFTER_SYNTHETIC_FINALIZATION,
             application,
             new CommittedSyntheticsCollection(
-                synthetics.getLegacyTypes(), finalMethods, finalClasses),
+                committed.getLegacyTypes(), finalMethods, finalClasses),
             ImmutableList.of()),
         lensBuilder.build(appView.graphLens(), appView.dexItemFactory()),
         PrunedItems.builder()
@@ -330,114 +325,25 @@
             intermediate,
             appView.dexItemFactory(),
             appView.graphLens(),
-            classToFeatureSplitMap);
+            classToFeatureSplitMap,
+            synthetics);
     return computeActualEquivalences(
         potentialEquivalences, generators, appView, intermediate, classToFeatureSplitMap);
   }
 
   private boolean isNotSyntheticType(DexType type) {
-    return !synthetics.containsNonLegacyType(type);
+    return !committed.containsNonLegacyType(type);
   }
 
   private boolean verifyNoNestedSynthetics() {
     // Check that a context is never itself synthetic class.
-    synthetics.forEachNonLegacyItem(
+    committed.forEachNonLegacyItem(
         item -> {
           assert isNotSyntheticType(item.getContext().getSynthesizingContextType());
         });
     return true;
   }
 
-  private void handleSynthesizedClassMapping(
-      List<DexProgramClass> finalSyntheticClasses,
-      DexApplication application,
-      InternalOptions options,
-      MainDexInfo mainDexInfo,
-      Map<DexType, DexType> derivedMainDexTypesToIgnore) {
-    boolean includeSynthesizedClassMappingInOutput = shouldAnnotateSynthetics(options);
-    if (includeSynthesizedClassMappingInOutput) {
-      updateSynthesizedClassMapping(application, finalSyntheticClasses);
-    }
-    updateMainDexListWithSynthesizedClassMap(application, mainDexInfo, derivedMainDexTypesToIgnore);
-    if (!includeSynthesizedClassMappingInOutput) {
-      clearSynthesizedClassMapping(application);
-    }
-  }
-
-  private void updateSynthesizedClassMapping(
-      DexApplication application, List<DexProgramClass> finalSyntheticClasses) {
-    ListMultimap<DexProgramClass, DexProgramClass> originalToSynthesized =
-        ArrayListMultimap.create();
-    for (DexType type : synthetics.getLegacyTypes()) {
-      DexProgramClass clazz = DexProgramClass.asProgramClassOrNull(application.definitionFor(type));
-      if (clazz != null) {
-        for (DexProgramClass origin : clazz.getSynthesizedFrom()) {
-          originalToSynthesized.put(origin, clazz);
-        }
-      }
-    }
-    for (DexProgramClass clazz : finalSyntheticClasses) {
-      for (DexProgramClass origin : clazz.getSynthesizedFrom()) {
-        originalToSynthesized.put(origin, clazz);
-      }
-    }
-    for (Map.Entry<DexProgramClass, Collection<DexProgramClass>> entry :
-        originalToSynthesized.asMap().entrySet()) {
-      DexProgramClass original = entry.getKey();
-      // Use a tree set to make sure that we have an ordering on the types.
-      // These types are put in an array in annotations in the output and we
-      // need a consistent ordering on them.
-      TreeSet<DexType> synthesized = new TreeSet<>(DexType::compareTo);
-      entry.getValue().stream()
-          .map(dexProgramClass -> dexProgramClass.type)
-          .forEach(synthesized::add);
-      synthesized.addAll(
-          DexAnnotation.readAnnotationSynthesizedClassMap(original, application.dexItemFactory));
-
-      DexAnnotation updatedAnnotation =
-          DexAnnotation.createAnnotationSynthesizedClassMap(
-              synthesized, application.dexItemFactory);
-
-      original.setAnnotations(original.annotations().getWithAddedOrReplaced(updatedAnnotation));
-    }
-  }
-
-  private void updateMainDexListWithSynthesizedClassMap(
-      DexApplication application,
-      MainDexInfo mainDexInfo,
-      Map<DexType, DexType> derivedMainDexTypesToIgnore) {
-    if (mainDexInfo.isEmpty()) {
-      return;
-    }
-    List<DexProgramClass> newMainDexClasses = new ArrayList<>();
-    mainDexInfo.forEachExcludingDependencies(
-        dexType -> {
-          DexProgramClass programClass =
-              DexProgramClass.asProgramClassOrNull(application.definitionFor(dexType));
-          if (programClass != null) {
-            Collection<DexType> derived =
-                DexAnnotation.readAnnotationSynthesizedClassMap(
-                    programClass, application.dexItemFactory);
-            for (DexType type : derived) {
-              DexType mappedType = derivedMainDexTypesToIgnore.getOrDefault(type, type);
-              DexProgramClass syntheticClass =
-                  DexProgramClass.asProgramClassOrNull(application.definitionFor(mappedType));
-              if (syntheticClass != null) {
-                newMainDexClasses.add(syntheticClass);
-              }
-            }
-          }
-        });
-    newMainDexClasses.forEach(mainDexInfo::addSyntheticClass);
-  }
-
-  private void clearSynthesizedClassMapping(DexApplication application) {
-    for (DexProgramClass clazz : application.classes()) {
-      clazz.setAnnotations(
-          clazz.annotations().getWithout(application.dexItemFactory.annotationSynthesizedClassMap));
-    }
-  }
-
   private static DexApplication buildLensAndProgram(
       AppView<?> appView,
       Map<DexType, EquivalenceGroup<SyntheticMethodDefinition>> syntheticMethodGroups,
@@ -448,23 +354,8 @@
     DexApplication application = appView.appInfo().app();
     DexItemFactory factory = appView.dexItemFactory();
     List<DexProgramClass> newProgramClasses = new ArrayList<>();
-
-    // TODO(b/168584485): Remove this once class-mapping support is removed.
-    Set<DexType> derivedMainDexTypes = Sets.newIdentityHashSet();
-    MainDexInfo mainDexInfo = appView.appInfo().getMainDexInfo();
-    mainDexInfo.forEachExcludingDependencies(
-        mainDexType -> {
-          derivedMainDexTypes.add(mainDexType);
-          DexProgramClass mainDexClass =
-              DexProgramClass.asProgramClassOrNull(
-                  appView.appInfo().definitionForWithoutExistenceAssert(mainDexType));
-          if (mainDexClass != null) {
-            derivedMainDexTypes.addAll(
-                DexAnnotation.readAnnotationSynthesizedClassMap(mainDexClass, factory));
-          }
-        });
-
     Set<DexType> pruned = Sets.newIdentityHashSet();
+
     syntheticMethodGroups.forEach(
         (syntheticType, syntheticGroup) -> {
           SyntheticMethodDefinition representative = syntheticGroup.getRepresentative();
@@ -565,8 +456,7 @@
             addMainDexAndSynthesizedFromForMember(
                 member,
                 externalSyntheticClass,
-                mainDexInfo,
-                derivedMainDexTypes,
+                appView.appInfo().getMainDexInfo(),
                 appForLookup::programDefinitionFor);
           }
         });
@@ -587,8 +477,7 @@
             addMainDexAndSynthesizedFromForMember(
                 member,
                 externalSyntheticClass,
-                mainDexInfo,
-                derivedMainDexTypes,
+                appView.appInfo().getMainDexInfo(),
                 appForLookup::programDefinitionFor);
           }
         });
@@ -638,11 +527,8 @@
       SyntheticDefinition<?, ?, ?> member,
       DexProgramClass externalSyntheticClass,
       MainDexInfo mainDexInfo,
-      Set<DexType> derivedMainDexTypes,
       Function<DexType, DexProgramClass> definitions) {
-    member
-        .getContext()
-        .addIfDerivedFromMainDexClass(externalSyntheticClass, mainDexInfo, derivedMainDexTypes);
+    member.getContext().addIfDerivedFromMainDexClass(externalSyntheticClass, mainDexInfo);
     // TODO(b/168584485): Remove this once class-mapping support is removed.
     DexProgramClass from = definitions.apply(member.getContext().getSynthesizingContextType());
     if (from != null) {
@@ -655,7 +541,6 @@
     // This is currently also disabled on CF to CF desugaring to avoid missing class references to
     // the annotated classes.
     // TODO(b/147485959): Find an alternative encoding for synthetics to avoid missing-class refs.
-    // TODO(b/168584485): Remove support for main-dex tracing with the class-map annotation.
     return options.intermediate && !options.cfToCfDesugar;
   }
 
@@ -670,10 +555,12 @@
     potentialEquivalences.forEach(
         members -> {
           List<List<T>> groups =
-              groupEquivalent(members, intermediate, appView.graphLens(), classToFeatureSplitMap);
+              groupEquivalent(
+                  members, intermediate, appView.graphLens(), classToFeatureSplitMap, synthetics);
           for (List<T> group : groups) {
             T representative =
-                findDeterministicRepresentative(group, appView.graphLens(), classToFeatureSplitMap);
+                findDeterministicRepresentative(
+                    group, appView.graphLens(), classToFeatureSplitMap, synthetics);
             // The representative is required to be the first element of the group.
             group.remove(representative);
             group.add(0, representative);
@@ -691,7 +578,8 @@
           // representative which is equal to 'context' here (see assert below).
           groups.sort(
               (a, b) ->
-                  a.compareToIncludingContext(b, appView.graphLens(), classToFeatureSplitMap));
+                  a.compareToIncludingContext(
+                      b, appView.graphLens(), classToFeatureSplitMap, synthetics));
           for (int i = 0; i < groups.size(); i++) {
             EquivalenceGroup<T> group = groups.get(i);
             assert group
@@ -702,7 +590,11 @@
             // of the synthetic name will be non-deterministic between the two.
             assert i == 0
                 || checkGroupsAreDistinct(
-                    groups.get(i - 1), group, appView.graphLens(), classToFeatureSplitMap);
+                    groups.get(i - 1),
+                    group,
+                    appView.graphLens(),
+                    classToFeatureSplitMap,
+                    synthetics);
             SyntheticKind kind = group.members.get(0).getKind();
             DexType representativeType =
                 createExternalType(kind, externalSyntheticTypePrefix, generators, appView);
@@ -716,14 +608,15 @@
       List<T> potentialEquivalence,
       boolean intermediate,
       GraphLens graphLens,
-      ClassToFeatureSplitMap classToFeatureSplitMap) {
+      ClassToFeatureSplitMap classToFeatureSplitMap,
+      SyntheticItems syntheticItems) {
     List<List<T>> groups = new ArrayList<>();
     // Each other member is in a shared group if it is actually equivalent to the first member.
     for (T synthetic : potentialEquivalence) {
       boolean requireNewGroup = true;
       for (List<T> group : groups) {
         if (synthetic.isEquivalentTo(
-            group.get(0), intermediate, graphLens, classToFeatureSplitMap)) {
+            group.get(0), intermediate, graphLens, classToFeatureSplitMap, syntheticItems)) {
           requireNewGroup = false;
           group.add(synthetic);
           break;
@@ -742,15 +635,20 @@
       EquivalenceGroup<T> g1,
       EquivalenceGroup<T> g2,
       GraphLens graphLens,
-      ClassToFeatureSplitMap classToFeatureSplitMap) {
-    int order = g1.compareToIncludingContext(g2, graphLens, classToFeatureSplitMap);
+      ClassToFeatureSplitMap classToFeatureSplitMap,
+      SyntheticItems syntheticItems) {
+    int order = g1.compareToIncludingContext(g2, graphLens, classToFeatureSplitMap, syntheticItems);
     assert order != 0;
-    assert order != g2.compareToIncludingContext(g1, graphLens, classToFeatureSplitMap);
+    assert order
+        != g2.compareToIncludingContext(g1, graphLens, classToFeatureSplitMap, syntheticItems);
     return true;
   }
 
   private static <T extends SyntheticDefinition<?, T, ?>> T findDeterministicRepresentative(
-      List<T> members, GraphLens graphLens, ClassToFeatureSplitMap classToFeatureSplitMap) {
+      List<T> members,
+      GraphLens graphLens,
+      ClassToFeatureSplitMap classToFeatureSplitMap,
+      SyntheticItems syntheticItems) {
     // Pick a deterministic member as representative.
     T smallest = members.get(0);
     for (int i = 1; i < members.size(); i++) {
@@ -794,7 +692,8 @@
           boolean intermediate,
           DexItemFactory factory,
           GraphLens graphLens,
-          ClassToFeatureSplitMap classToFeatureSplitMap) {
+          ClassToFeatureSplitMap classToFeatureSplitMap,
+          SyntheticItems syntheticItems) {
     if (definitions.isEmpty()) {
       return Collections.emptyList();
     }
@@ -817,7 +716,8 @@
     RepresentativeMap map = t -> syntheticTypes.contains(t) ? factory.voidType : t;
     Map<HashCode, List<T>> equivalences = new HashMap<>(definitions.size());
     for (T definition : definitions.values()) {
-      HashCode hash = definition.computeHash(map, intermediate, classToFeatureSplitMap);
+      HashCode hash =
+          definition.computeHash(map, intermediate, classToFeatureSplitMap, syntheticItems);
       equivalences.computeIfAbsent(hash, k -> new ArrayList<>()).add(definition);
     }
     return equivalences.values();
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
index 8263f40..9922011 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
@@ -84,6 +84,11 @@
 
   private final PendingSynthetics pending = new PendingSynthetics();
 
+  // Empty collection for use only in tests and utilities.
+  public static SyntheticItems empty() {
+    return new SyntheticItems(-1, CommittedSyntheticsCollection.empty());
+  }
+
   // Only for use from initial AppInfo/AppInfoWithClassHierarchy create functions. */
   public static CommittedItems createInitialSyntheticItems(DexApplication application) {
     return new CommittedItems(
@@ -215,6 +220,18 @@
     return isSyntheticClass(clazz.type);
   }
 
+  public Collection<DexType> getSynthesizingContexts(DexType type) {
+    SyntheticReference<?, ?, ?> reference = committed.getNonLegacyItem(type);
+    if (reference != null) {
+      return Collections.singletonList(reference.getContext().getSynthesizingContextType());
+    }
+    SyntheticDefinition<?, ?, ?> definition = pending.nonLegacyDefinitions.get(type);
+    if (definition != null) {
+      return Collections.singletonList(definition.getContext().getSynthesizingContextType());
+    }
+    return Collections.emptyList();
+  }
+
   // TODO(b/180091213): Implement this and remove client provided the oracle.
   public Set<DexReference> getSynthesizingContexts(
       DexProgramClass clazz, SynthesizingContextOracle oracle) {
@@ -445,6 +462,7 @@
 
   Result computeFinalSynthetics(AppView<?> appView) {
     assert !hasPendingSyntheticClasses();
-    return new SyntheticFinalization(appView.options(), committed).computeFinalSynthetics(appView);
+    return new SyntheticFinalization(appView.options(), this, committed)
+        .computeFinalSynthetics(appView);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
index 25e59ae..1b80f41 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
@@ -63,7 +63,7 @@
     }
   }
 
-  private static final String SYNTHETIC_CLASS_SEPARATOR = "-$$";
+  private static final String SYNTHETIC_CLASS_SEPARATOR = "$$";
   /**
    * The internal synthetic class separator is only used for representing synthetic items during
    * compilation. In particular, this separator must never be used to write synthetic classes to the
diff --git a/src/main/java/com/android/tools/r8/utils/AndroidApp.java b/src/main/java/com/android/tools/r8/utils/AndroidApp.java
index 21c3447..1534b4a 100644
--- a/src/main/java/com/android/tools/r8/utils/AndroidApp.java
+++ b/src/main/java/com/android/tools/r8/utils/AndroidApp.java
@@ -42,6 +42,7 @@
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.origin.PathOrigin;
 import com.android.tools.r8.shaking.FilteredClassPath;
+import com.android.tools.r8.synthesis.SyntheticItems;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.io.ByteStreams;
@@ -611,7 +612,8 @@
                       classDescriptor -> {
                         if (featureSplitConfiguration != null) {
                           DexType type = dexItemFactory.createType(classDescriptor);
-                          FeatureSplit featureSplit = classToFeatureSplitMap.getFeatureSplit(type);
+                          FeatureSplit featureSplit =
+                              classToFeatureSplitMap.getFeatureSplit(type, SyntheticItems.empty());
                           if (featureSplit != null && !featureSplit.isBase()) {
                             return featureSplitArchiveOutputStreams.get(featureSplit);
                           }
diff --git a/src/main/java/com/android/tools/r8/utils/TypeReferenceUtils.java b/src/main/java/com/android/tools/r8/utils/TypeReferenceUtils.java
index 76e6f33..15344f9 100644
--- a/src/main/java/com/android/tools/r8/utils/TypeReferenceUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/TypeReferenceUtils.java
@@ -11,6 +11,9 @@
 
   private static final Comparator<TypeReference> COMPARATOR =
       (type, other) -> {
+        if (type == other) {
+          return 0;
+        }
         // Handle null inputs (void).
         if (type == null) {
           return -1;
diff --git a/src/test/examplesAndroidO/multidex004/ref-list-1.txt b/src/test/examplesAndroidO/multidex004/ref-list-1.txt
index c817c33..bd195b3 100644
--- a/src/test/examplesAndroidO/multidex004/ref-list-1.txt
+++ b/src/test/examplesAndroidO/multidex004/ref-list-1.txt
@@ -1,4 +1,4 @@
-Lmultidex004/MainActivity-$$ExternalSyntheticLambda0;
+Lmultidex004/MainActivity$$ExternalSyntheticLambda0;
 Lmultidex004/MainActivity;
 Lmultidex004/VersionInterface;
 Lmultidex004/VersionStatic;
diff --git a/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java
index 82cfebf..43bbd99 100644
--- a/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java
@@ -361,15 +361,25 @@
   abstract D8IncrementalTestRunner test(String testName, String packageName, String mainClass);
 
   @Override
-  protected void testIntermediateWithMainDexList(String packageName, Path input,
-      int expectedMainDexListSize, String... mainDexClasses) throws Throwable {
+  protected void testIntermediateWithMainDexList(
+      String packageName,
+      Path input,
+      int expectedMainDexListSize,
+      List<String> mainDexClasses,
+      List<String> mainDexOverApproximation)
+      throws Throwable {
     // Skip those tests.
     Assume.assumeTrue(false);
   }
 
   @Override
-  protected Path buildDexThroughIntermediate(String packageName, Path input, OutputMode outputMode,
-      AndroidApiLevel minApi, String... mainDexClasses) throws Throwable {
+  protected Path buildDexThroughIntermediate(
+      String packageName,
+      Path input,
+      OutputMode outputMode,
+      AndroidApiLevel minApi,
+      List<String> mainDexClasses)
+      throws Throwable {
     // tests using this should already been skipped.
     throw new Unreachable();
   }
diff --git a/src/test/java/com/android/tools/r8/D8TestBuilder.java b/src/test/java/com/android/tools/r8/D8TestBuilder.java
index 4c88d91..4913bc5 100644
--- a/src/test/java/com/android/tools/r8/D8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/D8TestBuilder.java
@@ -6,6 +6,7 @@
 import com.android.tools.r8.D8Command.Builder;
 import com.android.tools.r8.TestBase.Backend;
 import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase.KeepRuleConsumer;
+import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.InternalOptions;
@@ -86,4 +87,16 @@
     builder.addMainDexRulesFiles(mainDexRuleFiles);
     return self();
   }
+
+  public D8TestBuilder addMainDexRules(String... rules) {
+    builder.addMainDexRules(Arrays.asList(rules), Origin.unknown());
+    return self();
+  }
+
+  public D8TestBuilder addMainDexKeepClassRules(Class<?>... classes) {
+    for (Class<?> clazz : classes) {
+      addMainDexRules("-keep class " + clazz.getTypeName());
+    }
+    return self();
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java
index 2773cf1..52480be 100644
--- a/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java
@@ -9,15 +9,19 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 import com.android.tools.r8.ToolHelper.DexVm;
 import com.android.tools.r8.ToolHelper.DexVm.Version;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.OffOrAuto;
 import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.StringUtils.BraceType;
 import com.android.tools.r8.utils.TestDescriptionWatcher;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
@@ -27,6 +31,8 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import com.google.common.collect.Sets.SetView;
 import com.google.common.io.ByteStreams;
 import java.io.IOException;
 import java.io.InputStream;
@@ -35,13 +41,12 @@
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.ExecutionException;
+import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
@@ -114,6 +119,24 @@
       return withBuilderTransformation(builder -> builder.addMainDexClasses(classes));
     }
 
+    C withMainDexKeepClassRules(List<String> classes) {
+      return withBuilderTransformation(
+          builder -> {
+            if (builder instanceof D8Command.Builder) {
+              ((D8Command.Builder) builder)
+                  .addMainDexRules(
+                      ListUtils.map(classes, c -> "-keep class " + c), Origin.unknown());
+            } else if (builder instanceof R8Command.Builder) {
+              ((R8Command.Builder) builder)
+                  .addMainDexRules(
+                      ListUtils.map(classes, c -> "-keep class " + c), Origin.unknown());
+            } else {
+              fail("Unexpected builder type: " + builder.getClass());
+            }
+            return builder;
+          });
+    }
+
     C withInterfaceMethodDesugaring(OffOrAuto behavior) {
       return withOptionConsumer(o -> o.interfaceMethodDesugaring = behavior);
     }
@@ -465,15 +488,20 @@
     testIntermediateWithMainDexList(
         "lambdadesugaring",
         1,
-        "lambdadesugaring.LambdaDesugaring$I");
+        ImmutableList.of("lambdadesugaring.LambdaDesugaring$I"),
+        ImmutableList.of());
   }
 
   @Test
   public void testLambdaDesugaringWithMainDexList2() throws Throwable {
     // Main dex class has many lambdas.
-    testIntermediateWithMainDexList("lambdadesugaring",
-        33,
-        "lambdadesugaring.LambdaDesugaring$Refs$B");
+    testIntermediateWithMainDexList(
+        "lambdadesugaring",
+        // TODO(b/180074885): Over approximation not present in R8.
+        this instanceof R8RunExamplesAndroidOTest ? 51 : 52,
+        ImmutableList.of("lambdadesugaring.LambdaDesugaring$Refs$B"),
+        // TODO(b/180074885): Over approximation due to invoke-dynamic reference adds as dependency.
+        ImmutableList.of("lambdadesugaring.LambdaDesugaring$Refs$D"));
   }
 
   @Test
@@ -483,7 +511,11 @@
         "interfacemethods",
         Paths.get(ToolHelper.EXAMPLES_ANDROID_N_BUILD_DIR, "interfacemethods" + JAR_EXTENSION),
         2,
-        "interfacemethods.I1");
+        ImmutableList.of("interfacemethods.I1"),
+        // TODO(b/180074885): Over approximation due to including I1-CC by being derived from I1,
+        //  but after desugaring I1 does not reference I1$-CC (the static method is moved), so it
+        //  is incorrect to include I1-CC in the main dex.
+        ImmutableList.of("interfacemethods.I1$-CC"));
   }
 
 
@@ -494,7 +526,11 @@
         "interfacemethods",
         Paths.get(ToolHelper.EXAMPLES_ANDROID_N_BUILD_DIR, "interfacemethods" + JAR_EXTENSION),
         2,
-        "interfacemethods.I2");
+        ImmutableList.of("interfacemethods.I2"),
+        // TODO(b/180074885): Over approximation due to including I2$-CC by being derived from I2,
+        //  but after desugaring I2 does not reference I2$-CC (the default method is moved), so it
+        //  is incorrect to include I2$-CC in the main dex.
+        ImmutableList.of("interfacemethods.I2$-CC"));
   }
 
   @Test
@@ -510,20 +546,23 @@
   private void testIntermediateWithMainDexList(
       String packageName,
       int expectedMainDexListSize,
-      String... mainDexClasses)
+      List<String> mainDexClasses,
+      List<String> mainDexOverApproximation)
       throws Throwable {
     testIntermediateWithMainDexList(
         packageName,
         Paths.get(EXAMPLE_DIR, packageName + JAR_EXTENSION),
         expectedMainDexListSize,
-        mainDexClasses);
+        mainDexClasses,
+        mainDexOverApproximation);
   }
 
   protected void testIntermediateWithMainDexList(
       String packageName,
       Path input,
       int expectedMainDexListSize,
-      String... mainDexClasses)
+      List<String> mainDexClasses,
+      List<String> mainDexOverApproximation)
       throws Throwable {
     AndroidApiLevel minApi = AndroidApiLevel.K;
 
@@ -534,16 +573,18 @@
             .withMinApiLevel(minApi)
             .withOptionConsumer(option -> option.minimalMainDex = true)
             .withOptionConsumer(option -> option.enableInheritanceClassInDexDistributor = false)
-            .withMainDexClass(mainDexClasses)
+            .withMainDexKeepClassRules(mainDexClasses)
             .withKeepAll();
     Path fullDexes = temp.getRoot().toPath().resolve(packageName + "full" + ZIP_EXTENSION);
     full.build(input, fullDexes);
 
     // Builds with intermediate in both output mode.
-    Path dexesThroughIndexedIntermediate = buildDexThroughIntermediate(
-        packageName, input, OutputMode.DexIndexed, minApi, mainDexClasses);
-    Path dexesThroughFilePerInputClassIntermediate = buildDexThroughIntermediate(
-        packageName, input, OutputMode.DexFilePerClassFile, minApi, mainDexClasses);
+    Path dexesThroughIndexedIntermediate =
+        buildDexThroughIntermediate(
+            packageName, input, OutputMode.DexIndexed, minApi, mainDexClasses);
+    Path dexesThroughFilePerInputClassIntermediate =
+        buildDexThroughIntermediate(
+            packageName, input, OutputMode.DexFilePerClassFile, minApi, mainDexClasses);
 
     // Collect main dex types.
     CodeInspector fullInspector = getMainDexInspector(fullDexes);
@@ -551,20 +592,45 @@
         getMainDexInspector(dexesThroughIndexedIntermediate);
     CodeInspector filePerInputClassIntermediateInspector =
         getMainDexInspector(dexesThroughFilePerInputClassIntermediate);
-    Collection<String> fullMainClasses = new HashSet<>();
+    Set<String> fullMainClasses = new HashSet<>();
     fullInspector.forAllClasses(
         clazz -> fullMainClasses.add(clazz.getFinalDescriptor()));
-    Collection<String> indexedIntermediateMainClasses = new HashSet<>();
+    Set<String> indexedIntermediateMainClasses = new HashSet<>();
     indexedIntermediateInspector.forAllClasses(
         clazz -> indexedIntermediateMainClasses.add(clazz.getFinalDescriptor()));
-    Collection<String> filePerInputClassIntermediateMainClasses = new HashSet<>();
+    Set<String> filePerInputClassIntermediateMainClasses = new HashSet<>();
     filePerInputClassIntermediateInspector.forAllClasses(
         clazz -> filePerInputClassIntermediateMainClasses.add(clazz.getFinalDescriptor()));
 
     // Check.
     Assert.assertEquals(expectedMainDexListSize, fullMainClasses.size());
-    Assert.assertEquals(fullMainClasses, indexedIntermediateMainClasses);
-    Assert.assertEquals(fullMainClasses, filePerInputClassIntermediateMainClasses);
+    SetView<String> adjustedFull =
+        Sets.difference(
+            fullMainClasses,
+            new HashSet<>(
+                ListUtils.map(mainDexOverApproximation, DescriptorUtils::javaTypeToDescriptor)));
+    assertEqualSets(adjustedFull, indexedIntermediateMainClasses);
+    assertEqualSets(adjustedFull, filePerInputClassIntermediateMainClasses);
+  }
+
+  <T> void assertEqualSets(Set<T> expected, Set<T> actual) {
+    SetView<T> missing = Sets.difference(expected, actual);
+    SetView<T> unexpected = Sets.difference(actual, expected);
+    if (missing.isEmpty() && unexpected.isEmpty()) {
+      return;
+    }
+    StringBuilder builder = new StringBuilder("Sets differ.");
+    if (!missing.isEmpty()) {
+      builder.append("\nMissing items: [\n  ");
+      StringUtils.append(builder, missing, "\n  ", BraceType.NONE);
+      builder.append("\n]");
+    }
+    if (!unexpected.isEmpty()) {
+      builder.append("\nUnexpected items: [\n  ");
+      StringUtils.append(builder, unexpected, "\n  ", BraceType.NONE);
+      builder.append("\n]");
+    }
+    fail(builder.toString());
   }
 
   protected Path buildDexThroughIntermediate(
@@ -572,7 +638,7 @@
       Path input,
       OutputMode outputMode,
       AndroidApiLevel minApi,
-      String... mainDexClasses)
+      List<String> mainDexClasses)
       throws Throwable {
     Path intermediateDex =
         temp.getRoot().toPath().resolve(packageName + "intermediate" + ZIP_EXTENSION);
@@ -591,7 +657,7 @@
         test(packageName + "dex", packageName, "N/A")
             .withOptionConsumer(option -> option.minimalMainDex = true)
             .withOptionConsumer(option -> option.enableInheritanceClassInDexDistributor = false)
-            .withMainDexClass(mainDexClasses)
+            .withMainDexKeepClassRules(mainDexClasses)
             .withMinApiLevel(minApi)
             .withKeepAll();
 
@@ -644,8 +710,7 @@
     }
   }
 
-  protected CodeInspector getMainDexInspector(Path zip)
-      throws IOException, ExecutionException {
+  protected CodeInspector getMainDexInspector(Path zip) throws IOException {
     try (ZipFile zipFile = new ZipFile(zip.toFile(), StandardCharsets.UTF_8)) {
       try (InputStream in =
           zipFile.getInputStream(zipFile.getEntry(ToolHelper.DEFAULT_DEX_FILENAME))) {
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontallyMergedClassInliningTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontallyMergedClassInliningTest.java
new file mode 100644
index 0000000..0ca2179
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontallyMergedClassInliningTest.java
@@ -0,0 +1,86 @@
+// Copyright (c) 2021, 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.classmerging.horizontal;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class HorizontallyMergedClassInliningTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public HorizontallyMergedClassInliningTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .addHorizontallyMergedClassesInspector(
+            inspector -> inspector.assertIsCompleteMergeGroup(A.class, B.class, C.class))
+        .allowAccessModification()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(
+            inspector -> {
+              assertThat(inspector.clazz(A.class), isAbsent());
+              assertThat(inspector.clazz(B.class), isAbsent());
+              assertThat(inspector.clazz(C.class), isAbsent());
+            })
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutput("Hello world!");
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      print(new A().build());
+      print(new B().build());
+      print(new C().build());
+    }
+
+    static void print(String[] strings) {
+      for (String string : strings) {
+        System.out.print(string);
+      }
+    }
+  }
+
+  static class A {
+
+    String[] build() {
+      return new String[] {"H", "e", "l", "l"};
+    }
+  }
+
+  static class B {
+
+    String[] build() {
+      return new String[] {"o", " ", "w", "o"};
+    }
+  }
+
+  static class C {
+
+    String[] build() {
+      return new String[] {"r", "l", "d", "!"};
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/backports/BackportMainDexTest.java b/src/test/java/com/android/tools/r8/desugar/backports/BackportMainDexTest.java
index 05f84af..81f0674 100644
--- a/src/test/java/com/android/tools/r8/desugar/backports/BackportMainDexTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/backports/BackportMainDexTest.java
@@ -153,7 +153,7 @@
     testForD8(parameters.getBackend())
         .addProgramClasses(CLASSES)
         .setMinApi(parameters.getApiLevel())
-        .addMainDexListClasses(MiniAssert.class, TestClass.class, User2.class)
+        .addMainDexRules(keepMainProguardConfiguration(TestClass.class))
         .setProgramConsumer(mainDexConsumer)
         .compile()
         .inspect(this::checkExpectedSynthetics)
@@ -185,44 +185,8 @@
     testForD8()
         .addProgramFiles(perClassOutput)
         .setMinApi(parameters.getApiLevel())
-        .addMainDexListClasses(MiniAssert.class, TestClass.class, User2.class)
-        .setProgramConsumer(mainDexConsumer)
-        .compile()
-        .inspect(this::checkExpectedSynthetics)
-        .run(parameters.getRuntime(), TestClass.class, getRunArgs())
-        .assertSuccessWithOutput(EXPECTED);
-    checkMainDex(mainDexConsumer);
-  }
-
-  // TODO(b/168584485): This test should be removed once support is dropped.
-  @Test
-  public void testD8MergingWithTraceCf() throws Exception {
-    assumeTrue(parameters.isDexRuntime());
-    Path out1 =
-        testForD8()
-            .addProgramClasses(User1.class)
-            .addClasspathClasses(CLASSES)
-            .setIntermediate(true)
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .writeToZip();
-
-    Path out2 =
-        testForD8()
-            .addProgramClasses(User2.class)
-            .addClasspathClasses(CLASSES)
-            .setIntermediate(true)
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .writeToZip();
-
-    MainDexConsumer mainDexConsumer = new MainDexConsumer();
-    testForD8(parameters.getBackend())
-        .addProgramClasses(TestClass.class, MiniAssert.class)
-        .addProgramFiles(out1, out2)
-        .setMinApi(parameters.getApiLevel())
-        .addMainDexListClassReferences(
-            traceMainDex(CLASSES, Collections.emptyList()).getMainDexList())
+        // Trace the classes run by main which will pick up their dependencies.
+        .addMainDexRules(keepMainProguardConfiguration(TestClass.class))
         .setProgramConsumer(mainDexConsumer)
         .compile()
         .inspect(this::checkExpectedSynthetics)
diff --git a/src/test/java/com/android/tools/r8/dexsplitter/SyntheticDistributionTest.java b/src/test/java/com/android/tools/r8/dexsplitter/SyntheticDistributionTest.java
index af73519..20c2b51 100644
--- a/src/test/java/com/android/tools/r8/dexsplitter/SyntheticDistributionTest.java
+++ b/src/test/java/com/android/tools/r8/dexsplitter/SyntheticDistributionTest.java
@@ -16,6 +16,7 @@
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.ThrowingConsumer;
@@ -55,7 +56,6 @@
             r8FullTestBuilder
                 .noMinification()
                 .enableInliningAnnotations()
-                .addInliningAnnotations()
                 .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.O));
     ThrowingConsumer<R8TestCompileResult, Exception> ensureLambdaNotInBase =
         r8TestCompileResult -> {
@@ -87,6 +87,10 @@
             .addFeatureSplit(FeatureClass.class)
             .addFeatureSplit(Feature2Class.class)
             .addKeepFeatureMainRules(BaseSuperClass.class, FeatureClass.class, Feature2Class.class)
+            .addKeepMethodRules(
+                Reference.methodFromMethod(
+                    BaseSuperClass.class.getDeclaredMethod(
+                        "keptApplyLambda", MyFunction.class, String.class)))
             .noMinification()
             .enableInliningAnnotations()
             .setMinApi(parameters.getApiLevel())
@@ -108,6 +112,10 @@
     }
 
     public abstract String getFromFeature();
+
+    public String keptApplyLambda(MyFunction fn, String arg) {
+      return fn.apply(arg);
+    }
   }
 
   public interface MyFunction {
@@ -133,7 +141,7 @@
 
     @NeverInline
     private String useTheLambda(MyFunction f) {
-      return f.apply("42");
+      return keptApplyLambda(f, "42");
     }
   }
 
@@ -159,7 +167,7 @@
 
     @NeverInline
     private String useTheLambda(MyFunction f) {
-      return f.apply("43");
+      return keptApplyLambda(f, "43");
     }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
index 1bbcb9e..d3d99ee 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
@@ -116,12 +116,11 @@
 
   @Test
   public void testD8DesugaredLambdasInMainDexList() throws Exception {
-    Path mainDexList = writeTextToTempFile(testClassMainDexName);
     TestMainDexListConsumer consumer = new TestMainDexListConsumer();
     testForD8()
         .setMinApi(AndroidApiLevel.K)
         .addProgramClasses(ImmutableList.of(TestClass.class, MyConsumer.class))
-        .addMainDexListFiles(ImmutableList.of(mainDexList))
+        .addMainDexListClasses(TestClass.class)
         .setMainDexListConsumer(consumer)
         .compile();
     assertTrue(consumer.called);
@@ -129,7 +128,6 @@
 
   @Test
   public void testD8DesugaredLambdasInMainDexListMerging() throws Exception {
-    Path mainDexList = writeTextToTempFile(testClassMainDexName);
     // Build intermediate dex code first.
     Path dexOutput =
         testForD8()
@@ -143,7 +141,7 @@
     testForD8()
         .setMinApi(AndroidApiLevel.K)
         .addProgramFiles(dexOutput)
-        .addMainDexListFiles(ImmutableList.of(mainDexList))
+        .addMainDexKeepClassRules(TestClass.class)
         .setMainDexListConsumer(consumer)
         .compile();
     assertTrue(consumer.called);
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexWithSynthesizedClassesTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexWithSynthesizedClassesTest.java
index 9fa7fe9..5e88d7d 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexWithSynthesizedClassesTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexWithSynthesizedClassesTest.java
@@ -72,7 +72,7 @@
     D8TestCompileResult compileResult =
         testForD8()
             .addProgramFiles(intermediateResult.writeToZip())
-            .addMainDexListClasses(TestClass.class, A.class)
+            .addMainDexKeepClassRules(TestClass.class, A.class)
             .setMinApiThreshold(parameters.getApiLevel())
             .compile();
     checkCompilationResult(compileResult);
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageFeatureWithSyntheticsTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageFeatureWithSyntheticsTest.java
index a203729..4eb6d15 100644
--- a/src/test/java/com/android/tools/r8/repackage/RepackageFeatureWithSyntheticsTest.java
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageFeatureWithSyntheticsTest.java
@@ -12,7 +12,6 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.google.common.collect.ImmutableList;
 import java.util.List;
 import org.junit.Test;
@@ -37,12 +36,16 @@
   private static final List<Class<?>> FIRST_CLASSES =
       ImmutableList.of(FIRST_FOO, FIRST_PKG_PRIVATE);
 
+  private static final Class<?> FIRST_FIRST_FOO =
+      com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first.first.Foo
+          .class;
+
+  private static final Class<?> FIRST_FIRST_PKG_PRIVATE =
+      com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first.first
+          .PkgProtectedMethod.class;
+
   private static final List<Class<?>> FIRST_FIRST_CLASSES =
-      ImmutableList.of(
-          com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first.first.Foo
-              .class,
-          com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first.first
-              .PkgProtectedMethod.class);
+      ImmutableList.of(FIRST_FIRST_FOO, FIRST_FIRST_PKG_PRIVATE);
 
   private static List<Class<?>> getTestClasses() {
     return ImmutableList.<Class<?>>builder()
@@ -84,11 +87,7 @@
             .addProgramClasses(getTestClasses())
             .addFeatureSplit(getFeatureClasses().toArray(new Class<?>[0]))
             .addKeepMainRule(TestClass.class)
-            .addKeepClassAndMembersRules(
-                com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first
-                    .PkgProtectedMethod.class,
-                com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first
-                    .first.PkgProtectedMethod.class)
+            .addKeepClassAndMembersRules(FIRST_PKG_PRIVATE, FIRST_FIRST_PKG_PRIVATE)
             .addKeepClassAndMembersRules(I.class)
             .addKeepMethodRules(
                 Reference.methodFromMethod(TestClass.class.getDeclaredMethod("run", I.class)))
@@ -106,20 +105,21 @@
     // Check that the first.Foo is repackaged but that the pkg private access class is not.
     // The implies that the lambda which is doing a package private access cannot be repackaged.
     // If it is, the access will fail resulting in a runtime exception.
-    CodeInspector baseInspector = compileResult.inspector();
-    assertThat(FIRST_FOO, isRepackagedAsExpected(baseInspector, "first"));
-    assertThat(FIRST_PKG_PRIVATE, isNotRepackaged(baseInspector));
-    assertEquals(
-        getTestClasses().size() + expectedSyntheticsInBase, baseInspector.allClasses().size());
-
-    // The feature first.first.Foo is not repackaged and neither is the lambda.
-    // TODO(b/180086194): first.first.Foo should have been repackaged, but is currently identified
-    //   as being in 'base' when inlining takes place.
-    CodeInspector featureInspector = new CodeInspector(compileResult.getFeature(0));
-    getFeatureClasses().forEach(c -> assertThat(c, isNotRepackaged(featureInspector)));
-    assertEquals(
-        getFeatureClasses().size() + expectedSyntheticsInFeature,
-        featureInspector.allClasses().size());
+    compileResult.inspect(
+        baseInspector -> {
+          assertThat(FIRST_FOO, isRepackagedAsExpected(baseInspector, "first"));
+          assertThat(FIRST_PKG_PRIVATE, isNotRepackaged(baseInspector));
+          assertEquals(
+              getTestClasses().size() + expectedSyntheticsInBase,
+              baseInspector.allClasses().size());
+        },
+        featureInspector -> {
+          assertThat(FIRST_FIRST_FOO, isRepackagedAsExpected(featureInspector, "first$1"));
+          assertThat(FIRST_FIRST_PKG_PRIVATE, isNotRepackaged(featureInspector));
+          assertEquals(
+              getFeatureClasses().size() + expectedSyntheticsInFeature,
+              featureInspector.allClasses().size());
+        });
 
     compileResult
         .addFeatureSplitsToRunClasspathFiles()
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/HorizontallyMergedClassesInspector.java b/src/test/java/com/android/tools/r8/utils/codeinspector/HorizontallyMergedClassesInspector.java
index a5c623c..91fb002 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/HorizontallyMergedClassesInspector.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/HorizontallyMergedClassesInspector.java
@@ -133,6 +133,11 @@
     return this;
   }
 
+  public HorizontallyMergedClassesInspector assertIsCompleteMergeGroup(Class<?>... classes) {
+    return assertIsCompleteMergeGroup(
+        Stream.of(classes).map(Reference::classFromClass).collect(Collectors.toList()));
+  }
+
   public HorizontallyMergedClassesInspector assertIsCompleteMergeGroup(String... typeNames) {
     return assertIsCompleteMergeGroup(
         Stream.of(typeNames).map(Reference::classFromTypeName).collect(Collectors.toList()));