diff --git a/src/main/java/com/android/tools/r8/graph/JarCode.java b/src/main/java/com/android/tools/r8/graph/JarCode.java
index 640172f..d64eaf0 100644
--- a/src/main/java/com/android/tools/r8/graph/JarCode.java
+++ b/src/main/java/com/android/tools/r8/graph/JarCode.java
@@ -10,9 +10,12 @@
 import com.android.tools.r8.ir.code.ValueNumberGenerator;
 import com.android.tools.r8.ir.conversion.IRBuilder;
 import com.android.tools.r8.ir.conversion.JarSourceCode;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.android.tools.r8.jar.InliningConstraintVisitor;
 import com.android.tools.r8.jar.JarRegisterEffectsVisitor;
 import com.android.tools.r8.naming.ClassNameMapper;
 import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.InternalOptions;
 import java.io.PrintWriter;
@@ -169,6 +172,21 @@
             DescriptorUtils.getDescriptorFromClassBinaryName(tryCatchBlockNode.type))));
   }
 
+  public Constraint computeInliningConstraint(
+      AppInfoWithLiveness appInfo, GraphLense graphLense, DexType invocationContext) {
+    InliningConstraintVisitor visitor =
+        new InliningConstraintVisitor(application, appInfo, graphLense, method, invocationContext);
+    AbstractInsnNode insn = node.instructions.getFirst();
+    while (insn != null) {
+      insn.accept(visitor);
+      if (visitor.isFinished()) {
+        break;
+      }
+      insn = insn.getNext();
+    }
+    return visitor.getConstraint();
+  }
+
   @Override
   public String toString() {
     triggerDelayedParsingIfNeccessary();
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java b/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java
index b343de7..1ad50bc 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeDirect.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.ir.conversion.CfBuilder;
 import com.android.tools.r8.ir.conversion.DexBuilder;
 import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
 import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
 import java.util.Collection;
 import java.util.Collections;
@@ -113,7 +114,7 @@
 
   @Override
   public Constraint inliningConstraint(AppInfoWithLiveness info, DexType invocationContext) {
-    return inliningConstraintForSinlgeTargetInvoke(info, invocationContext);
+    return new InliningConstraints(info).forInvokeDirect(getInvokedMethod(), invocationContext);
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java b/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java
index ff8f0d0..0fb447b 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeInterface.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.ir.conversion.CfBuilder;
 import com.android.tools.r8.ir.conversion.DexBuilder;
 import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
 import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
 import java.util.Collection;
 import java.util.List;
@@ -95,7 +96,7 @@
 
   @Override
   public Constraint inliningConstraint(AppInfoWithLiveness info, DexType invocationContext) {
-    return inliningConstraintForVirtualInvoke(info, invocationContext);
+    return new InliningConstraints(info).forInvokeInterface(getInvokedMethod(), invocationContext);
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java b/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java
index 5fe8972..56b659a 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java
@@ -5,9 +5,7 @@
 
 import com.android.tools.r8.cf.LoadStoreHelper;
 import com.android.tools.r8.cf.TypeVerificationHelper;
-import com.android.tools.r8.graph.AppInfo.ResolutionResult;
 import com.android.tools.r8.graph.AppInfoWithSubtyping;
-import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
@@ -85,85 +83,11 @@
     return lookupSingleTarget(appInfo, appInfo.dexItemFactory.objectType);
   }
 
+  // TODO(christofferqa): Pass an instance of InliningConstraints instead of [info] when
+  // InliningConstraints is complete.
   @Override
-  public abstract Constraint inliningConstraint(AppInfoWithLiveness info,
-      DexType invocationContext);
-
-  protected Constraint inliningConstraintForSinlgeTargetInvoke(AppInfoWithLiveness info,
-      DexType invocationContext) {
-    if (method.holder.isArrayType()) {
-      return Constraint.ALWAYS;
-    }
-    DexEncodedMethod target = lookupSingleTarget(info, invocationContext);
-    if (target != null) {
-      DexType methodHolder = target.method.holder;
-      DexClass methodClass = info.definitionFor(methodHolder);
-      if ((methodClass != null)) {
-        Constraint methodConstraint = Constraint
-            .deriveConstraint(invocationContext, methodHolder, target.accessFlags, info);
-        // We also have to take the constraint of the enclosing class into account.
-        Constraint classConstraint = Constraint
-            .deriveConstraint(invocationContext, methodHolder, methodClass.accessFlags, info);
-        return Constraint.min(methodConstraint, classConstraint);
-      }
-    }
-    return Constraint.NEVER;
-  }
-
-  protected Constraint inliningConstraintForVirtualInvoke(AppInfoWithSubtyping info,
-      DexType invocationContext) {
-    if (method.holder.isArrayType()) {
-      return Constraint.ALWAYS;
-    }
-    Collection<DexEncodedMethod> targets = lookupTargets(info, invocationContext);
-    if (targets == null) {
-      return Constraint.NEVER;
-    }
-
-    Constraint result = Constraint.ALWAYS;
-
-    // Perform resolution and derive inlining constraints based on the accessibility of the
-    // resolution result.
-    ResolutionResult resolutionResult = info.resolveMethod(method.holder, method);
-    DexEncodedMethod resolutionTarget = resolutionResult.asResultOfResolve();
-    if (resolutionTarget == null) {
-      // This will fail at runtime.
-      return Constraint.NEVER;
-    }
-    DexType methodHolder = resolutionTarget.method.holder;
-    DexClass methodClass = info.definitionFor(methodHolder);
-    assert methodClass != null;
-    Constraint methodConstraint = Constraint
-        .deriveConstraint(invocationContext, methodHolder, resolutionTarget.accessFlags, info);
-    result = Constraint.min(result, methodConstraint);
-    // We also have to take the constraint of the enclosing class of the resolution result
-    // into account. We do not allow inlining this method if it is calling something that
-    // is inaccessible. Inlining in that case could move the code to another package making a
-    // call succeed that should not succeed. Conversely, if the resolution result is accessible,
-    // we have to make sure that inlining cannot make it inaccessible.
-    Constraint classConstraint = Constraint
-        .deriveConstraint(invocationContext, methodHolder, methodClass.accessFlags, info);
-    result = Constraint.min(result, classConstraint);
-    if (result == Constraint.NEVER) {
-      return result;
-    }
-
-    // For each of the actual potential targets, derive constraints based on the accessibility
-    // of the method itself.
-    for (DexEncodedMethod target : targets) {
-      methodHolder = target.method.holder;
-      methodClass = info.definitionFor(methodHolder);
-      assert methodClass != null;
-      methodConstraint = Constraint
-          .deriveConstraint(invocationContext, methodHolder, target.accessFlags, info);
-      result = Constraint.min(result, methodConstraint);
-      if (result == Constraint.NEVER) {
-        return result;
-      }
-    }
-
-    return result;
-  }
+  public abstract Constraint inliningConstraint(
+      AppInfoWithLiveness info, DexType invocationContext);
 
   public abstract InlineAction computeInlining(InliningOracle decider, DexType invocationContext);
 
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java b/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java
index 81d4cdc..91f657d 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokePolymorphic.java
@@ -15,6 +15,7 @@
 import com.android.tools.r8.ir.conversion.DexBuilder;
 import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 import com.android.tools.r8.ir.optimize.Inliner.InlineAction;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
 import com.android.tools.r8.ir.optimize.InliningOracle;
 import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
 import java.util.Collection;
@@ -126,7 +127,8 @@
 
   @Override
   public Constraint inliningConstraint(AppInfoWithLiveness info, DexType invocationContext) {
-    return Constraint.NEVER;
+    return new InliningConstraints(info)
+        .forInvokePolymorphic(getInvokedMethod(), invocationContext);
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java b/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java
index 94df8d3..b985916 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeStatic.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.ir.conversion.DexBuilder;
 import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 import com.android.tools.r8.ir.optimize.Inliner.InlineAction;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
 import com.android.tools.r8.ir.optimize.InliningOracle;
 import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
 import java.util.Collection;
@@ -103,7 +104,7 @@
 
   @Override
   public Constraint inliningConstraint(AppInfoWithLiveness info, DexType invocationContext) {
-    return inliningConstraintForSinlgeTargetInvoke(info, invocationContext);
+    return new InliningConstraints(info).forInvokeStatic(getInvokedMethod(), invocationContext);
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java b/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java
index e5bd604..64f0d7b 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeSuper.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.ir.conversion.CfBuilder;
 import com.android.tools.r8.ir.conversion.DexBuilder;
 import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
 import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
 import java.util.Collection;
 import java.util.Collections;
@@ -112,7 +113,6 @@
 
   @Override
   public Constraint inliningConstraint(AppInfoWithLiveness info, DexType invocationContext) {
-    // The semantics of invoke super depend on the context.
-    return Constraint.SAMECLASS;
+    return new InliningConstraints(info).forInvokeSuper(getInvokedMethod(), invocationContext);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java b/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java
index d104270..85c80ed 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeVirtual.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.ir.conversion.CfBuilder;
 import com.android.tools.r8.ir.conversion.DexBuilder;
 import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
 import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
 import java.util.Collection;
 import java.util.List;
@@ -95,7 +96,7 @@
 
   @Override
   public Constraint inliningConstraint(AppInfoWithLiveness info, DexType invocationContext) {
-    return inliningConstraintForVirtualInvoke(info, invocationContext);
+    return new InliningConstraints(info).forInvokeVirtual(getInvokedMethod(), invocationContext);
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java b/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
new file mode 100644
index 0000000..d4a06cd
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
@@ -0,0 +1,148 @@
+// Copyright (c) 2018, 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;
+
+import com.android.tools.r8.graph.AppInfo.ResolutionResult;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLense;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
+import java.util.Collection;
+
+// Computes the inlining constraint for a given instruction.
+//
+// TODO(christofferqa): This class is incomplete.
+public class InliningConstraints {
+
+  private AppInfoWithLiveness appInfo;
+
+  // Currently used only by the vertical class merger (in all other cases this is the identity).
+  //
+  // When merging a type A into its subtype B we need to inline A.<init>() into B.<init>().
+  // Therefore, we need to be sure that A.<init>() can in fact be inlined into B.<init>() *before*
+  // we merge the two classes. However, at this point, we may reject the method A.<init>() from
+  // being inlined into B.<init>() only because it is not declared in the same class as B (which
+  // it would be after merging A and B).
+  //
+  // To circumvent this problem, the vertical class merger creates a graph lense that maps the
+  // type A to B, to create a temporary view of what the world would look like after class merging.
+  private GraphLense graphLense;
+
+  public InliningConstraints(AppInfoWithLiveness appInfo) {
+    this(appInfo, GraphLense.getIdentityLense());
+  }
+
+  public InliningConstraints(AppInfoWithLiveness appInfo, GraphLense graphLense) {
+    this.appInfo = appInfo;
+    this.graphLense = graphLense;
+  }
+
+  public Constraint forCheckCast(DexType type, DexType invocationContext) {
+    return Constraint.classIsVisible(invocationContext, type, appInfo);
+  }
+
+  public Constraint forInvokeDirect(DexMethod method, DexType invocationContext) {
+    return forSingleTargetInvoke(method, appInfo.lookupDirectTarget(method), invocationContext);
+  }
+
+  public Constraint forInvokeInterface(DexMethod method, DexType invocationContext) {
+    return forVirtualInvoke(method, appInfo.lookupInterfaceTargets(method), invocationContext);
+  }
+
+  public Constraint forInvokePolymorphic(DexMethod method, DexType invocationContext) {
+    return Constraint.NEVER;
+  }
+
+  public Constraint forInvokeStatic(DexMethod method, DexType invocationContext) {
+    return forSingleTargetInvoke(method, appInfo.lookupStaticTarget(method), invocationContext);
+  }
+
+  public Constraint forInvokeSuper(DexMethod method, DexType invocationContext) {
+    // The semantics of invoke super depend on the context.
+    return Constraint.SAMECLASS;
+  }
+
+  public Constraint forInvokeVirtual(DexMethod method, DexType invocationContext) {
+    return forVirtualInvoke(method, appInfo.lookupVirtualTargets(method), invocationContext);
+  }
+
+  private Constraint forSingleTargetInvoke(
+      DexMethod method, DexEncodedMethod target, DexType invocationContext) {
+    if (method.holder.isArrayType()) {
+      return Constraint.ALWAYS;
+    }
+    if (target != null) {
+      DexType methodHolder = graphLense.lookupType(target.method.holder);
+      DexClass methodClass = appInfo.definitionFor(methodHolder);
+      if (methodClass != null) {
+        Constraint methodConstraint =
+            Constraint.deriveConstraint(
+                invocationContext, methodHolder, target.accessFlags, appInfo);
+        // We also have to take the constraint of the enclosing class into account.
+        Constraint classConstraint =
+            Constraint.deriveConstraint(
+                invocationContext, methodHolder, methodClass.accessFlags, appInfo);
+        return Constraint.min(methodConstraint, classConstraint);
+      }
+    }
+    return Constraint.NEVER;
+  }
+
+  private Constraint forVirtualInvoke(
+      DexMethod method, Collection<DexEncodedMethod> targets, DexType invocationContext) {
+    if (method.holder.isArrayType()) {
+      return Constraint.ALWAYS;
+    }
+    if (targets == null) {
+      return Constraint.NEVER;
+    }
+
+    // Perform resolution and derive inlining constraints based on the accessibility of the
+    // resolution result.
+    ResolutionResult resolutionResult = appInfo.resolveMethod(method.holder, method);
+    DexEncodedMethod resolutionTarget = resolutionResult.asResultOfResolve();
+    if (resolutionTarget == null) {
+      // This will fail at runtime.
+      return Constraint.NEVER;
+    }
+
+    DexType methodHolder = graphLense.lookupType(resolutionTarget.method.holder);
+    DexClass methodClass = appInfo.definitionFor(methodHolder);
+    assert methodClass != null;
+    Constraint methodConstraint =
+        Constraint.deriveConstraint(
+            invocationContext, methodHolder, resolutionTarget.accessFlags, appInfo);
+    // We also have to take the constraint of the enclosing class of the resolution result
+    // into account. We do not allow inlining this method if it is calling something that
+    // is inaccessible. Inlining in that case could move the code to another package making a
+    // call succeed that should not succeed. Conversely, if the resolution result is accessible,
+    // we have to make sure that inlining cannot make it inaccessible.
+    Constraint classConstraint =
+        Constraint.deriveConstraint(
+            invocationContext, methodHolder, methodClass.accessFlags, appInfo);
+    Constraint result = Constraint.min(methodConstraint, classConstraint);
+    if (result == Constraint.NEVER) {
+      return result;
+    }
+
+    // For each of the actual potential targets, derive constraints based on the accessibility
+    // of the method itself.
+    for (DexEncodedMethod target : targets) {
+      methodHolder = graphLense.lookupType(target.method.holder);
+      assert appInfo.definitionFor(methodHolder) != null;
+      methodConstraint =
+          Constraint.deriveConstraint(invocationContext, methodHolder, target.accessFlags, appInfo);
+      result = Constraint.min(result, methodConstraint);
+      if (result == Constraint.NEVER) {
+        return result;
+      }
+    }
+
+    return result;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/jar/InliningConstraintVisitor.java b/src/main/java/com/android/tools/r8/jar/InliningConstraintVisitor.java
new file mode 100644
index 0000000..5652be8
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/jar/InliningConstraintVisitor.java
@@ -0,0 +1,128 @@
+// Copyright (c) 2018, 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.jar;
+
+import static org.objectweb.asm.Opcodes.ASM6;
+
+import com.android.tools.r8.dex.Constants;
+import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLense;
+import com.android.tools.r8.graph.JarApplicationReader;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.android.tools.r8.ir.optimize.InliningConstraints;
+import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+// This visitor can be used to determine if a piece of jar code has any instructions that the
+// inliner would not be willing to inline. This can be used to determine if a method can be force
+// inlined although its IR is still not available.
+//
+// TODO(christofferqa): This class is incomplete. Still need to add support for ConstClass,
+// InstanceGet, InstanceOf, InstancePut, Monitor, MoveException, NewArrayEmpty, NewInstance,
+// StaticGet, StaticPut, etc.
+public class InliningConstraintVisitor extends MethodVisitor {
+
+  private final JarApplicationReader application;
+  private final AppInfoWithLiveness appInfo;
+  private final InliningConstraints inliningConstraints;
+  private final DexMethod method;
+  private final DexType invocationContext;
+
+  private Constraint constraint = Constraint.ALWAYS;
+
+  public InliningConstraintVisitor(
+      JarApplicationReader application,
+      AppInfoWithLiveness appInfo,
+      GraphLense graphLense,
+      DexMethod method,
+      DexType invocationContext) {
+    super(ASM6);
+    this.application = application;
+    this.appInfo = appInfo;
+    this.inliningConstraints = new InliningConstraints(appInfo, graphLense);
+    this.method = method;
+    this.invocationContext = invocationContext;
+  }
+
+  public Constraint getConstraint() {
+    return constraint;
+  }
+
+  private void updateConstraint(Constraint other) {
+    constraint = Constraint.min(constraint, other);
+  }
+
+  // Used to signal that the result is ready, such that we do not need to visit all instructions of
+  // the method, if we can see early on that it cannot be inlined anyway.
+  public boolean isFinished() {
+    return constraint == Constraint.NEVER;
+  }
+
+  @Override
+  public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
+    DexType ownerType = application.getTypeFromName(owner);
+    DexMethod target = application.getMethod(ownerType, name, desc);
+    switch (opcode) {
+      case Opcodes.INVOKEINTERFACE:
+        updateConstraint(inliningConstraints.forInvokeInterface(target, invocationContext));
+        break;
+
+      case Opcodes.INVOKESPECIAL:
+        if (name.equals(Constants.INSTANCE_INITIALIZER_NAME) || ownerType == invocationContext) {
+          updateConstraint(inliningConstraints.forInvokeDirect(target, invocationContext));
+        } else {
+          updateConstraint(inliningConstraints.forInvokeSuper(target, invocationContext));
+        }
+        break;
+
+      case Opcodes.INVOKESTATIC:
+        updateConstraint(inliningConstraints.forInvokeStatic(target, invocationContext));
+        break;
+
+      case Opcodes.INVOKEVIRTUAL:
+        // Instructions that target a private method in the same class are translated to
+        // invoke-direct.
+        if (target.holder == method.holder) {
+          DexClass clazz = appInfo.definitionFor(target.holder);
+          if (clazz != null && clazz.lookupDirectMethod(target) != null) {
+            updateConstraint(inliningConstraints.forInvokeDirect(target, invocationContext));
+            break;
+          }
+        }
+
+        updateConstraint(inliningConstraints.forInvokeVirtual(target, invocationContext));
+        break;
+
+      default:
+        throw new Unreachable("Unexpected opcode " + opcode);
+    }
+  }
+
+  @Override
+  public void visitTypeInsn(int opcode, String typeName) {
+    DexType type = application.getTypeFromName(typeName);
+    switch (opcode) {
+      case Opcodes.ANEWARRAY:
+        break;
+
+      case Opcodes.CHECKCAST:
+        updateConstraint(inliningConstraints.forCheckCast(type, invocationContext));
+        break;
+
+      case Opcodes.INSTANCEOF:
+        break;
+
+      case Opcodes.NEW:
+        break;
+
+      default:
+        throw new Unreachable("Unexpected opcode " + opcode);
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
index 531c731..0ed3c11 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
@@ -22,12 +22,14 @@
 import com.android.tools.r8.graph.DexTypeList;
 import com.android.tools.r8.graph.GraphLense;
 import com.android.tools.r8.graph.GraphLense.Builder;
+import com.android.tools.r8.graph.JarCode;
 import com.android.tools.r8.graph.KeyedDexItem;
 import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.graph.ParameterAnnotationsList;
 import com.android.tools.r8.graph.PresortedComparable;
 import com.android.tools.r8.graph.UseRegistry;
 import com.android.tools.r8.ir.code.Invoke.Type;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 import com.android.tools.r8.ir.synthetic.ForwardMethodSourceCode;
 import com.android.tools.r8.ir.synthetic.SynthesizedCode;
 import com.android.tools.r8.logging.Log;
@@ -294,8 +296,7 @@
       if (appInfo.isPinned(method.method)) {
         return false;
       }
-      // TODO(christofferqa): We should always be able to force inline initializers.
-      if (method.isInstanceInitializer() && disallowInlining(method)) {
+      if (method.isInstanceInitializer() && disallowInlining(method, singleSubtype)) {
         // Cannot guarantee that markForceInline() will work.
         if (Log.ENABLED) {
           AbortReason.UNSAFE_INLINING.printLogMessageForClass(clazz);
@@ -1358,83 +1359,52 @@
     }
   }
 
-  private static boolean disallowInlining(DexEncodedMethod method) {
+  private boolean disallowInlining(DexEncodedMethod method, DexType invocationContext) {
     // TODO(christofferqa): Determine the situations where markForceInline() may fail, and ensure
     // that we always return true here in these cases.
-    MethodInlineDecision registry = new MethodInlineDecision();
-    method.getCode().registerCodeReferences(registry);
-    return registry.isInliningDisallowed();
+    if (method.getCode().isJarCode()) {
+      JarCode jarCode = method.getCode().asJarCode();
+      Constraint constraint =
+          jarCode.computeInliningConstraint(
+              appInfo,
+              new SingleTypeMapperGraphLense(method.method.holder, invocationContext),
+              invocationContext);
+      return constraint == Constraint.NEVER;
+    }
+    // TODO(christofferqa): For non-jar code we currently cannot guarantee that markForceInline()
+    // will succeed.
+    return true;
   }
 
-  private static class MethodInlineDecision extends UseRegistry {
-    private boolean disallowInlining = false;
+  private static class SingleTypeMapperGraphLense extends GraphLense {
 
-    public boolean isInliningDisallowed() {
-      return disallowInlining;
-    }
+    private final DexType source;
+    private final DexType target;
 
-    private boolean allowInlining() {
-      return true;
-    }
-
-    private boolean disallowInlining() {
-      disallowInlining = true;
-      return true;
+    public SingleTypeMapperGraphLense(DexType source, DexType target) {
+      this.source = source;
+      this.target = target;
     }
 
     @Override
-    public boolean registerInvokeInterface(DexMethod method) {
-      return disallowInlining();
+    public DexType lookupType(DexType type) {
+      return type == source ? target : type;
     }
 
     @Override
-    public boolean registerInvokeVirtual(DexMethod method) {
-      return disallowInlining();
+    public GraphLenseLookupResult lookupMethod(
+        DexMethod method, DexEncodedMethod context, Type type) {
+      throw new Unreachable();
     }
 
     @Override
-    public boolean registerInvokeDirect(DexMethod method) {
-      return allowInlining();
+    public DexField lookupField(DexField field) {
+      throw new Unreachable();
     }
 
     @Override
-    public boolean registerInvokeStatic(DexMethod method) {
-      return allowInlining();
-    }
-
-    @Override
-    public boolean registerInvokeSuper(DexMethod method) {
-      return allowInlining();
-    }
-
-    @Override
-    public boolean registerInstanceFieldWrite(DexField field) {
-      return allowInlining();
-    }
-
-    @Override
-    public boolean registerInstanceFieldRead(DexField field) {
-      return allowInlining();
-    }
-
-    @Override
-    public boolean registerNewInstance(DexType type) {
-      return allowInlining();
-    }
-
-    @Override
-    public boolean registerStaticFieldRead(DexField field) {
-      return allowInlining();
-    }
-
-    @Override
-    public boolean registerStaticFieldWrite(DexField field) {
-      return allowInlining();
-    }
-
-    @Override
-    public boolean registerTypeReference(DexType type) {
-      return allowInlining();
+    public boolean isContextFreeForMethods() {
+      throw new Unreachable();
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/classmerging/ClassMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/ClassMergingTest.java
index c2df29a..55f0919 100644
--- a/src/test/java/com/android/tools/r8/classmerging/ClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/ClassMergingTest.java
@@ -43,6 +43,7 @@
 import java.util.concurrent.ExecutionException;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
+import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
@@ -335,6 +336,7 @@
   //   }
   @Test
   @IgnoreForRangeOfVmVersions(from = Version.V5_1_1, to = Version.V6_0_1)
+  @Ignore // TODO(christofferqa): Need to use jasmin for the classes that are merge candidates.
   public void testSuperCallToMergedClassIsRewritten() throws Exception {
     String main = "classmerging.SuperCallToMergedClassIsRewrittenTest";
     Set<String> preservedClassNames =