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 d203a12..9ba4398 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
@@ -10,7 +10,6 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.ClassAccessFlags;
 import com.android.tools.r8.graph.DexAnnotationSet;
-import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexField;
@@ -33,7 +32,6 @@
 import com.android.tools.r8.ir.synthetic.ForwardMethodSourceCode;
 import com.android.tools.r8.ir.synthetic.SynthesizedCode;
 import com.android.tools.r8.origin.SynthesizedOrigin;
-import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.OptionalBool;
 import com.google.common.base.Suppliers;
 import com.google.common.primitives.Longs;
@@ -538,18 +536,8 @@
       return accessibilityBridge;
     }
 
-    boolean holderIsInterface() {
-      InternalOptions options = appView.options();
-      DexMethod implMethod = descriptor.implHandle.asMethod();
-      DexClass implMethodHolder = appView.definitionFor(implMethod.holder);
-      if (implMethodHolder == null) {
-        assert options
-            .desugaredLibraryConfiguration
-            .getBackportCoreLibraryMember()
-            .containsKey(implMethod.holder);
-        return false;
-      }
-      return implMethodHolder.isInterface();
+    boolean isInterface() {
+      return descriptor.implHandle.isInterface;
     }
   }
 
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 a5cf917..0c64b12 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
@@ -232,7 +232,7 @@
                 methodToCall.proto,
                 argValueTypes,
                 argRegisters,
-                target.holderIsInterface()));
+                target.isInterface()));
 
     // Does the method have return value?
     if (enforcedReturnType.isVoidType()) {
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index 6f18ef1..05f7848 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -1482,7 +1482,7 @@
     }
     Path path = temp.newFolder().toPath().resolve("classes.jar");
     ArchiveConsumer consumer = new ArchiveConsumer(path);
-    for (Class clazz : classes) {
+    for (Class<?> clazz : classes) {
       consumer.accept(
           ByteDataView.of(ToolHelper.getClassAsBytes(clazz)),
           DescriptorUtils.javaTypeToDescriptor(clazz.getTypeName()),
@@ -1492,6 +1492,24 @@
     return path;
   }
 
+  public Path buildOnDexRuntime(TestParameters parameters, byte[]... classes)
+      throws IOException, CompilationFailedException {
+    if (parameters.isDexRuntime()) {
+      return testForD8()
+          .addProgramClassFileData(classes)
+          .setMinApi(parameters.getApiLevel())
+          .compile()
+          .writeToZip();
+    }
+    Path path = temp.newFolder().toPath().resolve("classes.jar");
+    ArchiveConsumer consumer = new ArchiveConsumer(path);
+    for (byte[] clazz : classes) {
+      consumer.accept(ByteDataView.of(clazz), extractClassDescriptor(clazz), null);
+    }
+    consumer.finished(null);
+    return path;
+  }
+
   public static String binaryName(Class<?> clazz) {
     return DescriptorUtils.getBinaryNameFromJavaType(typeName(clazz));
   }
diff --git a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/StaticInterfaceMethodReferenceTest.java b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/StaticInterfaceMethodReferenceTest.java
new file mode 100644
index 0000000..627e0ae
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/StaticInterfaceMethodReferenceTest.java
@@ -0,0 +1,110 @@
+// 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.desugaring.interfacemethods;
+
+import static org.junit.Assert.assertFalse;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.utils.BooleanUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class StaticInterfaceMethodReferenceTest extends TestBase {
+
+  private final TestParameters parameters;
+  private final boolean isInterface;
+
+  @Parameterized.Parameters(name = "{0}, itf:{1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build(),
+        BooleanUtils.values());
+  }
+
+  public StaticInterfaceMethodReferenceTest(TestParameters parameters, boolean isInterface) {
+    this.parameters = parameters;
+    this.isInterface = isInterface;
+  }
+
+  @Test
+  public void test() throws Exception {
+    TestRunResult<?> result;
+    if (parameters.isCfRuntime()) {
+      result =
+          testForJvm()
+              .addProgramClasses(TestClass.class)
+              .addProgramClassFileData(getTarget(isInterface))
+              .run(parameters.getRuntime(), TestClass.class);
+    } else {
+      result =
+          testForD8()
+              .addOptionsModification(o -> o.testing.allowInvokeErrors = true)
+              .addProgramClasses(TestClass.class)
+              .addProgramClassFileData(getTarget(isInterface))
+              .run(parameters.getRuntime(), TestClass.class);
+    }
+    checkResult(result);
+  }
+
+  private void checkResult(TestRunResult<?> result) {
+    // If the reference is of correct type, or running on JDK8 which allows mismatch the
+    // output is the expected print.
+    if (isInterface
+        || (parameters.isCfRuntime() && parameters.getRuntime().asCf().getVm() == CfVm.JDK8)) {
+      result.assertSuccessWithOutputLines("Target::foo");
+      return;
+    }
+
+    // DEX runtimes do not check method reference types so the code will run.
+    // TODO(b/166732606): Compile to an ICCE? What about the "missing" target case?
+    assertFalse(isInterface);
+    if (parameters.isDexRuntime()) {
+      result.assertSuccessWithOutputLines("Target::foo");
+      return;
+    }
+
+    // Otherwise the run should result in an ICCE.
+    result.assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
+  }
+
+  private static byte[] getTarget(boolean isInterface) throws Exception {
+    return transformer(Target.class)
+        .setAccessFlags(
+            classAccessFlags -> {
+              if (isInterface) {
+                assert !classAccessFlags.isSuper();
+                assert classAccessFlags.isAbstract();
+                assert classAccessFlags.isInterface();
+              } else {
+                classAccessFlags.unsetAbstract();
+                classAccessFlags.unsetInterface();
+              }
+            })
+        .transform();
+  }
+
+  interface Target {
+
+    static void foo() {
+      System.out.println("Target::foo");
+    }
+  }
+
+  static class TestClass {
+
+    static void call(Runnable fn) {
+      fn.run();
+    }
+
+    public static void main(String[] args) {
+      call(Target::foo);
+    }
+  }
+}