diff --git a/src/library_desugar/jdk11/desugar_jdk_libs.json b/src/library_desugar/jdk11/desugar_jdk_libs.json
index 3d23d9f..0020bab 100644
--- a/src/library_desugar/jdk11/desugar_jdk_libs.json
+++ b/src/library_desugar/jdk11/desugar_jdk_libs.json
@@ -403,12 +403,34 @@
         "java.lang.Object java.util.concurrent.atomic.AtomicReference#getAndAccumulate(java.lang.Object, java.util.function.BinaryOperator)": "java.util.concurrent.atomic.DesugarAtomicReference",
         "java.lang.Object java.util.concurrent.atomic.AtomicReference#getAndUpdate(java.util.function.UnaryOperator)": "java.util.concurrent.atomic.DesugarAtomicReference",
         "java.lang.Object java.util.concurrent.atomic.AtomicReference#updateAndGet(java.util.function.UnaryOperator)": "java.util.concurrent.atomic.DesugarAtomicReference",
+        "java.util.Collection java.util.Collections#checkedCollection(java.util.Collection, java.lang.Class)": "java.util.DesugarCollections",
+        "java.util.Set java.util.Collections#checkedSet(java.util.Set, java.lang.Class)": "java.util.DesugarCollections",
+        "java.util.SortedSet java.util.Collections#checkedSortedSet(java.util.SortedSet, java.lang.Class)": "java.util.DesugarCollections",
+        "java.util.List java.util.Collections#checkedList(java.util.List, java.lang.Class)": "java.util.DesugarCollections",
+        "java.util.Map java.util.Collections#checkedMap(java.util.Map, java.lang.Class, java.lang.Class)": "java.util.DesugarCollections",
+        "java.util.SortedMap java.util.Collections#checkedSortedMap(java.util.SortedMap, java.lang.Class, java.lang.Class)": "java.util.DesugarCollections",
+        "java.util.Collection java.util.Collections#unmodifiableCollection(java.util.Collection)": "java.util.DesugarCollections",
+        "java.util.Set java.util.Collections#unmodifiableSet(java.util.Set)": "java.util.DesugarCollections",
+        "java.util.SortedSet java.util.Collections#unmodifiableSortedSet(java.util.SortedSet)": "java.util.DesugarCollections",
+        "java.util.List java.util.Collections#unmodifiableList(java.util.List)": "java.util.DesugarCollections",
+        "java.util.Map java.util.Collections#unmodifiableMap(java.util.Map)": "java.util.DesugarCollections",
+        "java.util.SortedMap java.util.Collections#unmodifiableSortedMap(java.util.SortedMap)": "java.util.DesugarCollections",
+        "java.util.Collection java.util.Collections#synchronizedCollection(java.util.Collection)": "java.util.DesugarCollections",
+        "java.util.Set java.util.Collections#synchronizedSet(java.util.Set)": "java.util.DesugarCollections",
+        "java.util.SortedSet java.util.Collections#synchronizedSortedSet(java.util.SortedSet)": "java.util.DesugarCollections",
+        "java.util.List java.util.Collections#synchronizedList(java.util.List)": "java.util.DesugarCollections",
         "java.util.Map java.util.Collections#synchronizedMap(java.util.Map)": "java.util.DesugarCollections",
         "java.util.SortedMap java.util.Collections#synchronizedSortedMap(java.util.SortedMap)": "java.util.DesugarCollections",
         "long java.util.concurrent.atomic.AtomicLong#accumulateAndGet(long, java.util.function.LongBinaryOperator)": "java.util.concurrent.atomic.DesugarAtomicLong",
         "long java.util.concurrent.atomic.AtomicLong#getAndAccumulate(long, java.util.function.LongBinaryOperator)": "java.util.concurrent.atomic.DesugarAtomicLong",
         "long java.util.concurrent.atomic.AtomicLong#getAndUpdate(java.util.function.LongUnaryOperator)": "java.util.concurrent.atomic.DesugarAtomicLong",
         "long java.util.concurrent.atomic.AtomicLong#updateAndGet(java.util.function.LongUnaryOperator)": "java.util.concurrent.atomic.DesugarAtomicLong"
+      },
+      "api_generic_types_conversion": {
+        "java.util.Collection java.util.Hashtable#values()": [-1, "java.util.Collection java.util.DesugarCollections#bridge_synchronizedCollection(java.util.Collection, java.lang.Object)"],
+        "java.util.Set java.util.Hashtable#entrySet()": [-1, "java.util.Set java.util.DesugarCollections#bridge_synchronizedSet(java.util.Set, java.lang.Object)"],
+        "java.util.Set java.util.Hashtable#keySet()": [-1, "java.util.Set java.util.DesugarCollections#bridge_synchronizedSet(java.util.Set, java.lang.Object)"],
+        "java.util.List java.util.Vector#subList(int, int)": [-1, "java.util.List java.util.DesugarCollections#bridge_synchronizedList(java.util.List, java.lang.Object)"]
       }
     }
   ],
diff --git a/src/library_desugar/jdk11/desugar_jdk_libs_nio.json b/src/library_desugar/jdk11/desugar_jdk_libs_nio.json
index 0f81af4..aa8b1c0 100644
--- a/src/library_desugar/jdk11/desugar_jdk_libs_nio.json
+++ b/src/library_desugar/jdk11/desugar_jdk_libs_nio.json
@@ -571,12 +571,34 @@
         "java.lang.Object java.util.concurrent.atomic.AtomicReference#getAndAccumulate(java.lang.Object, java.util.function.BinaryOperator)": "java.util.concurrent.atomic.DesugarAtomicReference",
         "java.lang.Object java.util.concurrent.atomic.AtomicReference#getAndUpdate(java.util.function.UnaryOperator)": "java.util.concurrent.atomic.DesugarAtomicReference",
         "java.lang.Object java.util.concurrent.atomic.AtomicReference#updateAndGet(java.util.function.UnaryOperator)": "java.util.concurrent.atomic.DesugarAtomicReference",
+        "java.util.Collection java.util.Collections#checkedCollection(java.util.Collection, java.lang.Class)": "java.util.DesugarCollections",
+        "java.util.Set java.util.Collections#checkedSet(java.util.Set, java.lang.Class)": "java.util.DesugarCollections",
+        "java.util.SortedSet java.util.Collections#checkedSortedSet(java.util.SortedSet, java.lang.Class)": "java.util.DesugarCollections",
+        "java.util.List java.util.Collections#checkedList(java.util.List, java.lang.Class)": "java.util.DesugarCollections",
+        "java.util.Map java.util.Collections#checkedMap(java.util.Map, java.lang.Class, java.lang.Class)": "java.util.DesugarCollections",
+        "java.util.SortedMap java.util.Collections#checkedSortedMap(java.util.SortedMap, java.lang.Class, java.lang.Class)": "java.util.DesugarCollections",
+        "java.util.Collection java.util.Collections#unmodifiableCollection(java.util.Collection)": "java.util.DesugarCollections",
+        "java.util.Set java.util.Collections#unmodifiableSet(java.util.Set)": "java.util.DesugarCollections",
+        "java.util.SortedSet java.util.Collections#unmodifiableSortedSet(java.util.SortedSet)": "java.util.DesugarCollections",
+        "java.util.List java.util.Collections#unmodifiableList(java.util.List)": "java.util.DesugarCollections",
+        "java.util.Map java.util.Collections#unmodifiableMap(java.util.Map)": "java.util.DesugarCollections",
+        "java.util.SortedMap java.util.Collections#unmodifiableSortedMap(java.util.SortedMap)": "java.util.DesugarCollections",
+        "java.util.Collection java.util.Collections#synchronizedCollection(java.util.Collection)": "java.util.DesugarCollections",
+        "java.util.Set java.util.Collections#synchronizedSet(java.util.Set)": "java.util.DesugarCollections",
+        "java.util.SortedSet java.util.Collections#synchronizedSortedSet(java.util.SortedSet)": "java.util.DesugarCollections",
+        "java.util.List java.util.Collections#synchronizedList(java.util.List)": "java.util.DesugarCollections",
         "java.util.Map java.util.Collections#synchronizedMap(java.util.Map)": "java.util.DesugarCollections",
         "java.util.SortedMap java.util.Collections#synchronizedSortedMap(java.util.SortedMap)": "java.util.DesugarCollections",
         "long java.util.concurrent.atomic.AtomicLong#accumulateAndGet(long, java.util.function.LongBinaryOperator)": "java.util.concurrent.atomic.DesugarAtomicLong",
         "long java.util.concurrent.atomic.AtomicLong#getAndAccumulate(long, java.util.function.LongBinaryOperator)": "java.util.concurrent.atomic.DesugarAtomicLong",
         "long java.util.concurrent.atomic.AtomicLong#getAndUpdate(java.util.function.LongUnaryOperator)": "java.util.concurrent.atomic.DesugarAtomicLong",
         "long java.util.concurrent.atomic.AtomicLong#updateAndGet(java.util.function.LongUnaryOperator)": "java.util.concurrent.atomic.DesugarAtomicLong"
+      },
+      "api_generic_types_conversion": {
+        "java.util.Collection java.util.Hashtable#values()": [-1, "java.util.Collection java.util.DesugarCollections#bridge_synchronizedCollection(java.util.Collection, java.lang.Object)"],
+        "java.util.Set java.util.Hashtable#entrySet()": [-1, "java.util.Set java.util.DesugarCollections#bridge_synchronizedSet(java.util.Set, java.lang.Object)"],
+        "java.util.Set java.util.Hashtable#keySet()": [-1, "java.util.Set java.util.DesugarCollections#bridge_synchronizedSet(java.util.Set, java.lang.Object)"],
+        "java.util.List java.util.Vector#subList(int, int)": [-1, "java.util.List java.util.DesugarCollections#bridge_synchronizedList(java.util.List, java.lang.Object)"]
       }
     },
     {
diff --git a/src/main/java/com/android/tools/r8/classmerging/Policy.java b/src/main/java/com/android/tools/r8/classmerging/Policy.java
index e7f52f3..7655762 100644
--- a/src/main/java/com/android/tools/r8/classmerging/Policy.java
+++ b/src/main/java/com/android/tools/r8/classmerging/Policy.java
@@ -8,7 +8,6 @@
 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.policies.VerticalClassMergerPolicy;
 import com.android.tools.r8.verticalclassmerging.policies.VerticalClassMergerPolicyWithPreprocessing;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -60,16 +59,7 @@
     return false;
   }
 
-  public VerticalClassMergerPolicy asVerticalClassMergerPolicy() {
-    return null;
-  }
-
-  public boolean isVerticalClassMergerPolicyWithPreprocessing() {
-    return false;
-  }
-
-  public VerticalClassMergerPolicyWithPreprocessing<?>
-      asVerticalClassMergerPolicyWithPreprocessing() {
+  public VerticalClassMergerPolicyWithPreprocessing<?> asVerticalClassMergerPolicy() {
     return null;
   }
 
diff --git a/src/main/java/com/android/tools/r8/graph/DexClass.java b/src/main/java/com/android/tools/r8/graph/DexClass.java
index ea46ea8..3c8c2fd 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -1141,9 +1141,8 @@
     return null;
   }
 
-  @SuppressWarnings("ReferenceEquality")
   public boolean isInSameNest(DexClass other) {
-    return isInANest() && other.isInANest() && getNestHost() == other.getNestHost();
+    return isInANest() && other.isInANest() && getNestHost().isIdenticalTo(other.getNestHost());
   }
 
   public void forEachNestMember(Consumer<DexType> consumer) {
diff --git a/src/main/java/com/android/tools/r8/utils/ArchiveResourceProvider.java b/src/main/java/com/android/tools/r8/utils/ArchiveResourceProvider.java
index 6532b8f..b73119d 100644
--- a/src/main/java/com/android/tools/r8/utils/ArchiveResourceProvider.java
+++ b/src/main/java/com/android/tools/r8/utils/ArchiveResourceProvider.java
@@ -93,8 +93,10 @@
     }
     if (!dexResources.isEmpty() && !classResources.isEmpty()) {
       throw new CompilationError(
-          "Cannot create android app from an archive '" + archive
-              + "' containing both DEX and Java-bytecode content");
+          "Cannot create android app from an archive '"
+              + archive
+              + "' containing both DEX and Java-bytecode content",
+          origin);
     }
     return !dexResources.isEmpty() ? dexResources : classResources;
   }
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/ClassMerger.java b/src/main/java/com/android/tools/r8/verticalclassmerging/ClassMerger.java
index a198871..86b9848 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/ClassMerger.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/ClassMerger.java
@@ -8,6 +8,7 @@
 import static com.android.tools.r8.ir.code.InvokeType.DIRECT;
 import static com.android.tools.r8.ir.code.InvokeType.STATIC;
 import static com.android.tools.r8.ir.code.InvokeType.VIRTUAL;
+import static java.util.function.Predicate.not;
 
 import com.android.tools.r8.cf.CfVersion;
 import com.android.tools.r8.errors.Unreachable;
@@ -93,6 +94,77 @@
     this.target = group.getTarget();
   }
 
+  public void setup() {
+    setupInvokeSuperMapping();
+  }
+
+  private void setupInvokeSuperMapping() {
+    source.forEachProgramMethod(this::redirectSuperCallsToMethod);
+  }
+
+  private void redirectSuperCallsToMethod(ProgramMethod sourceMethod) {
+    if (sourceMethod.getAccessFlags().belongsToDirectPool()) {
+      redirectSuperCallsToDirectMethod(sourceMethod);
+    } else {
+      redirectSuperCallsToVirtualMethod(sourceMethod);
+    }
+  }
+
+  private void redirectSuperCallsToDirectMethod(ProgramMethod sourceMethod) {
+    DexEncodedMethod definition = sourceMethod.getDefinition();
+    if (appView.options().canUseNestBasedAccess()
+        && source.isInSameNest(target)
+        && definition.isInstance()
+        && !definition.isInstanceInitializer()
+        && AccessControl.isMemberAccessible(sourceMethod, source, target, appView).isTrue()) {
+      lensBuilder.mapVirtualMethodToDirectInType(sourceMethod.getReference(), sourceMethod, target);
+    }
+  }
+
+  private void redirectSuperCallsToVirtualMethod(ProgramMethod sourceMethod) {
+    if (sourceMethod.getAccessFlags().isAbstract()) {
+      return;
+    }
+    if (source.isInterface()) {
+      // If we merge a default interface method from interface I to its subtype C, then we need
+      // to rewrite invocations on the form "invoke-super I.m()" to "invoke-direct C.m$I()".
+      //
+      // Unlike when we merge a class into its subclass (the else-branch below), we should *not*
+      // rewrite any invocations on the form "invoke-super J.m()" to "invoke-direct C.m$I()",
+      // if I has a supertype J. This is due to the fact that invoke-super instructions that
+      // resolve to a method on an interface never hit an implementation below that interface.
+      lensBuilder.mapVirtualMethodToDirectInType(sourceMethod.getReference(), sourceMethod, target);
+    } else {
+      // If we merge class B into class C, and class C contains an invocation super.m(), then it
+      // is insufficient to rewrite "invoke-super B.m()" to "invoke-{direct,virtual} C.m$B()" (the
+      // method C.m$B denotes the direct/virtual method that has been created in C for B.m). In
+      // particular, there might be an instruction "invoke-super A.m()" in C that resolves to B.m
+      // at runtime (A is a superclass of B), which also needs to be rewritten to
+      // "invoke-{direct,virtual} C.m$B()".
+      //
+      // We handle this by adding a mapping for [target] and all of its supertypes.
+      DexProgramClass current = target;
+      while (current != null) {
+        // Only rewrite the invoke-super call if it does not lead to a NoSuchMethodError.
+        boolean resolutionSucceeds =
+            appView
+                .appInfo()
+                .resolveMethodOnClass(current, sourceMethod.getReference())
+                .isSingleResolution();
+        if (!resolutionSucceeds) {
+          break;
+        }
+        DexMethod signatureInHolder =
+            sourceMethod.getReference().withHolder(current, dexItemFactory);
+        lensBuilder.mapVirtualMethodToDirectInType(signatureInHolder, sourceMethod, target);
+        current =
+            current.hasSuperType()
+                ? asProgramClassOrNull(appView.definitionFor(current.getSuperType()))
+                : null;
+      }
+    }
+  }
+
   public void merge() {
     // Merge the class [clazz] into [targetClass] by adding all methods to
     // targetClass that are not currently contained.
@@ -132,51 +204,37 @@
             add(directMethods, resultingDirectMethod, MethodSignatureEquivalence.get());
             lensBuilder.recordMove(directMethod.getDefinition(), resultingDirectMethod);
             blockRedirectionOfSuperCalls(resultingDirectMethod);
-
-            // Private methods in the parent class may be targeted with invoke-super if the two
-            // classes are in the same nest. Ensure such calls are mapped to invoke-direct.
-            if (definition.isInstance()
-                && definition.isPrivate()
-                && AccessControl.isMemberAccessible(directMethod, source, target, appView)
-                    .isTrue()) {
-              lensBuilder.mapVirtualMethodToDirectInType(
-                  definition.getReference(), definition, target.getType());
-            }
           }
         });
 
-    for (DexEncodedMethod virtualMethod : source.virtualMethods()) {
-      DexEncodedMethod shadowedBy = findMethodInTarget(virtualMethod);
+    for (DexEncodedMethod abstractMethod : source.virtualMethods(DexEncodedMethod::isAbstract)) {
+      DexEncodedMethod shadowedBy = findMethodInTarget(abstractMethod);
       if (shadowedBy != null) {
-        if (virtualMethod.isAbstract()) {
-          // Remove abstract/interface methods that are shadowed. The identity mapping below is
-          // needed to ensure we correctly fixup the mapping in case the signature refers to
-          // merged classes.
-          lensBuilder.recordSplit(virtualMethod, shadowedBy, null, null);
+        // Remove abstract/interface methods that are shadowed. The identity mapping below is
+        // needed to ensure we correctly fixup the mapping in case the signature refers to
+        // merged classes.
+        lensBuilder.recordSplit(abstractMethod, shadowedBy, null, null);
 
-          // The override now corresponds to the method in the parent, so unset its synthetic flag
-          // if the method in the parent is not synthetic.
-          if (!virtualMethod.isSyntheticMethod() && shadowedBy.isSyntheticMethod()) {
-            shadowedBy.getAccessFlags().demoteFromSynthetic();
-          }
-          continue;
+        // The override now corresponds to the method in the parent, so unset its synthetic flag
+        // if the method in the parent is not synthetic.
+        if (!abstractMethod.isSyntheticMethod() && shadowedBy.isSyntheticMethod()) {
+          shadowedBy.getAccessFlags().demoteFromSynthetic();
         }
       } else {
         // The method is not shadowed. If it is abstract, we can simply move it to the subclass.
-        // Non-abstract methods are handled below (they cannot simply be moved to the subclass as
-        // a virtual method, because they might be the target of an invoke-super instruction).
-        if (virtualMethod.isAbstract()) {
-          assert target.isAbstract();
-          // Update the holder of [virtualMethod] using renameMethod().
-          DexEncodedMethod resultingVirtualMethod =
-              renameMethod(virtualMethod, availableMethodSignatures, Rename.NEVER);
-          resultingVirtualMethod.setLibraryMethodOverride(virtualMethod.isLibraryMethodOverride());
-          lensBuilder.recordMove(virtualMethod, resultingVirtualMethod);
-          add(virtualMethods, resultingVirtualMethod, MethodSignatureEquivalence.get());
-          continue;
-        }
+        assert target.isAbstract();
+        // Update the holder of [virtualMethod] using renameMethod().
+        DexEncodedMethod resultingAbstractMethod =
+            renameMethod(abstractMethod, availableMethodSignatures, Rename.NEVER);
+        resultingAbstractMethod.setLibraryMethodOverride(abstractMethod.isLibraryMethodOverride());
+        lensBuilder.recordMove(abstractMethod, resultingAbstractMethod);
+        add(virtualMethods, resultingAbstractMethod, MethodSignatureEquivalence.get());
       }
+    }
 
+    for (DexEncodedMethod virtualMethod :
+        source.virtualMethods(not(DexEncodedMethod::isAbstract))) {
+      DexEncodedMethod shadowedBy = findMethodInTarget(virtualMethod);
       DexEncodedMethod resultingMethod;
       if (source.isInterface()) {
         // Moving a default interface method into its subtype. This method could be hit directly
@@ -210,10 +268,6 @@
           resultingMethod,
           MethodSignatureEquivalence.get());
 
-      // Record that invoke-super instructions in the target class should be redirected to the
-      // newly created direct method.
-      redirectSuperCallsInTarget(virtualMethod);
-
       DexEncodedMethod bridge = null;
       DexEncodedMethod override = shadowedBy;
       if (shadowedBy == null) {
@@ -468,66 +522,6 @@
         type -> true);
   }
 
-  private void redirectSuperCallsInTarget(DexEncodedMethod oldTarget) {
-    DexMethod oldTargetReference = oldTarget.getReference();
-    if (source.isInterface()) {
-      // If we merge a default interface method from interface I to its subtype C, then we need
-      // to rewrite invocations on the form "invoke-super I.m()" to "invoke-direct C.m$I()".
-      //
-      // Unlike when we merge a class into its subclass (the else-branch below), we should *not*
-      // rewrite any invocations on the form "invoke-super J.m()" to "invoke-direct C.m$I()",
-      // if I has a supertype J. This is due to the fact that invoke-super instructions that
-      // resolve to a method on an interface never hit an implementation below that interface.
-      lensBuilder.mapVirtualMethodToDirectInType(oldTargetReference, oldTarget, target.getType());
-    } else {
-      // If we merge class B into class C, and class C contains an invocation super.m(), then it
-      // is insufficient to rewrite "invoke-super B.m()" to "invoke-{direct,virtual} C.m$B()" (the
-      // method C.m$B denotes the direct/virtual method that has been created in C for B.m). In
-      // particular, there might be an instruction "invoke-super A.m()" in C that resolves to B.m
-      // at runtime (A is a superclass of B), which also needs to be rewritten to
-      // "invoke-{direct,virtual} C.m$B()".
-      //
-      // We handle this by adding a mapping for [target] and all of its supertypes.
-      DexProgramClass holder = target;
-      while (holder != null) {
-        DexMethod signatureInHolder = oldTargetReference.withHolder(holder, dexItemFactory);
-        // Only rewrite the invoke-super call if it does not lead to a NoSuchMethodError.
-        boolean resolutionSucceeds =
-            appView.appInfo().resolveMethodOnClass(holder, signatureInHolder).isSingleResolution();
-        if (resolutionSucceeds) {
-          lensBuilder.mapVirtualMethodToDirectInType(signatureInHolder, oldTarget, target.type);
-        } else {
-          break;
-        }
-
-        // Consider that A gets merged into B and B's subclass C gets merged into D. Instructions
-        // on the form "invoke-super {B,C,D}.m()" in D are changed into "invoke-direct D.m$C()" by
-        // the code above. However, instructions on the form "invoke-super A.m()" should also be
-        // changed into "invoke-direct D.m$C()". This is achieved by also considering the classes
-        // that have been merged into [holder].
-        Set<DexType> mergedTypes = verticallyMergedClassesBuilder.getSourcesFor(holder);
-        for (DexType type : mergedTypes) {
-          DexMethod signatureInType = oldTargetReference.withHolder(type, dexItemFactory);
-          // Resolution would have succeeded if the method used to be in [type], or if one of
-          // its super classes declared the method.
-          // TODO(b/315283244): Should not rely on lens for this. Instead precompute this before
-          //  merging any classes.
-          boolean resolutionSucceededBeforeMerge =
-              outerLensBuilder.hasMappingForSignatureInContext(holder, signatureInType)
-                  || appView.appInfo().lookupSuperTarget(signatureInHolder, holder, appView)
-                      != null;
-          if (resolutionSucceededBeforeMerge) {
-            lensBuilder.mapVirtualMethodToDirectInType(signatureInType, oldTarget, target.type);
-          }
-        }
-        holder =
-            holder.hasSuperType()
-                ? asProgramClassOrNull(appView.definitionFor(holder.getSuperType()))
-                : null;
-      }
-    }
-  }
-
   private void blockRedirectionOfSuperCalls(DexEncodedMethod method) {
     // We are merging a class B into C. The methods from B are being moved into C, and then we
     // subsequently rewrite the invoke-super instructions in C that hit a method in B, such that
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/ConnectedComponentVerticalClassMerger.java b/src/main/java/com/android/tools/r8/verticalclassmerging/ConnectedComponentVerticalClassMerger.java
index fdd9383..dc82f99 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/ConnectedComponentVerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/ConnectedComponentVerticalClassMerger.java
@@ -14,7 +14,7 @@
 public class ConnectedComponentVerticalClassMerger {
 
   private final AppView<AppInfoWithLiveness> appView;
-  private final Collection<VerticalMergeGroup> classesToMerge;
+  private final Collection<VerticalMergeGroup> groups;
 
   // The resulting graph lens that should be used after class merging.
   private final VerticalClassMergerGraphLens.Builder lensBuilder;
@@ -26,25 +26,31 @@
       VerticallyMergedClasses.builder();
 
   ConnectedComponentVerticalClassMerger(
-      AppView<AppInfoWithLiveness> appView, Collection<VerticalMergeGroup> classesToMerge) {
+      AppView<AppInfoWithLiveness> appView, Collection<VerticalMergeGroup> groups) {
     this.appView = appView;
-    this.classesToMerge = classesToMerge;
+    this.groups = groups;
     this.lensBuilder = new VerticalClassMergerGraphLens.Builder();
   }
 
   public boolean isEmpty() {
-    return classesToMerge.isEmpty();
+    return groups.isEmpty();
   }
 
   public VerticalClassMergerResult.Builder run() {
-    List<VerticalMergeGroup> classesToMergeSorted =
-        ListUtils.sort(classesToMerge, Comparator.comparing(group -> group.getSource().getType()));
-    for (VerticalMergeGroup group : classesToMergeSorted) {
-      ClassMerger classMerger =
-          new ClassMerger(
-              appView, lensBuilder, synthesizedBridges, verticallyMergedClassesBuilder, group);
-      classMerger.merge();
-    }
+    List<VerticalMergeGroup> groupsSorted =
+        ListUtils.sort(groups, Comparator.comparing(group -> group.getSource().getType()));
+    List<ClassMerger> classMergers =
+        ListUtils.map(
+            groupsSorted,
+            group ->
+                new ClassMerger(
+                    appView,
+                    lensBuilder,
+                    synthesizedBridges,
+                    verticallyMergedClassesBuilder,
+                    group));
+    classMergers.forEach(ClassMerger::setup);
+    classMergers.forEach(ClassMerger::merge);
     return VerticalClassMergerResult.builder(
         lensBuilder, synthesizedBridges, verticallyMergedClassesBuilder);
   }
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerGraphLens.java b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerGraphLens.java
index a3d1257..3987216 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerGraphLens.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerGraphLens.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.lens.GraphLens;
 import com.android.tools.r8.graph.lens.MethodLookupResult;
 import com.android.tools.r8.graph.proto.ArgumentInfoCollection;
@@ -515,9 +516,10 @@
       }
     }
 
-    public void mapVirtualMethodToDirectInType(DexMethod from, DexEncodedMethod to, DexType type) {
+    public void mapVirtualMethodToDirectInType(
+        DexMethod from, ProgramMethod to, DexProgramClass context) {
       contextualSuperToImplementationInContexts
-          .computeIfAbsent(type, ignoreKey(IdentityHashMap::new))
+          .computeIfAbsent(context.getType(), ignoreKey(IdentityHashMap::new))
           .put(from, to.getReference());
     }
 
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 bab7656..1874199 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerPolicyExecutor.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMergerPolicyExecutor.java
@@ -35,7 +35,6 @@
 import com.android.tools.r8.verticalclassmerging.policies.SameNestPolicy;
 import com.android.tools.r8.verticalclassmerging.policies.SameStartupPartitionPolicy;
 import com.android.tools.r8.verticalclassmerging.policies.SuccessfulVirtualMethodResolutionInTargetPolicy;
-import com.android.tools.r8.verticalclassmerging.policies.VerticalClassMergerPolicy;
 import com.android.tools.r8.verticalclassmerging.policies.VerticalClassMergerPolicyWithPreprocessing;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -113,18 +112,8 @@
   protected LinkedList<VerticalMergeGroup> apply(
       Policy policy, LinkedList<VerticalMergeGroup> linkedGroups, ExecutorService executorService)
       throws ExecutionException {
-    if (policy.isVerticalClassMergerPolicy()) {
-      return apply(policy.asVerticalClassMergerPolicy(), linkedGroups);
-    } else {
-      assert policy.isVerticalClassMergerPolicyWithPreprocessing();
-      return apply(policy.asVerticalClassMergerPolicyWithPreprocessing(), linkedGroups);
-    }
-  }
-
-  private LinkedList<VerticalMergeGroup> apply(
-      VerticalClassMergerPolicy policy, LinkedList<VerticalMergeGroup> linkedGroups) {
-    linkedGroups.removeIf(group -> !policy.canMerge(group));
-    return linkedGroups;
+    assert policy.isVerticalClassMergerPolicy();
+    return apply(policy.asVerticalClassMergerPolicy(), linkedGroups);
   }
 
   private <T> LinkedList<VerticalMergeGroup> apply(
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/policies/VerticalClassMergerPolicy.java b/src/main/java/com/android/tools/r8/verticalclassmerging/policies/VerticalClassMergerPolicy.java
index 49f179f..b5a6390 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/policies/VerticalClassMergerPolicy.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/policies/VerticalClassMergerPolicy.java
@@ -3,20 +3,21 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.verticalclassmerging.policies;
 
-import com.android.tools.r8.classmerging.Policy;
 import com.android.tools.r8.verticalclassmerging.VerticalMergeGroup;
+import java.util.Collection;
 
-public abstract class VerticalClassMergerPolicy extends Policy {
+public abstract class VerticalClassMergerPolicy
+    extends VerticalClassMergerPolicyWithPreprocessing<Void> {
 
   public abstract boolean canMerge(VerticalMergeGroup group);
 
   @Override
-  public boolean isVerticalClassMergerPolicy() {
-    return true;
+  public final boolean canMerge(VerticalMergeGroup group, Void data) {
+    return canMerge(group);
   }
 
   @Override
-  public VerticalClassMergerPolicy asVerticalClassMergerPolicy() {
-    return this;
+  public final Void preprocess(Collection<VerticalMergeGroup> groups) {
+    return null;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/policies/VerticalClassMergerPolicyWithPreprocessing.java b/src/main/java/com/android/tools/r8/verticalclassmerging/policies/VerticalClassMergerPolicyWithPreprocessing.java
index 7737ebc..5efbe75 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/policies/VerticalClassMergerPolicyWithPreprocessing.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/policies/VerticalClassMergerPolicyWithPreprocessing.java
@@ -14,13 +14,12 @@
   public abstract T preprocess(Collection<VerticalMergeGroup> groups);
 
   @Override
-  public boolean isVerticalClassMergerPolicyWithPreprocessing() {
+  public boolean isVerticalClassMergerPolicy() {
     return true;
   }
 
   @Override
-  public VerticalClassMergerPolicyWithPreprocessing<T>
-      asVerticalClassMergerPolicyWithPreprocessing() {
+  public VerticalClassMergerPolicyWithPreprocessing<T> asVerticalClassMergerPolicy() {
     return this;
   }
 }
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugarCollectionsTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugarCollectionsTest.java
new file mode 100644
index 0000000..a740261
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugarCollectionsTest.java
@@ -0,0 +1,283 @@
+// 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.desugar.desugaredlibrary;
+
+import static com.android.tools.r8.desugar.desugaredlibrary.test.CompilationSpecification.DEFAULT_SPECIFICATIONS;
+import static com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification.JDK11;
+import static com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification.JDK11_PATH;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.desugar.desugaredlibrary.test.CompilationSpecification;
+import com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification;
+import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.ImmutableList;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.SortedMap;
+import java.util.SortedSet;
+import java.util.Spliterator;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.Vector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class DesugarCollectionsTest extends DesugaredLibraryTestBase {
+
+  private final TestParameters parameters;
+  private final CompilationSpecification compilationSpecification;
+  private final LibraryDesugaringSpecification libraryDesugaringSpecification;
+
+  @Parameters(name = "{0}, spec: {1}, {2}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withDexRuntimesAndAllApiLevels().build(),
+        ImmutableList.of(JDK11, JDK11_PATH),
+        DEFAULT_SPECIFICATIONS);
+  }
+
+  public DesugarCollectionsTest(
+      TestParameters parameters,
+      LibraryDesugaringSpecification libraryDesugaringSpecification,
+      CompilationSpecification compilationSpecification) {
+    this.parameters = parameters;
+    this.compilationSpecification = compilationSpecification;
+    this.libraryDesugaringSpecification = libraryDesugaringSpecification;
+  }
+
+  @Test
+  public void testDesugarCollectionsTest() throws Throwable {
+    testForDesugaredLibrary(parameters, libraryDesugaringSpecification, compilationSpecification)
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutput(getExpectedResult());
+  }
+
+  private String getExpectedResult() {
+    List<String> result = new ArrayList<>();
+    for (int i = 0; i < 9; i++) {
+      result.add("item");
+    }
+    for (int i = 0; i < 6; i++) {
+      result.add("k v");
+    }
+    for (int i = 0; i < 6; i++) {
+      result.add("exception");
+    }
+    result.addAll(ImmutableList.of("one", "v", "k", "k=v"));
+    return StringUtils.lines(result);
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      successTest();
+      exceptionTest();
+      apiTest();
+    }
+
+    private static void apiTest() {
+      Vector<String> strings = new Vector<>();
+      strings.add("one");
+      strings.subList(0, 1).forEach(System.out::println);
+      Hashtable<String, String> table = new Hashtable<>();
+      table.put("k", "v");
+      table.values().forEach(System.out::println);
+      table.keySet().forEach(System.out::println);
+      table.entrySet().forEach(System.out::println);
+    }
+
+    private static void successTest() {
+      SortedSet<String> set = new TreeSet<>();
+      set.add("item");
+      Collections.unmodifiableCollection(set).forEach(System.out::println);
+      Collections.unmodifiableSet(set).forEach(System.out::println);
+      Collections.unmodifiableSortedSet(set).forEach(System.out::println);
+      Collections.synchronizedCollection(set).forEach(System.out::println);
+      Collections.synchronizedSet(set).forEach(System.out::println);
+      Collections.synchronizedSortedSet(set).forEach(System.out::println);
+      Collections.checkedCollection(set, String.class).forEach(System.out::println);
+      Collections.checkedSet(set, String.class).forEach(System.out::println);
+      Collections.checkedSortedSet(set, String.class).forEach(System.out::println);
+      SortedMap<String, String> map = new TreeMap<>();
+      map.put("k", "v");
+      Collections.unmodifiableMap(map).forEach((k, v) -> System.out.println(k + " " + v));
+      Collections.unmodifiableSortedMap(map).forEach((k, v) -> System.out.println(k + " " + v));
+      Collections.synchronizedMap(map).forEach((k, v) -> System.out.println(k + " " + v));
+      Collections.synchronizedSortedMap(map).forEach((k, v) -> System.out.println(k + " " + v));
+      Collections.checkedMap(map, String.class, String.class)
+          .forEach((k, v) -> System.out.println(k + " " + v));
+      Collections.checkedSortedMap(map, String.class, String.class)
+          .forEach((k, v) -> System.out.println(k + " " + v));
+    }
+
+    private static void exceptionTest() {
+      try {
+        Collections.unmodifiableCollection(new ImmutableList<>()).spliterator();
+        System.out.println("working");
+      } catch (UnsupportedOperationException e) {
+        System.out.println("exception");
+      }
+      try {
+        Collections.unmodifiableList(new ImmutableList<>()).spliterator();
+        System.out.println("working");
+      } catch (UnsupportedOperationException e) {
+        System.out.println("exception");
+      }
+      try {
+        Collections.synchronizedList(new ImmutableList<>()).spliterator();
+        System.out.println("working");
+      } catch (UnsupportedOperationException e) {
+        System.out.println("exception");
+      }
+      try {
+        Collections.synchronizedList(new ImmutableList<>()).spliterator();
+        System.out.println("working");
+      } catch (UnsupportedOperationException e) {
+        System.out.println("exception");
+      }
+      try {
+        Collections.checkedList(new ImmutableList<>(), Vector.class).spliterator();
+        System.out.println("working");
+      } catch (UnsupportedOperationException e) {
+        System.out.println("exception");
+      }
+      try {
+        Collections.checkedList(new ImmutableList<>(), Vector.class).spliterator();
+        System.out.println("working");
+      } catch (UnsupportedOperationException e) {
+        System.out.println("exception");
+      }
+    }
+
+    static class ImmutableList<T> implements List<T> {
+
+      @Override
+      public int size() {
+        return 0;
+      }
+
+      @Override
+      public boolean isEmpty() {
+        return false;
+      }
+
+      @Override
+      public boolean contains(Object o) {
+        return false;
+      }
+
+      @Override
+      public Iterator<T> iterator() {
+        return null;
+      }
+
+      @Override
+      public Object[] toArray() {
+        return new Object[0];
+      }
+
+      @Override
+      public <T1> T1[] toArray(T1[] a) {
+        return null;
+      }
+
+      @Override
+      public boolean add(T t) {
+        return false;
+      }
+
+      @Override
+      public boolean remove(Object o) {
+        return false;
+      }
+
+      @Override
+      public boolean containsAll(Collection<?> c) {
+        return false;
+      }
+
+      @Override
+      public boolean addAll(Collection<? extends T> c) {
+        return false;
+      }
+
+      @Override
+      public boolean addAll(int index, Collection<? extends T> c) {
+        return false;
+      }
+
+      @Override
+      public boolean removeAll(Collection<?> c) {
+        return false;
+      }
+
+      @Override
+      public boolean retainAll(Collection<?> c) {
+        return false;
+      }
+
+      @Override
+      public void clear() {}
+
+      @Override
+      public T get(int index) {
+        return null;
+      }
+
+      @Override
+      public T set(int index, T element) {
+        return null;
+      }
+
+      @Override
+      public void add(int index, T element) {}
+
+      @Override
+      public T remove(int index) {
+        return null;
+      }
+
+      @Override
+      public int indexOf(Object o) {
+        return 0;
+      }
+
+      @Override
+      public int lastIndexOf(Object o) {
+        return 0;
+      }
+
+      @Override
+      public ListIterator<T> listIterator() {
+        return null;
+      }
+
+      @Override
+      public ListIterator<T> listIterator(int index) {
+        return null;
+      }
+
+      @Override
+      public List<T> subList(int fromIndex, int toIndex) {
+        return null;
+      }
+
+      @Override
+      public Spliterator<T> spliterator() {
+        throw new UnsupportedOperationException();
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/files/ArchiveWithDexTest.java b/src/test/java/com/android/tools/r8/files/ArchiveWithDexTest.java
index 0c3bd18..85b25f3 100644
--- a/src/test/java/com/android/tools/r8/files/ArchiveWithDexTest.java
+++ b/src/test/java/com/android/tools/r8/files/ArchiveWithDexTest.java
@@ -4,6 +4,8 @@
 package com.android.tools.r8.files;
 
 import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticOrigin;
+import static org.hamcrest.CoreMatchers.allOf;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
@@ -11,10 +13,15 @@
 
 import com.android.tools.r8.ArchiveProgramResourceProvider;
 import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.DexIndexedConsumer;
+import com.android.tools.r8.R8;
+import com.android.tools.r8.R8Command;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.origin.PathOrigin;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.ArchiveResourceProvider;
 import com.android.tools.r8.utils.BooleanBox;
@@ -33,6 +40,8 @@
 @RunWith(Parameterized.class)
 public class ArchiveWithDexTest extends TestBase {
 
+  static final String MESSAGE = "containing both DEX and Java-bytecode content";
+
   @Parameter() public TestParameters parameters;
 
   @Parameters(name = "{0}")
@@ -41,6 +50,7 @@
   }
 
   private static Path zipWithDexAndClass;
+  private static Origin zipWithDexAndClassOrigin;
 
   @BeforeClass
   public static void createZipWitDexAndClass() throws IOException {
@@ -51,6 +61,7 @@
     Files.createFile(zipContent.resolve("other.dex"));
     zipWithDexAndClass = getStaticTemp().newFolder().toPath().resolve("input.zip");
     ZipUtils.zip(zipWithDexAndClass, zipContent);
+    zipWithDexAndClassOrigin = new PathOrigin(zipWithDexAndClass);
   }
 
   private void checkOneDexFiles(Path archive) throws Exception {
@@ -85,6 +96,41 @@
   }
 
   @Test
+  public void testFileInputD8() {
+    assertThrows(
+        CompilationFailedException.class,
+        () ->
+            testForD8(Backend.DEX)
+                .addProgramFiles(zipWithDexAndClass)
+                .setMinApi(AndroidApiLevel.B)
+                .compileWithExpectedDiagnostics(
+                    diagnostics ->
+                        diagnostics.assertErrorsMatch(
+                            allOf(
+                                diagnosticMessage(containsString("input.zip")),
+                                diagnosticMessage(containsString(MESSAGE)),
+                                diagnosticOrigin(zipWithDexAndClassOrigin)))));
+  }
+
+  @Test
+  public void testProviderInputD8() {
+    assertThrows(
+        CompilationFailedException.class,
+        () ->
+            testForD8(Backend.DEX)
+                .addProgramResourceProviders(
+                    ArchiveProgramResourceProvider.fromArchive(zipWithDexAndClass))
+                .setMinApi(AndroidApiLevel.B)
+                .compileWithExpectedDiagnostics(
+                    diagnostics ->
+                        diagnostics.assertErrorsMatch(
+                            allOf(
+                                // When using providers the file name is not in the message.
+                                diagnosticMessage(containsString(MESSAGE)),
+                                diagnosticOrigin(zipWithDexAndClassOrigin)))));
+  }
+
+  @Test
   public void testR8() {
     assertThrows(
         CompilationFailedException.class,
@@ -97,10 +143,10 @@
                 .compileWithExpectedDiagnostics(
                     diagnostics ->
                         diagnostics.assertErrorsMatch(
-                            diagnosticMessage(
-                                containsString(
-                                    "Cannot create android app from an archive containing both DEX"
-                                        + " and Java-bytecode content.")))));
+                            allOf(
+                                // When using providers the file name is not in the message.
+                                diagnosticMessage(containsString(MESSAGE)),
+                                diagnosticOrigin(zipWithDexAndClassOrigin)))));
   }
 
   @Test
@@ -130,6 +176,19 @@
   }
 
   @Test
+  public void testRawCommandBuilderR8() throws Exception {
+    // Check that the error is wrapped and reported at the point of compiling (not arg building).
+    R8Command command =
+        R8Command.builder()
+            .addProgramResourceProvider(
+                ArchiveProgramResourceProvider.fromArchive(zipWithDexAndClass))
+            .setMinApiLevel(1)
+            .setProgramConsumer(DexIndexedConsumer.emptyConsumer())
+            .build();
+    assertThrows(CompilationFailedException.class, () -> R8.run(command));
+  }
+
+  @Test
   public void testR8LegacyProgramResourceProviderDontIgnoreDex() {
     assertThrows(
         CompilationFailedException.class,
@@ -142,8 +201,10 @@
                 .compileWithExpectedDiagnostics(
                     diagnostics ->
                         diagnostics.assertErrorsMatch(
-                            diagnosticMessage(
-                                containsString("containing both DEX and Java-bytecode content")))));
+                            allOf(
+                                // When using providers the file name is not in the message.
+                                diagnosticMessage(containsString(MESSAGE)),
+                                diagnosticOrigin(zipWithDexAndClassOrigin)))));
   }
 
   static class TestClass {
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/ConditionalRuleOnMemberFieldWithKeepInitTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/ConditionalRuleOnMemberFieldWithKeepInitTest.java
new file mode 100644
index 0000000..68db4f1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/ConditionalRuleOnMemberFieldWithKeepInitTest.java
@@ -0,0 +1,85 @@
+// 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.shaking.ifrule;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.google.common.collect.ImmutableList;
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ConditionalRuleOnMemberFieldWithKeepInitTest extends TestBase {
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDefaultDexRuntime().build();
+  }
+
+  private TestParameters parameters;
+
+  public ConditionalRuleOnMemberFieldWithKeepInitTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  private void testKeepRule(String keepRule, List<Class<?>> absent, List<Class<?>> present)
+      throws IOException, ExecutionException, CompilationFailedException {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(A.class, TestClass.class)
+        .addKeepRules(keepRule)
+        .addKeepMainRule(TestClass.class)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("42")
+        .inspect(
+            inspector -> {
+              absent.forEach(clazz -> assertThat(inspector.clazz(clazz), isAbsent()));
+              present.forEach(clazz -> assertThat(inspector.clazz(clazz), isPresent()));
+            });
+  }
+
+  @Test
+  public void testJustStarConditionalKeepClassMembers() throws Exception {
+    String keepRule = "-if class * -keepclasseswithmembers class <1> { <init>(); }";
+    testKeepRule(keepRule, ImmutableList.of(), ImmutableList.of(TestClass.class, A.class));
+  }
+
+  @Test
+  public void testJustStarConditionalKeepClass() throws Exception {
+    String keepRule = "-if class * -keep class <1> { <init>(); }";
+    testKeepRule(keepRule, ImmutableList.of(), ImmutableList.of(TestClass.class, A.class));
+  }
+
+  @Test
+  public void testStarWithMethodConditionalKeepClassMembers() throws Exception {
+    String keepRule = "-if class * { int z; } -keepclasseswithmembers class <1> { <init>(); }";
+    testKeepRule(keepRule, ImmutableList.of(), ImmutableList.of(TestClass.class, A.class));
+  }
+
+  @Test
+  public void testStarWithMethodConditionalKeepClass() throws Exception {
+    String keepRule = "-if class * { int z; } -keep class <1> { <init>(); }";
+    testKeepRule(keepRule, ImmutableList.of(), ImmutableList.of(TestClass.class, A.class));
+  }
+
+  static class A {
+    public static int z = 42;
+  }
+
+  static class TestClass {
+    public static void main(String[] args) {
+      System.out.println(A.z);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/ConditionalRuleOnMemberWithKeepInitSimpleInlineTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/ConditionalRuleOnMemberWithKeepInitSimpleInlineTest.java
new file mode 100644
index 0000000..f2300e3
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/ConditionalRuleOnMemberWithKeepInitSimpleInlineTest.java
@@ -0,0 +1,87 @@
+// 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.shaking.ifrule;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.google.common.collect.ImmutableList;
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ConditionalRuleOnMemberWithKeepInitSimpleInlineTest extends TestBase {
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDefaultDexRuntime().build();
+  }
+
+  private TestParameters parameters;
+
+  public ConditionalRuleOnMemberWithKeepInitSimpleInlineTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  private void testKeepRule(String keepRule, List<Class<?>> absent, List<Class<?>> present)
+      throws IOException, ExecutionException, CompilationFailedException {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(A.class, TestClass.class)
+        .addKeepRules(keepRule)
+        .addKeepMainRule(TestClass.class)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("bar")
+        .inspect(
+            inspector -> {
+              absent.forEach(clazz -> assertThat(inspector.clazz(clazz), isAbsent()));
+              present.forEach(clazz -> assertThat(inspector.clazz(clazz), isPresent()));
+            });
+  }
+
+  @Test
+  public void testJustStarConditionalKeepClassMembers() throws Exception {
+    String keepRule = "-if class * -keepclasseswithmembers class <1> { <init>(); }";
+    testKeepRule(keepRule, ImmutableList.of(), ImmutableList.of(TestClass.class, A.class));
+  }
+
+  @Test
+  public void testJustStarConditionalKeepClass() throws Exception {
+    String keepRule = "-if class * -keep class <1> { <init>(); }";
+    testKeepRule(keepRule, ImmutableList.of(), ImmutableList.of(TestClass.class, A.class));
+  }
+
+  @Test
+  public void testStarWithMethodConditionalKeepClassMembers() throws Exception {
+    String keepRule = "-if class * { bar(); } -keepclasseswithmembers class <1> { <init>(); }";
+    testKeepRule(keepRule, ImmutableList.of(), ImmutableList.of(TestClass.class, A.class));
+  }
+
+  @Test
+  public void testStarWithMethodConditionalKeepClass() throws Exception {
+    String keepRule = "-if class * { bar(); } -keep class <1> { <init>(); }";
+    testKeepRule(keepRule, ImmutableList.of(), ImmutableList.of(TestClass.class, A.class));
+  }
+
+  static class A {
+    public static String bar() {
+      return "bar";
+    }
+  }
+
+  static class TestClass {
+    public static void main(String[] args) {
+      System.out.println(A.bar());
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/ConditionalRuleOnMemberWithKeepInitTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/ConditionalRuleOnMemberWithKeepInitTest.java
new file mode 100644
index 0000000..38ff7d5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/ConditionalRuleOnMemberWithKeepInitTest.java
@@ -0,0 +1,89 @@
+// 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.shaking.ifrule;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.google.common.collect.ImmutableList;
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ConditionalRuleOnMemberWithKeepInitTest extends TestBase {
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDefaultDexRuntime().build();
+  }
+
+  private TestParameters parameters;
+
+  public ConditionalRuleOnMemberWithKeepInitTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  private void testKeepRule(String keepRule, List<Class<?>> absent, List<Class<?>> present)
+      throws IOException, ExecutionException, CompilationFailedException {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(A.class, TestClass.class)
+        .addKeepRules(keepRule)
+        .addKeepMainRule(TestClass.class)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("bar")
+        .inspect(
+            inspector -> {
+              absent.forEach(clazz -> assertThat(inspector.clazz(clazz), isAbsent()));
+              present.forEach(clazz -> assertThat(inspector.clazz(clazz), isPresent()));
+            });
+  }
+
+  @Test
+  public void testJustStarConditionalKeepClassMembers() throws Exception {
+    String keepRule = "-if class * -keepclasseswithmembers class <1> { <init>(); }";
+    // TODO(b/316100042) We should keep A here
+    testKeepRule(keepRule, ImmutableList.of(A.class), ImmutableList.of(TestClass.class));
+  }
+
+  @Test
+  public void testJustStarConditionalKeepClass() throws Exception {
+    String keepRule = "-if class * -keep class <1> { <init>(); }";
+    // TODO(b/316100042) We should keep A here
+    testKeepRule(keepRule, ImmutableList.of(A.class), ImmutableList.of(TestClass.class));
+  }
+
+  @Test
+  public void testStarWithMethodConditionalKeepClassMembers() throws Exception {
+    String keepRule = "-if class * { bar(); } -keepclasseswithmembers class <1> { <init>(); }";
+    testKeepRule(keepRule, ImmutableList.of(), ImmutableList.of(TestClass.class, A.class));
+  }
+
+  @Test
+  public void testStarWithMethodConditionalKeepClass() throws Exception {
+    String keepRule = "-if class * { bar(); } -keep class <1> { <init>(); }";
+    testKeepRule(keepRule, ImmutableList.of(), ImmutableList.of(TestClass.class, A.class));
+  }
+
+  static class A {
+    public static void bar() {
+      System.out.println("bar");
+    }
+  }
+
+  static class TestClass {
+    public static void main(String[] args) {
+      A.bar();
+    }
+  }
+}
diff --git a/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1 b/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1
index 758e8f0..c5ef954 100644
--- a/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1
+++ b/third_party/openjdk/desugar_jdk_libs_11.tar.gz.sha1
@@ -1 +1 @@
-47cfa6d72be316cdaff6e5042111a18215ac4405
\ No newline at end of file
+d50abf6c508c1332eb80f35f5631e99e2e8329b5
\ No newline at end of file