diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index 8e7e7fd..34e9cba 100644
--- a/src/main/java/com/android/tools/r8/Version.java
+++ b/src/main/java/com/android/tools/r8/Version.java
@@ -11,7 +11,7 @@
 
   // This field is accessed from release scripts using simple pattern matching.
   // Therefore, changing this field could break our release scripts.
-  public static final String LABEL = "1.6.56";
+  public static final String LABEL = "1.6.57";
 
   private Version() {
   }
diff --git a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
index 92a4963..54fbf9f 100644
--- a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
@@ -238,6 +238,10 @@
     return this;
   }
 
+  public static DexProgramClass asProgramClassOrNull(DexClass clazz) {
+    return clazz != null ? clazz.asProgramClass() : null;
+  }
+
   @Override
   public boolean isNotProgramClass() {
     return false;
diff --git a/src/main/java/com/android/tools/r8/graph/DexType.java b/src/main/java/com/android/tools/r8/graph/DexType.java
index 055b120..b0e5373 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.graph;
 
+import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
 import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.COMPANION_CLASS_NAME_SUFFIX;
 import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.DISPATCH_CLASS_NAME_SUFFIX;
 import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.EMULATE_LIBRARY_CLASS_NAME_SUFFIX;
@@ -71,10 +72,16 @@
 
   public boolean isAlwaysNull(AppView<AppInfoWithLiveness> appView) {
     if (isClassType()) {
-      DexClass clazz = appView.definitionFor(this);
-      return clazz != null
-          && clazz.isProgramClass()
-          && !appView.appInfo().isInstantiatedDirectlyOrIndirectly(this);
+      DexProgramClass clazz = asProgramClassOrNull(appView.definitionFor(this));
+      if (clazz == null) {
+        return false;
+      }
+      if (appView.options().enableUninstantiatedTypeOptimizationForInterfaces) {
+        return !appView.appInfo().isInstantiatedDirectlyOrIndirectly(clazz.type);
+      } else {
+        return !clazz.isInterface()
+            && !appView.appInfo().isInstantiatedDirectlyOrIndirectly(clazz.type);
+      }
     }
     return false;
   }
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index 0098813..d826aa9 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -240,6 +240,8 @@
   public boolean enableValuePropagation = true;
   public boolean enableFieldTypePropagation = true;
   public boolean enableUninstantiatedTypeOptimization = true;
+  // Currently disabled, see b/146957343.
+  public boolean enableUninstantiatedTypeOptimizationForInterfaces = false;
   // TODO(b/138917494): Disable until we have numbers on potential performance penalties.
   public boolean enableRedundantConstNumberOptimization = false;
 
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index 797d185..3f140b8 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -26,6 +26,7 @@
 import com.android.tools.r8.jasmin.JasminBuilder;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.shaking.serviceloader.ServiceLoaderMultipleTest.Greeter;
+import com.android.tools.r8.transformers.ClassFileTransformer;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.AndroidAppConsumers;
@@ -166,6 +167,10 @@
     return testForMainDexListGenerator(temp);
   }
 
+  public static ClassFileTransformer transformer(Class<?> clazz) throws IOException {
+    return ClassFileTransformer.create(clazz);
+  }
+
   // Actually running Proguard should only be during development.
   private static final boolean RUN_PROGUARD = System.getProperty("run_proguard") != null;
   // Actually running r8.jar in a forked process.
diff --git a/src/test/java/com/android/tools/r8/TestRunResult.java b/src/test/java/com/android/tools/r8/TestRunResult.java
index 4dd10a1..7440dba 100644
--- a/src/test/java/com/android/tools/r8/TestRunResult.java
+++ b/src/test/java/com/android/tools/r8/TestRunResult.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8;
 
+import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotEquals;
@@ -99,6 +100,15 @@
     return self();
   }
 
+  public RR assertFailureWithErrorThatThrows(Class<? extends Throwable> expectedError) {
+    assertFailure();
+    assertThat(
+        errorMessage("Run stderr incorrect.", expectedError.getName()),
+        result.stderr,
+        containsString(expectedError.getName()));
+    return self();
+  }
+
   public CodeInspector inspector() throws IOException, ExecutionException {
     // Inspection post run implies success. If inspection of an invalid program is needed it should
     // be done on the compilation result or on the input.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/B146957343.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/B146957343.java
new file mode 100644
index 0000000..f454913
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/B146957343.java
@@ -0,0 +1,93 @@
+// 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.optimize.uninstantiatedtypes;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.io.IOException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.objectweb.asm.Opcodes;
+
+@RunWith(Parameterized.class)
+public class B146957343 extends TestBase implements Opcodes {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().withAllApiLevels().build();
+  }
+
+  public B146957343(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  private byte[] getAimplementsI() throws IOException {
+    return transformer(A.class).setImplements(I.class).transform();
+  }
+
+  @Test
+  public void testWithoutR8() throws Exception {
+    testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
+        .addProgramClasses(I.class, J.class, Main.class)
+        .addProgramClassFileData(getAimplementsI())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("In A.f()");
+  }
+
+  @Test
+  public void testWithUninstantiatedTypeOptimizationForInterfaces() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(I.class, J.class, Main.class)
+        .addProgramClassFileData(getAimplementsI())
+        .addKeepMainRule(Main.class)
+        .addKeepRules("-keep class **A { createA(); }")
+        .setMinApi(parameters.getApiLevel())
+        .addOptionsModification(
+            options -> options.enableUninstantiatedTypeOptimizationForInterfaces = true)
+        .compile()
+        .disassemble()
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatThrows(NullPointerException.class);
+  }
+
+  @Test
+  public void testWithoutUninstantiatedTypeOptimizationForInterfaces() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(I.class, J.class, Main.class)
+        .addProgramClassFileData(getAimplementsI())
+        .addKeepMainRule(Main.class)
+        .addKeepRules("-keep class **A { createA(); }")
+        .setMinApi(parameters.getApiLevel())
+        .addOptionsModification(
+            options -> options.enableUninstantiatedTypeOptimizationForInterfaces = false)
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("In A.f()");
+  }
+
+  public interface I {}
+
+  public interface J extends I {}
+
+  public static class A implements J {
+    public static J createA() {
+      return new A();
+    }
+
+    public void f() {
+      System.out.println("In A.f()");
+    }
+  }
+
+  public static class Main {
+    public static void main(String[] args) {
+      ((A) A.createA()).f();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java b/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java
index b951b4f..b42be41 100644
--- a/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java
@@ -40,7 +40,8 @@
     D8,
     JAVAC,
     PROGUARD,
-    R8
+    R8,
+    R8_ENABLE_UNININSTANTATED_TYPE_OPTIMIZATION_FOR_INTERFACES
   }
 
   private enum Mode {
@@ -207,6 +208,27 @@
             .setMinApi(parameters.getRuntime())
             .run(parameters.getRuntime(), mainClass.name);
     checkTestRunResult(r8Result, Compiler.R8);
+
+    R8TestRunResult r8ResultWithUninstantiatedTypeOptimizationForInterfaces =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(inputJar)
+            .addKeepMainRule(mainClass.name)
+            .addKeepRules(
+                "-keep class TestClass { public static I g; }",
+                "-neverinline class TestClass { public static void m(); }")
+            .enableProguardTestOptions()
+            .addOptionsModification(
+                options -> {
+                  if (mode == Mode.INVOKE_UNVERIFIABLE_METHOD) {
+                    options.testing.allowTypeErrors = true;
+                  }
+                  options.enableUninstantiatedTypeOptimizationForInterfaces = true;
+                })
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), mainClass.name);
+    checkTestRunResult(
+        r8ResultWithUninstantiatedTypeOptimizationForInterfaces,
+        Compiler.R8_ENABLE_UNININSTANTATED_TYPE_OPTIMIZATION_FOR_INTERFACES);
   }
 
   private void checkTestRunResult(TestRunResult<?> result, Compiler compiler) {
@@ -219,7 +241,9 @@
         if (useInterface) {
           result.assertSuccessWithOutput(getExpectedOutput(compiler));
         } else {
-          if (compiler == Compiler.R8 || compiler == Compiler.PROGUARD) {
+          if (compiler == Compiler.R8
+              || compiler == Compiler.R8_ENABLE_UNININSTANTATED_TYPE_OPTIMIZATION_FOR_INTERFACES
+              || compiler == Compiler.PROGUARD) {
             result.assertSuccessWithOutput(getExpectedOutput(compiler));
           } else {
             result
@@ -233,7 +257,8 @@
         if (useInterface) {
           result.assertSuccessWithOutput(getExpectedOutput(compiler));
         } else {
-          if (compiler == Compiler.R8) {
+          if (compiler == Compiler.R8
+              || compiler == Compiler.R8_ENABLE_UNININSTANTATED_TYPE_OPTIMIZATION_FOR_INTERFACES) {
             result
                 .assertFailureWithOutput(getExpectedOutput(compiler))
                 .assertFailureWithErrorThatMatches(
@@ -261,7 +286,9 @@
       if (useInterface) {
         return StringUtils.joinLines("Hello!", "In verifiable method!", "Goodbye!", "");
       } else {
-        if (compiler == Compiler.R8 || compiler == Compiler.PROGUARD) {
+        if (compiler == Compiler.R8
+            || compiler == Compiler.R8_ENABLE_UNININSTANTATED_TYPE_OPTIMIZATION_FOR_INTERFACES
+            || compiler == Compiler.PROGUARD) {
           // The unverifiable method has been removed as a result of tree shaking, so the code does
           // not fail with a verification error when trying to load class `UnverifiableClass`.
           return StringUtils.joinLines("Hello!", "In verifiable method!", "Goodbye!", "");
@@ -274,14 +301,14 @@
     }
     assert mode == Mode.INVOKE_UNVERIFIABLE_METHOD;
     if (useInterface) {
-      if (compiler == Compiler.R8) {
+      if (compiler == Compiler.R8_ENABLE_UNININSTANTATED_TYPE_OPTIMIZATION_FOR_INTERFACES) {
         return StringUtils.joinLines(
             "Hello!",
             "Unexpected outcome of getstatic",
             "Unexpected outcome of checkcast",
             "Goodbye!",
             "");
-      } else if (compiler == Compiler.PROGUARD) {
+      } else if (compiler == Compiler.R8 || compiler == Compiler.PROGUARD) {
         return StringUtils.joinLines("Hello!", "Unexpected outcome of checkcast", "Goodbye!", "");
       } else if (compiler == Compiler.DX || compiler == Compiler.D8) {
         if (ToolHelper.getDexVm().getVersion() == Version.V4_0_4
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
index 74f4321..5c6a305 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
@@ -207,9 +207,9 @@
     assertThat(clazz, isPresent());
     assertEquals(minify, clazz.isRenamed());
     MethodSubject f1 = clazz.uniqueMethodWithName("f1");
-    assertThat(f1, not(isPresent()));
+    assertThat(f1, isPresent());
     MethodSubject f2 = clazz.uniqueMethodWithName("f2");
-    assertThat(f2, not(isPresent()));
+    assertThat(f2, isPresent());
     MethodSubject f3 = clazz.uniqueMethodWithName("f3");
     assertThat(f3, not(isPresent()));
     MethodSubject f4 = clazz.uniqueMethodWithName("f4");
diff --git a/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java b/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
new file mode 100644
index 0000000..8157f47
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
@@ -0,0 +1,199 @@
+// 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.transformers;
+
+import static org.objectweb.asm.Opcodes.ASM7;
+
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.naming.MemberNaming.MethodSignature;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.transformers.MethodTransformer.MethodContext;
+import com.android.tools.r8.utils.DescriptorUtils;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+
+public class ClassFileTransformer {
+
+  /**
+   * Basic algorithm for transforming the content of a class file.
+   *
+   * <p>The provided transformers are nested in the order given: the first in the list will receive
+   * is call back first, if it forwards to 'super' then the seconds call back will be called, etc,
+   * until finally the writer will be called. If the writer is not called the effect is as if the
+   * callback was never called and its content will not be in the result.
+   */
+  public static byte[] transform(
+      byte[] bytes,
+      List<ClassTransformer> classTransformers,
+      List<MethodTransformer> methodTransformers) {
+    ClassReader reader = new ClassReader(bytes);
+    ClassWriter writer = new ClassWriter(reader, 0);
+    ClassVisitor subvisitor = new InnerMostClassTransformer(writer, methodTransformers);
+    for (int i = classTransformers.size() - 1; i >= 0; i--) {
+      classTransformers.get(i).setSubVisitor(subvisitor);
+      subvisitor = classTransformers.get(i);
+    }
+    reader.accept(subvisitor, 0);
+    return writer.toByteArray();
+  }
+
+  // Inner-most bride from the class transformation to the method transformers.
+  private static class InnerMostClassTransformer extends ClassVisitor {
+    ClassReference classReference;
+    final List<MethodTransformer> methodTransformers;
+
+    InnerMostClassTransformer(ClassWriter writer, List<MethodTransformer> methodTransformers) {
+      super(ASM7, writer);
+      this.methodTransformers = methodTransformers;
+    }
+
+    @Override
+    public void visit(
+        int version,
+        int access,
+        String name,
+        String signature,
+        String superName,
+        String[] interfaces) {
+      super.visit(version, access, name, signature, superName, interfaces);
+      classReference = Reference.classFromBinaryName(name);
+    }
+
+    @Override
+    public MethodVisitor visitMethod(
+        int access, String name, String descriptor, String signature, String[] exceptions) {
+      MethodContext context = createMethodContext(access, name, descriptor);
+      MethodVisitor subvisitor = super.visitMethod(access, name, descriptor, signature, exceptions);
+      for (int i = methodTransformers.size() - 1; i >= 0; i--) {
+        MethodTransformer transformer = methodTransformers.get(i);
+        transformer.setSubVisitor(subvisitor);
+        transformer.setContext(context);
+        subvisitor = transformer;
+      }
+      return subvisitor;
+    }
+
+    private MethodContext createMethodContext(int access, String name, String descriptor) {
+      // Maybe clean up this parsing of info as it is not very nice.
+      MethodSignature methodSignature = MethodSignature.fromSignature(name, descriptor);
+      MethodReference methodReference =
+          Reference.method(
+              classReference,
+              name,
+              Arrays.stream(methodSignature.parameters)
+                  .map(DescriptorUtils::javaTypeToDescriptor)
+                  .map(Reference::typeFromDescriptor)
+                  .collect(Collectors.toList()),
+              methodSignature.type.equals("void")
+                  ? null
+                  : Reference.typeFromDescriptor(
+                      DescriptorUtils.javaTypeToDescriptor(methodSignature.type)));
+      return new MethodContext(methodReference, access);
+    }
+  }
+
+  // Transformer utilities.
+
+  private final byte[] bytes;
+  private final List<ClassTransformer> classTransformers = new ArrayList<>();
+  private final List<MethodTransformer> methodTransformers = new ArrayList<>();
+
+  private ClassFileTransformer(byte[] bytes) {
+    this.bytes = bytes;
+  }
+
+  public static ClassFileTransformer create(byte[] bytes) {
+    return new ClassFileTransformer(bytes);
+  }
+
+  public static ClassFileTransformer create(Class<?> clazz) throws IOException {
+    return create(ToolHelper.getClassAsBytes(clazz));
+  }
+
+  public byte[] transform() {
+    return ClassFileTransformer.transform(bytes, classTransformers, methodTransformers);
+  }
+
+  /** Base addition of a transformer on the class. */
+  public ClassFileTransformer addClassTransformer(ClassTransformer transformer) {
+    classTransformers.add(transformer);
+    return this;
+  }
+
+  /** Base addtion of a transformer on methods. */
+  public ClassFileTransformer addMethodTransformer(MethodTransformer transformer) {
+    methodTransformers.add(transformer);
+    return this;
+  }
+
+  /** Unconditionally replace the implements clause of a class. */
+  public ClassFileTransformer setImplements(Class<?>... interfaces) {
+    return addClassTransformer(
+        new ClassTransformer() {
+          @Override
+          public void visit(
+              int version,
+              int access,
+              String name,
+              String signature,
+              String superName,
+              String[] ignoredInterfaces) {
+            super.visit(
+                version,
+                access,
+                name,
+                signature,
+                superName,
+                Arrays.stream(interfaces)
+                    .map(clazz -> DescriptorUtils.getBinaryNameFromJavaType(clazz.getTypeName()))
+                    .toArray(String[]::new));
+          }
+        });
+  }
+
+  /** Abstraction of the MethodVisitor.visitMethodInsn method with its continuation. */
+  @FunctionalInterface
+  public interface MethodInsnTransform {
+    void visitMethodInsn(
+        int opcode,
+        String owner,
+        String name,
+        String descriptor,
+        boolean isInterface,
+        MethodInsnTransformContinuation continuation);
+  }
+
+  /** Continuation for transforming a method. Will continue with the super visitor if called. */
+  @FunctionalInterface
+  public interface MethodInsnTransformContinuation {
+    void visitMethodInsn(
+        int opcode, String owner, String name, String descriptor, boolean isInterface);
+  }
+
+  public ClassFileTransformer transformMethodInsnInMethod(
+      String methodName, MethodInsnTransform transform) {
+    return addMethodTransformer(
+        new MethodTransformer() {
+          @Override
+          public void visitMethodInsn(
+              int opcode, String owner, String name, String descriptor, boolean isInterface) {
+            if (getContext().method.getMethodName().equals(methodName)) {
+              transform.visitMethodInsn(
+                  opcode, owner, name, descriptor, isInterface, super::visitMethodInsn);
+            } else {
+              super.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
+            }
+          }
+        });
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/transformers/ClassTransformer.java b/src/test/java/com/android/tools/r8/transformers/ClassTransformer.java
new file mode 100644
index 0000000..885257e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/transformers/ClassTransformer.java
@@ -0,0 +1,25 @@
+// 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.transformers;
+
+import static org.objectweb.asm.Opcodes.ASM7;
+
+import org.objectweb.asm.ClassVisitor;
+
+/**
+ * Class for transforming the content of a class.
+ *
+ * <p>This is just a simple wrapper on the ASM ClassVisitor interface.
+ */
+public class ClassTransformer extends ClassVisitor {
+  public ClassTransformer() {
+    super(ASM7, null);
+  }
+
+  // Package internals.
+
+  void setSubVisitor(ClassVisitor visitor) {
+    this.cv = visitor;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/transformers/MethodTransformer.java b/src/test/java/com/android/tools/r8/transformers/MethodTransformer.java
new file mode 100644
index 0000000..a5ffa82
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/transformers/MethodTransformer.java
@@ -0,0 +1,57 @@
+// 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.transformers;
+
+import static org.objectweb.asm.Opcodes.ASM7;
+
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.MethodReference;
+import org.objectweb.asm.MethodVisitor;
+
+/**
+ * Class for transforming the content of a method.
+ *
+ * <p>This is just a simple wrapper on the ASM MethodVisitor interface with some added methods for
+ * obtaining context information.
+ */
+public class MethodTransformer extends MethodVisitor {
+
+  static class MethodContext {
+    public final MethodReference method;
+    public final int accessFlags;
+
+    public MethodContext(MethodReference method, int accessFlags) {
+      this.method = method;
+      this.accessFlags = accessFlags;
+    }
+  }
+
+  private MethodContext context;
+
+  public MethodTransformer() {
+    super(ASM7, null);
+  }
+
+  public ClassReference getHolder() {
+    return getContext().method.getHolderClass();
+  }
+
+  public MethodReference getMethod() {
+    return getContext().method;
+  }
+
+  // Package internals.
+
+  MethodContext getContext() {
+    return context;
+  }
+
+  void setSubVisitor(MethodVisitor visitor) {
+    this.mv = visitor;
+  }
+
+  void setContext(MethodContext context) {
+    this.context = context;
+  }
+}