diff --git a/src/main/java/com/android/tools/r8/D8Command.java b/src/main/java/com/android/tools/r8/D8Command.java
index 3291692..f0591ee 100644
--- a/src/main/java/com/android/tools/r8/D8Command.java
+++ b/src/main/java/com/android/tools/r8/D8Command.java
@@ -256,6 +256,7 @@
     internal.passthroughDexCode = true;
 
     // Assert some of R8 optimizations are disabled.
+    assert !internal.enableDynamicTypeOptimization;
     assert !internal.enableInlining;
     assert !internal.enableClassInlining;
     assert !internal.enableHorizontalClassMerging;
diff --git a/src/main/java/com/android/tools/r8/R8Command.java b/src/main/java/com/android/tools/r8/R8Command.java
index 5980ac3..f000ece 100644
--- a/src/main/java/com/android/tools/r8/R8Command.java
+++ b/src/main/java/com/android/tools/r8/R8Command.java
@@ -676,6 +676,7 @@
             ? LineNumberOptimization.ON
             : LineNumberOptimization.OFF;
 
+    assert internal.enableDynamicTypeOptimization || !proguardConfiguration.isOptimizing();
     assert internal.enableHorizontalClassMerging || !proguardConfiguration.isOptimizing();
     assert internal.enableVerticalClassMerging || !proguardConfiguration.isOptimizing();
     if (internal.debug) {
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 3a5bd94..15ee862 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -112,6 +112,7 @@
 
   public void disableGlobalOptimizations() {
     enableArgumentRemoval = false;
+    enableDynamicTypeOptimization = false;
     enableInlining = false;
     enableClassInlining = false;
     enableClassStaticizer = false;
@@ -133,6 +134,7 @@
   public boolean passthroughDexCode = false;
 
   // Optimization-related flags. These should conform to -dontoptimize and disableAllOptimizations.
+  public boolean enableDynamicTypeOptimization = true;
   public boolean enableHorizontalClassMerging = true;
   public boolean enableVerticalClassMerging = true;
   public boolean enableArgumentRemoval = true;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/dynamictype/DynamicTypeOptimizationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/dynamictype/DynamicTypeOptimizationTest.java
new file mode 100644
index 0000000..849927a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/dynamictype/DynamicTypeOptimizationTest.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.ir.optimize.dynamictype;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class DynamicTypeOptimizationTest extends TestBase {
+
+  private final boolean enableDynamicTypeOptimization;
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{1}, enable dynamic type optimization: {0}")
+  public static List<Object[]> data() {
+    return buildParameters(BooleanUtils.values(), getTestParameters().withAllRuntimes().build());
+  }
+
+  public DynamicTypeOptimizationTest(
+      boolean enableDynamicTypeOptimization, TestParameters parameters) {
+    this.enableDynamicTypeOptimization = enableDynamicTypeOptimization;
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(DynamicTypeOptimizationTest.class)
+        .addKeepMainRule(TestClass.class)
+        // Keep B to ensure that we will treat it as being instantiated.
+        .addKeepClassRulesWithAllowObfuscation(B.class)
+        .addOptionsModification(
+            options -> options.enableDynamicTypeOptimization = enableDynamicTypeOptimization)
+        .enableInliningAnnotations()
+        .setMinApi(parameters.getRuntime())
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(StringUtils.lines("Hello world!"));
+  }
+
+  private void inspect(CodeInspector inspector) {
+    ClassSubject mainClassSubject = inspector.clazz(TestClass.class);
+    assertThat(mainClassSubject, isPresent());
+
+    ClassSubject interfaceSubject = inspector.clazz(I.class);
+    assertThat(interfaceSubject, isPresent());
+
+    ClassSubject aClassSubject = inspector.clazz(A.class);
+    assertThat(aClassSubject, isPresent());
+
+    // Verify that the check-cast instruction is still present in testCheckCastRemoval().
+    MethodSubject testCheckCastRemovalMethod =
+        mainClassSubject.uniqueMethodWithName("testCheckCastRemoval");
+    assertThat(testCheckCastRemovalMethod, isPresent());
+    assertTrue(
+        testCheckCastRemovalMethod
+            .streamInstructions()
+            .anyMatch(instruction -> instruction.isCheckCast(aClassSubject.getFinalName())));
+
+    // Verify that the instance-of instruction is only present in testInstanceOfRemoval() if the
+    // dynamic type optimization is disabled.
+    MethodSubject testInstanceOfRemovalMethod =
+        mainClassSubject.uniqueMethodWithName("testInstanceOfRemoval");
+    assertThat(testInstanceOfRemovalMethod, isPresent());
+    // TODO(b/127461806): Update expectation.
+    assertTrue(
+        testInstanceOfRemovalMethod
+            .streamInstructions()
+            .anyMatch(instruction -> instruction.isInstanceOf(aClassSubject.getFinalName())));
+
+    // Verify that world() has been inlined() into testMethodInlining() unless the dynamic type
+    // optimization is disabled.
+    MethodSubject testMethodInliningMethod =
+        mainClassSubject.uniqueMethodWithName("testMethodInlining");
+    assertThat(testMethodInliningMethod, isPresent());
+    // TODO(b/127461806): Update expectation.
+    assertThat(
+        testMethodInliningMethod, invokesMethod(interfaceSubject.uniqueMethodWithName("world")));
+
+    // Verify that exclamationMark() has been rebound in testMethodRebinding() unless the dynamic
+    // type optimization is disabled.
+    MethodSubject testMethodRebindingMethod =
+        mainClassSubject.uniqueMethodWithName("testMethodRebinding");
+    assertThat(testMethodRebindingMethod, isPresent());
+    // TODO(b/127461806): Update expectation.
+    assertThat(
+        testMethodRebindingMethod,
+        invokesMethod(interfaceSubject.uniqueMethodWithName("exclamationMark")));
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) {
+      testCheckCastRemoval();
+      testInstanceOfRemoval();
+      testMethodInlining();
+      testMethodRebinding();
+    }
+
+    @NeverInline
+    private static void testCheckCastRemoval() {
+      // Used to verify that we do not remove check-cast instructions, since these are sometimes
+      // required for the program to pass the static type checker.
+      A obj = (A) get();
+      obj.hello();
+    }
+
+    @NeverInline
+    private static void testInstanceOfRemoval() {
+      // Used to verify that we remove trivial instance-of instructions.
+      if (get() instanceof A) {
+        System.out.print(" ");
+      }
+    }
+
+    @NeverInline
+    private static void testMethodInlining() {
+      // Used to verify that we identify a single target despite of the imprecise static type.
+      get().world();
+    }
+
+    @NeverInline
+    private static void testMethodRebinding() {
+      // Used to verify that we rebind to the most specific target when inlining is not possible.
+      get().exclamationMark();
+    }
+
+    @NeverInline
+    private static I get() {
+      return new A();
+    }
+  }
+
+  interface I {
+
+    void hello();
+
+    void world();
+
+    @NeverInline
+    void exclamationMark();
+  }
+
+  static class A implements I {
+
+    @Override
+    public void hello() {
+      System.out.print("Hello");
+    }
+
+    @Override
+    public void world() {
+      System.out.print("world");
+    }
+
+    @NeverInline
+    @Override
+    public void exclamationMark() {
+      System.out.println("!");
+    }
+  }
+
+  static class B implements I {
+
+    @Override
+    public void hello() {
+      System.out.println("Unreachable");
+    }
+
+    @Override
+    public void world() {
+      System.out.println("Unreachable");
+    }
+
+    @NeverInline
+    @Override
+    public void exclamationMark() {
+      System.out.println("Unreachable");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java
index 5f1b405..ded4f14 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java
@@ -222,6 +222,11 @@
   }
 
   @Override
+  public boolean isInstanceOf(String type) {
+    return isInstanceOf() && ((CfInstanceOf) instruction).getType().toString().equals(type);
+  }
+
+  @Override
   public boolean isIf() {
     return instruction instanceof CfIf || instruction instanceof CfIfCmp;
   }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/CodeMatchers.java b/src/test/java/com/android/tools/r8/utils/codeinspector/CodeMatchers.java
index 7d5381a..5dacc5a 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/CodeMatchers.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/CodeMatchers.java
@@ -31,7 +31,7 @@
 
       @Override
       public void describeTo(Description description) {
-        description.appendText(" does not invoke `" + target.toSourceString() + "`");
+        description.appendText("invokes method `" + target.toSourceString() + "`");
       }
 
       @Override
@@ -42,6 +42,6 @@
   }
 
   public static Predicate<InstructionSubject> isInvokeWithTarget(DexMethod target) {
-    return instruction -> instruction.isInvokeStatic() && instruction.getMethod() == target;
+    return instruction -> instruction.isInvoke() && instruction.getMethod() == target;
   }
 }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java
index 93faa64..3b04382 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java
@@ -340,6 +340,11 @@
     return instruction instanceof InstanceOf;
   }
 
+  @Override
+  public boolean isInstanceOf(String type) {
+    return isInstanceOf() && ((InstanceOf) instruction).getType().toString().equals(type);
+  }
+
   public boolean isConst4() {
     return instruction instanceof Const4;
   }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
index f2eb753..d297a3b 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
@@ -78,6 +78,8 @@
 
   boolean isInstanceOf();
 
+  boolean isInstanceOf(String type);
+
   boolean isIf(); // Also include CF/if_cmp* instructions.
 
   boolean isPackedSwitch();