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 e8f5829..0100fd5 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -9,6 +9,7 @@
 
 import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.dex.Marker;
+import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.DexDebugEvent.AdvanceLine;
 import com.android.tools.r8.graph.DexDebugEvent.AdvancePC;
 import com.android.tools.r8.graph.DexDebugEvent.Default;
@@ -717,6 +718,44 @@
           .put(doubleType, boxedDoubleType)
           .build());
 
+  public final Map<DexType, DexMethod> unboxPrimitiveMethod =
+      ImmutableMap.<DexType, DexMethod>builder()
+          .put(boxedBooleanType, createUnboxMethod(booleanType, unboxBooleanMethodName))
+          .put(boxedByteType, createUnboxMethod(byteType, unboxByteMethodName))
+          .put(boxedCharType, createUnboxMethod(charType, unboxCharMethodName))
+          .put(boxedShortType, createUnboxMethod(shortType, unboxShortMethodName))
+          .put(boxedIntType, createUnboxMethod(intType, unboxIntMethodName))
+          .put(boxedLongType, createUnboxMethod(longType, unboxLongMethodName))
+          .put(boxedFloatType, createUnboxMethod(floatType, unboxFloatMethodName))
+          .put(boxedDoubleType, createUnboxMethod(doubleType, unboxDoubleMethodName))
+          .build();
+
+  private DexMethod createUnboxMethod(DexType primitiveType, DexString unboxMethodName) {
+    DexProto proto = createProto(primitiveType);
+    return createMethod(primitiveToBoxed.get(primitiveType), proto, unboxMethodName);
+  }
+
+  // Works both with the boxed and unboxed type.
+  public DexMethod getUnboxPrimitiveMethod(DexType type) {
+    DexType boxType = primitiveToBoxed.getOrDefault(type, type);
+    DexMethod unboxMethod = unboxPrimitiveMethod.get(boxType);
+    if (unboxMethod == null) {
+      throw new Unreachable("Invalid primitive type descriptor: " + type);
+    }
+    return unboxMethod;
+  }
+
+  // Works both with the boxed and unboxed type.
+  public DexMethod getBoxPrimitiveMethod(DexType type) {
+    DexType boxType = primitiveToBoxed.getOrDefault(type, type);
+    DexType primitive = getPrimitiveFromBoxed(boxType);
+    if (primitive == null) {
+      throw new Unreachable("Invalid primitive type descriptor: " + type);
+    }
+    DexProto proto = createProto(boxType, primitive);
+    return createMethod(boxType, proto, valueOfMethodName);
+  }
+
   public DexType getBoxedForPrimitiveType(DexType primitive) {
     assert primitive.isPrimitiveType();
     return primitiveToBoxed.get(primitive);
diff --git a/src/main/java/com/android/tools/r8/graph/analysis/DesugaredLibraryConversionWrapperAnalysis.java b/src/main/java/com/android/tools/r8/graph/analysis/DesugaredLibraryConversionWrapperAnalysis.java
index 28d6be7..c9788bd 100644
--- a/src/main/java/com/android/tools/r8/graph/analysis/DesugaredLibraryConversionWrapperAnalysis.java
+++ b/src/main/java/com/android/tools/r8/graph/analysis/DesugaredLibraryConversionWrapperAnalysis.java
@@ -8,6 +8,8 @@
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.ProgramDefinition;
 import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.code.Invoke;
+import com.android.tools.r8.ir.code.Invoke.Type;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverter;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverter.Mode;
 import com.android.tools.r8.utils.collections.ProgramMethodSet;
@@ -30,33 +32,33 @@
     converter.registerCallbackIfRequired(method);
   }
 
-  private void traceInvoke(DexMethod invokedMethod) {
-    converter.registerWrappersForLibraryInvokeIfRequired(invokedMethod);
+  private void traceInvoke(DexMethod invokedMethod, Type invokeType, ProgramMethod context) {
+    converter.registerWrappersForLibraryInvokeIfRequired(invokedMethod, invokeType, context);
   }
 
   @Override
   public void traceInvokeStatic(DexMethod invokedMethod, ProgramMethod context) {
-    this.traceInvoke(invokedMethod);
+    this.traceInvoke(invokedMethod, Type.STATIC, context);
   }
 
   @Override
   public void traceInvokeDirect(DexMethod invokedMethod, ProgramMethod context) {
-    this.traceInvoke(invokedMethod);
+    this.traceInvoke(invokedMethod, Type.DIRECT, context);
   }
 
   @Override
   public void traceInvokeInterface(DexMethod invokedMethod, ProgramMethod context) {
-    this.traceInvoke(invokedMethod);
+    this.traceInvoke(invokedMethod, Type.INTERFACE, context);
   }
 
   @Override
   public void traceInvokeSuper(DexMethod invokedMethod, ProgramMethod context) {
-    this.traceInvoke(invokedMethod);
+    this.traceInvoke(invokedMethod, Type.SUPER, context);
   }
 
   @Override
   public void traceInvokeVirtual(DexMethod invokedMethod, ProgramMethod context) {
-    this.traceInvoke(invokedMethod);
+    this.traceInvoke(invokedMethod, Invoke.Type.VIRTUAL, context);
   }
 
   public ProgramMethodSet generateCallbackMethods() {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/ClassConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/ClassConverter.java
index 136d452..3129b82 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/ClassConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/ClassConverter.java
@@ -76,6 +76,11 @@
       D8CfInstructionDesugaringEventConsumer instructionDesugaringEventConsumer =
           CfInstructionDesugaringEventConsumer.createForD8(methodProcessor);
 
+      // TODO(b/191656218): Move upfront the loop and use maybe the class event consumer.
+      if (appView.options().isDesugaredLibraryCompilation()) {
+        converter.ensureWrappersForL8(instructionDesugaringEventConsumer);
+      }
+
       // Process the wave and wait for all IR processing to complete.
       methodProcessor.newWave();
       ThreadUtils.processItems(
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index f1a9945..51a7e60 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -96,7 +96,6 @@
 import com.android.tools.r8.ir.optimize.string.StringOptimizer;
 import com.android.tools.r8.ir.regalloc.LinearScanRegisterAllocator;
 import com.android.tools.r8.ir.regalloc.RegisterAllocator;
-import com.android.tools.r8.ir.synthetic.SynthesizedCode;
 import com.android.tools.r8.logging.Log;
 import com.android.tools.r8.naming.IdentifierNameStringMarker;
 import com.android.tools.r8.optimize.argumentpropagation.ArgumentPropagator;
@@ -229,8 +228,7 @@
       this.instructionDesugaring = CfInstructionDesugaringCollection.create(appView);
       this.classDesugaring = instructionDesugaring.createClassDesugaringCollection();
       this.interfaceMethodRewriter = null;
-      this.desugaredLibraryAPIConverter =
-          new DesugaredLibraryAPIConverter(appView, Mode.GENERATE_CALLBACKS_AND_WRAPPERS);
+      this.desugaredLibraryAPIConverter = null;
       this.covariantReturnTypeAnnotationTransformer = null;
       this.dynamicTypeOptimization = null;
       this.classInliner = null;
@@ -322,10 +320,7 @@
       this.identifierNameStringMarker = null;
       this.devirtualizer = null;
       this.typeChecker = null;
-      this.desugaredLibraryAPIConverter =
-          appView.rewritePrefix.isRewriting()
-              ? new DesugaredLibraryAPIConverter(appView, Mode.GENERATE_CALLBACKS_AND_WRAPPERS)
-              : null;
+      this.desugaredLibraryAPIConverter = null;
       this.serviceLoaderRewriter = null;
       this.methodOptimizationInfoCollector = null;
       this.enumValueOptimizer = null;
@@ -366,6 +361,13 @@
         D8NestBasedAccessDesugaring::clearNestAttributes);
   }
 
+  public void ensureWrappersForL8(
+      D8CfInstructionDesugaringEventConsumer instructionDesugaringEventConsumer) {
+    assert appView.options().isDesugaredLibraryCompilation();
+    instructionDesugaring.withDesugaredLibraryAPIConverter(
+        converter -> converter.ensureWrappersForL8(instructionDesugaringEventConsumer));
+  }
+
   private void staticizeClasses(
       OptimizationFeedback feedback, ExecutorService executorService, GraphLens applied)
       throws ExecutionException {
@@ -431,7 +433,6 @@
       new EmulatedInterfaceApplicationRewriter(appView).rewriteApplication(builder);
     }
     processCovariantReturnTypeAnnotations(builder);
-    generateDesugaredLibraryAPIWrappers(builder, executor);
 
     timing.end();
 
@@ -458,7 +459,7 @@
       D8MethodProcessor methodProcessor, ExecutorService executorService)
       throws ExecutionException {
     D8CfPostProcessingDesugaringEventConsumer eventConsumer =
-        CfPostProcessingDesugaringEventConsumer.createForD8(methodProcessor, appView);
+        CfPostProcessingDesugaringEventConsumer.createForD8(methodProcessor);
     methodProcessor.newWave();
     InterfaceMethodProcessorFacade interfaceDesugaring =
         instructionDesugaring.getInterfaceMethodPostProcessingDesugaring(ExcludeDexResources);
@@ -483,6 +484,9 @@
 
     rewriteEnclosingLambdaMethodAttributes(
         appView, classConverterResult.getForcefullyMovedLambdaMethods());
+
+    instructionDesugaring.withDesugaredLibraryAPIConverter(
+        DesugaredLibraryAPIConverter::generateTrackingWarnings);
   }
 
   public void desugarClassesForD8(
@@ -591,32 +595,14 @@
     }
   }
 
-  private boolean needsIRConversion(ProgramMethod method) {
+  private boolean needsIRConversion() {
     if (appView.enableWholeProgramOptimizations()) {
       return true;
     }
     if (options.testing.forceIRForCfToCfDesugar) {
       return true;
     }
-    if (options.isDesugaredLibraryCompilation()) {
-      return true;
-    }
-    if (!options.cfToCfDesugar) {
-      return true;
-    }
-    if (desugaredLibraryAPIConverter != null
-        && desugaredLibraryAPIConverter.shouldRegisterCallback(method)) {
-      return true;
-    }
-    if (method.getDefinition().getCode() instanceof SynthesizedCode) {
-      // SynthesizedCode needs IR to generate the code.
-      return true;
-    } else {
-      NeedsIRDesugarUseRegistry useRegistry =
-          new NeedsIRDesugarUseRegistry(method, appView, desugaredLibraryAPIConverter);
-      method.registerCodeReferences(useRegistry);
-      return useRegistry.needsDesugaring();
-    }
+    return !options.cfToCfDesugar;
   }
 
   private void checkPrefixMerging(ProgramMethod method) {
@@ -831,9 +817,6 @@
     runInterfaceDesugaringProcessorsForR8(IncludeAllResources, executorService);
     feedback.updateVisibleOptimizationInfo();
 
-    printPhase("Desugared library API Conversion finalization");
-    generateDesugaredLibraryAPIWrappers(builder, executorService);
-
     if (serviceLoaderRewriter != null) {
       processSynthesizedServiceLoaderMethods(
           serviceLoaderRewriter.getServiceLoadMethods(), executorService);
@@ -997,14 +980,6 @@
     removeDeadCodeAndFinalizeIR(code, OptimizationFeedbackIgnore.getInstance(), Timing.empty());
   }
 
-  private void generateDesugaredLibraryAPIWrappers(
-      DexApplication.Builder<?> builder, ExecutorService executorService)
-      throws ExecutionException {
-    if (desugaredLibraryAPIConverter != null) {
-      desugaredLibraryAPIConverter.finalizeWrappers(builder, this, executorService);
-    }
-  }
-
   private void clearDexMethodCompilationState() {
     appView.appInfo().classes().forEach(this::clearDexMethodCompilationState);
   }
@@ -1172,7 +1147,7 @@
       options.testing.hookInIrConversion.run();
     }
 
-    if (!needsIRConversion(method) || options.skipIR) {
+    if (!needsIRConversion() || options.skipIR) {
       feedback.markProcessed(method.getDefinition(), ConstraintWithTarget.NEVER);
       return Timing.empty();
     }
@@ -1524,10 +1499,9 @@
 
     previous = printMethod(code, "IR after interface method rewriting (SSA)", previous);
 
-    // This pass has to be after interfaceMethodRewriter and BackportedMethodRewriter.
     if (desugaredLibraryAPIConverter != null
-        && (!appView.enableWholeProgramOptimizations()
-            || methodProcessor.isPrimaryMethodProcessor())) {
+        && appView.enableWholeProgramOptimizations()
+        && methodProcessor.isPrimaryMethodProcessor()) {
       timing.begin("Desugar library API");
       desugaredLibraryAPIConverter.desugar(code);
       timing.end();
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java b/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java
deleted file mode 100644
index 0d1c587..0000000
--- a/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.conversion;
-
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexCallSite;
-import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.graph.UseRegistry;
-import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverter;
-
-class NeedsIRDesugarUseRegistry extends UseRegistry {
-
-  private boolean needsDesugaring = false;
-  private final ProgramMethod context;
-  private final DesugaredLibraryAPIConverter desugaredLibraryAPIConverter;
-
-  public NeedsIRDesugarUseRegistry(
-      ProgramMethod method,
-      AppView<?> appView,
-      DesugaredLibraryAPIConverter desugaredLibraryAPIConverter) {
-    super(appView.dexItemFactory());
-    this.context = method;
-    this.desugaredLibraryAPIConverter = desugaredLibraryAPIConverter;
-  }
-
-  public boolean needsDesugaring() {
-    return needsDesugaring;
-  }
-
-  @Override
-  public void registerInitClass(DexType type) {
-    if (!needsDesugaring
-        && desugaredLibraryAPIConverter != null
-        && desugaredLibraryAPIConverter.canConvert(type)) {
-      needsDesugaring = true;
-    }
-  }
-
-  @Override
-  public void registerInvokeVirtual(DexMethod method) {
-    registerDesugaredLibraryAPIConverter(method);
-  }
-
-  @Override
-  public void registerInvokeDirect(DexMethod method) {
-    registerDesugaredLibraryAPIConverter(method);
-  }
-
-  private void registerDesugaredLibraryAPIConverter(DexMethod method) {
-    if (!needsDesugaring) {
-      needsDesugaring =
-          desugaredLibraryAPIConverter != null
-              && desugaredLibraryAPIConverter.shouldRewriteInvoke(method);
-    }
-  }
-
-  @Override
-  public void registerInvokeStatic(DexMethod method) {
-    registerDesugaredLibraryAPIConverter(method);
-  }
-
-  @Override
-  public void registerInvokeInterface(DexMethod method) {
-    registerDesugaredLibraryAPIConverter(method);
-  }
-
-  @Override
-  public void registerInvokeStatic(DexMethod method, boolean itf) {
-    registerInvokeStatic(method);
-  }
-
-  @Override
-  public void registerCallSite(DexCallSite callSite) {
-    super.registerCallSite(callSite);
-    needsDesugaring = true;
-  }
-
-  @Override
-  public void registerInvokeSuper(DexMethod method) {
-    registerDesugaredLibraryAPIConverter(method);
-  }
-
-  @Override
-  public void registerInstanceFieldRead(DexField field) {}
-
-  @Override
-  public void registerInstanceFieldWrite(DexField field) {}
-
-  @Override
-  public void registerNewInstance(DexType type) {}
-
-  @Override
-  public void registerStaticFieldRead(DexField field) {}
-
-  @Override
-  public void registerStaticFieldWrite(DexField field) {}
-
-  @Override
-  public void registerTypeReference(DexType type) {}
-
-  @Override
-  public void registerInstanceOf(DexType type) {}
-}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringCollection.java b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringCollection.java
index 8512734..b4f0bec 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringCollection.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringCollection.java
@@ -7,11 +7,13 @@
 import com.android.tools.r8.contexts.CompilationContext.MethodProcessingContext;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverter;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.RetargetingInfo;
 import com.android.tools.r8.ir.desugar.itf.InterfaceMethodProcessorFacade;
 import com.android.tools.r8.ir.desugar.itf.InterfaceMethodRewriter.Flavor;
 import com.android.tools.r8.ir.desugar.nest.D8NestBasedAccessDesugaring;
 import com.android.tools.r8.utils.ThrowingConsumer;
+import java.util.function.Consumer;
 
 /**
  * Abstracts a collection of low-level desugarings (i.e., mappings from class-file instructions to
@@ -64,4 +66,7 @@
       Flavor flavor);
 
   public abstract RetargetingInfo getRetargetingInfo();
+
+  public abstract void withDesugaredLibraryAPIConverter(
+      Consumer<DesugaredLibraryAPIConverter> consumer);
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java
index d497332..bb2feb2 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java
@@ -15,6 +15,7 @@
 import com.android.tools.r8.ir.conversion.ClassConverterResult;
 import com.android.tools.r8.ir.conversion.D8MethodProcessor;
 import com.android.tools.r8.ir.desugar.backports.BackportedMethodDesugaringEventConsumer;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverterEventConsumer;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryRetargeterInstructionEventConsumer;
 import com.android.tools.r8.ir.desugar.invokespecial.InvokeSpecialBridgeInfo;
 import com.android.tools.r8.ir.desugar.invokespecial.InvokeSpecialToSelfDesugaringEventConsumer;
@@ -48,7 +49,8 @@
         RecordDesugaringEventConsumer,
         TwrCloseResourceDesugaringEventConsumer,
         InterfaceMethodDesugaringEventConsumer,
-        DesugaredLibraryRetargeterInstructionEventConsumer {
+        DesugaredLibraryRetargeterInstructionEventConsumer,
+        DesugaredLibraryAPIConverterEventConsumer {
 
   public static D8CfInstructionDesugaringEventConsumer createForD8(
       D8MethodProcessor methodProcessor) {
@@ -68,6 +70,21 @@
     return new CfInstructionDesugaringEventConsumer() {
 
       @Override
+      public void acceptWrapperProgramClass(DexProgramClass clazz) {
+        assert false;
+      }
+
+      @Override
+      public void acceptWrapperClasspathClass(DexClasspathClass clazz) {
+        assert false;
+      }
+
+      @Override
+      public void acceptAPIConversion(ProgramMethod method) {
+        assert false;
+      }
+
+      @Override
       public void acceptDesugaredLibraryRetargeterDispatchProgramClass(DexProgramClass clazz) {
         assert false;
       }
@@ -229,6 +246,21 @@
       methodProcessor.scheduleDesugaredMethodForProcessing(method);
     }
 
+    @Override
+    public void acceptWrapperProgramClass(DexProgramClass clazz) {
+      methodProcessor.scheduleDesugaredMethodsForProcessing(clazz.programMethods());
+    }
+
+    @Override
+    public void acceptWrapperClasspathClass(DexClasspathClass clazz) {
+      // Intentionally empty.
+    }
+
+    @Override
+    public void acceptAPIConversion(ProgramMethod method) {
+      methodProcessor.scheduleDesugaredMethodForProcessing(method);
+    }
+
     public List<ProgramMethod> finalizeDesugaring(
         AppView<?> appView, ClassConverterResult.Builder classConverterResultBuilder) {
       List<ProgramMethod> needsProcessing = new ArrayList<>();
@@ -348,6 +380,24 @@
     }
 
     @Override
+    public void acceptWrapperProgramClass(DexProgramClass clazz) {
+      // TODO(b/189912077): There should be nothing to do.
+      assert false;
+    }
+
+    @Override
+    public void acceptWrapperClasspathClass(DexClasspathClass clazz) {
+      // TODO(b/189912077): Should be added to live non program types.
+      assert false;
+    }
+
+    @Override
+    public void acceptAPIConversion(ProgramMethod method) {
+      // TODO(b/189912077): There should be nothing to do.
+      assert false;
+    }
+
+    @Override
     public void acceptBackportedMethod(ProgramMethod backportedMethod, ProgramMethod context) {
       // Intentionally empty. The backported method will be hit by the tracing in R8 as if it was
       // present in the input code, and thus nothing needs to be done.
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringCollection.java b/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringCollection.java
index 666e233..b9fc5b9 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringCollection.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringCollection.java
@@ -5,6 +5,7 @@
 
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverter;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryRetargeterPostProcessor;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.RetargetingInfo;
 import com.android.tools.r8.ir.desugar.itf.InterfaceMethodProcessorFacade;
@@ -51,10 +52,6 @@
         AppView<?> appView,
         InterfaceMethodProcessorFacade interfaceMethodProcessorFacade,
         RetargetingInfo retargetingInfo) {
-      if (appView.options().desugaredLibraryConfiguration.getRetargetCoreLibMember().isEmpty()
-          && interfaceMethodProcessorFacade == null) {
-        return empty();
-      }
       ArrayList<CfPostProcessingDesugaring> desugarings = new ArrayList<>();
       if (!appView.options().desugaredLibraryConfiguration.getRetargetCoreLibMember().isEmpty()) {
         desugarings.add(new DesugaredLibraryRetargeterPostProcessor(appView, retargetingInfo));
@@ -62,6 +59,18 @@
       if (interfaceMethodProcessorFacade != null) {
         desugarings.add(interfaceMethodProcessorFacade);
       }
+      DesugaredLibraryAPIConverter desugaredLibraryAPIConverter =
+          appView.rewritePrefix.isRewriting() && !appView.enableWholeProgramOptimizations()
+              ? new DesugaredLibraryAPIConverter(appView, null)
+              : null;
+      // At this point the desugaredLibraryAPIConverter is required to be last to generate
+      // call-backs on the forwarding methods.
+      if (desugaredLibraryAPIConverter != null) {
+        desugarings.add(desugaredLibraryAPIConverter);
+      }
+      if (desugarings.isEmpty()) {
+        return empty();
+      }
       return new NonEmptyCfPostProcessingDesugaringCollection(desugarings);
     }
 
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringEventConsumer.java
index 5734cab..a916284 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringEventConsumer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringEventConsumer.java
@@ -10,6 +10,7 @@
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.conversion.D8MethodProcessor;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverter;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverterEventConsumer.DesugaredLibraryAPIConverterPostProcessingEventConsumer;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryRetargeterInstructionEventConsumer.DesugaredLibraryRetargeterPostProcessingEventConsumer;
 import com.android.tools.r8.ir.desugar.itf.InterfaceProcessingDesugaringEventConsumer;
 import com.android.tools.r8.shaking.Enqueuer.SyntheticAdditions;
@@ -23,16 +24,12 @@
  */
 public abstract class CfPostProcessingDesugaringEventConsumer
     implements DesugaredLibraryRetargeterPostProcessingEventConsumer,
-        InterfaceProcessingDesugaringEventConsumer {
-  protected DesugaredLibraryAPIConverter desugaredLibraryAPIConverter;
-
-  protected CfPostProcessingDesugaringEventConsumer(AppView<?> appView) {
-    this.desugaredLibraryAPIConverter = new DesugaredLibraryAPIConverter(appView, null);
-  }
+        InterfaceProcessingDesugaringEventConsumer,
+        DesugaredLibraryAPIConverterPostProcessingEventConsumer {
 
   public static D8CfPostProcessingDesugaringEventConsumer createForD8(
-      D8MethodProcessor methodProcessor, AppView<?> appView) {
-    return new D8CfPostProcessingDesugaringEventConsumer(methodProcessor, appView);
+      D8MethodProcessor methodProcessor) {
+    return new D8CfPostProcessingDesugaringEventConsumer(methodProcessor);
   }
 
   public static R8PostProcessingDesugaringEventConsumer createForR8(
@@ -49,9 +46,7 @@
     // concurrently processing other methods.
     private final ProgramMethodSet methodsToReprocess = ProgramMethodSet.createConcurrent();
 
-    private D8CfPostProcessingDesugaringEventConsumer(
-        D8MethodProcessor methodProcessor, AppView<?> appView) {
-      super(appView);
+    private D8CfPostProcessingDesugaringEventConsumer(D8MethodProcessor methodProcessor) {
       this.methodProcessor = methodProcessor;
     }
 
@@ -92,15 +87,24 @@
       methodProcessor.scheduleDesugaredMethodsForProcessing(methodsToReprocess);
       methodProcessor.awaitMethodProcessing();
     }
+
+    @Override
+    public void acceptAPIConversionCallback(ProgramMethod method) {
+      methodsToReprocess.add(method);
+    }
   }
 
   public static class R8PostProcessingDesugaringEventConsumer
       extends CfPostProcessingDesugaringEventConsumer {
     private final SyntheticAdditions additions;
 
-    protected R8PostProcessingDesugaringEventConsumer(
-        AppView<?> appView, SyntheticAdditions additions) {
-      super(appView);
+    // The desugaredLibraryAPIConverter is required here because call-backs need to be generated
+    // once forwarding methods are generated. We should be able to remove it once the interface
+    // method desugaring and the API converter are moved cf to cf in R8.
+    private final DesugaredLibraryAPIConverter desugaredLibraryAPIConverter;
+
+    R8PostProcessingDesugaringEventConsumer(AppView<?> appView, SyntheticAdditions additions) {
+      this.desugaredLibraryAPIConverter = new DesugaredLibraryAPIConverter(appView, null);
       this.additions = additions;
     }
 
@@ -127,10 +131,7 @@
     @Override
     public void acceptForwardingMethod(ProgramMethod method) {
       additions.addLiveMethod(method);
-      ProgramMethod callback = desugaredLibraryAPIConverter.generateCallbackIfRequired(method);
-      if (callback != null) {
-        additions.addLiveMethod(callback);
-      }
+      desugaredLibraryAPIConverter.generateCallbackIfRequired(method, this);
     }
 
     @Override
@@ -142,5 +143,10 @@
     public void acceptEmulatedInterfaceMethod(ProgramMethod method) {
       assert false : "TODO(b/183998768): Support Interface processing in R8";
     }
+
+    @Override
+    public void acceptAPIConversionCallback(ProgramMethod method) {
+      additions.addLiveMethod(method);
+    }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/EmptyCfInstructionDesugaringCollection.java b/src/main/java/com/android/tools/r8/ir/desugar/EmptyCfInstructionDesugaringCollection.java
index 7991ac3..17e219e 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/EmptyCfInstructionDesugaringCollection.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/EmptyCfInstructionDesugaringCollection.java
@@ -7,11 +7,13 @@
 import com.android.tools.r8.contexts.CompilationContext.MethodProcessingContext;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.desugar.CfClassDesugaringCollection.EmptyCfClassDesugaringCollection;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverter;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.RetargetingInfo;
 import com.android.tools.r8.ir.desugar.itf.InterfaceMethodProcessorFacade;
 import com.android.tools.r8.ir.desugar.itf.InterfaceMethodRewriter.Flavor;
 import com.android.tools.r8.ir.desugar.nest.D8NestBasedAccessDesugaring;
 import com.android.tools.r8.utils.ThrowingConsumer;
+import java.util.function.Consumer;
 
 public class EmptyCfInstructionDesugaringCollection extends CfInstructionDesugaringCollection {
 
@@ -73,4 +75,9 @@
   public RetargetingInfo getRetargetingInfo() {
     return null;
   }
+
+  @Override
+  public void withDesugaredLibraryAPIConverter(Consumer<DesugaredLibraryAPIConverter> consumer) {
+    // Intentionally empty.
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java
index 6975252..e0a9c07 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java
@@ -407,7 +407,7 @@
       }
       DexType fromTypeAsPrimitive = factory.getPrimitiveFromBoxed(boxedType);
       if (fromTypeAsPrimitive != null) {
-        addPrimitiveUnboxing(fromTypeAsPrimitive, boxedType, instructions, factory);
+        addPrimitiveUnboxing(boxedType, instructions, factory);
         addPrimitiveWideningConversion(fromTypeAsPrimitive, toType, instructions);
         return;
       }
@@ -424,7 +424,7 @@
           || (boxedFromType != factory.booleanType
               && boxedFromType != factory.charType
               && toType == factory.boxedNumberType)) {
-        addPrimitiveBoxing(fromType, boxedFromType, instructions, factory);
+        addPrimitiveBoxing(boxedFromType, instructions, factory);
         return;
       }
     }
@@ -513,55 +513,19 @@
         "converted to " + toType.toSourceString() + " via primitive widening conversion.");
   }
 
-  private static DexMethod getUnboxMethod(byte primitive, DexType boxType, DexItemFactory factory) {
-    DexProto proto;
-    switch (primitive) {
-      case 'Z':  // byte
-        proto = factory.createProto(factory.booleanType);
-        return factory.createMethod(boxType, proto, factory.unboxBooleanMethodName);
-      case 'B':  // byte
-        proto = factory.createProto(factory.byteType);
-        return factory.createMethod(boxType, proto, factory.unboxByteMethodName);
-      case 'S':  // short
-        proto = factory.createProto(factory.shortType);
-        return factory.createMethod(boxType, proto, factory.unboxShortMethodName);
-      case 'C':  // char
-        proto = factory.createProto(factory.charType);
-        return factory.createMethod(boxType, proto, factory.unboxCharMethodName);
-      case 'I':  // int
-        proto = factory.createProto(factory.intType);
-        return factory.createMethod(boxType, proto, factory.unboxIntMethodName);
-      case 'J':  // long
-        proto = factory.createProto(factory.longType);
-        return factory.createMethod(boxType, proto, factory.unboxLongMethodName);
-      case 'F':  // float
-        proto = factory.createProto(factory.floatType);
-        return factory.createMethod(boxType, proto, factory.unboxFloatMethodName);
-      case 'D':  // double
-        proto = factory.createProto(factory.doubleType);
-        return factory.createMethod(boxType, proto, factory.unboxDoubleMethodName);
-      default:
-        throw new Unreachable("Invalid primitive type descriptor: " + primitive);
-    }
-  }
-
   private static void addPrimitiveUnboxing(
-      DexType primitiveType,
       DexType boxType,
       Builder<CfInstruction> instructions,
       DexItemFactory factory) {
-    DexMethod method = getUnboxMethod(primitiveType.descriptor.content[0], boxType, factory);
+    DexMethod method = factory.getUnboxPrimitiveMethod(boxType);
     instructions.add(new CfInvoke(Opcodes.INVOKEVIRTUAL, method, false));
   }
 
   private static void addPrimitiveBoxing(
-      DexType primitiveType,
       DexType boxType,
       Builder<CfInstruction> instructions,
       DexItemFactory factory) {
-    // Generate factory method fo boxing.
-    DexProto proto = factory.createProto(boxType, primitiveType);
-    DexMethod method = factory.createMethod(boxType, proto, factory.valueOfMethodName);
+    DexMethod method = factory.getBoxPrimitiveMethod(boxType);
     instructions.add(new CfInvoke(Opcodes.INVOKESTATIC, method, false));
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/NonEmptyCfInstructionDesugaringCollection.java b/src/main/java/com/android/tools/r8/ir/desugar/NonEmptyCfInstructionDesugaringCollection.java
index a7f1a33..25556ca 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/NonEmptyCfInstructionDesugaringCollection.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/NonEmptyCfInstructionDesugaringCollection.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.desugar.CfClassDesugaringCollection.EmptyCfClassDesugaringCollection;
 import com.android.tools.r8.ir.desugar.CfClassDesugaringCollection.NonEmptyCfClassDesugaringCollection;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverter;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryRetargeter;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.RetargetingInfo;
 import com.android.tools.r8.ir.desugar.invokespecial.InvokeSpecialToSelfDesugaring;
@@ -35,6 +36,7 @@
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
+import java.util.function.Consumer;
 
 public class NonEmptyCfInstructionDesugaringCollection extends CfInstructionDesugaringCollection {
 
@@ -45,6 +47,7 @@
   private final RecordRewriter recordRewriter;
   private final DesugaredLibraryRetargeter desugaredLibraryRetargeter;
   private final InterfaceMethodRewriter interfaceMethodRewriter;
+  private final DesugaredLibraryAPIConverter desugaredLibraryAPIConverter;
 
   NonEmptyCfInstructionDesugaringCollection(AppView<?> appView) {
     this.appView = appView;
@@ -53,6 +56,7 @@
       this.recordRewriter = null;
       this.desugaredLibraryRetargeter = null;
       this.interfaceMethodRewriter = null;
+      this.desugaredLibraryAPIConverter = null;
       return;
     }
     this.nestBasedAccessDesugaring = NestBasedAccessDesugaring.create(appView);
@@ -72,14 +76,25 @@
       desugarings.add(new TwrInstructionDesugaring(appView));
     }
     // TODO(b/183998768): Enable interface method rewriter cf to cf also in R8.
-    interfaceMethodRewriter =
-        appView.options().isInterfaceMethodDesugaringEnabled()
-                && !appView.enableWholeProgramOptimizations()
-            ? new InterfaceMethodRewriter(
-                appView, backportedMethodRewriter, desugaredLibraryRetargeter)
-            : null;
-    if (interfaceMethodRewriter != null) {
+    if (appView.options().isInterfaceMethodDesugaringEnabled()
+        && !appView.enableWholeProgramOptimizations()) {
+      interfaceMethodRewriter =
+          new InterfaceMethodRewriter(
+              appView, backportedMethodRewriter, desugaredLibraryRetargeter);
       desugarings.add(interfaceMethodRewriter);
+    } else {
+      interfaceMethodRewriter = null;
+    }
+    desugaredLibraryAPIConverter =
+        appView.rewritePrefix.isRewriting() && !appView.enableWholeProgramOptimizations()
+            ? new DesugaredLibraryAPIConverter(
+                appView,
+                interfaceMethodRewriter,
+                desugaredLibraryRetargeter,
+                backportedMethodRewriter)
+            : null;
+    if (desugaredLibraryAPIConverter != null) {
+      desugarings.add(desugaredLibraryAPIConverter);
     }
     desugarings.add(new LambdaInstructionDesugaring(appView));
     desugarings.add(new InvokeSpecialToSelfDesugaring(appView));
@@ -332,4 +347,11 @@
     }
     return null;
   }
+
+  @Override
+  public void withDesugaredLibraryAPIConverter(Consumer<DesugaredLibraryAPIConverter> consumer) {
+    if (desugaredLibraryAPIConverter != null) {
+      consumer.accept(desugaredLibraryAPIConverter);
+    }
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryAPIConverter.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryAPIConverter.java
index b50ac86..34406c3 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryAPIConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryAPIConverter.java
@@ -4,10 +4,21 @@
 
 package com.android.tools.r8.ir.desugar.desugaredlibrary;
 
+import com.android.tools.r8.cf.code.CfArrayLoad;
+import com.android.tools.r8.cf.code.CfArrayStore;
+import com.android.tools.r8.cf.code.CfCheckCast;
+import com.android.tools.r8.cf.code.CfConstNumber;
+import com.android.tools.r8.cf.code.CfInstruction;
+import com.android.tools.r8.cf.code.CfInvoke;
+import com.android.tools.r8.cf.code.CfLoad;
+import com.android.tools.r8.cf.code.CfNewArray;
+import com.android.tools.r8.cf.code.CfReturn;
+import com.android.tools.r8.cf.code.CfStackInstruction;
+import com.android.tools.r8.cf.code.CfStackInstruction.Opcode;
+import com.android.tools.r8.contexts.CompilationContext.MethodProcessingContext;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.CfCode;
 import com.android.tools.r8.graph.DebugLocalInfo;
-import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexClassAndMethod;
 import com.android.tools.r8.graph.DexClasspathClass;
@@ -17,6 +28,7 @@
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexProto;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
@@ -25,11 +37,24 @@
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InstructionListIterator;
 import com.android.tools.r8.ir.code.Invoke;
+import com.android.tools.r8.ir.code.Invoke.Type;
 import com.android.tools.r8.ir.code.InvokeMethod;
 import com.android.tools.r8.ir.code.InvokeStatic;
+import com.android.tools.r8.ir.code.MemberType;
 import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.ir.conversion.IRConverter;
+import com.android.tools.r8.ir.code.ValueType;
+import com.android.tools.r8.ir.desugar.BackportedMethodRewriter;
+import com.android.tools.r8.ir.desugar.CfInstructionDesugaring;
+import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer;
+import com.android.tools.r8.ir.desugar.CfPostProcessingDesugaring;
+import com.android.tools.r8.ir.desugar.CfPostProcessingDesugaringEventConsumer;
+import com.android.tools.r8.ir.desugar.FreshLocalProvider;
+import com.android.tools.r8.ir.desugar.LocalStackAllocator;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverterEventConsumer.DesugaredLibraryAPIConverterPostProcessingEventConsumer;
+import com.android.tools.r8.ir.desugar.itf.InterfaceMethodRewriter;
+import com.android.tools.r8.ir.synthetic.DesugaredLibraryAPIConversionCfCodeProvider.APIConversionCfCodeProvider;
 import com.android.tools.r8.ir.synthetic.DesugaredLibraryAPIConversionCfCodeProvider.APIConverterWrapperCfCodeProvider;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.OptionalBool;
@@ -38,15 +63,16 @@
 import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
 import com.google.common.collect.Sets;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.function.Consumer;
+import org.objectweb.asm.Opcodes;
 
 // I convert library calls with desugared parameters/return values so they can work normally.
 // In the JSON of the desugared library, one can specify conversions between desugared and
@@ -62,7 +88,8 @@
 // DesugarType is only a rewritten type (generated through rewriting of type).
 // The type, from the library, may either be rewritten to the desugarType,
 // or be a rewritten type (generated through rewriting of vivifiedType).
-public class DesugaredLibraryAPIConverter {
+public class DesugaredLibraryAPIConverter
+    implements CfInstructionDesugaring, CfPostProcessingDesugaring {
 
   static final String VIVIFIED_PREFIX = "$-vivified-$.";
   public static final String DESCRIPTOR_VIVIFIED_PREFIX = "L$-vivified-$/";
@@ -72,6 +99,11 @@
   // For debugging only, allows to assert that synthesized code in R8 have been synthesized in the
   // Enqueuer and not during IR processing.
   private final Mode mode;
+  // This is used to filter out double desugaring on backported methods.
+  private final BackportedMethodRewriter backportedMethodRewriter;
+  private final InterfaceMethodRewriter interfaceMethodRewriter;
+  private final DesugaredLibraryRetargeter retargeter;
+
   private final DesugaredLibraryWrapperSynthesizer wrapperSynthesizor;
   private final Map<DexClass, Set<DexEncodedMethod>> callBackMethods = new IdentityHashMap<>();
   private final Map<DexProgramClass, List<DexEncodedMethod>> pendingCallBackMethods =
@@ -85,9 +117,29 @@
   }
 
   public DesugaredLibraryAPIConverter(AppView<?> appView, Mode mode) {
+    this(appView, mode, null, null, null);
+  }
+
+  public DesugaredLibraryAPIConverter(
+      AppView<?> appView,
+      InterfaceMethodRewriter interfaceMethodRewriter,
+      DesugaredLibraryRetargeter retargeter,
+      BackportedMethodRewriter backportedMethodRewriter) {
+    this(appView, null, interfaceMethodRewriter, retargeter, backportedMethodRewriter);
+  }
+
+  private DesugaredLibraryAPIConverter(
+      AppView<?> appView,
+      Mode mode,
+      InterfaceMethodRewriter interfaceMethodRewriter,
+      DesugaredLibraryRetargeter retargeter,
+      BackportedMethodRewriter backportedMethodRewriter) {
     this.appView = appView;
     this.factory = appView.dexItemFactory();
     this.mode = mode;
+    this.interfaceMethodRewriter = interfaceMethodRewriter;
+    this.retargeter = retargeter;
+    this.backportedMethodRewriter = backportedMethodRewriter;
     this.wrapperSynthesizor = new DesugaredLibraryWrapperSynthesizer(appView, this);
     if (appView.options().testing.trackDesugaredAPIConversions) {
       trackedCallBackAPIs = Sets.newConcurrentHashSet();
@@ -98,6 +150,88 @@
     }
   }
 
+  // TODO(b/191656218): Consider parallelizing post processing across classes instead of per
+  // implementor
+  // method.
+  @Override
+  public void postProcessingDesugaring(
+      Collection<DexProgramClass> programClasses,
+      CfPostProcessingDesugaringEventConsumer eventConsumer,
+      ExecutorService executorService) {
+    assert noPendingWrappersOrConversions();
+    for (DexProgramClass clazz : programClasses) {
+      if (!appView.isAlreadyLibraryDesugared(clazz)) {
+        ArrayList<DexEncodedMethod> callbacks = new ArrayList<>();
+        for (ProgramMethod virtualProgramMethod : clazz.virtualProgramMethods()) {
+          if (shouldRegisterCallback(virtualProgramMethod)) {
+            if (trackedCallBackAPIs != null) {
+              trackedCallBackAPIs.add(virtualProgramMethod.getReference());
+            }
+            ProgramMethod callback =
+                generateCallbackMethod(
+                    virtualProgramMethod.getDefinition(),
+                    virtualProgramMethod.getHolder(),
+                    eventConsumer);
+            callbacks.add(callback.getDefinition());
+          }
+        }
+        if (!callbacks.isEmpty()) {
+          clazz.addVirtualMethods(callbacks);
+        }
+      }
+    }
+    assert noPendingWrappersOrConversions();
+    generateTrackingWarnings();
+  }
+
+  private boolean noPendingWrappersOrConversions() {
+    for (DexProgramClass pendingSyntheticClass :
+        appView.getSyntheticItems().getPendingSyntheticClasses()) {
+      assert !isAPIConversionSyntheticType(pendingSyntheticClass.type);
+    }
+    return true;
+  }
+
+  @Override
+  public Collection<CfInstruction> desugarInstruction(
+      CfInstruction instruction,
+      FreshLocalProvider freshLocalProvider,
+      LocalStackAllocator localStackAllocator,
+      CfInstructionDesugaringEventConsumer eventConsumer,
+      ProgramMethod context,
+      MethodProcessingContext methodProcessingContext,
+      DexItemFactory dexItemFactory) {
+    assert !appView.enableWholeProgramOptimizations();
+    if (needsDesugaring(instruction, context)) {
+      assert instruction.isInvoke();
+      return rewriteLibraryInvoke(
+          instruction.asInvoke(),
+          methodProcessingContext,
+          localStackAllocator,
+          eventConsumer,
+          context);
+    }
+    return null;
+  }
+
+  @Override
+  public boolean needsDesugaring(CfInstruction instruction, ProgramMethod context) {
+    if (!instruction.isInvoke()) {
+      return false;
+    }
+    if (isAPIConversionSyntheticType(context.getHolderType())) {
+      return false;
+    }
+    CfInvoke invoke = instruction.asInvoke();
+    return shouldRewriteInvoke(
+        invoke.getMethod(), invoke.getInvokeType(context), invoke.isInterface(), context);
+  }
+
+  private boolean isAPIConversionSyntheticType(DexType type) {
+    return wrapperSynthesizor.isSyntheticWrapper(type)
+        || appView.getSyntheticItems().isSyntheticOfKind(type, SyntheticKind.API_CONVERSION);
+  }
+
   public static boolean isVivifiedType(DexType type) {
     return type.descriptor.toString().startsWith(DESCRIPTOR_VIVIFIED_PREFIX);
   }
@@ -108,6 +242,8 @@
 
   public void desugar(IRCode code) {
 
+    assert appView.enableWholeProgramOptimizations();
+
     if (wrapperSynthesizor.isSyntheticWrapper(code.method().getHolderType())) {
       return;
     }
@@ -128,26 +264,32 @@
           continue;
         }
         InvokeMethod invokeMethod = instruction.asInvokeMethod();
-        DexMethod invokedMethod;
-        if (invokeMethod.isInvokeSuper()) {
-          DexClassAndMethod result =
-              appView
-                  .appInfoForDesugaring()
-                  .lookupSuperTarget(invokeMethod.getInvokedMethod(), code.context());
-          invokedMethod = result != null ? result.getReference() : null;
-        } else {
-          // TODO(b/192439456): Make a test to prove resolution is needed here and fix it.
-          invokedMethod = invokeMethod.getInvokedMethod();
-        }
+        DexMethod invokedMethod = invokeMethod.getInvokedMethod();
         // Library methods do not understand desugared types, hence desugared types have to be
         // converted around non desugared library calls for the invoke to resolve.
-        if (invokedMethod != null && shouldRewriteInvoke(invokedMethod)) {
+        if (invokedMethod != null
+            && shouldRewriteInvoke(
+                invokedMethod,
+                invokeMethod.getType(),
+                invokeMethod.getInterfaceBit(),
+                code.context())) {
           rewriteLibraryInvoke(code, invokeMethod, iterator, blockIterator);
         }
       }
     }
   }
 
+  private DexClassAndMethod getMethodForDesugaring(
+      DexMethod invokedMethod, boolean isInvokeSuper, boolean isInterface, ProgramMethod context) {
+    // TODO(b/191656218): Use lookupInvokeSpecial instead when this is all to Cf.
+    return isInvokeSuper
+        ? appView.appInfoForDesugaring().lookupSuperTarget(invokedMethod, context)
+        : appView
+            .appInfoForDesugaring()
+            .resolveMethod(invokedMethod, isInterface)
+            .getResolutionPair();
+  }
+
   private boolean validateCallbackWasGeneratedInEnqueuer(ProgramMethod method) {
     if (!shouldRegisterCallback(method)) {
       return true;
@@ -157,16 +299,76 @@
     return true;
   }
 
-  public boolean shouldRewriteInvoke(DexMethod invokedMethod) {
-    if (appView.rewritePrefix.hasRewrittenType(invokedMethod.holder, appView)
-        || invokedMethod.holder.isArrayType()) {
+  // TODO(b/191656218): Consider caching the result.
+  private boolean shouldRewriteInvoke(
+      DexMethod unresolvedInvokedMethod,
+      Type invokeType,
+      boolean isInterface,
+      ProgramMethod context) {
+    DexClassAndMethod invokedMethod =
+        getMethodForDesugaring(
+            unresolvedInvokedMethod, invokeType == Type.SUPER, isInterface, context);
+    if (invokedMethod == null) {
+      // Implies a resolution/look-up failure, we do not convert to keep the runtime error.
       return false;
     }
-    DexClass dexClass = appView.definitionFor(invokedMethod.holder);
+    DexType holderType = invokedMethod.getHolderType();
+    if (appView.rewritePrefix.hasRewrittenType(holderType, appView) || holderType.isArrayType()) {
+      return false;
+    }
+    DexClass dexClass = appView.definitionFor(holderType);
     if (dexClass == null || !dexClass.isLibraryClass()) {
       return false;
     }
-    return appView.rewritePrefix.hasRewrittenTypeInSignature(invokedMethod.proto, appView);
+    if (isEmulatedInterfaceOverride(invokedMethod)) {
+      return false;
+    }
+    if (isAlreadyDesugared(unresolvedInvokedMethod, invokeType, isInterface, context)) {
+      return false;
+    }
+    return appView.rewritePrefix.hasRewrittenTypeInSignature(invokedMethod.getProto(), appView);
+  }
+
+  // The problem is that a method can resolve into a library method which is not present at runtime,
+  // the code relies in that case on emulated interface dispatch. We should not convert such API.
+  private boolean isEmulatedInterfaceOverride(DexClassAndMethod invokedMethod) {
+    if (interfaceMethodRewriter == null) {
+      return false;
+    }
+    if (!interfaceMethodRewriter.getEmulatedMethods().contains(invokedMethod.getName())) {
+      return false;
+    }
+    DexClassAndMethod interfaceResult =
+        appView
+            .appInfoForDesugaring()
+            .lookupMaximallySpecificMethod(invokedMethod.getHolder(), invokedMethod.getReference());
+    return interfaceResult != null
+        && appView
+            .options()
+            .desugaredLibraryConfiguration
+            .getEmulateLibraryInterface()
+            .containsKey(interfaceResult.getHolderType());
+  }
+
+  private boolean isAlreadyDesugared(
+      DexMethod unresolvedInvokedMethod,
+      Type invokeType,
+      boolean isInterface,
+      ProgramMethod context) {
+    if (interfaceMethodRewriter != null
+        && interfaceMethodRewriter.needsRewriting(unresolvedInvokedMethod, invokeType, context)) {
+      return true;
+    }
+    if (retargeter != null
+        && retargeter.hasNewInvokeTarget(
+            unresolvedInvokedMethod, isInterface, invokeType == Type.SUPER, context)) {
+      return true;
+    }
+    if (backportedMethodRewriter != null
+        && backportedMethodRewriter.methodIsBackport(unresolvedInvokedMethod)) {
+      return true;
+    }
+    return false;
   }
 
   public void registerCallbackIfRequired(ProgramMethod method) {
@@ -175,16 +377,18 @@
     }
   }
 
-  public ProgramMethod generateCallbackIfRequired(ProgramMethod method) {
+  public void generateCallbackIfRequired(
+      ProgramMethod method, DesugaredLibraryAPIConverterPostProcessingEventConsumer eventConsumer) {
     if (!shouldRegisterCallback(method)) {
-      return null;
+      return;
     }
     if (trackedCallBackAPIs != null) {
       trackedCallBackAPIs.add(method.getReference());
     }
-    ProgramMethod callback = generateCallbackMethod(method.getDefinition(), method.getHolder());
-    method.getHolder().addVirtualMethod(callback.getDefinition());
-    return callback;
+    ProgramMethod callback =
+        generateCallbackMethod(method.getDefinition(), method.getHolder(), eventConsumer);
+    callback.getHolder().addVirtualMethod(callback.getDefinition());
+    assert noPendingWrappersOrConversions();
   }
 
   public boolean shouldRegisterCallback(ProgramMethod method) {
@@ -198,6 +402,7 @@
     DexEncodedMethod definition = method.getDefinition();
     if (definition.isPrivateMethod()
         || definition.isStatic()
+        || definition.isAbstract()
         || definition.isLibraryMethodOverride().isFalse()) {
       return false;
     }
@@ -322,19 +527,9 @@
     return appView.dexItemFactory().createMethod(holder, newProto, originalMethod.name);
   }
 
-  public void finalizeWrappers(
-      DexApplication.Builder<?> builder, IRConverter irConverter, ExecutorService executorService)
-      throws ExecutionException {
-    // In D8, we generate the wrappers here. In R8, wrappers have already been generated in the
-    // enqueuer, so nothing needs to be done.
-    if (appView.enableWholeProgramOptimizations()) {
-      return;
-    }
-    SortedProgramMethodSet callbacks = generateCallbackMethods();
-    irConverter.processMethodsConcurrently(callbacks, executorService);
-    if (appView.options().isDesugaredLibraryCompilation()) {
-      wrapperSynthesizor.finalizeWrappersForL8();
-    }
+  public void ensureWrappersForL8(CfInstructionDesugaringEventConsumer eventConsumer) {
+    assert appView.options().isDesugaredLibraryCompilation();
+    wrapperSynthesizor.ensureWrappersForL8(eventConsumer);
   }
 
   public SortedProgramMethodSet generateCallbackMethods() {
@@ -345,7 +540,7 @@
           List<DexEncodedMethod> newVirtualMethods = new ArrayList<>();
           callbacks.forEach(
               callback -> {
-                ProgramMethod callbackMethod = generateCallbackMethod(callback, clazz);
+                ProgramMethod callbackMethod = generateCallbackMethod(callback, clazz, null);
                 newVirtualMethods.add(callbackMethod.getDefinition());
                 allCallbackMethods.add(callbackMethod);
               });
@@ -369,12 +564,14 @@
   }
 
   private ProgramMethod generateCallbackMethod(
-      DexEncodedMethod originalMethod, DexProgramClass clazz) {
+      DexEncodedMethod originalMethod,
+      DexProgramClass clazz,
+      DesugaredLibraryAPIConverterPostProcessingEventConsumer eventConsumer) {
     DexMethod methodToInstall =
         methodWithVivifiedTypeInSignature(originalMethod.getReference(), clazz.type, appView);
     CfCode cfCode =
         new APIConverterWrapperCfCodeProvider(
-                appView, originalMethod.getReference(), null, this, clazz.isInterface())
+                appView, originalMethod.getReference(), null, this, clazz.isInterface(), null)
             .generateCfCode();
     DexEncodedMethod newMethod =
         wrapperSynthesizor.newSynthesizedMethod(methodToInstall, originalMethod, cfCode);
@@ -382,7 +579,13 @@
     if (originalMethod.isLibraryMethodOverride().isTrue()) {
       newMethod.setLibraryMethodOverride(OptionalBool.TRUE);
     }
-    return new ProgramMethod(clazz, newMethod);
+    ProgramMethod callback = new ProgramMethod(clazz, newMethod);
+    if (eventConsumer != null) {
+      eventConsumer.acceptAPIConversionCallback(callback);
+    } else {
+      assert appView.enableWholeProgramOptimizations();
+    }
+    return callback;
   }
 
   private void generateTrackDesugaredAPIWarnings(Set<DexMethod> tracked, String inner) {
@@ -425,8 +628,11 @@
     return vivifiedType;
   }
 
-  public void registerWrappersForLibraryInvokeIfRequired(DexMethod invokedMethod) {
-    if (!shouldRewriteInvoke(invokedMethod)) {
+  public void registerWrappersForLibraryInvokeIfRequired(
+      DexMethod invokedMethod, Type invokeType, ProgramMethod context) {
+    // TODO(b/191656218): Once R8 support is done, use the isInterface bit instead of the inexact
+    //  invokeType == Type.INTERFACE here.
+    if (!shouldRewriteInvoke(invokedMethod, invokeType, invokeType == Type.INTERFACE, context)) {
       return;
     }
     if (trackedAPIs != null) {
@@ -443,6 +649,305 @@
     }
   }
 
+  private static DexType invalidType(
+      DexMethod invokedMethod,
+      DexMethod returnConversion,
+      DexMethod[] parameterConversions,
+      AppView<?> appView) {
+    DexMethod convertedMethod =
+        methodWithVivifiedTypeInSignature(invokedMethod, invokedMethod.holder, appView);
+    if (invokedMethod.getReturnType() != convertedMethod.getReturnType()
+        && returnConversion == null) {
+      return invokedMethod.getReturnType();
+    }
+    for (int i = 0; i < invokedMethod.getArity(); i++) {
+      if (invokedMethod.getParameter(i) != convertedMethod.getParameter(i)
+          && parameterConversions[i] == null) {
+        return invokedMethod.getParameter(i);
+      }
+    }
+    return null;
+  }
+
+  public static DexMethod getConvertedAPI(
+      DexMethod invokedMethod,
+      DexMethod returnConversion,
+      DexMethod[] parameterConversions,
+      AppView<?> appView) {
+    DexType newReturnType =
+        returnConversion != null ? returnConversion.getParameter(0) : invokedMethod.getReturnType();
+    DexType[] newParameterTypes = new DexType[parameterConversions.length];
+    for (int i = 0; i < parameterConversions.length; i++) {
+      newParameterTypes[i] =
+          parameterConversions[i] != null
+              ? parameterConversions[i].getReturnType()
+              : invokedMethod.getParameter(i);
+    }
+    DexMethod convertedAPI =
+        appView
+            .dexItemFactory()
+            .createMethod(
+                invokedMethod.holder,
+                appView.dexItemFactory().createProto(newReturnType, newParameterTypes),
+                invokedMethod.name);
+    assert convertedAPI
+            == methodWithVivifiedTypeInSignature(invokedMethod, invokedMethod.holder, appView)
+        || invalidType(invokedMethod, returnConversion, parameterConversions, appView) != null;
+    return convertedAPI;
+  }
+
+  private DexMethod computeReturnConversion(
+      DexMethod invokedMethod, DesugaredLibraryAPIConverterEventConsumer eventConsumer) {
+    DexType returnType = invokedMethod.proto.returnType;
+    if (!appView.rewritePrefix.hasRewrittenType(returnType, appView)) {
+      return null;
+    }
+    if (canConvert(returnType)) {
+      DexType newReturnType = DesugaredLibraryAPIConverter.vivifiedTypeFor(returnType, appView);
+      return ensureConversionMethod(returnType, newReturnType, returnType, eventConsumer);
+    }
+    reportInvalidInvoke(returnType, invokedMethod, "return ");
+    return null;
+  }
+
+  private DexMethod[] computeParameterConversions(
+      DexMethod invokedMethod, DesugaredLibraryAPIConverterEventConsumer eventConsumer) {
+    DexMethod[] parameterConversions = new DexMethod[invokedMethod.getArity()];
+    DexType[] parameters = invokedMethod.proto.parameters.values;
+    for (int i = 0; i < parameters.length; i++) {
+      DexType argType = parameters[i];
+      if (appView.rewritePrefix.hasRewrittenType(argType, appView)) {
+        if (canConvert(argType)) {
+          DexType argVivifiedType = vivifiedTypeFor(argType, appView);
+          parameterConversions[i] =
+              ensureConversionMethod(argType, argType, argVivifiedType, eventConsumer);
+        } else {
+          reportInvalidInvoke(argType, invokedMethod, "parameter ");
+        }
+      }
+    }
+    return parameterConversions;
+  }
+
+  private Collection<CfInstruction> rewriteLibraryInvoke(
+      CfInvoke invoke,
+      MethodProcessingContext methodProcessingContext,
+      LocalStackAllocator localStackAllocator,
+      CfInstructionDesugaringEventConsumer eventConsumer,
+      ProgramMethod context) {
+    DexMethod invokedMethod = invoke.getMethod();
+    if (trackedAPIs != null) {
+      trackedAPIs.add(invokedMethod);
+    }
+    if (shouldOutlineAPIConversion(invoke, context)) {
+      DexMethod outlinedAPIConversion =
+          createOutlinedAPIConversion(invoke, methodProcessingContext, eventConsumer);
+      return Collections.singletonList(
+          new CfInvoke(Opcodes.INVOKESTATIC, outlinedAPIConversion, false));
+    }
+    return rewriteLibraryInvokeToInlineAPIConversion(
+        invoke, methodProcessingContext, localStackAllocator, eventConsumer);
+  }
+
+  // If the option is set, we try to outline API conversions as much as possible to reduce the
+  // number
+  // of soft verification failures. We cannot outline API conversions through super invokes, to
+  // instance initializers and to non public methods.
+  private boolean shouldOutlineAPIConversion(CfInvoke invoke, ProgramMethod context) {
+    if (invoke.isInvokeSuper(context.getHolderType())) {
+      return false;
+    }
+    if (invoke.getMethod().isInstanceInitializer(appView.dexItemFactory())) {
+      return false;
+    }
+    DexClassAndMethod methodForDesugaring =
+        getMethodForDesugaring(invoke.getMethod(), false, invoke.isInterface(), context);
+    assert methodForDesugaring != null;
+    return methodForDesugaring.getAccessFlags().isPublic();
+  }
+
+  private Collection<CfInstruction> rewriteLibraryInvokeToInlineAPIConversion(
+      CfInvoke invoke,
+      MethodProcessingContext methodProcessingContext,
+      LocalStackAllocator localStackAllocator,
+      CfInstructionDesugaringEventConsumer eventConsumer) {
+
+    DexMethod invokedMethod = invoke.getMethod();
+    DexMethod returnConversion = computeReturnConversion(invokedMethod, eventConsumer);
+    DexMethod[] parameterConversions = computeParameterConversions(invokedMethod, eventConsumer);
+
+    // If only the last 2 parameters require conversion, we do everything inlined.
+    // If other parameters require conversion, we outline the parameter conversion but keep the API
+    // call inlined.
+    // The returned value is always converted inlined.
+    boolean requireOutlinedParameterConversion = false;
+    for (int i = 0; i < parameterConversions.length - 2; i++) {
+      requireOutlinedParameterConversion |= parameterConversions[i] != null;
+    }
+
+    ArrayList<CfInstruction> cfInstructions = new ArrayList<>();
+    if (requireOutlinedParameterConversion) {
+      addOutlineParameterConversionInstructions(
+          parameterConversions,
+          cfInstructions,
+          methodProcessingContext,
+          invokedMethod,
+          localStackAllocator,
+          eventConsumer);
+    } else {
+      addInlineParameterConversionInstructions(parameterConversions, cfInstructions);
+    }
+
+    DexMethod convertedMethod =
+        getConvertedAPI(invokedMethod, returnConversion, parameterConversions, appView);
+    cfInstructions.add(new CfInvoke(invoke.getOpcode(), convertedMethod, invoke.isInterface()));
+
+    if (returnConversion != null) {
+      cfInstructions.add(new CfInvoke(Opcodes.INVOKESTATIC, returnConversion, false));
+    }
+
+    return cfInstructions;
+  }
+
+  // The parameters are converted and returned in an array of converted parameters. The parameter
+  // array then needs to be unwrapped at the call site.
+  private void addOutlineParameterConversionInstructions(
+      DexMethod[] parameterConversions,
+      ArrayList<CfInstruction> cfInstructions,
+      MethodProcessingContext methodProcessingContext,
+      DexMethod invokedMethod,
+      LocalStackAllocator localStackAllocator,
+      CfInstructionDesugaringEventConsumer eventConsumer) {
+    localStackAllocator.allocateLocalStack(4);
+    DexProto newProto =
+        appView
+            .dexItemFactory()
+            .createProto(
+                appView.dexItemFactory().objectArrayType, invokedMethod.getParameters().values);
+    ProgramMethod parameterConversion =
+        appView
+            .getSyntheticItems()
+            .createMethod(
+                SyntheticKind.API_CONVERSION_PARAMETERS,
+                methodProcessingContext.createUniqueContext(),
+                appView,
+                builder ->
+                    builder
+                        .setProto(newProto)
+                        .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
+                        .setCode(
+                            methodSignature ->
+                                computeParameterConversionCfCode(
+                                    methodSignature.holder, invokedMethod, parameterConversions)));
+    eventConsumer.acceptAPIConversion(parameterConversion);
+    cfInstructions.add(
+        new CfInvoke(Opcodes.INVOKESTATIC, parameterConversion.getReference(), false));
+    for (int i = 0; i < parameterConversions.length; i++) {
+      cfInstructions.add(new CfStackInstruction(Opcode.Dup));
+      cfInstructions.add(new CfConstNumber(i, ValueType.INT));
+      DexType parameterType =
+          parameterConversions[i] != null
+              ? parameterConversions[i].getReturnType()
+              : invokedMethod.getParameter(i);
+      cfInstructions.add(new CfArrayLoad(MemberType.OBJECT));
+      if (parameterType.isPrimitiveType()) {
+        cfInstructions.add(new CfCheckCast(factory.getBoxedForPrimitiveType(parameterType)));
+        DexMethod method = appView.dexItemFactory().getUnboxPrimitiveMethod(parameterType);
+        cfInstructions.add(new CfInvoke(Opcodes.INVOKEVIRTUAL, method, false));
+      } else {
+        cfInstructions.add(new CfCheckCast(parameterType));
+      }
+      cfInstructions.add(new CfStackInstruction(Opcode.Swap));
+    }
+    cfInstructions.add(new CfStackInstruction(Opcode.Pop));
+  }
+
+  private CfCode computeParameterConversionCfCode(
+      DexType holder, DexMethod invokedMethod, DexMethod[] parameterConversions) {
+    ArrayList<CfInstruction> cfInstructions = new ArrayList<>();
+    cfInstructions.add(new CfConstNumber(parameterConversions.length, ValueType.INT));
+    cfInstructions.add(new CfNewArray(factory.objectArrayType));
+    int stackIndex = 0;
+    for (int i = 0; i < invokedMethod.getArity(); i++) {
+      cfInstructions.add(new CfStackInstruction(Opcode.Dup));
+      cfInstructions.add(new CfConstNumber(i, ValueType.INT));
+      DexType param = invokedMethod.getParameter(i);
+      cfInstructions.add(new CfLoad(ValueType.fromDexType(param), stackIndex));
+      if (parameterConversions[i] != null) {
+        cfInstructions.add(new CfInvoke(Opcodes.INVOKESTATIC, parameterConversions[i], false));
+      }
+      if (param.isPrimitiveType()) {
+        DexMethod method = appView.dexItemFactory().getBoxPrimitiveMethod(param);
+        cfInstructions.add(new CfInvoke(Opcodes.INVOKESTATIC, method, false));
+      }
+      cfInstructions.add(new CfArrayStore(MemberType.OBJECT));
+      if (param == appView.dexItemFactory().longType
+          || param == appView.dexItemFactory().doubleType) {
+        stackIndex++;
+      }
+      stackIndex++;
+    }
+    cfInstructions.add(new CfReturn(ValueType.OBJECT));
+    return new CfCode(
+        holder,
+        invokedMethod.getParameters().size() + 4,
+        invokedMethod.getParameters().size(),
+        cfInstructions);
+  }
+
+  private void addInlineParameterConversionInstructions(
+      DexMethod[] parameterConversions, ArrayList<CfInstruction> cfInstructions) {
+    if (parameterConversions.length > 0
+        && parameterConversions[parameterConversions.length - 1] != null) {
+      cfInstructions.add(
+          new CfInvoke(
+              Opcodes.INVOKESTATIC, parameterConversions[parameterConversions.length - 1], false));
+    }
+    if (parameterConversions.length > 1
+        && parameterConversions[parameterConversions.length - 2] != null) {
+      cfInstructions.add(new CfStackInstruction(Opcode.Swap));
+      cfInstructions.add(
+          new CfInvoke(
+              Opcodes.INVOKESTATIC, parameterConversions[parameterConversions.length - 2], false));
+      cfInstructions.add(new CfStackInstruction(Opcode.Swap));
+    }
+  }
+
+  private DexMethod createOutlinedAPIConversion(
+      CfInvoke invoke,
+      MethodProcessingContext methodProcessingContext,
+      CfInstructionDesugaringEventConsumer eventConsumer) {
+    DexMethod invokedMethod = invoke.getMethod();
+    DexProto newProto =
+        invoke.isInvokeStatic()
+            ? invokedMethod.proto
+            : factory.prependTypeToProto(invokedMethod.getHolderType(), invokedMethod.getProto());
+    DexMethod returnConversion = computeReturnConversion(invokedMethod, eventConsumer);
+    DexMethod[] parameterConversions = computeParameterConversions(invokedMethod, eventConsumer);
+    ProgramMethod outline =
+        appView
+            .getSyntheticItems()
+            .createMethod(
+                SyntheticKind.API_CONVERSION,
+                methodProcessingContext.createUniqueContext(),
+                appView,
+                builder ->
+                    builder
+                        .setProto(newProto)
+                        .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
+                        .setCode(
+                            methodSignature ->
+                                new APIConversionCfCodeProvider(
+                                        appView,
+                                        methodSignature.holder,
+                                        invoke,
+                                        returnConversion,
+                                        parameterConversions)
+                                    .generateCfCode()));
+    eventConsumer.acceptAPIConversion(outline);
+    return outline.getReference();
+  }
+
   private void rewriteLibraryInvoke(
       IRCode code,
       InvokeMethod invokeMethod,
@@ -574,7 +1079,7 @@
 
   private Instruction createParameterConversion(
       IRCode code, DexType argType, DexType argVivifiedType, Value inValue) {
-    DexMethod conversionMethod = ensureConversionMethod(argType, argType, argVivifiedType);
+    DexMethod conversionMethod = ensureConversionMethod(argType, argType, argVivifiedType, null);
     // The value is null only if the input is null.
     Value convertedValue =
         createConversionValue(code, inValue.getType().nullability(), argVivifiedType, null);
@@ -583,7 +1088,8 @@
 
   private Instruction createReturnConversionAndReplaceUses(
       IRCode code, InvokeMethod invokeMethod, DexType returnType, DexType returnVivifiedType) {
-    DexMethod conversionMethod = ensureConversionMethod(returnType, returnVivifiedType, returnType);
+    DexMethod conversionMethod =
+        ensureConversionMethod(returnType, returnVivifiedType, returnType, null);
     Value outValue = invokeMethod.outValue();
     Value convertedValue =
         createConversionValue(code, Nullability.maybeNull(), returnType, outValue.getLocalInfo());
@@ -600,7 +1106,11 @@
     }
   }
 
-  public DexMethod ensureConversionMethod(DexType type, DexType srcType, DexType destType) {
+  public DexMethod ensureConversionMethod(
+      DexType type,
+      DexType srcType,
+      DexType destType,
+      DesugaredLibraryAPIConverterEventConsumer eventConsumer) {
     // ConversionType holds the methods "rewrittenType convert(type)" and the other way around.
     // But everything is going to be rewritten, so we need to use vivifiedType and type".
     DexType conversionHolder =
@@ -608,8 +1118,8 @@
     if (conversionHolder == null) {
       conversionHolder =
           type == srcType
-              ? wrapperSynthesizor.ensureTypeWrapper(type)
-              : wrapperSynthesizor.ensureVivifiedTypeWrapper(type);
+              ? wrapperSynthesizor.ensureTypeWrapper(type, eventConsumer)
+              : wrapperSynthesizor.ensureVivifiedTypeWrapper(type, eventConsumer);
     }
     assert conversionHolder != null;
     return factory.createMethod(
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryAPIConverterEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryAPIConverterEventConsumer.java
new file mode 100644
index 0000000..7af64bb
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryAPIConverterEventConsumer.java
@@ -0,0 +1,23 @@
+// 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.ir.desugar.desugaredlibrary;
+
+import com.android.tools.r8.graph.DexClasspathClass;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.ProgramMethod;
+
+public interface DesugaredLibraryAPIConverterEventConsumer {
+
+  void acceptWrapperProgramClass(DexProgramClass clazz);
+
+  void acceptWrapperClasspathClass(DexClasspathClass clazz);
+
+  void acceptAPIConversion(ProgramMethod method);
+
+  interface DesugaredLibraryAPIConverterPostProcessingEventConsumer {
+
+    void acceptAPIConversionCallback(ProgramMethod method);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryRetargeterSyntheticHelper.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryRetargeterSyntheticHelper.java
index 1f8322f..02eb59b 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryRetargeterSyntheticHelper.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryRetargeterSyntheticHelper.java
@@ -150,6 +150,7 @@
               .setCode(
                   methodSig ->
                       new EmulateInterfaceSyntheticCfCodeProvider(
+                              methodSig.getHolderType(),
                               emulatedDispatchMethod.getHolderType(),
                               desugarMethod,
                               itfMethod,
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryWrapperSynthesizer.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryWrapperSynthesizer.java
index 6c1e889..7e2164f 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryWrapperSynthesizer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryWrapperSynthesizer.java
@@ -117,14 +117,16 @@
     return appView.options().desugaredLibraryConfiguration.getWrapperConversions().contains(type);
   }
 
-  DexType ensureTypeWrapper(DexType type) {
-    return ensureWrappers(type).getWrapper().type;
+  DexType ensureTypeWrapper(DexType type, DesugaredLibraryAPIConverterEventConsumer eventConsumer) {
+    return ensureWrappers(type, eventConsumer).getWrapper().type;
   }
 
-  DexType ensureVivifiedTypeWrapper(DexType type) {
-    return ensureWrappers(type).getVivifiedWrapper().type;
+  DexType ensureVivifiedTypeWrapper(
+      DexType type, DesugaredLibraryAPIConverterEventConsumer eventConsumer) {
+    return ensureWrappers(type, eventConsumer).getVivifiedWrapper().type;
   }
 
+
   public void registerWrapper(DexType type) {
     wrappersToGenerate.add(type);
     assert getValidClassToWrap(type) != null;
@@ -161,13 +163,17 @@
     }
   }
 
-  private Wrappers ensureWrappers(DexType type) {
+  private Wrappers ensureWrappers(
+      DexType type, DesugaredLibraryAPIConverterEventConsumer eventConsumer) {
     assert canGenerateWrapper(type) : type;
     DexClass dexClass = getValidClassToWrap(type);
-    return ensureWrappers(dexClass, ignored -> {});
+    return ensureWrappers(dexClass, ignored -> {}, eventConsumer);
   }
 
-  private Wrappers ensureWrappers(DexClass context, Consumer<DexClasspathClass> creationCallback) {
+  private Wrappers ensureWrappers(
+      DexClass context,
+      Consumer<DexClasspathClass> creationCallback,
+      DesugaredLibraryAPIConverterEventConsumer eventConsumer) {
     DexType type = context.type;
     DexClass wrapper;
     DexClass vivifiedWrapper;
@@ -180,15 +186,20 @@
               vivifiedTypeFor(type),
               type,
               programContext,
-              wrapperField -> synthesizeVirtualMethodsForTypeWrapper(programContext, wrapperField));
+              eventConsumer,
+              wrapperField ->
+                  synthesizeVirtualMethodsForTypeWrapper(
+                      programContext, wrapperField, eventConsumer));
       vivifiedWrapper =
           ensureProgramWrapper(
               SyntheticKind.VIVIFIED_WRAPPER,
               type,
               vivifiedTypeFor(type),
               programContext,
+              eventConsumer,
               wrapperField ->
-                  synthesizeVirtualMethodsForVivifiedTypeWrapper(programContext, wrapperField));
+                  synthesizeVirtualMethodsForVivifiedTypeWrapper(
+                      programContext, wrapperField, eventConsumer));
       DexField wrapperField = getWrapperUniqueField(wrapper);
       DexField vivifiedWrapperField = getWrapperUniqueField(vivifiedWrapper);
       ensureProgramConversionMethod(
@@ -205,7 +216,9 @@
               type,
               classpathOrLibraryContext,
               creationCallback,
-              wrapperField -> synthesizeVirtualMethodsForTypeWrapper(context, wrapperField));
+              eventConsumer,
+              wrapperField ->
+                  synthesizeVirtualMethodsForTypeWrapper(context, wrapperField, eventConsumer));
       vivifiedWrapper =
           ensureClasspathWrapper(
               SyntheticKind.VIVIFIED_WRAPPER,
@@ -213,8 +226,10 @@
               vivifiedTypeFor(type),
               classpathOrLibraryContext,
               creationCallback,
+              eventConsumer,
               wrapperField ->
-                  synthesizeVirtualMethodsForVivifiedTypeWrapper(context, wrapperField));
+                  synthesizeVirtualMethodsForVivifiedTypeWrapper(
+                      context, wrapperField, eventConsumer));
       DexField wrapperField = getWrapperUniqueField(wrapper);
       DexField vivifiedWrapperField = getWrapperUniqueField(vivifiedWrapper);
       ensureClasspathConversionMethod(
@@ -242,6 +257,7 @@
       DexType wrappingType,
       DexType wrappedType,
       DexProgramClass programContext,
+      DesugaredLibraryAPIConverterEventConsumer eventConsumer,
       Function<DexEncodedField, DexEncodedMethod[]> virtualMethodProvider) {
     return appView
         .getSyntheticItems()
@@ -252,9 +268,13 @@
             builder -> buildWrapper(wrappingType, wrappedType, programContext, builder),
             // The creation of virtual methods may require new wrappers, this needs to happen
             // once the wrapper is created to avoid infinite recursion.
-            wrapper ->
-                wrapper.setVirtualMethods(
-                    virtualMethodProvider.apply(getWrapperUniqueEncodedField(wrapper))));
+            wrapper -> {
+              if (eventConsumer != null) {
+                eventConsumer.acceptWrapperProgramClass(wrapper);
+              }
+              wrapper.setVirtualMethods(
+                  virtualMethodProvider.apply(getWrapperUniqueEncodedField(wrapper)));
+            });
   }
 
   private DexClasspathClass ensureClasspathWrapper(
@@ -263,6 +283,7 @@
       DexType wrappedType,
       ClasspathOrLibraryClass classpathOrLibraryContext,
       Consumer<DexClasspathClass> creationCallback,
+      DesugaredLibraryAPIConverterEventConsumer eventConsumer,
       Function<DexEncodedField, DexEncodedMethod[]> virtualMethodProvider) {
     return appView
         .getSyntheticItems()
@@ -276,6 +297,9 @@
             // The creation of virtual methods may require new wrappers, this needs to happen
             // once the wrapper is created to avoid infinite recursion.
             wrapper -> {
+              if (eventConsumer != null) {
+                eventConsumer.acceptWrapperClasspathClass(wrapper);
+              }
               wrapper.setVirtualMethods(
                   virtualMethodProvider.apply(getWrapperUniqueEncodedField(wrapper)));
               creationCallback.accept(wrapper);
@@ -382,7 +406,9 @@
   }
 
   private DexEncodedMethod[] synthesizeVirtualMethodsForVivifiedTypeWrapper(
-      DexClass dexClass, DexEncodedField wrapperField) {
+      DexClass dexClass,
+      DexEncodedField wrapperField,
+      DesugaredLibraryAPIConverterEventConsumer eventConsumer) {
     List<DexEncodedMethod> dexMethods = allImplementedMethods(dexClass);
     List<DexEncodedMethod> generatedMethods = new ArrayList<>();
     // Each method should use only types in their signature, but each method the wrapper forwards
@@ -421,7 +447,12 @@
       } else {
         cfCode =
             new APIConverterVivifiedWrapperCfCodeProvider(
-                    appView, methodToInstall, wrapperField.getReference(), converter, isInterface)
+                    appView,
+                    methodToInstall,
+                    wrapperField.getReference(),
+                    converter,
+                    isInterface,
+                    eventConsumer)
                 .generateCfCode();
       }
       DexEncodedMethod newDexEncodedMethod =
@@ -432,7 +463,9 @@
   }
 
   private DexEncodedMethod[] synthesizeVirtualMethodsForTypeWrapper(
-      DexClass dexClass, DexEncodedField wrapperField) {
+      DexClass dexClass,
+      DexEncodedField wrapperField,
+      DesugaredLibraryAPIConverterEventConsumer eventConsumer) {
     List<DexEncodedMethod> dexMethods = allImplementedMethods(dexClass);
     List<DexEncodedMethod> generatedMethods = new ArrayList<>();
     // Each method should use only vivified types in their signature, but each method the wrapper
@@ -465,7 +498,8 @@
                     dexEncodedMethod.getReference(),
                     wrapperField.getReference(),
                     converter,
-                    isInterface)
+                    isInterface,
+                    eventConsumer)
                 .generateCfCode();
       }
       DexEncodedMethod newDexEncodedMethod =
@@ -574,7 +608,7 @@
         field, fieldAccessFlags, FieldTypeSignature.noSignature(), DexAnnotationSet.empty(), null);
   }
 
-  void finalizeWrappersForL8() {
+  void ensureWrappersForL8(DesugaredLibraryAPIConverterEventConsumer eventConsumer) {
     DesugaredLibraryConfiguration conf = appView.options().desugaredLibraryConfiguration;
     for (DexType type : conf.getWrapperConversions()) {
       assert !conf.getCustomConversions().containsKey(type);
@@ -582,7 +616,7 @@
       // In broken set-ups we can end up having a json files containing wrappers of non desugared
       // classes. Such wrappers are not required since the class won't be rewritten.
       if (validClassToWrap.isProgramClass()) {
-        ensureWrappers(validClassToWrap, ignored -> {});
+        ensureWrappers(validClassToWrap, ignored -> {}, eventConsumer);
       }
     }
   }
@@ -599,7 +633,8 @@
             classpathWrapper -> {
               changed.set(true);
               synthesizedCallback.accept(classpathWrapper);
-            });
+            },
+            null);
       }
     }
   }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/itf/EmulatedInterfaceProcessor.java b/src/main/java/com/android/tools/r8/ir/desugar/itf/EmulatedInterfaceProcessor.java
index 1c29a09..c73f3e4 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/itf/EmulatedInterfaceProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/itf/EmulatedInterfaceProcessor.java
@@ -130,9 +130,10 @@
         .setProto(emulatedMethod.getProto())
         .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
         .setCode(
-            theMethod ->
+            emulatedInterfaceMethod ->
                 new EmulateInterfaceSyntheticCfCodeProvider(
-                        theMethod.getHolderType(),
+                        emulatedInterfaceMethod.getHolderType(),
+                        method.getHolderType(),
                         companionMethod,
                         libraryMethod,
                         extraDispatchCases,
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodRewriter.java
index 3e93691..640e740 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodRewriter.java
@@ -214,6 +214,10 @@
     }
   }
 
+  public Set<DexString> getEmulatedMethods() {
+    return emulatedMethods;
+  }
+
   private void initializeEmulatedInterfaceVariables() {
     Map<DexType, DexType> emulateLibraryInterface =
         options.desugaredLibraryConfiguration.getEmulateLibraryInterface();
diff --git a/src/main/java/com/android/tools/r8/ir/synthetic/DesugaredLibraryAPIConversionCfCodeProvider.java b/src/main/java/com/android/tools/r8/ir/synthetic/DesugaredLibraryAPIConversionCfCodeProvider.java
index db93ced..214eab9 100644
--- a/src/main/java/com/android/tools/r8/ir/synthetic/DesugaredLibraryAPIConversionCfCodeProvider.java
+++ b/src/main/java/com/android/tools/r8/ir/synthetic/DesugaredLibraryAPIConversionCfCodeProvider.java
@@ -32,6 +32,8 @@
 import com.android.tools.r8.ir.code.If;
 import com.android.tools.r8.ir.code.ValueType;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverter;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverterEventConsumer;
+import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.collections.ImmutableDeque;
 import com.android.tools.r8.utils.collections.ImmutableInt2ReferenceSortedMap;
 import java.util.ArrayList;
@@ -62,22 +64,25 @@
   public static class APIConverterVivifiedWrapperCfCodeProvider
       extends DesugaredLibraryAPIConversionCfCodeProvider {
 
-    DexField wrapperField;
-    DexMethod forwardMethod;
-    DesugaredLibraryAPIConverter converter;
-    boolean itfCall;
+    private final DexField wrapperField;
+    private final DexMethod forwardMethod;
+    private final DesugaredLibraryAPIConverter converter;
+    private final boolean itfCall;
+    private final DesugaredLibraryAPIConverterEventConsumer eventConsumer;
 
     public APIConverterVivifiedWrapperCfCodeProvider(
         AppView<?> appView,
         DexMethod forwardMethod,
         DexField wrapperField,
         DesugaredLibraryAPIConverter converter,
-        boolean itfCall) {
+        boolean itfCall,
+        DesugaredLibraryAPIConverterEventConsumer eventConsumer) {
       super(appView, wrapperField.holder);
       this.forwardMethod = forwardMethod;
       this.wrapperField = wrapperField;
       this.converter = converter;
       this.itfCall = itfCall;
+      this.eventConsumer = eventConsumer;
     }
 
     @Override
@@ -98,7 +103,8 @@
           instructions.add(
               new CfInvoke(
                   Opcodes.INVOKESTATIC,
-                  converter.ensureConversionMethod(param, param, vivifiedTypeFor(param)),
+                  converter.ensureConversionMethod(
+                      param, param, vivifiedTypeFor(param), eventConsumer),
                   false));
           newParameters[index - 1] = vivifiedTypeFor(param);
         }
@@ -130,7 +136,7 @@
             new CfInvoke(
                 Opcodes.INVOKESTATIC,
                 converter.ensureConversionMethod(
-                    returnType, vivifiedTypeFor(returnType), returnType),
+                    returnType, vivifiedTypeFor(returnType), returnType, eventConsumer),
                 false));
       }
       if (returnType == factory.voidType) {
@@ -149,19 +155,22 @@
     DexMethod forwardMethod;
     DesugaredLibraryAPIConverter converter;
     boolean itfCall;
+    private final DesugaredLibraryAPIConverterEventConsumer eventConsumer;
 
     public APIConverterWrapperCfCodeProvider(
         AppView<?> appView,
         DexMethod forwardMethod,
         DexField wrapperField,
         DesugaredLibraryAPIConverter converter,
-        boolean itfCall) {
+        boolean itfCall,
+        DesugaredLibraryAPIConverterEventConsumer eventConsumer) {
       //  Var wrapperField is null if should forward to receiver.
       super(appView, wrapperField == null ? forwardMethod.holder : wrapperField.holder);
       this.forwardMethod = forwardMethod;
       this.wrapperField = wrapperField;
       this.converter = converter;
       this.itfCall = itfCall;
+      this.eventConsumer = eventConsumer;
     }
 
     @Override
@@ -185,7 +194,8 @@
           instructions.add(
               new CfInvoke(
                   Opcodes.INVOKESTATIC,
-                  converter.ensureConversionMethod(param, vivifiedTypeFor(param), param),
+                  converter.ensureConversionMethod(
+                      param, vivifiedTypeFor(param), param, eventConsumer),
                   false));
         }
         if (param == factory.longType || param == factory.doubleType) {
@@ -206,7 +216,7 @@
             new CfInvoke(
                 Opcodes.INVOKESTATIC,
                 converter.ensureConversionMethod(
-                    returnType, returnType, vivifiedTypeFor(returnType)),
+                    returnType, returnType, vivifiedTypeFor(returnType), eventConsumer),
                 false));
         returnType = vivifiedTypeFor(returnType);
       }
@@ -282,6 +292,70 @@
     }
   }
 
+  public static class APIConversionCfCodeProvider extends SyntheticCfCodeProvider {
+
+    private final CfInvoke initialInvoke;
+    private final DexMethod returnConversion;
+    private final DexMethod[] parameterConversions;
+
+    public APIConversionCfCodeProvider(
+        AppView<?> appView,
+        DexType holder,
+        CfInvoke initialInvoke,
+        DexMethod returnConversion,
+        DexMethod[] parameterConversions) {
+      super(appView, holder);
+      this.initialInvoke = initialInvoke;
+      this.returnConversion = returnConversion;
+      this.parameterConversions = parameterConversions;
+    }
+
+    @Override
+    public CfCode generateCfCode() {
+      DexMethod invokedMethod = initialInvoke.getMethod();
+      DexMethod convertedMethod =
+          DesugaredLibraryAPIConverter.getConvertedAPI(
+              invokedMethod, returnConversion, parameterConversions, appView);
+
+      List<CfInstruction> instructions = new ArrayList<>();
+
+      boolean isStatic = initialInvoke.getOpcode() == Opcodes.INVOKESTATIC;
+      if (!isStatic) {
+        instructions.add(new CfLoad(ValueType.fromDexType(invokedMethod.holder), 0));
+      }
+      int receiverShift = BooleanUtils.intValue(!isStatic);
+      int stackIndex = 0;
+      for (int i = 0; i < invokedMethod.getArity(); i++) {
+        DexType param = invokedMethod.getParameter(i);
+        instructions.add(new CfLoad(ValueType.fromDexType(param), stackIndex + receiverShift));
+        if (parameterConversions[i] != null) {
+          instructions.add(new CfInvoke(Opcodes.INVOKESTATIC, parameterConversions[i], false));
+        }
+        if (param == appView.dexItemFactory().longType
+            || param == appView.dexItemFactory().doubleType) {
+          stackIndex++;
+        }
+        stackIndex++;
+      }
+
+      // Actual call to converted value.
+      instructions.add(
+          new CfInvoke(initialInvoke.getOpcode(), convertedMethod, initialInvoke.isInterface()));
+
+      // Return conversion.
+      if (returnConversion != null) {
+        instructions.add(new CfInvoke(Opcodes.INVOKESTATIC, returnConversion, false));
+      }
+
+      if (invokedMethod.getReturnType().isVoidType()) {
+        instructions.add(new CfReturnVoid());
+      } else {
+        instructions.add(new CfReturn(ValueType.fromDexType(invokedMethod.getReturnType())));
+      }
+      return standardCfCodeFromInstructions(instructions);
+    }
+  }
+
   public static class APIConverterConstructorCfCodeProvider extends SyntheticCfCodeProvider {
 
     DexField wrapperField;
diff --git a/src/main/java/com/android/tools/r8/ir/synthetic/EmulateInterfaceSyntheticCfCodeProvider.java b/src/main/java/com/android/tools/r8/ir/synthetic/EmulateInterfaceSyntheticCfCodeProvider.java
index 7f26a19..e1ba3b2 100644
--- a/src/main/java/com/android/tools/r8/ir/synthetic/EmulateInterfaceSyntheticCfCodeProvider.java
+++ b/src/main/java/com/android/tools/r8/ir/synthetic/EmulateInterfaceSyntheticCfCodeProvider.java
@@ -36,12 +36,13 @@
   private final List<Pair<DexType, DexMethod>> extraDispatchCases;
 
   public EmulateInterfaceSyntheticCfCodeProvider(
+      DexType holder,
       DexType interfaceType,
       DexMethod companionMethod,
       DexMethod libraryMethod,
       List<Pair<DexType, DexMethod>> extraDispatchCases,
       AppView<?> appView) {
-    super(appView, interfaceType);
+    super(appView, holder);
     this.interfaceType = interfaceType;
     this.companionMethod = companionMethod;
     this.libraryMethod = libraryMethod;
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 4c1ac7c..216fcfc 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
@@ -51,7 +51,9 @@
     THROW_NSME("ThrowNSME", 16, true),
     TWR_CLOSE_RESOURCE("TwrCloseResource", 17, true),
     SERVICE_LOADER("ServiceLoad", 18, true),
-    OUTLINE("Outline", 19, true);
+    OUTLINE("Outline", 19, true),
+    API_CONVERSION("APIConversion", 26, true),
+    API_CONVERSION_PARAMETERS("APIConversionParameters", 28, true);
 
     static {
       assert verifyNoOverlappingIds();
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/BufferedReaderTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/BufferedReaderTest.java
index ddebca5..fdca331 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/BufferedReaderTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/BufferedReaderTest.java
@@ -126,7 +126,7 @@
       Path desugaredLib =
           getDesugaredLibraryInCF(parameters, this::configurationForLibraryCompilation);
 
-      // Run on the JVM with desuagred library on classpath.
+      // Run on the JVM with desugared library on classpath.
       testForJvm()
           .addProgramFiles(jar)
           .addRunClasspathFiles(desugaredLib)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DefaultMethodOverrideInLibraryTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DefaultMethodOverrideInLibraryTest.java
index 1f4d791..b3ac06f 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DefaultMethodOverrideInLibraryTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DefaultMethodOverrideInLibraryTest.java
@@ -37,7 +37,7 @@
 @RunWith(Parameterized.class)
 public class DefaultMethodOverrideInLibraryTest extends DesugaredLibraryTestBase {
 
-  static final String EXPECTED = StringUtils.lines("0", "42");
+  static final String EXPECTED = StringUtils.lines("0", "42", "0", "0", "42", "42");
 
   private final TestParameters parameters;
 
@@ -127,16 +127,32 @@
   static class MyIntegerArrayListWithoutOverride extends ArrayList<Integer>
       implements MyIntegerList {
     // No override of spliterator.
+
+    public Spliterator<Integer> superSpliteratorItf() {
+      return MyIntegerList.super.spliterator();
+    }
+
+    public Spliterator<Integer> superSpliterator() {
+      return super.spliterator();
+    }
   }
 
   // Derived list with an override of spliterator. The call must hit the classes override and that
-  // will explictly call the custom default method.
+  // will explicitly call the custom default method.
   static class MyIntegerArrayListWithOverride extends ArrayList<Integer> implements MyIntegerList {
 
     @Override
     public Spliterator<Integer> spliterator() {
       return MyIntegerList.super.spliterator();
     }
+
+    public Spliterator<Integer> superSpliteratorItf() {
+      return MyIntegerList.super.spliterator();
+    }
+
+    public Spliterator<Integer> superSpliterator() {
+      return super.spliterator();
+    }
   }
 
   static class Main {
@@ -144,6 +160,11 @@
     public static void main(String[] args) {
       System.out.println(new MyIntegerArrayListWithoutOverride().spliterator().estimateSize());
       System.out.println(new MyIntegerArrayListWithOverride().spliterator().estimateSize());
+      System.out.println(new MyIntegerArrayListWithoutOverride().superSpliterator().estimateSize());
+      System.out.println(new MyIntegerArrayListWithOverride().superSpliterator().estimateSize());
+      System.out.println(
+          new MyIntegerArrayListWithoutOverride().superSpliteratorItf().estimateSize());
+      System.out.println(new MyIntegerArrayListWithOverride().superSpliteratorItf().estimateSize());
     }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/FreezePeriodTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/FreezePeriodTest.java
new file mode 100644
index 0000000..ac48549
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/FreezePeriodTest.java
@@ -0,0 +1,208 @@
+// Copyright (c) 2019, 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.conversiontests;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import java.nio.file.Path;
+import java.time.MonthDay;
+import java.util.List;
+import org.junit.BeforeClass;
+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 FreezePeriodTest extends DesugaredLibraryTestBase {
+
+  private final TestParameters parameters;
+  private final boolean shrinkDesugaredLibrary;
+  private static final AndroidApiLevel MIN_SUPPORTED = AndroidApiLevel.O;
+  private static final String EXPECTED_RESULT =
+      StringUtils.lines(
+          "FP:--05-05;--06-06",
+          "FP:--05-05;--06-06",
+          "FP:--05-05;--06-0601",
+          "MFP:--05-05;--06-06");
+  private static Path CUSTOM_LIB;
+
+  @Parameters(name = "{0}, shrinkDesugaredLibrary: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getConversionParametersUpToExcluding(MIN_SUPPORTED), BooleanUtils.values());
+  }
+
+  public FreezePeriodTest(TestParameters parameters, boolean shrinkDesugaredLibrary) {
+    this.shrinkDesugaredLibrary = shrinkDesugaredLibrary;
+    this.parameters = parameters;
+  }
+
+  @BeforeClass
+  public static void compileCustomLib() throws Exception {
+    CUSTOM_LIB =
+        testForD8(getStaticTemp())
+            .addProgramClasses(FreezePeriod.class)
+            .setMinApi(MIN_SUPPORTED)
+            .compile()
+            .writeToZip();
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+    testForD8()
+        .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P))
+        .setMinApi(parameters.getApiLevel())
+        .addProgramClasses(Executor.class, MyFreezePeriod.class)
+        .addLibraryClasses(FreezePeriod.class)
+        .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+        .compile()
+        .addDesugaredCoreLibraryRunClassPath(
+            this::buildDesugaredLibrary,
+            parameters.getApiLevel(),
+            keepRuleConsumer.get(),
+            shrinkDesugaredLibrary)
+        .addRunClasspathFiles(CUSTOM_LIB)
+        .run(parameters.getRuntime(), Executor.class)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
+  }
+
+  @Test
+  public void testD8CfToCf() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+    Path jar =
+        testForD8(Backend.CF)
+            .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P))
+            .setMinApi(parameters.getApiLevel())
+            .addProgramClasses(Executor.class, MyFreezePeriod.class)
+            .addLibraryClasses(FreezePeriod.class)
+            .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+            .compile()
+            .writeToZip();
+    String desugaredLibraryKeepRules = "";
+    if (shrinkDesugaredLibrary && keepRuleConsumer.get() != null) {
+      // Collection keep rules is only implemented in the DEX writer.
+      assertEquals(0, keepRuleConsumer.get().length());
+      desugaredLibraryKeepRules = "-keep class * { *; }";
+    }
+    if (parameters.getRuntime().isDex()) {
+      testForD8()
+          .addProgramFiles(jar)
+          .setMinApi(parameters.getApiLevel())
+          .disableDesugaring()
+          .compile()
+          .addDesugaredCoreLibraryRunClassPath(
+              this::buildDesugaredLibrary,
+              parameters.getApiLevel(),
+              desugaredLibraryKeepRules,
+              shrinkDesugaredLibrary)
+          .addRunClasspathFiles(CUSTOM_LIB)
+          .run(parameters.getRuntime(), Executor.class)
+          .assertSuccessWithOutput(EXPECTED_RESULT);
+    } else {
+      testForJvm()
+          .addProgramFiles(jar)
+          .addRunClasspathFiles(getDesugaredLibraryInCF(parameters, options -> {}))
+          .addRunClasspathFiles(CUSTOM_LIB)
+          .run(parameters.getRuntime(), Executor.class)
+          .assertSuccessWithOutput(EXPECTED_RESULT);
+    }
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+    testForR8(parameters.getBackend())
+        .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P))
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Executor.class)
+        .addProgramClasses(Executor.class, MyFreezePeriod.class)
+        .addLibraryClasses(FreezePeriod.class)
+        .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+        .allowStdoutMessages()
+        .compile()
+        .addDesugaredCoreLibraryRunClassPath(
+            this::buildDesugaredLibrary,
+            parameters.getApiLevel(),
+            keepRuleConsumer.get(),
+            shrinkDesugaredLibrary)
+        .addRunClasspathFiles(CUSTOM_LIB)
+        .run(parameters.getRuntime(), Executor.class)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
+  }
+
+  static class Executor {
+
+    public static void main(String[] args) {
+      testConversion2ArgsOrLess();
+      testConversion3ArgsOrMore();
+      testConversionWithValuesOnStack();
+      testConversionSuperInit();
+    }
+
+    private static void testConversionSuperInit() {
+      MyFreezePeriod myFreezePeriod = new MyFreezePeriod(MonthDay.of(5, 5), MonthDay.of(6, 6));
+      System.out.println(myFreezePeriod.print());
+    }
+
+    private static void testConversionWithValuesOnStack() {
+      print(0, new FreezePeriod(MonthDay.of(5, 5), MonthDay.of(6, 6)), 1);
+    }
+
+    private static void testConversion3ArgsOrMore() {
+      FreezePeriod freezePeriod2 = new FreezePeriod(MonthDay.of(5, 5), MonthDay.of(6, 6), 0, 1);
+      System.out.println(freezePeriod2.print());
+    }
+
+    private static void testConversion2ArgsOrLess() {
+      FreezePeriod freezePeriod = new FreezePeriod(MonthDay.of(5, 5), MonthDay.of(6, 6));
+      System.out.println(freezePeriod.print());
+    }
+
+    static void print(int i1, FreezePeriod freezePeriod, int i2) {
+      System.out.println(freezePeriod.print() + i1 + i2);
+    }
+  }
+
+  static class MyFreezePeriod extends FreezePeriod {
+
+    public MyFreezePeriod(MonthDay start, MonthDay end) {
+      super(start, end);
+    }
+
+    public String print() {
+      return "M" + super.print();
+    }
+  }
+
+  // This class will be put at compilation time as library and on the runtime class path.
+  // This class is convenient for easy testing. Each method plays the role of methods in the
+  // platform APIs for which argument/return values need conversion.
+  static class FreezePeriod {
+
+    private final MonthDay start;
+    private final MonthDay end;
+
+    public FreezePeriod(MonthDay start, MonthDay end) {
+      this.start = start;
+      this.end = end;
+    }
+
+    public FreezePeriod(MonthDay start, MonthDay end, int extra1, Integer extra2) {
+      this.start = start;
+      this.end = end;
+    }
+
+    public String print() {
+      return "FP:" + start + ";" + end;
+    }
+  }
+}