diff --git a/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java b/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java
index 813ea84..9a07dd2 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java
@@ -8,7 +8,6 @@
 import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
 import com.android.tools.r8.utils.SetUtils;
 import com.android.tools.r8.utils.WorkList;
-import com.android.tools.r8.utils.WorkList.EqualityTest;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
@@ -42,7 +41,7 @@
       DexType type,
       Consumer<DexProgramClass> subTypeConsumer,
       Consumer<DexCallSite> callSiteConsumer) {
-    WorkList<DexType> workList = new WorkList<>(EqualityTest.IDENTITY);
+    WorkList<DexType> workList = WorkList.newIdentityWorkList();
     workList.addIfNotSeen(type);
     workList.addIfNotSeen(allImmediateSubtypes(type));
     while (workList.hasNext()) {
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 3601754..8900031 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -815,6 +815,15 @@
     return !clinit.getOptimizationInfo().classInitializerMayBePostponed();
   }
 
+  public void forEachImmediateSupertype(Consumer<DexType> fn) {
+    if (superType != null) {
+      fn.accept(superType);
+    }
+    for (DexType iface : interfaces.values) {
+      fn.accept(iface);
+    }
+  }
+
   public Iterable<DexType> allImmediateSupertypes() {
     Iterator<DexType> iterator =
         superType != null
diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index a7bb64b..319db57 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -31,6 +31,7 @@
 import com.android.tools.r8.graph.DexAnnotationSet;
 import com.android.tools.r8.graph.DexCallSite;
 import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexClassAndMethod;
 import com.android.tools.r8.graph.DexClasspathClass;
 import com.android.tools.r8.graph.DexDefinition;
 import com.android.tools.r8.graph.DexEncodedField;
@@ -54,6 +55,7 @@
 import com.android.tools.r8.graph.FieldAccessInfoImpl;
 import com.android.tools.r8.graph.InnerClassAttribute;
 import com.android.tools.r8.graph.LookupResult;
+import com.android.tools.r8.graph.LookupResult.LookupResultSuccess;
 import com.android.tools.r8.graph.ObjectAllocationInfoCollectionImpl;
 import com.android.tools.r8.graph.PresortedComparable;
 import com.android.tools.r8.graph.ProgramMethod;
@@ -95,6 +97,7 @@
 import com.android.tools.r8.utils.SetUtils;
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.android.tools.r8.utils.Timing;
+import com.android.tools.r8.utils.WorkList;
 import com.google.common.base.Equivalence.Wrapper;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSortedSet;
@@ -290,8 +293,11 @@
   private final Set<DexEncodedMethod> pendingReflectiveUses = Sets.newLinkedHashSet();
 
   /** A cache for DexMethod that have been marked reachable. */
+  private final Map<DexProgramClass, Set<DexEncodedMethod>> reachableVirtualResolutions =
+      new IdentityHashMap<>();
+
   private final Map<DexMethod, MarkedResolutionTarget> virtualTargetsMarkedAsReachable =
-      Maps.newIdentityHashMap();
+      new IdentityHashMap<>();
 
   /**
    * A set of references we have reported missing to dedupe warnings.
@@ -415,22 +421,24 @@
     return getProgramClassOrNull(type) != null;
   }
 
-  private DexProgramClass getProgramClassOrNull(DexType type) {
+  private DexClass definitionFor(DexType type) {
     DexClass clazz = appView.definitionFor(type);
-    if (clazz != null) {
-      if (clazz.isProgramClass()) {
-        return clazz.asProgramClass();
-      }
-      if (liveNonProgramTypes.add(clazz) && clazz.isLibraryClass()) {
-        // TODO(b/149201735): This likely needs to apply to classpath too.
-        ensureMethodsContinueToWidenAccess(clazz);
-        // TODO(b/149201158): This should apply to classpath too (likely even hard fail).
-        warnIfLibraryTypeInheritsFromProgramType(clazz.asLibraryClass());
-      }
-    } else {
+    if (clazz == null) {
       reportMissingClass(type);
+      return null;
     }
-    return null;
+    if (liveNonProgramTypes.add(clazz) && clazz.isLibraryClass()) {
+      // TODO(b/149201735): This likely needs to apply to classpath too.
+      ensureMethodsContinueToWidenAccess(clazz);
+      // Only libraries must not derive program. Classpath classes can, assuming correct keep rules.
+      warnIfLibraryTypeInheritsFromProgramType(clazz.asLibraryClass());
+    }
+    return clazz;
+  }
+
+  private DexProgramClass getProgramClassOrNull(DexType type) {
+    DexClass clazz = definitionFor(type);
+    return clazz != null && clazz.isProgramClass() ? clazz.asProgramClass() : null;
   }
 
   private void warnIfLibraryTypeInheritsFromProgramType(DexLibraryClass clazz) {
@@ -725,6 +733,7 @@
     // we have to look at the interface chain and mark default methods as reachable, not taking
     // the shadowing of other interface chains into account.
     // See https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-5.html#jvms-5.4.3.3
+    // TODO(b/148271337): Support lookupVirtualDispatchTarget(CallSite) and replace this.
     ScopedDexMethodSet seen = new ScopedDexMethodSet();
     for (DexType iface : descriptor.interfaces) {
       DexProgramClass ifaceClazz = getProgramClassOrNull(iface);
@@ -1685,95 +1694,107 @@
   }
 
   /**
-   * Marks all methods live that can be reached by calls previously seen.
+   * Marks all methods live that are overrides of reachable methods for a given class.
    *
-   * <p>This should only be invoked if the given type newly becomes instantiated. In essence, this
-   * method replays all the invokes we have seen so far that could apply to this type and marks the
-   * corresponding methods live.
-   *
-   * <p>Only methods that are visible in this type are considered. That is, only those methods that
-   * are either defined directly on this type or that are defined on a supertype but are not
-   * shadowed by another inherited method. Furthermore, default methods from implemented interfaces
-   * that are not otherwise shadowed are considered, too.
-   *
-   * <p>Finally all methods on library types that resolve starting at the instantiated type are
-   * marked live.
+   * <p>Only reachable methods in the hierarchy of the given class and above are considered, and
+   * only the lowest such reachable target (ie, mirroring resolution). All library and classpath
+   * methods are considered reachable.
    */
   private void transitionMethodsForInstantiatedClass(DexProgramClass instantiatedClass) {
+    assert !instantiatedClass.isAnnotation();
+    assert !instantiatedClass.isInterface();
     ScopedDexMethodSet seen = new ScopedDexMethodSet();
-    Set<DexType> interfaces = Sets.newIdentityHashSet();
-    DexProgramClass current = instantiatedClass;
-    do {
-      // We only have to look at virtual methods here, as only those can actually be executed at
-      // runtime. Illegal dispatch situations and the corresponding exceptions are already handled
-      // by the reachability logic.
-      transitionReachableVirtualMethods(current, seen);
-      Collections.addAll(interfaces, current.interfaces.values);
-      current = getProgramClassOrNull(current.superType);
-    } while (current != null && !objectAllocationInfoCollection.isInstantiatedDirectly(current));
-
-    // The set now contains all virtual methods on the type and its supertype that are reachable.
-    // In a second step, we now look at interfaces. We have to do this in this order due to JVM
-    // semantics for default methods. A default method is only reachable if it is not overridden in
-    // any superclass. Also, it is not defined which default method is chosen if multiple
-    // interfaces define the same default method. Hence, for every interface (direct or indirect),
-    // we have to look at the interface chain and mark default methods as reachable, not taking
-    // the shadowing of other interface chains into account.
-    // See https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-5.html#jvms-5.4.3.3
-    for (DexType iface : interfaces) {
-      DexClass clazz = appView.definitionFor(iface);
-      if (clazz == null) {
-        reportMissingClass(iface);
-        // TODO(herhut): In essence, our subtyping chain is broken here. Handle that case better.
-        break;
-      }
-      transitionDefaultMethodsForInstantiatedClass(iface, seen);
-    }
-
-    // When tracing the main-dex content, library roots must be specified, thus there are no
-    // implicit edges from library methods.
-    if (getMode().isTracingMainDex()) {
-      return;
-    }
-
-    // When a type becomes live, all library methods on that type become live too.
-    // This is done by searching the library supertypes and then resolving each method defined by
-    // such a library type from the point of the instantiated type. If the resolved targets are in
-    // the program, i.e., the instantiated type has a method overidding a library method, then the
-    // program method is live.
-    Deque<DexClass> librarySearchItems = new ArrayDeque<>();
-    librarySearchItems.add(instantiatedClass);
-    while (!librarySearchItems.isEmpty()) {
-      DexClass clazz = librarySearchItems.pop();
-      if (clazz.isNotProgramClass()) {
-        markLibraryAndClasspathMethodOverridesAsLive(clazz, instantiatedClass);
-      }
-      if (clazz.superType != null) {
-        DexClass superClass = appView.definitionFor(clazz.superType);
-        if (superClass != null) {
-          librarySearchItems.add(superClass);
+    WorkList<DexType> worklist = WorkList.newIdentityWorkList();
+    // First we lookup and mark all targets on the instantiated class for each reachable method in
+    // the super chain (inclusive).
+    {
+      DexClass clazz = instantiatedClass;
+      while (clazz != null) {
+        if (clazz.isProgramClass()) {
+          markProgramMethodOverridesAsLive(instantiatedClass, clazz.asProgramClass(), seen);
+        } else {
+          markLibraryAndClasspathMethodOverridesAsLive(instantiatedClass, clazz);
         }
+        worklist.addIfNotSeen(Arrays.asList(clazz.interfaces.values));
+        clazz = clazz.superType != null ? definitionFor(clazz.superType) : null;
       }
-      for (DexType iface : clazz.interfaces.values) {
-        DexClass ifaceClass = appView.definitionFor(iface);
-        if (ifaceClass != null) {
-          librarySearchItems.add(ifaceClass);
-        }
+    }
+    // The targets for methods on the type and its supertype that are reachable are now marked.
+    // In a second step, we look at interfaces. We order the search this way such that a
+    // method reachable on a class takes precedence when reporting edges. That order mirrors JVM
+    // resolution/dispatch.
+    while (worklist.hasNext()) {
+      DexType type = worklist.next();
+      DexClass iface = definitionFor(type);
+      if (iface == null) {
+        continue;
+      }
+      assert iface.superType == appInfo.dexItemFactory().objectType;
+      if (iface.isNotProgramClass()) {
+        markLibraryAndClasspathMethodOverridesAsLive(instantiatedClass, iface);
+      } else {
+        markProgramMethodOverridesAsLive(instantiatedClass, iface.asProgramClass(), seen);
+      }
+      worklist.addIfNotSeen(Arrays.asList(iface.interfaces.values));
+    }
+  }
+
+  private Set<DexEncodedMethod> getReachableVirtualResolutions(DexProgramClass clazz) {
+    return reachableVirtualResolutions.getOrDefault(clazz, Collections.emptySet());
+  }
+
+  private void markProgramMethodOverridesAsLive(
+      DexProgramClass instantiatedClass,
+      DexProgramClass superClass,
+      ScopedDexMethodSet seenMethods) {
+    for (DexEncodedMethod resolution : getReachableVirtualResolutions(superClass)) {
+      if (seenMethods.addMethod(resolution)) {
+        markLiveOverrides(instantiatedClass, superClass, resolution);
       }
     }
   }
 
+  private void markLiveOverrides(
+      DexProgramClass instantiatedClass,
+      DexProgramClass reachableHolder,
+      DexEncodedMethod reachableMethod) {
+    assert reachableHolder.type == reachableMethod.method.holder;
+    // The validity of the reachable method is checked at the point it becomes "reachable" and is
+    // resolved. If the method is private, then the dispatch is not "virtual" and the method is
+    // simply marked live on its holder.
+    if (reachableMethod.isPrivateMethod()) {
+      markVirtualMethodAsLive(
+          reachableHolder,
+          reachableMethod,
+          graphReporter.reportReachableMethodAsLive(
+              reachableMethod.method, new ProgramMethod(reachableHolder, reachableMethod)));
+      return;
+    }
+    // Otherwise, we set the initial holder type to be the holder of the reachable method, which
+    // ensures that access will be generally valid.
+    SingleResolutionResult result =
+        new SingleResolutionResult(reachableHolder, reachableHolder, reachableMethod);
+    DexClassAndMethod lookup = result.lookupVirtualDispatchTarget(instantiatedClass, appView);
+    if (lookup == null || !lookup.isProgramMethod() || lookup.getMethod().isAbstract()) {
+      return;
+    }
+    ProgramMethod method = lookup.asProgramMethod();
+    markVirtualMethodAsLive(
+        method.getHolder(),
+        method.getMethod(),
+        graphReporter.reportReachableMethodAsLive(reachableMethod.method, method));
+  }
+
   private void markLibraryAndClasspathMethodOverridesAsLive(
-      DexClass libraryClass, DexProgramClass instantiatedClass) {
+      DexProgramClass instantiatedClass, DexClass libraryClass) {
     assert libraryClass.isNotProgramClass();
     assert !instantiatedClass.isInterface() || instantiatedClass.isAnnotation();
     for (DexEncodedMethod method : libraryClass.virtualMethods()) {
-      // Note: it may be worthwhile to add a resolution cache here. If so, it must still ensure
-      // that all library override edges are reported to the kept-graph consumer.
-      ResolutionResult firstResolution =
-          appView.appInfo().resolveMethod(instantiatedClass, method.method);
-      markResolutionAsLive(libraryClass, firstResolution);
-      markOverridesAsLibraryMethodOverrides(method.method, instantiatedClass);
+      assert !method.isPrivateMethod();
+      // Note: It would be reasonable to not process methods already seen during the marking of
+      // program usages, but that would cause the methods to not be marked as library overrides.
+      markLibraryOrClasspathOverrideLive(
+          instantiatedClass, libraryClass, appInfo.resolveMethod(libraryClass, method.method));
 
       // Due to API conversion, some overrides can be hidden since they will be rewritten. See
       // class comment of DesugaredLibraryAPIConverter and vivifiedType logic.
@@ -1785,47 +1806,50 @@
             DesugaredLibraryAPIConverter.methodWithVivifiedTypeInSignature(
                 method.method, method.method.holder, appView);
         assert methodToResolve != method.method;
-        ResolutionResult secondResolution =
-            appView.appInfo().resolveMethod(instantiatedClass, methodToResolve);
-        markResolutionAsLive(libraryClass, secondResolution);
-        markOverridesAsLibraryMethodOverrides(methodToResolve, instantiatedClass);
+        markLibraryOrClasspathOverrideLive(
+            instantiatedClass,
+            libraryClass,
+            appInfo.resolveMethod(instantiatedClass, methodToResolve));
       }
-
     }
   }
 
-  private void markResolutionAsLive(DexClass libraryClass, ResolutionResult resolution) {
-    if (resolution.isVirtualTarget()) {
-      DexEncodedMethod target = resolution.getSingleTarget();
-      DexProgramClass targetHolder = getProgramClassOrNull(target.method.holder);
-      if (targetHolder != null
-          && shouldMarkLibraryMethodOverrideAsReachable(targetHolder, target)) {
-        markVirtualMethodAsLive(
-            targetHolder, target, KeepReason.isLibraryMethod(targetHolder, libraryClass.type));
-      }
+  private void markLibraryOrClasspathOverrideLive(
+      DexProgramClass instantiatedClass,
+      DexClass libraryOrClasspathClass,
+      ResolutionResult resolution) {
+    DexClassAndMethod lookup = resolution.lookupVirtualDispatchTarget(instantiatedClass, appView);
+    if (lookup == null || !lookup.isProgramMethod() || lookup.getMethod().isAbstract()) {
+      return;
     }
+    DexProgramClass clazz = lookup.asProgramMethod().getHolder();
+    DexEncodedMethod target = lookup.getMethod();
+    if (shouldMarkLibraryMethodOverrideAsReachable(clazz, target)) {
+      markVirtualMethodAsLive(
+          clazz, target, KeepReason.isLibraryMethod(clazz, libraryOrClasspathClass.type));
+    }
+    markOverridesAsLibraryMethodOverrides(target, instantiatedClass);
   }
 
   private void markOverridesAsLibraryMethodOverrides(
-      DexMethod libraryMethod, DexProgramClass instantiatedClass) {
-    Set<DexProgramClass> visited = SetUtils.newIdentityHashSet(instantiatedClass);
-    Deque<DexProgramClass> worklist = DequeUtils.newArrayDeque(instantiatedClass);
-    while (!worklist.isEmpty()) {
-      DexProgramClass clazz = worklist.removeFirst();
-      assert visited.contains(clazz);
-      DexEncodedMethod libraryMethodOverride = clazz.lookupVirtualMethod(libraryMethod);
-      if (libraryMethodOverride != null) {
-        if (libraryMethodOverride.isLibraryMethodOverride().isTrue()) {
+      DexEncodedMethod libraryMethodOverride, DexProgramClass instantiatedClass) {
+    libraryMethodOverride.setLibraryMethodOverride(OptionalBool.TRUE);
+    WorkList<DexType> worklist = WorkList.newIdentityWorkList();
+    instantiatedClass.forEachImmediateSupertype(worklist::addIfNotSeen);
+    while (worklist.hasNext()) {
+      DexType type = worklist.next();
+      DexProgramClass clazz = getProgramClassOrNull(type);
+      if (clazz == null) {
+        continue;
+      }
+      DexEncodedMethod override = clazz.lookupVirtualMethod(libraryMethodOverride.method);
+      if (override != null) {
+        if (override.isLibraryMethodOverride().isTrue()) {
           continue;
         }
-        libraryMethodOverride.setLibraryMethodOverride(OptionalBool.TRUE);
+        override.setLibraryMethodOverride(OptionalBool.TRUE);
       }
-      for (DexType superType : clazz.allImmediateSupertypes()) {
-        DexProgramClass superClass = getProgramClassOrNull(superType);
-        if (superClass != null && visited.add(superClass)) {
-          worklist.add(superClass);
-        }
-      }
+      clazz.forEachImmediateSupertype(worklist::addIfNotSeen);
     }
   }
 
@@ -2171,6 +2195,10 @@
     // each possible target edge below.
     assert resolution.holder.isProgramClass();
 
+    reachableVirtualResolutions
+        .computeIfAbsent(resolution.holder.asProgramClass(), k -> Sets.newIdentityHashSet())
+        .add(resolution.method);
+
     assert interfaceInvoke == holder.isInterface();
     DexProgramClass context = contextOrNull == null ? null : contextOrNull.getHolder();
     LookupResult lookupResult =
@@ -2180,11 +2208,12 @@
     if (!lookupResult.isLookupResultSuccess()) {
       return;
     }
-    for (DexEncodedMethod encodedPossibleTarget :
-        lookupResult.asLookupResultSuccess().getMethodTargets()) {
+    LookupResultSuccess lookupResultSuccess = lookupResult.asLookupResultSuccess();
+    for (DexEncodedMethod encodedPossibleTarget : lookupResultSuccess.getMethodTargets()) {
       if (encodedPossibleTarget.isAbstract()) {
         continue;
       }
+      // TODO(b/139464956): Replace this downwards search once targets are found for live types.
       markPossibleTargetsAsReachable(resolution, encodedPossibleTarget);
     }
   }
@@ -2196,20 +2225,8 @@
     assert !encodedPossibleTarget.isAbstract();
     DexMethod possibleTarget = encodedPossibleTarget.method;
     DexProgramClass clazz = getProgramClassOrNull(possibleTarget.holder);
-    if (clazz == null) {
-      return;
-    }
-    ReachableVirtualMethodsSet reachable =
-        reachableVirtualMethods.computeIfAbsent(clazz, ignore -> new ReachableVirtualMethodsSet());
-    if (!reachable.add(encodedPossibleTarget, reason)) {
-      return;
-    }
-
-    // If the holder type is instantiated, the method is live. Otherwise check whether we find
-    // a subtype that does not shadow this methods but is instantiated.
-    // Note that library classes are always considered instantiated, as we do not know where
-    // they are instantiated.
-    if (!isInstantiatedOrHasInstantiatedSubtype(clazz)) {
+    // If the holder type is uninstantiated (directly or indirectly) the method is not live yet.
+    if (clazz == null || !isInstantiatedOrHasInstantiatedSubtype(clazz)) {
       return;
     }
 
@@ -2218,7 +2235,8 @@
       markVirtualMethodAsLive(
           clazz,
           encodedPossibleTarget,
-          graphReporter.reportReachableMethodAsLive(encodedPossibleTarget, reason));
+          graphReporter.reportReachableMethodAsLive(
+              reason.method.method, new ProgramMethod(clazz, encodedPossibleTarget)));
     } else {
       Deque<DexType> worklist =
           new ArrayDeque<>(appInfo.allImmediateSubtypes(possibleTarget.holder));
diff --git a/src/main/java/com/android/tools/r8/shaking/GraphReporter.java b/src/main/java/com/android/tools/r8/shaking/GraphReporter.java
index c172b52..37be4b3 100644
--- a/src/main/java/com/android/tools/r8/shaking/GraphReporter.java
+++ b/src/main/java/com/android/tools/r8/shaking/GraphReporter.java
@@ -26,6 +26,7 @@
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexReference;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.references.TypeReference;
@@ -248,6 +249,17 @@
   }
 
   public KeepReasonWitness reportReachableMethodAsLive(
+      DexMethod overriddenMethod, ProgramMethod derivedMethod) {
+    if (keptGraphConsumer != null && overriddenMethod != derivedMethod.getMethod().method) {
+      return reportEdge(
+          getMethodGraphNode(overriddenMethod),
+          getMethodGraphNode(derivedMethod.getMethod().method),
+          EdgeKind.OverridingMethod);
+    }
+    return KeepReasonWitness.INSTANCE;
+  }
+
+  public KeepReasonWitness reportReachableMethodAsLive(
       DexEncodedMethod encodedMethod, MarkedResolutionTarget reason) {
     if (keptGraphConsumer != null) {
       return reportEdge(
diff --git a/src/main/java/com/android/tools/r8/utils/WorkList.java b/src/main/java/com/android/tools/r8/utils/WorkList.java
index b631262..835c528 100644
--- a/src/main/java/com/android/tools/r8/utils/WorkList.java
+++ b/src/main/java/com/android/tools/r8/utils/WorkList.java
@@ -15,7 +15,15 @@
   private final Deque<T> workingList = new ArrayDeque<>();
   private final Set<T> seen;
 
-  public WorkList(EqualityTest equalityTest) {
+  public static <T> WorkList<T> newIdentityWorkList() {
+    return new WorkList<T>(EqualityTest.IDENTITY);
+  }
+
+  public WorkList() {
+    this(EqualityTest.HASH);
+  }
+
+  private WorkList(EqualityTest equalityTest) {
     if (equalityTest == EqualityTest.HASH) {
       seen = new HashSet<>();
     } else {
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/FunctionConversionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/FunctionConversionTest.java
index 66cdcbc..687a673 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/FunctionConversionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/FunctionConversionTest.java
@@ -8,7 +8,6 @@
 
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
-import com.android.tools.r8.desugar.desugaredlibrary.conversiontests.MoreFunctionConversionTest.CustomLibClass;
 import com.android.tools.r8.ir.desugar.DesugaredLibraryWrapperSynthesizer;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.BooleanUtils;