diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index fd547cf..c03d928 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -369,7 +369,7 @@
         if (options.enableClassMerging && options.enableInlining) {
           timing.begin("ClassMerger");
           VerticalClassMerger classMerger =
-              new VerticalClassMerger(application, appViewWithLiveness, timing);
+              new VerticalClassMerger(application, appViewWithLiveness, executorService, timing);
           appView.setGraphLense(classMerger.run());
           timing.end();
           application = application.asDirect().rewrittenWithLense(appView.getGraphLense());
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/MethodPoolCollection.java b/src/main/java/com/android/tools/r8/ir/optimize/MethodPoolCollection.java
index 9af3967..bd3acb6 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/MethodPoolCollection.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/MethodPoolCollection.java
@@ -7,13 +7,16 @@
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.utils.MethodSignatureEquivalence;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
 import com.google.common.base.Equivalence;
 import com.google.common.base.Equivalence.Wrapper;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Deque;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -22,6 +25,7 @@
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
+import java.util.function.Predicate;
 
 // Per-class collection of method signatures.
 //
@@ -41,13 +45,30 @@
     timing.begin("Building method pool collection");
     try {
       List<Future<?>> futures = new ArrayList<>();
-      submitAll(application.classes(), futures, executorService);
+      @SuppressWarnings("unchecked")
+      List<DexClass> classes = (List) application.classes();
+      submitAll(classes, futures, executorService);
       ThreadUtils.awaitFutures(futures);
     } finally {
       timing.end();
     }
   }
 
+  public MethodPool buildForHierarchy(
+      DexClass clazz, ExecutorService executorService, Timing timing) throws ExecutionException {
+    timing.begin("Building method pool collection");
+    try {
+      List<Future<?>> futures = new ArrayList<>();
+      submitAll(
+          getAllSuperTypesInclusive(clazz, methodPools::containsKey), futures, executorService);
+      submitAll(getAllSubTypesExclusive(clazz, methodPools::containsKey), futures, executorService);
+      ThreadUtils.awaitFutures(futures);
+    } finally {
+      timing.end();
+    }
+    return get(clazz);
+  }
+
   public MethodPool get(DexClass clazz) {
     assert methodPools.containsKey(clazz);
     return methodPools.get(clazz);
@@ -64,8 +85,8 @@
   }
 
   private void submitAll(
-      Iterable<DexProgramClass> classes, List<Future<?>> futures, ExecutorService executorService) {
-    for (DexProgramClass clazz : classes) {
+      Iterable<DexClass> classes, List<Future<?>> futures, ExecutorService executorService) {
+    for (DexClass clazz : classes) {
       futures.add(executorService.submit(computeMethodPoolPerClass(clazz)));
     }
   }
@@ -101,6 +122,51 @@
     };
   }
 
+  private Set<DexClass> getAllSuperTypesInclusive(
+      DexClass subject, Predicate<DexClass> stoppingCriterion) {
+    Set<DexClass> superTypes = new HashSet<>();
+    Deque<DexClass> worklist = new ArrayDeque<>();
+    worklist.add(subject);
+    while (!worklist.isEmpty()) {
+      DexClass clazz = worklist.pop();
+      if (stoppingCriterion.test(clazz)) {
+        continue;
+      }
+      if (superTypes.add(clazz)) {
+        if (clazz.superType != null) {
+          addNonNull(worklist, application.definitionFor(clazz.superType));
+        }
+        for (DexType interfaceType : clazz.interfaces.values) {
+          addNonNull(worklist, application.definitionFor(interfaceType));
+        }
+      }
+    }
+    return superTypes;
+  }
+
+  private Set<DexClass> getAllSubTypesExclusive(
+      DexClass subject, Predicate<DexClass> stoppingCriterion) {
+    Set<DexClass> subTypes = new HashSet<>();
+    Deque<DexClass> worklist = new ArrayDeque<>();
+    subject.type.forAllExtendsSubtypes(
+        type -> addNonNull(worklist, application.definitionFor(type)));
+    subject.type.forAllImplementsSubtypes(
+        type -> addNonNull(worklist, application.definitionFor(type)));
+    while (!worklist.isEmpty()) {
+      DexClass clazz = worklist.pop();
+      if (stoppingCriterion.test(clazz)) {
+        continue;
+      }
+      if (subTypes.add(clazz)) {
+        clazz.type.forAllExtendsSubtypes(
+            type -> addNonNull(worklist, application.definitionFor(type)));
+        clazz.type.forAllImplementsSubtypes(
+            type -> addNonNull(worklist, application.definitionFor(type)));
+      }
+    }
+    return subTypes;
+  }
+
   public static class MethodPool {
     private MethodPool superType;
     private final Set<MethodPool> interfaces = new HashSet<>();
@@ -124,6 +190,10 @@
       assert added;
     }
 
+    public void seen(DexMethod method) {
+      seen(MethodSignatureEquivalence.get().wrap(method));
+    }
+
     public synchronized void seen(Wrapper<DexMethod> method) {
       boolean added = methodPool.add(method);
       assert added;
@@ -144,4 +214,10 @@
           || subTypes.stream().anyMatch(subType -> subType.hasSeenDownwardRecursive(method));
     }
   }
+
+  private static <T> void addNonNull(Collection<T> collection, T item) {
+    if (item != null) {
+      collection.add(item);
+    }
+  }
 }
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 4d072c4..451b2cb 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
@@ -7,6 +7,7 @@
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppInfo.ResolutionResult;
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.Code;
 import com.android.tools.r8.graph.DexAnnotationSet;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexClass;
@@ -22,6 +23,7 @@
 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.GraphLense.GraphLenseLookupResult;
 import com.android.tools.r8.graph.JarCode;
 import com.android.tools.r8.graph.KeyedDexItem;
 import com.android.tools.r8.graph.MethodAccessFlags;
@@ -30,6 +32,8 @@
 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.optimize.MethodPoolCollection;
+import com.android.tools.r8.ir.optimize.MethodPoolCollection.MethodPool;
 import com.android.tools.r8.ir.synthetic.ForwardMethodSourceCode;
 import com.android.tools.r8.ir.synthetic.SynthesizedCode;
 import com.android.tools.r8.logging.Log;
@@ -58,7 +62,11 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
 import java.util.function.Predicate;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.MethodNode;
 
 /**
  * Merges Supertypes with a single implementation into their single subtype.
@@ -150,7 +158,9 @@
 
   private final DexApplication application;
   private final AppInfoWithLiveness appInfo;
+  private final ExecutorService executorService;
   private final GraphLense graphLense;
+  private final MethodPoolCollection methodPoolCollection;
   private final Timing timing;
   private Collection<DexMethod> invokes;
 
@@ -170,10 +180,15 @@
   private final VerticalClassMergerGraphLense.Builder renamedMembersLense;
 
   public VerticalClassMerger(
-      DexApplication application, AppView<AppInfoWithLiveness> appView, Timing timing) {
+      DexApplication application,
+      AppView<AppInfoWithLiveness> appView,
+      ExecutorService executorService,
+      Timing timing) {
     this.application = application;
     this.appInfo = appView.getAppInfo();
+    this.executorService = executorService;
     this.graphLense = appView.getGraphLense();
+    this.methodPoolCollection = new MethodPoolCollection(application);
     this.renamedMembersLense = VerticalClassMergerGraphLense.builder(appInfo);
     this.timing = timing;
 
@@ -520,7 +535,7 @@
     }
   }
 
-  public GraphLense run() {
+  public GraphLense run() throws ExecutionException {
     timing.begin("merge");
     GraphLense mergingGraphLense = mergeClasses(graphLense);
     timing.end();
@@ -561,7 +576,7 @@
     }
   }
 
-  private GraphLense mergeClasses(GraphLense graphLense) {
+  private GraphLense mergeClasses(GraphLense graphLense) throws ExecutionException {
     Deque<DexProgramClass> worklist = new ArrayDeque<>();
     Set<DexProgramClass> seenBefore = new HashSet<>();
 
@@ -726,7 +741,7 @@
       this.target = target;
     }
 
-    public boolean merge() {
+    public boolean merge() throws ExecutionException {
       // Merge the class [clazz] into [targetClass] by adding all methods to
       // targetClass that are not currently contained.
       // Step 1: Merge methods
@@ -792,12 +807,37 @@
           }
         }
 
-        // This virtual method could be called directly from a sub class via an invoke-super
-        // instruction. Therefore, we translate this virtual method into a direct method, such that
-        // relevant invoke-super instructions can be rewritten into invoke-direct instructions.
-        DexEncodedMethod resultingDirectMethod =
-            renameMethod(virtualMethod, availableMethodSignatures, Rename.ALWAYS);
-        makePrivate(resultingDirectMethod);
+        DexEncodedMethod resultingDirectMethod;
+        if (source.accessFlags.isInterface()) {
+          // Moving a default interface method into its subtype. This method could be hit directly
+          // via an invoke-super instruction from any of the transitive subtypes of this interface,
+          // due to the way invoke-super works on default interface methods. In order to be able
+          // to hit this method directly after the merge, we need to make it public, and find a
+          // method name that does not collide with one in the hierarchy of this class.
+          MethodPool methodPoolForTarget =
+              methodPoolCollection.buildForHierarchy(target, executorService, timing);
+          resultingDirectMethod =
+              renameMethod(
+                  virtualMethod,
+                  method ->
+                      availableMethodSignatures.test(method)
+                          && !methodPoolForTarget.hasSeen(
+                              MethodSignatureEquivalence.get().wrap(method)),
+                  Rename.ALWAYS,
+                  getStaticProto(virtualMethod.method.holder, virtualMethod.method.proto));
+          makeStatic(resultingDirectMethod);
+
+          // Update method pool collection now that we are adding a new public method.
+          methodPoolForTarget.seen(resultingDirectMethod.method);
+        } else {
+          // This virtual method could be called directly from a sub class via an invoke-super in-
+          // struction. Therefore, we translate this virtual method into a direct method, such that
+          // relevant invoke-super instructions can be rewritten into invoke-direct instructions.
+          resultingDirectMethod =
+              renameMethod(virtualMethod, availableMethodSignatures, Rename.ALWAYS);
+          makePrivate(resultingDirectMethod);
+        }
+
         add(directMethods, resultingDirectMethod, MethodSignatureEquivalence.get());
 
         // Record that invoke-super instructions in the target class should be redirected to the
@@ -811,7 +851,7 @@
           // Note that this method is added independently of whether it will actually be used. If
           // it turns out that the method is never used, it will be removed by the final round
           // of tree shaking.
-          shadowedBy = buildBridgeMethod(virtualMethod, resultingDirectMethod.method);
+          shadowedBy = buildBridgeMethod(virtualMethod, resultingDirectMethod);
           add(virtualMethods, shadowedBy, MethodSignatureEquivalence.get());
         }
 
@@ -903,7 +943,8 @@
         // rewrite any invocations on the form "invoke-super J.m()" to "invoke-direct C.m$I()",
         // if I has a supertype J. This is due to the fact that invoke-super instructions that
         // resolve to a method on an interface never hit an implementation below that interface.
-        deferredRenamings.mapVirtualMethodToDirectInType(oldTarget, newTarget, target.type);
+        deferredRenamings.mapVirtualMethodToDirectInType(
+            oldTarget, new GraphLenseLookupResult(newTarget, Type.STATIC), target.type);
       } else {
         // If we merge class B into class C, and class C contains an invocation super.m(), then it
         // is insufficient to rewrite "invoke-super B.m()" to "invoke-direct C.m$B()" (the method
@@ -922,7 +963,7 @@
                   || appInfo.lookupSuperTarget(signatureInHolder, holder.type) != null;
           if (resolutionSucceeds) {
             deferredRenamings.mapVirtualMethodToDirectInType(
-                signatureInHolder, newTarget, target.type);
+                signatureInHolder, new GraphLenseLookupResult(newTarget, Type.DIRECT), target.type);
           } else {
             break;
           }
@@ -944,7 +985,9 @@
                       || appInfo.lookupSuperTarget(signatureInHolder, holder.type) != null;
               if (resolutionSucceededBeforeMerge) {
                 deferredRenamings.mapVirtualMethodToDirectInType(
-                    signatureInType, newTarget, target.type);
+                    signatureInType,
+                    new GraphLenseLookupResult(newTarget, Type.DIRECT),
+                    target.type);
               }
             }
           }
@@ -974,23 +1017,38 @@
     }
 
     private DexEncodedMethod buildBridgeMethod(
-        DexEncodedMethod method, DexMethod invocationTarget) {
+        DexEncodedMethod method, DexEncodedMethod invocationTarget) {
       DexType holder = target.type;
-      DexProto proto = invocationTarget.proto;
+      DexProto proto = method.method.proto;
       DexString name = method.method.name;
       MethodAccessFlags accessFlags = method.accessFlags.copy();
       accessFlags.setBridge();
       accessFlags.setSynthetic();
       accessFlags.unsetAbstract();
-      DexEncodedMethod bridge = new DexEncodedMethod(
-          application.dexItemFactory.createMethod(holder, proto, name),
-          accessFlags,
-          DexAnnotationSet.empty(),
-          ParameterAnnotationsList.empty(),
-          new SynthesizedCode(
-              new ForwardMethodSourceCode(holder, proto, holder, invocationTarget, Type.DIRECT),
-              registry -> registry.registerInvokeDirect(invocationTarget)),
-          method.hasClassFileVersion() ? method.getClassFileVersion() : -1);
+      SynthesizedCode code;
+      if (invocationTarget.isPrivateMethod()) {
+        assert !invocationTarget.isStaticMethod();
+        code =
+            new SynthesizedCode(
+                new ForwardMethodSourceCode(
+                    holder, proto, holder, invocationTarget.method, Type.DIRECT),
+                registry -> registry.registerInvokeDirect(invocationTarget.method));
+      } else {
+        assert invocationTarget.isStaticMethod();
+        code =
+            new SynthesizedCode(
+                new ForwardMethodSourceCode(
+                    holder, proto, null, invocationTarget.method, Type.STATIC),
+                registry -> registry.registerInvokeStatic(invocationTarget.method));
+      }
+      DexEncodedMethod bridge =
+          new DexEncodedMethod(
+              application.dexItemFactory.createMethod(holder, proto, name),
+              accessFlags,
+              DexAnnotationSet.empty(),
+              ParameterAnnotationsList.empty(),
+              code,
+              method.hasClassFileVersion() ? method.getClassFileVersion() : -1);
       if (method.getOptimizationInfo().isPublicized()) {
         // The bridge is now the public method serving the role of the original method, and should
         // reflect that this method was publicized.
@@ -1106,6 +1164,14 @@
 
     private DexEncodedMethod renameMethod(
         DexEncodedMethod method, Predicate<DexMethod> availableMethodSignatures, Rename strategy) {
+      return renameMethod(method, availableMethodSignatures, strategy, method.method.proto);
+    }
+
+    private DexEncodedMethod renameMethod(
+        DexEncodedMethod method,
+        Predicate<DexMethod> availableMethodSignatures,
+        Rename strategy,
+        DexProto newProto) {
       // We cannot handle renaming static initializers yet and constructors should have been
       // renamed already.
       assert !method.accessFlags.isConstructor() || strategy == Rename.NEVER;
@@ -1115,8 +1181,7 @@
       DexMethod newSignature;
       switch (strategy) {
         case IF_NEEDED:
-          newSignature =
-              application.dexItemFactory.createMethod(target.type, method.method.proto, oldName);
+          newSignature = application.dexItemFactory.createMethod(target.type, newProto, oldName);
           if (availableMethodSignatures.test(newSignature)) {
             break;
           }
@@ -1126,15 +1191,13 @@
           int count = 1;
           do {
             DexString newName = getFreshName(oldName.toSourceString(), count, oldHolder);
-            newSignature =
-                application.dexItemFactory.createMethod(target.type, method.method.proto, newName);
+            newSignature = application.dexItemFactory.createMethod(target.type, newProto, newName);
             count++;
           } while (!availableMethodSignatures.test(newSignature));
           break;
 
         case NEVER:
-          newSignature =
-              application.dexItemFactory.createMethod(target.type, method.method.proto, oldName);
+          newSignature = application.dexItemFactory.createMethod(target.type, newProto, oldName);
           assert availableMethodSignatures.test(newSignature);
           break;
 
@@ -1173,6 +1236,24 @@
     method.accessFlags.setPrivate();
   }
 
+  private static void makeStatic(DexEncodedMethod method) {
+    method.accessFlags.setStatic();
+
+    Code code = method.getCode();
+    if (code.isJarCode()) {
+      MethodNode node = code.asJarCode().getNode();
+      node.access |= Opcodes.ACC_STATIC;
+      node.desc = method.method.proto.toDescriptorString();
+    }
+  }
+
+  private DexProto getStaticProto(DexType receiverType, DexProto proto) {
+    DexType[] parameterTypes = new DexType[proto.parameters.size() + 1];
+    parameterTypes[0] = receiverType;
+    System.arraycopy(proto.parameters.values, 0, parameterTypes, 1, proto.parameters.size());
+    return appInfo.dexItemFactory.createProto(proto.returnType, parameterTypes);
+  }
+
   private class TreeFixer {
 
     private final Builder lense = GraphLense.builder();
diff --git a/src/main/java/com/android/tools/r8/shaking/VerticalClassMergerGraphLense.java b/src/main/java/com/android/tools/r8/shaking/VerticalClassMergerGraphLense.java
index fa10215..5974e60 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMergerGraphLense.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMergerGraphLense.java
@@ -48,14 +48,15 @@
   private final AppInfo appInfo;
 
   private final Set<DexMethod> mergedMethods;
-  private final Map<DexType, Map<DexMethod, DexMethod>> contextualVirtualToDirectMethodMaps;
+  private final Map<DexType, Map<DexMethod, GraphLenseLookupResult>>
+      contextualVirtualToDirectMethodMaps;
 
   public VerticalClassMergerGraphLense(
       AppInfo appInfo,
       Map<DexField, DexField> fieldMap,
       Map<DexMethod, DexMethod> methodMap,
       Set<DexMethod> mergedMethods,
-      Map<DexType, Map<DexMethod, DexMethod>> contextualVirtualToDirectMethodMaps,
+      Map<DexType, Map<DexMethod, GraphLenseLookupResult>> contextualVirtualToDirectMethodMaps,
       GraphLense previousLense) {
     super(ImmutableMap.of(), methodMap, fieldMap, previousLense, appInfo.dexItemFactory);
     this.appInfo = appInfo;
@@ -73,17 +74,18 @@
     assert isContextFreeForMethod(method) || (context != null && type != null);
     GraphLenseLookupResult previous = previousLense.lookupMethod(method, context, type);
     if (previous.getType() == Type.SUPER && !mergedMethods.contains(context.method)) {
-      Map<DexMethod, DexMethod> virtualToDirectMethodMap =
+      Map<DexMethod, GraphLenseLookupResult> virtualToDirectMethodMap =
           contextualVirtualToDirectMethodMaps.get(context.method.holder);
       if (virtualToDirectMethodMap != null) {
-        DexMethod directMethod = virtualToDirectMethodMap.get(previous.getMethod());
-        if (directMethod != null) {
+        GraphLenseLookupResult lookup = virtualToDirectMethodMap.get(previous.getMethod());
+        if (lookup != null) {
           // If the super class A of the enclosing class B (i.e., context.method.holder)
           // has been merged into B during vertical class merging, and this invoke-super instruction
           // was resolving to a method in A, then the target method has been changed to a direct
           // method and moved into B, so that we need to use an invoke-direct instruction instead of
-          // invoke-super.
-          return new GraphLenseLookupResult(directMethod, Type.DIRECT);
+          // invoke-super (or invoke-static, if the method was originally a default interface
+          // method).
+          return lookup;
         }
       }
     }
@@ -102,11 +104,11 @@
     ImmutableSet.Builder<DexMethod> builder = ImmutableSet.builder();
     for (DexMethod previous : previousLense.lookupMethodInAllContexts(method)) {
       builder.add(methodMap.getOrDefault(previous, previous));
-      for (Map<DexMethod, DexMethod> virtualToDirectMethodMap :
+      for (Map<DexMethod, GraphLenseLookupResult> virtualToDirectMethodMap :
           contextualVirtualToDirectMethodMaps.values()) {
-        DexMethod directMethod = virtualToDirectMethodMap.get(previous);
-        if (directMethod != null) {
-          builder.add(directMethod);
+        GraphLenseLookupResult lookup = virtualToDirectMethodMap.get(previous);
+        if (lookup != null) {
+          builder.add(lookup.getMethod());
         }
       }
     }
@@ -124,7 +126,7 @@
       return false;
     }
     DexMethod previous = previousLense.lookupMethod(method);
-    for (Map<DexMethod, DexMethod> virtualToDirectMethodMap :
+    for (Map<DexMethod, GraphLenseLookupResult> virtualToDirectMethodMap :
         contextualVirtualToDirectMethodMaps.values()) {
       if (virtualToDirectMethodMap.containsKey(previous)) {
         return false;
@@ -139,8 +141,8 @@
     protected final Map<DexField, DexField> fieldMap = new HashMap<>();
     protected final Map<DexMethod, DexMethod> methodMap = new HashMap<>();
     private final ImmutableSet.Builder<DexMethod> mergedMethodsBuilder = ImmutableSet.builder();
-    private final Map<DexType, Map<DexMethod, DexMethod>> contextualVirtualToDirectMethodMaps =
-        new HashMap<>();
+    private final Map<DexType, Map<DexMethod, GraphLenseLookupResult>>
+        contextualVirtualToDirectMethodMaps = new HashMap<>();
 
     private Builder(AppInfo appInfo) {
       this.appInfo = appInfo;
@@ -189,7 +191,7 @@
     }
 
     public boolean hasMappingForSignatureInContext(DexType context, DexMethod signature) {
-      Map<DexMethod, DexMethod> virtualToDirectMethodMap =
+      Map<DexMethod, GraphLenseLookupResult> virtualToDirectMethodMap =
           contextualVirtualToDirectMethodMaps.get(context);
       if (virtualToDirectMethodMap != null) {
         return virtualToDirectMethodMap.containsKey(signature);
@@ -209,8 +211,9 @@
       methodMap.put(from, to);
     }
 
-    public void mapVirtualMethodToDirectInType(DexMethod from, DexMethod to, DexType type) {
-      Map<DexMethod, DexMethod> virtualToDirectMethodMap =
+    public void mapVirtualMethodToDirectInType(
+        DexMethod from, GraphLenseLookupResult to, DexType type) {
+      Map<DexMethod, GraphLenseLookupResult> virtualToDirectMethodMap =
           contextualVirtualToDirectMethodMaps.computeIfAbsent(type, key -> new HashMap<>());
       virtualToDirectMethodMap.put(from, to);
     }
@@ -220,8 +223,10 @@
       methodMap.putAll(builder.methodMap);
       mergedMethodsBuilder.addAll(builder.mergedMethodsBuilder.build());
       for (DexType context : builder.contextualVirtualToDirectMethodMaps.keySet()) {
-        Map<DexMethod, DexMethod> current = contextualVirtualToDirectMethodMaps.get(context);
-        Map<DexMethod, DexMethod> other = builder.contextualVirtualToDirectMethodMaps.get(context);
+        Map<DexMethod, GraphLenseLookupResult> current =
+            contextualVirtualToDirectMethodMaps.get(context);
+        Map<DexMethod, GraphLenseLookupResult> other =
+            builder.contextualVirtualToDirectMethodMaps.get(context);
         if (current != null) {
           current.putAll(other);
         } else {