diff --git a/src/main/java/com/android/tools/r8/graph/CfCode.java b/src/main/java/com/android/tools/r8/graph/CfCode.java
index 50083f2..141484c 100644
--- a/src/main/java/com/android/tools/r8/graph/CfCode.java
+++ b/src/main/java/com/android/tools/r8/graph/CfCode.java
@@ -412,7 +412,9 @@
       Origin origin,
       boolean shouldApplyCodeRewritings) {
     if (!verifyFrames(method, appView, origin, shouldApplyCodeRewritings)) {
-      instructions.removeIf(CfInstruction::isFrame);
+      ArrayList<CfInstruction> copy = new ArrayList<>(instructions);
+      copy.removeIf(CfInstruction::isFrame);
+      setInstructions(copy);
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/AccessorMethodSourceCode.java b/src/main/java/com/android/tools/r8/ir/desugar/AccessorMethodSourceCode.java
index b283f96..d7b3d0a 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/AccessorMethodSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/AccessorMethodSourceCode.java
@@ -1,129 +1,47 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
+// 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.desugar;
 
 import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.CfCode;
 import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexMethodHandle;
-import com.android.tools.r8.graph.DexProto;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.code.Invoke;
-import com.android.tools.r8.ir.code.Position;
-import com.android.tools.r8.ir.code.ValueType;
-import com.android.tools.r8.ir.conversion.IRBuilder;
-import java.util.ArrayList;
-import java.util.List;
+import com.android.tools.r8.ir.synthetic.ForwardMethodBuilder;
 
 // Source code representing synthesized accessor method.
-final class AccessorMethodSourceCode extends SynthesizedLambdaSourceCode {
 
-  AccessorMethodSourceCode(LambdaClass lambda, Position callerPosition) {
-    super(
-        lambda, lambda.target.callTarget, callerPosition, null /* no receiver for static method */);
-    // We should never need an accessor for interface methods since
-    // they are supposed to be public.
-    assert !descriptor().implHandle.type.isInvokeInterface();
-    assert checkSignatures();
-  }
+public class AccessorMethodSourceCode {
 
-  private boolean checkSignatures() {
-    DexMethodHandle implHandle = descriptor().implHandle;
-    assert implHandle != null;
-
-    DexType[] accessorParams = proto.parameters.values;
-    DexMethod implMethod = implHandle.asMethod();
-    DexProto implProto = implMethod.proto;
-    DexType[] implParams = implProto.parameters.values;
-
-    int index = 0;
-    if (implHandle.type.isInvokeInstance() || implHandle.type.isInvokeDirect()) {
-      assert accessorParams[index] == descriptor().getImplReceiverType();
-      index++;
-    }
-
-    for (DexType implParam : implParams) {
-      assert accessorParams[index] == implParam;
-      index++;
-    }
-    assert index == accessorParams.length;
-
-    assert delegatingToConstructor()
-        ? this.proto.returnType == implMethod.holder
-        : this.proto.returnType == implProto.returnType;
-    return true;
-  }
-
-  // Are we delegating to a constructor?
-  private boolean delegatingToConstructor() {
-    return descriptor().implHandle.type.isInvokeConstructor();
-  }
-
-  private Invoke.Type inferInvokeType() {
-    switch (descriptor().implHandle.type) {
+  public static CfCode build(LambdaClass lambda, DexMethod accessor) {
+    DexMethod target = lambda.descriptor.implHandle.asMethod();
+    ForwardMethodBuilder forwardMethodBuilder =
+        ForwardMethodBuilder.builder(lambda.appView.dexItemFactory()).setStaticSource(accessor);
+    switch (lambda.descriptor.implHandle.type) {
       case INVOKE_INSTANCE:
-        return Invoke.Type.VIRTUAL;
+        {
+          forwardMethodBuilder.setVirtualTarget(target, false);
+          break;
+        }
       case INVOKE_STATIC:
-        return Invoke.Type.STATIC;
+        {
+          forwardMethodBuilder.setStaticTarget(target, false);
+          break;
+        }
       case INVOKE_DIRECT:
+        {
+          forwardMethodBuilder.setDirectTarget(target, false);
+          break;
+        }
       case INVOKE_CONSTRUCTOR:
-        return Invoke.Type.DIRECT;
+        {
+          forwardMethodBuilder.setConstructorTarget(target, lambda.appView.dexItemFactory());
+          break;
+        }
       case INVOKE_INTERFACE:
         throw new Unreachable("Accessor for an interface method?");
       default:
         throw new Unreachable();
     }
-  }
-
-  @Override
-  protected void prepareInstructions() {
-    DexMethod implMethod = descriptor().implHandle.asMethod();
-    DexType[] accessorParams = proto.parameters.values;
-
-    // Prepare call arguments.
-    List<ValueType> argValueTypes = new ArrayList<>();
-    List<Integer> argRegisters = new ArrayList<>();
-
-    // If we are delegating to a constructor, we need to create the instance
-    // first. This instance will be the first argument to the call.
-    if (delegatingToConstructor()) {
-      int instance = nextRegister(ValueType.OBJECT);
-      add(builder -> builder.addNewInstance(instance, implMethod.holder));
-      argValueTypes.add(ValueType.OBJECT);
-      argRegisters.add(instance);
-    }
-
-    for (int i = 0; i < accessorParams.length; i++) {
-      DexType param = accessorParams[i];
-      argValueTypes.add(ValueType.fromDexType(param));
-      argRegisters.add(getParamRegister(i));
-    }
-
-    // Method call to the original impl-method.
-    // Mirroring assert in constructor, we never need accessors to interfaces.
-    assert !descriptor().implHandle.type.isInvokeInterface();
-    add(
-        builder ->
-            builder.addInvoke(
-                inferInvokeType(),
-                implMethod,
-                implMethod.proto,
-                argValueTypes,
-                argRegisters,
-                false /* isInterface */));
-
-    // Does the method have return value?
-    if (proto.returnType == factory().voidType) {
-      add(IRBuilder::addReturn);
-    } else if (delegatingToConstructor()) {
-      // Return newly created instance
-      add(builder -> builder.addReturn(argRegisters.get(0)));
-    } else {
-      ValueType valueType = ValueType.fromDexType(proto.returnType);
-      int tempValue = nextRegister(valueType);
-      add(builder -> builder.addMoveResult(tempValue));
-      add(builder -> builder.addReturn(tempValue));
-    }
+    return forwardMethodBuilder.build();
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
index 6dc372e..99bad27 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
@@ -9,6 +9,7 @@
 import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.CfCode;
 import com.android.tools.r8.graph.Code;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexItemFactory;
@@ -1397,7 +1398,7 @@
 
   private interface TemplateMethodFactory {
 
-    Code create(InternalOptions options, DexMethod method);
+    CfCode create(InternalOptions options, DexMethod method);
   }
 
   private interface MethodInvokeRewriter {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CovariantReturnTypeAnnotationTransformer.java b/src/main/java/com/android/tools/r8/ir/desugar/CovariantReturnTypeAnnotationTransformer.java
index 4d5c7be..01fb238 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CovariantReturnTypeAnnotationTransformer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CovariantReturnTypeAnnotationTransformer.java
@@ -22,10 +22,8 @@
 import com.android.tools.r8.graph.DexValue.DexValueType;
 import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.ir.code.Invoke;
 import com.android.tools.r8.ir.conversion.IRConverter;
-import com.android.tools.r8.ir.synthetic.ForwardMethodSourceCode;
-import com.android.tools.r8.ir.synthetic.SynthesizedCode;
+import com.android.tools.r8.ir.synthetic.ForwardMethodBuilder;
 import com.google.common.base.Predicates;
 import java.util.HashSet;
 import java.util.LinkedList;
@@ -111,12 +109,13 @@
       DexProgramClass clazz,
       List<DexEncodedMethod> methodsWithCovariantReturnTypeAnnotation,
       List<DexEncodedMethod> covariantReturnTypeMethods) {
-    for (DexEncodedMethod method : clazz.virtualMethods()) {
-      if (methodHasCovariantReturnTypeAnnotation(method)) {
-        methodsWithCovariantReturnTypeAnnotation.add(method);
-        buildCovariantReturnTypeMethodsForMethod(clazz, method, covariantReturnTypeMethods);
-      }
-    }
+    clazz.forEachProgramVirtualMethod(
+        method -> {
+          if (methodHasCovariantReturnTypeAnnotation(method.getDefinition())) {
+            methodsWithCovariantReturnTypeAnnotation.add(method.getDefinition());
+            buildCovariantReturnTypeMethodsForMethod(method, covariantReturnTypeMethods);
+          }
+        });
   }
 
   private boolean methodHasCovariantReturnTypeAnnotation(DexEncodedMethod method) {
@@ -132,13 +131,11 @@
   // variantReturnTypes annotations on the given method. Adds the newly constructed, synthetic
   // methods to the list covariantReturnTypeMethods.
   private void buildCovariantReturnTypeMethodsForMethod(
-      DexProgramClass clazz,
-      DexEncodedMethod method,
-      List<DexEncodedMethod> covariantReturnTypeMethods) {
-    assert methodHasCovariantReturnTypeAnnotation(method);
-    for (DexType covariantReturnType : getCovariantReturnTypes(clazz, method)) {
+      ProgramMethod method, List<DexEncodedMethod> covariantReturnTypeMethods) {
+    assert methodHasCovariantReturnTypeAnnotation(method.getDefinition());
+    for (DexType covariantReturnType : getCovariantReturnTypes(method)) {
       DexEncodedMethod covariantReturnTypeMethod =
-          buildCovariantReturnTypeMethod(clazz, method, covariantReturnType);
+          buildCovariantReturnTypeMethod(method, covariantReturnType);
       covariantReturnTypeMethods.add(covariantReturnTypeMethod);
     }
   }
@@ -149,32 +146,35 @@
   //
   // Note: any "synchronized" or "strictfp" modifier could be dropped safely.
   private DexEncodedMethod buildCovariantReturnTypeMethod(
-      DexProgramClass clazz, DexEncodedMethod method, DexType covariantReturnType) {
+      ProgramMethod method, DexType covariantReturnType) {
+    DexProgramClass methodHolder = method.getHolder();
+    DexMethod methodReference = method.getReference();
+    DexEncodedMethod methodDefinition = method.getDefinition();
     DexProto newProto =
         factory.createProto(
-            covariantReturnType, method.method.proto.parameters, method.method.proto.shorty);
-    MethodAccessFlags newAccessFlags = method.accessFlags.copy();
+            covariantReturnType, methodReference.proto.parameters, methodReference.proto.shorty);
+    MethodAccessFlags newAccessFlags = methodDefinition.accessFlags.copy();
     newAccessFlags.setBridge();
     newAccessFlags.setSynthetic();
-    DexMethod newMethod = factory.createMethod(method.holder(), newProto, method.method.name);
-    ForwardMethodSourceCode.Builder forwardSourceCodeBuilder =
-        ForwardMethodSourceCode.builder(newMethod);
-    forwardSourceCodeBuilder
-        .setReceiver(clazz.type)
-        .setTargetReceiver(method.holder())
-        .setTarget(method.method)
-        .setInvokeType(Invoke.Type.VIRTUAL)
-        .setCastResult();
+    DexMethod newMethod =
+        factory.createMethod(methodHolder.getType(), newProto, methodReference.getName());
+    ForwardMethodBuilder forwardMethodBuilder =
+        ForwardMethodBuilder.builder(factory)
+            .setNonStaticSource(newMethod)
+            .setVirtualTarget(methodReference, methodHolder.isInterface())
+            .setCastResult();
     DexEncodedMethod newVirtualMethod =
         new DexEncodedMethod(
             newMethod,
             newAccessFlags,
-            method.annotations().keepIf(x -> !isCovariantReturnTypeAnnotation(x.annotation)),
-            method.parameterAnnotationsList.keepIf(Predicates.alwaysTrue()),
-            new SynthesizedCode(forwardSourceCodeBuilder::build),
+            methodDefinition
+                .annotations()
+                .keepIf(x -> !isCovariantReturnTypeAnnotation(x.annotation)),
+            methodDefinition.parameterAnnotationsList.keepIf(Predicates.alwaysTrue()),
+            forwardMethodBuilder.build(),
             true);
-    // Optimize to generate DexCode instead of SynthesizedCode.
-    ProgramMethod programMethod = new ProgramMethod(clazz, newVirtualMethod);
+    // Optimize to generate DexCode instead of CfCode.
+    ProgramMethod programMethod = new ProgramMethod(methodHolder, newVirtualMethod);
     converter.optimizeSynthesizedMethod(programMethod);
     return newVirtualMethod;
   }
@@ -187,12 +187,15 @@
   //   @Override
   //   public Foo foo() { ... return new SubOfSubOfFoo(); }
   // then this method returns the set { SubOfFoo, SubOfSubOfFoo }.
-  private Set<DexType> getCovariantReturnTypes(DexClass clazz, DexEncodedMethod method) {
+  private Set<DexType> getCovariantReturnTypes(ProgramMethod method) {
     Set<DexType> covariantReturnTypes = new HashSet<>();
-    for (DexAnnotation annotation : method.annotations().annotations) {
+    for (DexAnnotation annotation : method.getDefinition().annotations().annotations) {
       if (isCovariantReturnTypeAnnotation(annotation.annotation)) {
         getCovariantReturnTypesFromAnnotation(
-            clazz, method, annotation.annotation, covariantReturnTypes);
+            method.getHolder(),
+            method.getDefinition(),
+            annotation.annotation,
+            covariantReturnTypes);
       }
     }
     return covariantReturnTypes;
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
index 67d389f..069f4b3 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
@@ -32,8 +32,7 @@
 import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.graph.ParameterAnnotationsList;
 import com.android.tools.r8.ir.code.Invoke.Type;
-import com.android.tools.r8.ir.synthetic.ForwardMethodSourceCode;
-import com.android.tools.r8.ir.synthetic.SynthesizedCode;
+import com.android.tools.r8.ir.synthetic.ForwardMethodBuilder;
 import com.android.tools.r8.origin.SynthesizedOrigin;
 import com.android.tools.r8.utils.Pair;
 import com.google.common.collect.BiMap;
@@ -260,15 +259,13 @@
 
       DexMethod origMethod = direct.method;
       DexMethod newMethod = rewriter.staticAsMethodOfDispatchClass(origMethod);
-      ForwardMethodSourceCode.Builder forwardSourceCodeBuilder =
-          ForwardMethodSourceCode.builder(newMethod);
       // Create a forwarding method to the library static interface method. The method is added
       // to the dispatch class, however, the targeted method is still on the interface, so the
       // interface bit should be set to true.
-      forwardSourceCodeBuilder
-          .setTarget(origMethod)
-          .setInvokeType(Type.STATIC)
-          .setIsInterface(true);
+      ForwardMethodBuilder forwardMethodBuilder =
+          ForwardMethodBuilder.builder(appView.dexItemFactory())
+              .setStaticSource(newMethod)
+              .setStaticTarget(origMethod, true);
       DexEncodedMethod newEncodedMethod =
           new DexEncodedMethod(
               newMethod,
@@ -276,7 +273,7 @@
                   Constants.ACC_PUBLIC | Constants.ACC_STATIC | Constants.ACC_SYNTHETIC, false),
               DexAnnotationSet.empty(),
               ParameterAnnotationsList.empty(),
-              new SynthesizedCode(forwardSourceCodeBuilder::build),
+              forwardMethodBuilder.build(),
               true);
       newEncodedMethod.getMutableOptimizationInfo().markNeverInline();
       dispatchMethods.add(newEncodedMethod);
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaAccessorMethodWithSynthesizedCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaAccessorMethodWithSynthesizedCode.java
deleted file mode 100644
index a733540..0000000
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaAccessorMethodWithSynthesizedCode.java
+++ /dev/null
@@ -1,44 +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.desugar;
-
-import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexMethodHandle;
-import com.android.tools.r8.graph.UseRegistry;
-import java.util.function.Consumer;
-
-public class LambdaAccessorMethodWithSynthesizedCode extends LambdaSynthesizedCode {
-
-  public LambdaAccessorMethodWithSynthesizedCode(LambdaClass lambda) {
-    super(lambda);
-  }
-
-  @Override
-  public SourceCodeProvider getSourceCodeProvider() {
-    return callerPosition -> new AccessorMethodSourceCode(lambda, callerPosition);
-  }
-
-  @Override
-  public Consumer<UseRegistry> getRegistryCallback() {
-    return registry -> {
-      DexMethodHandle handle = lambda.descriptor.implHandle;
-      DexMethod target = handle.asMethod();
-      switch (handle.type) {
-        case INVOKE_STATIC:
-          registry.registerInvokeStatic(target);
-          break;
-        case INVOKE_INSTANCE:
-          registry.registerInvokeVirtual(target);
-          break;
-        case INVOKE_CONSTRUCTOR:
-        case INVOKE_DIRECT:
-          registry.registerInvokeDirect(target);
-          break;
-        default:
-          throw new Unreachable("Unexpected handle type: " + handle.type);
-      }
-    };
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaBridgeMethodSourceCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaBridgeMethodSourceCode.java
index f0eb914..ddcdc6e 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaBridgeMethodSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaBridgeMethodSourceCode.java
@@ -4,71 +4,21 @@
 
 package com.android.tools.r8.ir.desugar;
 
+import com.android.tools.r8.graph.CfCode;
 import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.code.Invoke;
-import com.android.tools.r8.ir.code.Position;
-import com.android.tools.r8.ir.code.ValueType;
-import com.android.tools.r8.ir.conversion.IRBuilder;
-import java.util.ArrayList;
-import java.util.List;
+import com.android.tools.r8.ir.synthetic.ForwardMethodBuilder;
 
 // Source code representing synthesized lambda bridge method.
-final class LambdaBridgeMethodSourceCode extends SynthesizedLambdaSourceCode {
 
-  private final DexMethod mainMethod;
+final class LambdaBridgeMethodSourceCode {
 
-  LambdaBridgeMethodSourceCode(
-      LambdaClass lambda, DexMethod mainMethod, DexMethod bridgeMethod, Position callerPosition) {
-    super(lambda, bridgeMethod, callerPosition);
-    this.mainMethod = mainMethod;
-  }
-
-  @Override
-  protected void prepareInstructions() {
-    DexType[] currentParams = proto.parameters.values;
-    DexType[] enforcedParams = descriptor().enforcedProto.parameters.values;
-
-    // Prepare call arguments.
-    List<ValueType> argValueTypes = new ArrayList<>();
-    List<Integer> argRegisters = new ArrayList<>();
-
-    // Always add a receiver representing 'this' of the lambda class.
-    argValueTypes.add(ValueType.OBJECT);
-    argRegisters.add(getReceiverRegister());
-
-    // Prepare arguments.
-    for (int i = 0; i < currentParams.length; i++) {
-      DexType expectedParamType = enforcedParams[i];
-      argValueTypes.add(ValueType.fromDexType(expectedParamType));
-      argRegisters.add(enforceParameterType(
-          getParamRegister(i), currentParams[i], expectedParamType));
-    }
-
-    // Method call to the main functional interface method.
-    add(
-        builder ->
-            builder.addInvoke(
-                Invoke.Type.VIRTUAL,
-                this.mainMethod,
-                this.mainMethod.proto,
-                argValueTypes,
-                argRegisters,
-                false /* isInterface */));
-
-    // Does the method have return value?
-    if (proto.returnType == factory().voidType) {
-      add(IRBuilder::addReturn);
-    } else {
-      ValueType valueType = ValueType.fromDexType(proto.returnType);
-      int tempValue = nextRegister(valueType);
-      add(builder -> builder.addMoveResult(tempValue));
-      // We lack precise sub-type information, but there should not be a need to cast to object.
-      if (proto.returnType != mainMethod.proto.returnType
-          && proto.returnType != factory().objectType) {
-        add(builder -> builder.addCheckCast(tempValue, proto.returnType));
-      }
-      add(builder -> builder.addReturn(tempValue));
-    }
+  public static CfCode build(
+      LambdaClass lambdaClass, DexMethod bridgeMethod, DexMethod mainMethod) {
+    return ForwardMethodBuilder.builder(lambdaClass.appView.dexItemFactory())
+        .setNonStaticSource(bridgeMethod)
+        .setVirtualTarget(mainMethod, false)
+        .setCastArguments(lambdaClass.appView.appInfoForDesugaring())
+        .setCastResult()
+        .build();
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaBridgeMethodSynthesizedCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaBridgeMethodSynthesizedCode.java
deleted file mode 100644
index 6e109dd..0000000
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaBridgeMethodSynthesizedCode.java
+++ /dev/null
@@ -1,43 +0,0 @@
-// 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.ir.desugar;
-
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.UseRegistry;
-import java.util.function.Consumer;
-
-class LambdaBridgeMethodSynthesizedCode extends LambdaSynthesizedCode {
-
-  private final DexMethod mainMethod;
-  private final DexMethod bridgeMethod;
-
-  LambdaBridgeMethodSynthesizedCode(
-      LambdaClass lambda, DexMethod mainMethod, DexMethod bridgeMethod) {
-    super(lambda);
-    this.mainMethod = mainMethod;
-    this.bridgeMethod = bridgeMethod;
-  }
-
-  @Override
-  public SourceCodeProvider getSourceCodeProvider() {
-    return callerPosition ->
-        new LambdaBridgeMethodSourceCode(lambda, mainMethod, bridgeMethod, callerPosition);
-  }
-
-  @Override
-  public Consumer<UseRegistry> getRegistryCallback() {
-    return registry -> {
-      registry.registerInvokeVirtual(mainMethod);
-
-      DexType bridgeMethodReturnType = bridgeMethod.proto.returnType;
-      if (!bridgeMethodReturnType.isVoidType()
-          && bridgeMethodReturnType != mainMethod.proto.returnType
-          && bridgeMethodReturnType != dexItemFactory().objectType) {
-        registry.registerCheckCast(bridgeMethodReturnType);
-      }
-    };
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
index cc6fec7..73b78aa2 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
@@ -234,7 +234,7 @@
                 Constants.ACC_PUBLIC | Constants.ACC_FINAL, false),
             DexAnnotationSet.empty(),
             ParameterAnnotationsList.empty(),
-            new LambdaMainMethodSynthesizedCode(this, mainMethod),
+            LambdaMainMethodSourceCode.build(this, mainMethod),
             true);
 
     // Synthesize bridge methods.
@@ -252,7 +252,7 @@
                   false),
               DexAnnotationSet.empty(),
               ParameterAnnotationsList.empty(),
-              new LambdaBridgeMethodSynthesizedCode(this, mainMethod, bridgeMethod),
+              LambdaBridgeMethodSourceCode.build(this, bridgeMethod, mainMethod),
               true);
     }
     return methods;
@@ -273,7 +273,7 @@
                 true),
             DexAnnotationSet.empty(),
             ParameterAnnotationsList.empty(),
-            new LambdaConstructorSynthesizedCode(this),
+            LambdaConstructorSourceCode.build(this),
             true);
 
     // Class constructor for stateless lambda classes.
@@ -285,7 +285,7 @@
                   Constants.ACC_SYNTHETIC | Constants.ACC_STATIC, true),
               DexAnnotationSet.empty(),
               ParameterAnnotationsList.empty(),
-              new LambdaClassConstructorSynthesizedCode(this),
+              LambdaClassConstructorSourceCode.build(this),
               true);
     }
     return methods;
@@ -748,13 +748,14 @@
           MethodAccessFlags.fromSharedAccessFlags(
               Constants.ACC_SYNTHETIC | Constants.ACC_STATIC | Constants.ACC_PUBLIC,
               false);
+
       DexEncodedMethod accessorEncodedMethod =
           new DexEncodedMethod(
               callTarget,
               accessorFlags,
               DexAnnotationSet.empty(),
               ParameterAnnotationsList.empty(),
-              new LambdaAccessorMethodWithSynthesizedCode(LambdaClass.this),
+              AccessorMethodSourceCode.build(LambdaClass.this, callTarget),
               true);
 
       // We may arrive here concurrently so we need must update the methods of the class atomically.
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClassConstructorSourceCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClassConstructorSourceCode.java
index 6b85039..fd7a8b9 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClassConstructorSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClassConstructorSourceCode.java
@@ -4,40 +4,34 @@
 
 package com.android.tools.r8.ir.desugar;
 
-import com.android.tools.r8.ir.code.Invoke;
-import com.android.tools.r8.ir.code.Position;
-import com.android.tools.r8.ir.code.ValueType;
-import com.android.tools.r8.ir.conversion.IRBuilder;
+import com.android.tools.r8.cf.code.CfFieldInstruction;
+import com.android.tools.r8.cf.code.CfInvoke;
+import com.android.tools.r8.cf.code.CfNew;
+import com.android.tools.r8.cf.code.CfReturnVoid;
+import com.android.tools.r8.cf.code.CfStackInstruction;
+import com.android.tools.r8.cf.code.CfStackInstruction.Opcode;
+import com.android.tools.r8.graph.CfCode;
 import com.google.common.collect.ImmutableList;
+import org.objectweb.asm.Opcodes;
 
 // Source code representing synthesized lambda class constructor.
 // Used for stateless lambdas to instantiate singleton instance.
-final class LambdaClassConstructorSourceCode extends SynthesizedLambdaSourceCode {
+final class LambdaClassConstructorSourceCode {
 
-  LambdaClassConstructorSourceCode(LambdaClass lambda, Position callerPosition) {
-    super(lambda, lambda.classConstructor, callerPosition, null /* Class initializer is static */);
-    assert lambda.lambdaField != null;
-  }
-
-  @Override
-  protected void prepareInstructions() {
-    // Create and initialize an instance.
-    int instance = nextRegister(ValueType.OBJECT);
-    add(builder -> builder.addNewInstance(instance, lambda.type));
-    add(
-        builder ->
-            builder.addInvoke(
-                Invoke.Type.DIRECT,
-                lambda.constructor,
-                lambda.constructor.proto,
-                ImmutableList.of(ValueType.OBJECT),
-                ImmutableList.of(instance),
-                false /* isInterface */));
-
-    // Assign to a field.
-    add(builder -> builder.addStaticPut(instance, lambda.lambdaField));
-
-    // Final return.
-    add(IRBuilder::addReturn);
+  public static CfCode build(LambdaClass lambda) {
+    int maxStack = 2;
+    int maxLocals = 0;
+    return new CfCode(
+        lambda.type,
+        maxStack,
+        maxLocals,
+        ImmutableList.of(
+            new CfNew(lambda.type),
+            new CfStackInstruction(Opcode.Dup),
+            new CfInvoke(Opcodes.INVOKESPECIAL, lambda.constructor, false),
+            new CfFieldInstruction(Opcodes.PUTSTATIC, lambda.lambdaField, lambda.lambdaField),
+            new CfReturnVoid()),
+        ImmutableList.of(),
+        ImmutableList.of());
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClassConstructorSynthesizedCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClassConstructorSynthesizedCode.java
deleted file mode 100644
index 2dbac91..0000000
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClassConstructorSynthesizedCode.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// 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.ir.desugar;
-
-import com.android.tools.r8.graph.UseRegistry;
-import java.util.function.Consumer;
-
-class LambdaClassConstructorSynthesizedCode extends LambdaSynthesizedCode {
-
-  LambdaClassConstructorSynthesizedCode(LambdaClass lambda) {
-    super(lambda);
-  }
-
-  @Override
-  public SourceCodeProvider getSourceCodeProvider() {
-    return callerPosition -> new LambdaClassConstructorSourceCode(lambda, callerPosition);
-  }
-
-  @Override
-  public Consumer<UseRegistry> getRegistryCallback() {
-    return registry -> {
-      registry.registerNewInstance(lambda.type);
-      registry.registerInvokeDirect(lambda.constructor);
-      registry.registerStaticFieldWrite(lambda.lambdaField);
-    };
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaConstructorSourceCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaConstructorSourceCode.java
index a8161d4..65ead77 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaConstructorSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaConstructorSourceCode.java
@@ -4,70 +4,56 @@
 
 package com.android.tools.r8.ir.desugar;
 
+import com.android.tools.r8.cf.code.CfFieldInstruction;
+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.CfReturnVoid;
+import com.android.tools.r8.cf.code.CfTryCatch;
+import com.android.tools.r8.graph.CfCode;
 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.ir.code.Invoke;
-import com.android.tools.r8.ir.code.Position;
-import com.android.tools.r8.ir.conversion.IRBuilder;
-import java.util.Collections;
-
 // Source code representing synthesized lambda constructor.
-final class LambdaConstructorSourceCode extends SynthesizedLambdaSourceCode {
+import com.android.tools.r8.ir.code.ValueType;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableList.Builder;
+import org.objectweb.asm.Opcodes;
 
-  LambdaConstructorSourceCode(LambdaClass lambda, Position callerPosition) {
-    super(lambda, lambda.constructor, callerPosition);
-  }
+final class LambdaConstructorSourceCode {
 
-  @Override
-  protected void prepareInstructions() {
+  public static CfCode build(LambdaClass lambda) {
+    int maxStack = 1;
+    ImmutableList<CfTryCatch> tryCatchRanges = ImmutableList.of();
+    ImmutableList<CfCode.LocalVariableInfo> localVariables = ImmutableList.of();
+    Builder<CfInstruction> instructions = ImmutableList.builder();
     // Super constructor call (always java.lang.Object.<init>()).
-    DexMethod objectInitMethod = factory().objectMembers.constructor;
-    add(
-        builder -> {
-          assert builder.getReceiverValue() != null;
-          builder.addInvoke(
-              Invoke.Type.DIRECT,
-              objectInitMethod,
-              objectInitMethod.proto,
-              Collections.singletonList(builder.getReceiverValue()),
-              false /* isInterface */);
-        });
-
+    instructions.add(new CfLoad(ValueType.OBJECT, 0));
+    instructions.add(
+        new CfInvoke(
+            Opcodes.INVOKESPECIAL,
+            lambda.appView.dexItemFactory().objectMembers.constructor,
+            false));
     // Assign capture fields.
-    DexType[] capturedTypes = captures();
-    int capturedValues = capturedTypes.length;
-    if (capturedValues > 0) {
-      for (int i = 0; i < capturedValues; i++) {
-        DexField field = lambda.getCaptureField(i);
-        int idx = i;
-        add(builder -> builder.addInstancePut(getParamRegister(idx), getReceiverRegister(), field));
-      }
+    DexType[] capturedTypes = lambda.descriptor.captures.values;
+    int maxLocals = 1;
+    for (int i = 0; i < capturedTypes.length; i++) {
+      DexField field = lambda.getCaptureField(i);
+      assert field.type == capturedTypes[i];
+      ValueType type = ValueType.fromDexType(field.type);
+      instructions.add(new CfLoad(ValueType.OBJECT, 0));
+      instructions.add(new CfLoad(type, maxLocals));
+      instructions.add(new CfFieldInstruction(Opcodes.PUTFIELD, field, field));
+      maxLocals += type.requiredRegisters();
+      maxStack += type.requiredRegisters();
     }
-
     // Final return.
-    add(IRBuilder::addReturn);
-  }
-
-  @Override
-  public int hashCode() {
-    // We want all zero-parameter constructor source code instances to
-    // be treated as equal, since it only has one call to super constructor,
-    // which is always java.lang.Object.<init>().
-    return captures().length == 0
-        ? System.identityHashCode(factory().objectMembers.constructor)
-        : super.hashCode();
-  }
-
-  @Override
-  public boolean equals(Object obj) {
-    if (!(obj instanceof LambdaConstructorSourceCode)) {
-      return false;
-    }
-    if (captures().length == 0) {
-      // See comment in hashCode().
-      return ((LambdaConstructorSourceCode) obj).captures().length == 0;
-    }
-    return super.equals(obj);
+    instructions.add(new CfReturnVoid());
+    return new CfCode(
+        lambda.constructor.holder,
+        maxStack,
+        maxLocals,
+        instructions.build(),
+        tryCatchRanges,
+        localVariables);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaConstructorSynthesizedCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaConstructorSynthesizedCode.java
deleted file mode 100644
index 1809d69..0000000
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaConstructorSynthesizedCode.java
+++ /dev/null
@@ -1,32 +0,0 @@
-// 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.ir.desugar;
-
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.UseRegistry;
-import java.util.function.Consumer;
-
-class LambdaConstructorSynthesizedCode extends LambdaSynthesizedCode {
-
-  LambdaConstructorSynthesizedCode(LambdaClass lambda) {
-    super(lambda);
-  }
-
-  @Override
-  public SourceCodeProvider getSourceCodeProvider() {
-    return callerPosition -> new LambdaConstructorSourceCode(lambda, callerPosition);
-  }
-
-  @Override
-  public Consumer<UseRegistry> getRegistryCallback() {
-    return registry -> {
-      registry.registerInvokeDirect(dexItemFactory().objectMembers.constructor);
-      DexType[] capturedTypes = captures();
-      for (int i = 0; i < capturedTypes.length; i++) {
-        registry.registerInstanceFieldWrite(lambda.getCaptureField(i));
-      }
-    };
-  }
-}
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 ac55e68..30ea01c 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
@@ -4,7 +4,21 @@
 
 package com.android.tools.r8.ir.desugar;
 
+import com.android.tools.r8.cf.code.CfCheckCast;
+import com.android.tools.r8.cf.code.CfFieldInstruction;
+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.CfNew;
+import com.android.tools.r8.cf.code.CfNumberConversion;
+import com.android.tools.r8.cf.code.CfReturn;
+import com.android.tools.r8.cf.code.CfReturnVoid;
+import com.android.tools.r8.cf.code.CfStackInstruction;
+import com.android.tools.r8.cf.code.CfStackInstruction.Opcode;
+import com.android.tools.r8.cf.code.CfThrow;
+import com.android.tools.r8.cf.code.CfTryCatch;
 import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.CfCode;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
@@ -12,27 +26,25 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.code.Invoke;
 import com.android.tools.r8.ir.code.NumericType;
-import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.ValueType;
-import com.android.tools.r8.ir.conversion.IRBuilder;
 import com.android.tools.r8.ir.desugar.LambdaClass.InvalidLambdaImplTarget;
-import com.android.tools.r8.ir.synthetic.ExceptionThrowingSourceCode;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableList.Builder;
 import com.google.common.collect.Lists;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
+import org.objectweb.asm.Opcodes;
 
 // Source code representing synthesized lambda main method
-final class LambdaMainMethodSourceCode extends SynthesizedLambdaSourceCode {
+final class LambdaMainMethodSourceCode {
 
-  LambdaMainMethodSourceCode(LambdaClass lambda, DexMethod mainMethod, Position callerPosition) {
-    super(lambda, mainMethod, callerPosition);
-  }
-
-  private boolean checkSignatures(
-      DexType[] captures, DexType[] enforcedParams, DexType enforcedReturnType,
-      List<DexType> implReceiverAndArgs, DexType implReturnType) {
+  private static boolean checkSignatures(
+      DexType[] captures,
+      DexType[] enforcedParams,
+      DexType enforcedReturnType,
+      List<DexType> implReceiverAndArgs,
+      DexType implReturnType,
+      DexItemFactory factory) {
     List<DexType> capturesAndParams = new ArrayList<>();
     capturesAndParams.addAll(Lists.newArrayList(captures));
     capturesAndParams.addAll(Lists.newArrayList(enforcedParams));
@@ -43,23 +55,19 @@
     }
 
     for (int i = 0; i < size; i++) {
-      if (!isSameOrAdaptableTo(capturesAndParams.get(i), implReceiverAndArgs.get(i))) {
+      if (!isSameOrAdaptableTo(capturesAndParams.get(i), implReceiverAndArgs.get(i), factory)) {
         assert false;
       }
     }
 
     if (!enforcedReturnType.isVoidType()
-        && !isSameOrAdaptableTo(implReturnType, enforcedReturnType)) {
+        && !isSameOrAdaptableTo(implReturnType, enforcedReturnType, factory)) {
       assert false;
     }
     return true;
   }
 
-  private DexType getPrimitiveFromBoxed(DexType boxedPrimitive) {
-    return factory().getPrimitiveFromBoxed(boxedPrimitive);
-  }
-
-  private DexType getBoxedForPrimitiveType(DexType primitive) {
+  private static DexType getBoxedForPrimitiveType(DexType primitive, DexItemFactory factory) {
     switch (primitive.descriptor.content[0]) {
       case 'Z':  // byte
       case 'B':  // byte
@@ -69,19 +77,18 @@
       case 'J':  // long
       case 'F':  // float
       case 'D':  // double
-        return factory().getBoxedForPrimitiveType(primitive);
+        return factory.getBoxedForPrimitiveType(primitive);
       default:
         throw new Unreachable("Invalid primitive type descriptor: " + primitive);
     }
   }
 
   // Checks if the types are the same OR type `a` is adaptable to type `b`.
-  private boolean isSameOrAdaptableTo(DexType a, DexType b) {
+  private static boolean isSameOrAdaptableTo(DexType a, DexType b, DexItemFactory factory) {
     if (a == b) {
       return true;
     }
 
-    DexItemFactory factory = factory();
     if (a.isArrayType()) {
       // Arrays are only adaptable to java.lang.Object or other arrays, note that we
       // don't check element type inheritance in the second case since we assume the
@@ -100,7 +107,7 @@
       }
 
       // `a` is primitive and `b` is a supertype of the boxed type `a`.
-      DexType boxedPrimitiveType = getBoxedForPrimitiveType(a);
+      DexType boxedPrimitiveType = getBoxedForPrimitiveType(a, factory);
       if (b == boxedPrimitiveType ||
           b == factory.objectType ||
           b == factory.serializableType ||
@@ -120,7 +127,7 @@
       }
       // `a` is a boxed type for `a*` which can be
       // widened to primitive type `b`.
-      DexType unboxedA = getPrimitiveFromBoxed(a);
+      DexType unboxedA = factory.getPrimitiveFromBoxed(a);
       return unboxedA != null &&
           isSameOrAdaptableTo(unboxedA.descriptor.content[0], b.descriptor.content[0]);
     }
@@ -135,7 +142,7 @@
 
   // For two primitive types `a` is adjustable to `b` iff `a` is the same as `b`
   // or can be converted to `b` via a primitive widening conversion.
-  private boolean isSameOrAdaptableTo(byte from, byte to) {
+  private static boolean isSameOrAdaptableTo(byte from, byte to) {
     if (from == to) {
       return true;
     }
@@ -159,33 +166,31 @@
     }
   }
 
-  @Override
-  protected void prepareInstructions() {
-    DexType[] capturedTypes = captures();
-    DexType[] erasedParams = descriptor().erasedProto.parameters.values;
-    DexType erasedReturnType = descriptor().erasedProto.returnType;
-    DexType[] enforcedParams = descriptor().enforcedProto.parameters.values;
-    DexType enforcedReturnType = descriptor().enforcedProto.returnType;
-
+  public static CfCode build(LambdaClass lambda, DexMethod mainMethod) {
+    DexItemFactory factory = lambda.appView.dexItemFactory();
     LambdaClass.Target target = lambda.target;
     if (target instanceof InvalidLambdaImplTarget) {
-      add(
-          builder -> {
-            InvalidLambdaImplTarget invalidTarget = (InvalidLambdaImplTarget) target;
-            ExceptionThrowingSourceCode.build(builder, invalidTarget.exceptionType);
-          });
-      return;
+      InvalidLambdaImplTarget invalidTarget = (InvalidLambdaImplTarget) target;
+      DexType exceptionType = invalidTarget.exceptionType;
+      return buildThrowingCode(mainMethod, exceptionType, factory);
     }
 
     DexMethod methodToCall = target.callTarget;
+    DexType[] capturedTypes = lambda.descriptor.captures.values;
+    DexType[] erasedParams = lambda.descriptor.erasedProto.parameters.values;
+    DexType erasedReturnType = lambda.descriptor.erasedProto.returnType;
+    DexType[] enforcedParams = lambda.descriptor.enforcedProto.parameters.values;
+    DexType enforcedReturnType = lambda.descriptor.enforcedProto.returnType;
 
     // Only constructor call should use direct invoke type since super
     // and private methods require accessor methods.
     boolean constructorTarget = target.invokeType == Invoke.Type.DIRECT;
-    assert !constructorTarget || methodToCall.name == factory().constructorMethodName;
+    assert !constructorTarget || methodToCall.name == factory.constructorMethodName;
 
+    boolean targetWithReceiver =
+        target.invokeType == Invoke.Type.VIRTUAL || target.invokeType == Invoke.Type.INTERFACE;
     List<DexType> implReceiverAndArgs = new ArrayList<>();
-    if (target.invokeType == Invoke.Type.VIRTUAL || target.invokeType == Invoke.Type.INTERFACE) {
+    if (targetWithReceiver) {
       implReceiverAndArgs.add(methodToCall.holder);
     }
     implReceiverAndArgs.addAll(Lists.newArrayList(methodToCall.proto.parameters.values));
@@ -195,87 +200,129 @@
         || target.invokeType == Invoke.Type.VIRTUAL
         || target.invokeType == Invoke.Type.DIRECT
         || target.invokeType == Invoke.Type.INTERFACE;
-    assert checkSignatures(capturedTypes, enforcedParams,
-        enforcedReturnType, implReceiverAndArgs,
-        constructorTarget ? target.callTarget.holder : implReturnType);
+    assert checkSignatures(
+        capturedTypes,
+        enforcedParams,
+        enforcedReturnType,
+        implReceiverAndArgs,
+        constructorTarget ? target.callTarget.holder : implReturnType,
+        factory);
 
-    // Prepare call arguments.
-    List<ValueType> argValueTypes = new ArrayList<>();
-    List<Integer> argRegisters = new ArrayList<>();
+    int maxStack = 0;
+    Builder<CfInstruction> instructions = ImmutableList.builder();
 
     // If the target is a constructor, we need to create the instance first.
-    // This instance will be the first argument to the call.
+    // This instance will be the first argument to the call and the dup will be on stack at return.
     if (constructorTarget) {
-      int instance = nextRegister(ValueType.OBJECT);
-      add(builder -> builder.addNewInstance(instance, methodToCall.holder));
-      argValueTypes.add(ValueType.OBJECT);
-      argRegisters.add(instance);
+      instructions.add(new CfNew(methodToCall.holder));
+      instructions.add(new CfStackInstruction(Opcode.Dup));
+      maxStack += 2;
     }
 
     // Load captures if needed.
     int capturedValues = capturedTypes.length;
     for (int i = 0; i < capturedValues; i++) {
-      ValueType valueType = ValueType.fromDexType(capturedTypes[i]);
-      int register = nextRegister(valueType);
-
-      argValueTypes.add(valueType);
-      argRegisters.add(register);
-
-      // Read field into tmp local.
       DexField field = lambda.getCaptureField(i);
-      add(builder -> builder.addInstanceGet(register, getReceiverRegister(), field));
+      ValueType valueType = ValueType.fromDexType(field.type);
+      instructions.add(new CfLoad(ValueType.OBJECT, 0));
+      instructions.add(new CfFieldInstruction(Opcodes.GETFIELD, field, field));
+      maxStack += valueType.requiredRegisters();
     }
 
     // Prepare arguments.
+    int maxLocals = 1; // Local 0 is the lambda/receiver.
     for (int i = 0; i < erasedParams.length; i++) {
+      ValueType valueType = ValueType.fromDexType(mainMethod.getParameters().values[i]);
+      instructions.add(new CfLoad(valueType, maxLocals));
+      maxLocals += valueType.requiredRegisters();
       DexType expectedParamType = implReceiverAndArgs.get(i + capturedValues);
-      argValueTypes.add(ValueType.fromDexType(expectedParamType));
-      argRegisters.add(prepareParameterValue(
-          getParamRegister(i), erasedParams[i], enforcedParams[i], expectedParamType));
+      maxStack =
+          Math.max(
+              maxStack,
+              prepareParameterValue(
+                  erasedParams[i], enforcedParams[i], expectedParamType, instructions, factory));
     }
 
-    // Method call to the method implementing lambda or method-ref.
-    add(
-        builder ->
-            builder.addInvoke(
-                target.invokeType,
-                methodToCall,
-                methodToCall.proto,
-                argValueTypes,
-                argRegisters,
-                target.isInterface()));
+    instructions.add(
+        new CfInvoke(target.invokeType.getCfOpcode(), methodToCall, target.isInterface()));
+    DexType methodToCallReturnType = methodToCall.getReturnType();
+    if (!methodToCallReturnType.isVoidType()) {
+      maxStack =
+          Math.max(maxStack, ValueType.fromDexType(methodToCallReturnType).requiredRegisters());
+    }
 
-    // Does the method have return value?
     if (enforcedReturnType.isVoidType()) {
-      add(IRBuilder::addReturn);
-    } else if (constructorTarget) {
-      // Return newly created instance
-      int instanceRegister = argRegisters.get(0);
-      int adjustedValue = prepareReturnValue(instanceRegister,
-          erasedReturnType, enforcedReturnType, methodToCall.holder);
-      add(builder -> builder.addReturn(adjustedValue));
+      if (!methodToCallReturnType.isVoidType()) {
+        instructions.add(
+            new CfStackInstruction(methodToCallReturnType.isWideType() ? Opcode.Pop2 : Opcode.Pop));
+      }
+      instructions.add(new CfReturnVoid());
     } else {
-      ValueType implValueType = ValueType.fromDexType(implReturnType);
-      int tempValue = nextRegister(implValueType);
-      add(builder -> builder.addMoveResult(tempValue));
-      int adjustedValue = prepareReturnValue(tempValue,
-          erasedReturnType, enforcedReturnType, methodToCall.proto.returnType);
-      add(builder -> builder.addReturn(adjustedValue));
+      // Either the new instance or the called-method result is on top of stack.
+      assert constructorTarget || !methodToCallReturnType.isVoidType();
+      maxStack =
+          Math.max(
+              maxStack,
+              prepareReturnValue(
+                  erasedReturnType,
+                  enforcedReturnType,
+                  constructorTarget ? methodToCall.holder : methodToCallReturnType,
+                  instructions,
+                  factory));
+      instructions.add(new CfReturn(ValueType.fromDexType(enforcedReturnType)));
     }
+
+    ImmutableList<CfTryCatch> tryCatchRanges = ImmutableList.of();
+    ImmutableList<CfCode.LocalVariableInfo> localVariables = ImmutableList.of();
+    CfCode code =
+        new CfCode(
+            mainMethod.holder,
+            maxStack,
+            maxLocals,
+            instructions.build(),
+            tryCatchRanges,
+            localVariables);
+    return code;
+  }
+
+  private static CfCode buildThrowingCode(
+      DexMethod method, DexType exceptionType, DexItemFactory factory) {
+    DexProto initProto = factory.createProto(factory.voidType);
+    DexMethod initMethod =
+        factory.createMethod(exceptionType, initProto, factory.constructorMethodName);
+    int maxStack = 2;
+    int maxLocals = 1;
+    for (DexType param : method.proto.parameters.values) {
+      maxLocals += ValueType.fromDexType(param).requiredRegisters();
+    }
+    ImmutableList<CfTryCatch> tryCatchRanges = ImmutableList.of();
+    ImmutableList<CfCode.LocalVariableInfo> localVariables = ImmutableList.of();
+    return new CfCode(
+        method.holder,
+        maxStack,
+        maxLocals,
+        ImmutableList.of(
+            new CfNew(exceptionType),
+            new CfStackInstruction(Opcode.Dup),
+            new CfInvoke(Opcodes.INVOKESPECIAL, initMethod, false),
+            new CfThrow()),
+        tryCatchRanges,
+        localVariables);
   }
 
   // Adds necessary casts and transformations to adjust the value
   // returned by impl-method to expected return type of the method.
-  private int prepareReturnValue(int register,
-      DexType erasedType, DexType enforcedType, DexType actualType) {
-    // `actualType` must be adjusted to `enforcedType` first.
-    register = adjustType(register, actualType, enforcedType, true);
-
+  private static int prepareReturnValue(
+      DexType erasedType,
+      DexType enforcedType,
+      DexType actualType,
+      Builder<CfInstruction> instructions,
+      DexItemFactory factory) {
     // `erasedType` and `enforcedType` may only differ when they both
     // are class types and `erasedType` is a base type of `enforcedType`,
     // so no transformation is actually needed.
-    assert LambdaDescriptor.isSameOrDerived(factory(), enforcedType, erasedType);
-    return register;
+    assert LambdaDescriptor.isSameOrDerived(factory, enforcedType, erasedType);
+    return adjustType(actualType, enforcedType, true, instructions, factory);
   }
 
   // Adds necessary casts and transformations to adjust parameter
@@ -285,16 +332,50 @@
   // be converted to enforced parameter type (`enforcedType`), which,
   // in its turn, may need to be adjusted to the parameter type of
   // the impl-method (`expectedType`).
-  private int prepareParameterValue(int register,
-      DexType erasedType, DexType enforcedType, DexType expectedType) {
-    register = enforceParameterType(register, erasedType, enforcedType);
-    register = adjustType(register, enforcedType, expectedType, false);
-    return register;
+  private static int prepareParameterValue(
+      DexType erasedType,
+      DexType enforcedType,
+      DexType expectedType,
+      Builder<CfInstruction> instructions,
+      DexItemFactory factory) {
+    enforceParameterType(erasedType, enforcedType, instructions, factory);
+    return adjustType(enforcedType, expectedType, false, instructions, factory);
   }
 
-  private int adjustType(int register, DexType fromType, DexType toType, boolean returnType) {
+  private static void enforceParameterType(
+      DexType paramType,
+      DexType enforcedType,
+      Builder<CfInstruction> instructions,
+      DexItemFactory factory) {
+    // `paramType` must be either same as `enforcedType` or both must be class
+    // types and `enforcedType` must be a subclass of `paramType` in which case
+    // a cast need to be inserted.
+    if (paramType != enforcedType) {
+      assert LambdaDescriptor.isSameOrDerived(factory, enforcedType, paramType);
+      instructions.add(new CfCheckCast(enforcedType));
+    }
+  }
+
+  private static int adjustType(
+      DexType fromType,
+      DexType toType,
+      boolean returnType,
+      Builder<CfInstruction> instructions,
+      DexItemFactory factory) {
+    internalAdjustType(fromType, toType, returnType, instructions, factory);
+    return Math.max(
+        ValueType.fromDexType(fromType).requiredRegisters(),
+        ValueType.fromDexType(toType).requiredRegisters());
+  }
+
+  private static void internalAdjustType(
+      DexType fromType,
+      DexType toType,
+      boolean returnType,
+      Builder<CfInstruction> instructions,
+      DexItemFactory factory) {
     if (fromType == toType) {
-      return register;
+      return;
     }
 
     boolean fromTypePrimitive = fromType.isPrimitiveType();
@@ -302,7 +383,8 @@
 
     // If both are primitive they must be convertible via primitive widening conversion.
     if (fromTypePrimitive && toTypePrimitive) {
-      return addPrimitiveWideningConversion(register, fromType, toType);
+      addPrimitiveWideningConversion(fromType, toType, instructions);
+      return;
     }
 
     // If the first one is a boxed primitive type and the second one is a primitive
@@ -310,62 +392,64 @@
     // widening conversion.
     if (toTypePrimitive) {
       DexType boxedType = fromType;
-      if (boxedType == factory().objectType) {
+      if (boxedType == factory.objectType) {
         // We are in situation when from(=java.lang.Object) is being adjusted to a
         // primitive type, in which case we assume it is of proper box type.
-        boxedType = getBoxedForPrimitiveType(toType);
-        register = castToBoxedType(register, boxedType);
+        boxedType = getBoxedForPrimitiveType(toType, factory);
+        instructions.add(new CfCheckCast(boxedType));
       }
-      DexType fromTypeAsPrimitive = getPrimitiveFromBoxed(boxedType);
+      DexType fromTypeAsPrimitive = factory.getPrimitiveFromBoxed(boxedType);
       if (fromTypeAsPrimitive != null) {
-        int unboxedRegister = addPrimitiveUnboxing(register, fromTypeAsPrimitive, boxedType);
-        return addPrimitiveWideningConversion(unboxedRegister, fromTypeAsPrimitive, toType);
+        addPrimitiveUnboxing(fromTypeAsPrimitive, boxedType, instructions, factory);
+        addPrimitiveWideningConversion(fromTypeAsPrimitive, toType, instructions);
+        return;
       }
     }
 
     // If the first one is a primitive type and the second one is a boxed
     // type for this primitive type, just box the value.
     if (fromTypePrimitive) {
-      DexType boxedFromType = getBoxedForPrimitiveType(fromType);
-      if (toType == boxedFromType ||
-          toType == factory().objectType ||
-          toType == factory().serializableType ||
-          toType == factory().comparableType ||
-          (boxedFromType != factory().booleanType &&
-              boxedFromType != factory().charType &&
-              toType == factory().boxedNumberType)) {
-        return addPrimitiveBoxing(register, fromType, boxedFromType);
+      DexType boxedFromType = getBoxedForPrimitiveType(fromType, factory);
+      if (toType == boxedFromType
+          || toType == factory.objectType
+          || toType == factory.serializableType
+          || toType == factory.comparableType
+          || (boxedFromType != factory.booleanType
+              && boxedFromType != factory.charType
+              && toType == factory.boxedNumberType)) {
+        addPrimitiveBoxing(fromType, boxedFromType, instructions, factory);
+        return;
       }
     }
 
-    if (fromType.isArrayType() && (toType == factory().objectType || toType.isArrayType())) {
+    if (fromType.isArrayType() && (toType == factory.objectType || toType.isArrayType())) {
       // If `fromType` is an array and `toType` is java.lang.Object, no cast is needed.
       // If both `fromType` and `toType` are arrays, no cast is needed since we assume
       // the input code is verifiable.
-      return register;
+      return;
     }
 
     if ((fromType.isClassType() && toType.isClassType())
-        || (fromType == factory().objectType && toType.isArrayType())) {
-      if (returnType) {
+        || (fromType == factory.objectType && toType.isArrayType())) {
+      if (returnType && toType != factory.objectType) {
         // For return type adjustment in case `fromType` and `toType` are both reference types,
         // `fromType` does NOT have to be deriving from `toType` and we need to add a cast.
         // NOTE: we don't check `toType` for being actually a supertype, since we
         // might not have full classpath with inheritance information to do that.
-        int finalRegister = register;
-        add(builder -> builder.addCheckCast(finalRegister, toType));
+        instructions.add(new CfCheckCast(toType));
       }
-      return register;
+      return;
     }
 
     throw new Unreachable("Unexpected type adjustment from "
         + fromType.toSourceString() + " to " + toType);
   }
 
-  private int addPrimitiveWideningConversion(int register, DexType fromType, DexType toType) {
+  private static void addPrimitiveWideningConversion(
+      DexType fromType, DexType toType, Builder<CfInstruction> instructions) {
     assert fromType.isPrimitiveType() && toType.isPrimitiveType();
     if (fromType == toType) {
-      return register;
+      return;
     }
 
     NumericType from = NumericType.fromDexType(fromType);
@@ -379,14 +463,13 @@
           if (from != NumericType.BYTE) {
             break; // Only BYTE can be converted to SHORT via widening conversion.
           }
-          int result = nextRegister(ValueType.INT);
-          add(builder -> builder.addConversion(to, NumericType.INT, result, register));
-          return result;
+            instructions.add(new CfNumberConversion(NumericType.INT, to));
+            return;
         }
 
         case INT:
           if (from == NumericType.BYTE || from == NumericType.CHAR || from == NumericType.SHORT) {
-            return register; // No actual conversion is needed.
+            return;
           }
           break;
 
@@ -394,27 +477,24 @@
           if (from == NumericType.FLOAT || from == NumericType.DOUBLE) {
             break; // Not a widening conversion.
           }
-          int result = nextRegister(ValueType.LONG);
-          add(builder -> builder.addConversion(to, NumericType.INT, result, register));
-          return result;
+            instructions.add(new CfNumberConversion(NumericType.INT, to));
+            return;
         }
 
         case FLOAT: {
           if (from == NumericType.DOUBLE) {
             break; // Not a widening conversion.
           }
-          int result = nextRegister(ValueType.FLOAT);
           NumericType type = (from == NumericType.LONG) ? NumericType.LONG : NumericType.INT;
-          add(builder -> builder.addConversion(to, type, result, register));
-          return result;
+            instructions.add(new CfNumberConversion(type, to));
+            return;
         }
 
         case DOUBLE: {
-          int result = nextRegister(ValueType.DOUBLE);
           NumericType type = (from == NumericType.FLOAT || from == NumericType.LONG)
               ? from : NumericType.INT;
-          add(builder -> builder.addConversion(to, type, result, register));
-          return result;
+            instructions.add(new CfNumberConversion(type, to));
+            return;
         }
         default:
           // exception is thrown below
@@ -426,8 +506,7 @@
         "converted to " + toType.toSourceString() + " via primitive widening conversion.");
   }
 
-  private DexMethod getUnboxMethod(byte primitive, DexType boxType) {
-    DexItemFactory factory = factory();
+  private static DexMethod getUnboxMethod(byte primitive, DexType boxType, DexItemFactory factory) {
     DexProto proto;
     switch (primitive) {
       case 'Z':  // byte
@@ -459,53 +538,23 @@
     }
   }
 
-  private int addPrimitiveUnboxing(int register, DexType primitiveType, DexType boxType) {
-    DexMethod method = getUnboxMethod(primitiveType.descriptor.content[0], boxType);
-
-    List<ValueType> argValueTypes = ImmutableList.of(ValueType.OBJECT);
-    List<Integer> argRegisters = Collections.singletonList(register);
-    add(
-        builder ->
-            builder.addInvoke(
-                Invoke.Type.VIRTUAL,
-                method,
-                method.proto,
-                argValueTypes,
-                argRegisters,
-                false /* isInterface */));
-
-    ValueType valueType = ValueType.fromDexType(primitiveType);
-    int result = nextRegister(valueType);
-    add(builder -> builder.addMoveResult(result));
-    return result;
+  private static void addPrimitiveUnboxing(
+      DexType primitiveType,
+      DexType boxType,
+      Builder<CfInstruction> instructions,
+      DexItemFactory factory) {
+    DexMethod method = getUnboxMethod(primitiveType.descriptor.content[0], boxType, factory);
+    instructions.add(new CfInvoke(Opcodes.INVOKEVIRTUAL, method, false));
   }
 
-  private int castToBoxedType(int register, DexType boxType) {
-    add(builder -> builder.addCheckCast(register, boxType));
-    return register;
-  }
-
-  private int addPrimitiveBoxing(int register, DexType primitiveType, DexType boxType) {
+  private static void addPrimitiveBoxing(
+      DexType primitiveType,
+      DexType boxType,
+      Builder<CfInstruction> instructions,
+      DexItemFactory factory) {
     // Generate factory method fo boxing.
-    DexItemFactory factory = factory();
     DexProto proto = factory.createProto(boxType, primitiveType);
     DexMethod method = factory.createMethod(boxType, proto, factory.valueOfMethodName);
-
-    ValueType valueType = ValueType.fromDexType(primitiveType);
-    List<ValueType> argValueTypes = ImmutableList.of(valueType);
-    List<Integer> argRegisters = Collections.singletonList(register);
-    add(
-        builder ->
-            builder.addInvoke(
-                Invoke.Type.STATIC,
-                method,
-                method.proto,
-                argValueTypes,
-                argRegisters,
-                false /* isInterface */));
-
-    int result = nextRegister(ValueType.OBJECT);
-    add(builder -> builder.addMoveResult(result));
-    return result;
+    instructions.add(new CfInvoke(Opcodes.INVOKESTATIC, method, false));
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSynthesizedCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSynthesizedCode.java
deleted file mode 100644
index 7c24b63..0000000
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSynthesizedCode.java
+++ /dev/null
@@ -1,66 +0,0 @@
-// 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.ir.desugar;
-
-import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.UseRegistry;
-import com.android.tools.r8.ir.code.Invoke;
-import com.android.tools.r8.ir.code.Invoke.Type;
-import java.util.function.Consumer;
-
-public class LambdaMainMethodSynthesizedCode extends LambdaSynthesizedCode {
-
-  private final DexMethod mainMethod;
-
-  LambdaMainMethodSynthesizedCode(LambdaClass lambda, DexMethod mainMethod) {
-    super(lambda);
-    this.mainMethod = mainMethod;
-  }
-
-  @Override
-  public SourceCodeProvider getSourceCodeProvider() {
-    return callerPosition -> new LambdaMainMethodSourceCode(lambda, mainMethod, callerPosition);
-  }
-
-  @Override
-  public Consumer<UseRegistry> getRegistryCallback() {
-    return registry -> {
-      LambdaClass.Target target = lambda.target;
-      assert target.invokeType == Invoke.Type.STATIC
-          || target.invokeType == Invoke.Type.VIRTUAL
-          || target.invokeType == Invoke.Type.DIRECT
-          || target.invokeType == Invoke.Type.INTERFACE;
-
-      boolean constructorTarget = target.invokeType == Type.DIRECT;
-      if (constructorTarget) {
-        registry.registerNewInstance(target.callTarget.holder);
-      }
-
-      DexType[] capturedTypes = captures();
-      for (int i = 0; i < capturedTypes.length; i++) {
-        registry.registerInstanceFieldRead(lambda.getCaptureField(i));
-      }
-
-      switch (target.invokeType) {
-        case DIRECT:
-          registry.registerInvokeDirect(target.callTarget);
-          break;
-        case INTERFACE:
-          registry.registerInvokeInterface(target.callTarget);
-          break;
-        case STATIC:
-          registry.registerInvokeStatic(target.callTarget);
-          break;
-        case VIRTUAL:
-          registry.registerInvokeVirtual(target.callTarget);
-          break;
-        default:
-          throw new Unreachable();
-      }
-    };
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaSynthesizedCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaSynthesizedCode.java
deleted file mode 100644
index 5643288..0000000
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaSynthesizedCode.java
+++ /dev/null
@@ -1,42 +0,0 @@
-// 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.ir.desugar;
-
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexTypeList;
-import com.android.tools.r8.graph.UseRegistry;
-import com.android.tools.r8.ir.synthetic.SynthesizedCode;
-import java.util.function.Consumer;
-
-abstract class LambdaSynthesizedCode extends SynthesizedCode {
-
-  final LambdaClass lambda;
-
-  LambdaSynthesizedCode(LambdaClass lambda) {
-    super(null);
-    this.lambda = lambda;
-  }
-
-  final DexItemFactory dexItemFactory() {
-    return lambda.appView.dexItemFactory();
-  }
-
-  final LambdaDescriptor descriptor() {
-    return lambda.descriptor;
-  }
-
-  final DexType[] captures() {
-    DexTypeList captures = descriptor().captures;
-    assert captures != null;
-    return captures.values;
-  }
-
-  @Override
-  public abstract SourceCodeProvider getSourceCodeProvider();
-
-  @Override
-  public abstract Consumer<UseRegistry> getRegistryCallback();
-}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/SynthesizedLambdaSourceCode.java b/src/main/java/com/android/tools/r8/ir/desugar/SynthesizedLambdaSourceCode.java
deleted file mode 100644
index fc12713..0000000
--- a/src/main/java/com/android/tools/r8/ir/desugar/SynthesizedLambdaSourceCode.java
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.desugar;
-
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexTypeList;
-import com.android.tools.r8.ir.code.Position;
-import com.android.tools.r8.ir.synthetic.SyntheticSourceCode;
-
-// Represents source code of synthesized lambda class methods.
-abstract class SynthesizedLambdaSourceCode extends SyntheticSourceCode {
-
-  final DexMethod currentMethod;
-  final LambdaClass lambda;
-
-  SynthesizedLambdaSourceCode(
-      LambdaClass lambda, DexMethod currentMethod, Position callerPosition, DexType receiver) {
-    super(receiver, currentMethod, callerPosition);
-    this.lambda = lambda;
-    this.currentMethod = currentMethod;
-  }
-
-  SynthesizedLambdaSourceCode(
-      LambdaClass lambda, DexMethod currentMethod, Position callerPosition) {
-    this(lambda, currentMethod, callerPosition, lambda.type);
-  }
-
-  final LambdaDescriptor descriptor() {
-    return lambda.descriptor;
-  }
-
-  final DexType[] captures() {
-    DexTypeList captures = descriptor().captures;
-    assert captures != null;
-    return captures.values;
-  }
-
-  final DexItemFactory factory() {
-    return lambda.appView.dexItemFactory();
-  }
-
-  final int enforceParameterType(int register, DexType paramType, DexType enforcedType) {
-    // `paramType` must be either same as `enforcedType` or both must be class
-    // types and `enforcedType` must be a subclass of `paramType` in which case
-    // a cast need to be inserted.
-    if (paramType != enforcedType) {
-      assert LambdaDescriptor.isSameOrDerived(factory(), enforcedType, paramType);
-      add(builder -> builder.addCheckCast(register, enforcedType));
-    }
-    return register;
-  }
-
-  @Override
-  public String toString() {
-    return currentMethod.toSourceString();
-  }
-}
-
diff --git a/src/main/java/com/android/tools/r8/ir/synthetic/ForwardMethodBuilder.java b/src/main/java/com/android/tools/r8/ir/synthetic/ForwardMethodBuilder.java
new file mode 100644
index 0000000..8d8ca9f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/synthetic/ForwardMethodBuilder.java
@@ -0,0 +1,243 @@
+// 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.synthetic;
+
+import com.android.tools.r8.cf.code.CfCheckCast;
+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.CfNew;
+import com.android.tools.r8.cf.code.CfReturn;
+import com.android.tools.r8.cf.code.CfReturnVoid;
+import com.android.tools.r8.cf.code.CfStackInstruction;
+import com.android.tools.r8.cf.code.CfStackInstruction.Opcode;
+import com.android.tools.r8.cf.code.CfTryCatch;
+import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.CfCode;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.code.ValueType;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableList.Builder;
+import org.objectweb.asm.Opcodes;
+
+public class ForwardMethodBuilder {
+
+  public static ForwardMethodBuilder builder(DexItemFactory factory) {
+    return new ForwardMethodBuilder(factory);
+  }
+
+  private enum InvokeType {
+    STATIC,
+    VIRTUAL,
+    SPECIAL
+  }
+
+  private final DexItemFactory factory;
+
+  private DexMethod sourceMethod = null;
+  private DexMethod targetMethod = null;
+
+  private boolean staticSource = false;
+
+  private InvokeType invokeType = null;
+  private Boolean isInterface = null;
+  private boolean castResult = false;
+  private boolean isConstructorDelegate = false;
+  private AppInfoWithClassHierarchy appInfoForCastArguments = null;
+
+  private ForwardMethodBuilder(DexItemFactory factory) {
+    this.factory = factory;
+  }
+
+  public ForwardMethodBuilder setNonStaticSource(DexMethod method) {
+    sourceMethod = method;
+    staticSource = false;
+    return this;
+  }
+
+  public ForwardMethodBuilder setStaticSource(DexMethod method) {
+    sourceMethod = method;
+    staticSource = true;
+    return this;
+  }
+
+  public ForwardMethodBuilder setStaticTarget(DexMethod method, boolean isInterface) {
+    targetMethod = method;
+    invokeType = InvokeType.STATIC;
+    this.isInterface = isInterface;
+    return this;
+  }
+
+  public ForwardMethodBuilder setVirtualTarget(DexMethod method, boolean isInterface) {
+    targetMethod = method;
+    invokeType = InvokeType.VIRTUAL;
+    this.isInterface = isInterface;
+    return this;
+  }
+
+  public ForwardMethodBuilder setDirectTarget(DexMethod method, boolean isInterface) {
+    targetMethod = method;
+    invokeType = InvokeType.SPECIAL;
+    this.isInterface = isInterface;
+    return this;
+  }
+
+  public ForwardMethodBuilder setCastResult() {
+    castResult = true;
+    return this;
+  }
+
+  public ForwardMethodBuilder setCastArguments(AppInfoWithClassHierarchy appInfo) {
+    appInfoForCastArguments = appInfo;
+    return this;
+  }
+
+  public ForwardMethodBuilder setConstructorTarget(DexMethod method, DexItemFactory factory) {
+    assert method.isInstanceInitializer(factory);
+    targetMethod = method;
+    isConstructorDelegate = true;
+    invokeType = InvokeType.SPECIAL;
+    isInterface = false;
+    return this;
+  }
+
+  public CfCode build() {
+    assert validate();
+    int maxStack = 0;
+    int maxLocals = 0;
+    Builder<CfInstruction> instructions = ImmutableList.builder();
+    if (isConstructorDelegate) {
+      // A constructor delegate allocates a new instance of the type.
+      // It is dup'ed on the stack so it is ready to return after the invoke call.
+      assert isStaticSource();
+      assert invokeType == InvokeType.SPECIAL;
+      instructions.add(new CfNew(targetMethod.getHolderType()));
+      instructions.add(new CfStackInstruction(Opcode.Dup));
+      maxStack += 2;
+    } else if (!isStaticSource()) {
+      // If source is not static, load the receiver.
+      instructions.add(new CfLoad(ValueType.OBJECT, maxLocals));
+      maybeInsertArgumentCast(-1, sourceMethod.holder, instructions);
+      maxStack += 1;
+      maxLocals += 1;
+    }
+    DexType[] sourceParameters = getSourceParameters();
+    for (int i = 0; i < sourceParameters.length; i++) {
+      DexType parameter = sourceParameters[i];
+      ValueType parameterType = ValueType.fromDexType(parameter);
+      instructions.add(new CfLoad(parameterType, maxLocals));
+      maxLocals += parameterType.requiredRegisters();
+      maybeInsertArgumentCast(i, parameter, instructions);
+    }
+    instructions.add(new CfInvoke(getInvokeOpcode(), targetMethod, isInterface));
+    if (isSourceReturnVoid()) {
+      assert !isConstructorDelegate;
+      instructions.add(new CfReturnVoid());
+    } else {
+      if (!isConstructorDelegate && sourceMethod.getReturnType() != targetMethod.getReturnType()) {
+        assert castResult;
+        if (sourceMethod.getReturnType() != factory.objectType) {
+          instructions.add(new CfCheckCast(sourceMethod.getReturnType()));
+        }
+      }
+      instructions.add(new CfReturn(getSourceReturnType()));
+    }
+    ImmutableList<CfTryCatch> tryCatchRanges = ImmutableList.of();
+    ImmutableList<CfCode.LocalVariableInfo> localVariables = ImmutableList.of();
+    return new CfCode(
+        sourceMethod.holder,
+        maxStack,
+        maxLocals,
+        instructions.build(),
+        tryCatchRanges,
+        localVariables);
+  }
+
+  private void maybeInsertArgumentCast(
+      int argumentIndex, DexType sourceArgumentType, Builder<CfInstruction> instructions) {
+    if (appInfoForCastArguments == null) {
+      return;
+    }
+    // Shift argument index if mapping between static and non-static.
+    if (isStaticSource() != isStaticTarget()) {
+      argumentIndex += isStaticSource() ? -1 : 1;
+    }
+    // Argument -1 is the receiver.
+    DexType targetArgumentType =
+        argumentIndex == -1
+            ? targetMethod.holder
+            : targetMethod.getParameters().values[argumentIndex];
+    if (sourceArgumentType != targetArgumentType
+        && targetArgumentType != appInfoForCastArguments.dexItemFactory().objectType) {
+      assert appInfoForCastArguments.isSubtype(targetArgumentType, sourceArgumentType);
+      instructions.add(new CfCheckCast(targetArgumentType));
+    }
+  }
+
+  private int getInvokeOpcode() {
+    switch (invokeType) {
+      case STATIC:
+        return Opcodes.INVOKESTATIC;
+      case VIRTUAL:
+        return Opcodes.INVOKEVIRTUAL;
+      case SPECIAL:
+        return Opcodes.INVOKESPECIAL;
+    }
+    throw new Unreachable("Unexpected invoke type: " + invokeType);
+  }
+
+  private DexType[] getSourceParameters() {
+    return sourceMethod.getParameters().values;
+  }
+
+  private boolean isSourceReturnVoid() {
+    return sourceMethod.getReturnType().isVoidType();
+  }
+
+  private ValueType getSourceReturnType() {
+    assert !isSourceReturnVoid();
+    return ValueType.fromDexType(sourceMethod.getReturnType());
+  }
+
+  private boolean isStaticSource() {
+    return staticSource;
+  }
+
+  private boolean isStaticTarget() {
+    return invokeType == InvokeType.STATIC;
+  }
+
+  private int sourceArguments() {
+    return sourceMethod.getParameters().size() + (isStaticSource() ? 0 : 1);
+  }
+
+  private int targetArguments() {
+    // A constructor delegate will allocate the instance so that is subtracted from args.
+    return targetMethod.getParameters().size()
+        + (isStaticTarget() || isConstructorDelegate ? 0 : 1);
+  }
+
+  private boolean validate() {
+    assert sourceMethod != null;
+    assert targetMethod != null;
+    assert invokeType != null;
+    assert isInterface != null;
+    assert sourceArguments() == targetArguments();
+    if (isConstructorDelegate) {
+      assert isStaticSource();
+      assert !sourceMethod.getReturnType().isVoidType();
+      assert targetMethod.getReturnType().isVoidType();
+      assert invokeType == InvokeType.SPECIAL;
+    } else if (castResult) {
+      assert ValueType.fromDexType(sourceMethod.getReturnType())
+          == ValueType.fromDexType(targetMethod.getReturnType());
+    } else {
+      assert sourceMethod.getReturnType() == targetMethod.getReturnType();
+    }
+    return true;
+  }
+}