diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index e53349e..b9b47c0 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 = "2.0.62";
+  public static final String LABEL = "2.0.63";
 
   private Version() {
   }
diff --git a/src/main/java/com/android/tools/r8/graph/AppInfo.java b/src/main/java/com/android/tools/r8/graph/AppInfo.java
index ad19ed4..b830c3e 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfo.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfo.java
@@ -436,6 +436,16 @@
     return builder.resolve();
   }
 
+  // Non-private lookup (ie, not resolution) to find interface targets.
+  public DexEncodedMethod lookupMaximallySpecificTarget(DexClass clazz, DexMethod method) {
+    MaximallySpecificMethodsBuilder builder = new MaximallySpecificMethodsBuilder(clazz);
+    resolveMethodStep3Helper(clazz, method, builder);
+    ResolutionResult resolution = builder.resolve();
+    return resolution.isSingleResolution()
+        ? resolution.asSingleResolution().getResolvedMethod()
+        : null;
+  }
+
   /** Helper method that builds the set of maximally specific methods. */
   private void resolveMethodStep3Helper(
       DexClass clazz, DexMethod method, MaximallySpecificMethodsBuilder builder) {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
index 5ff8e57..7ca1e54 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
@@ -327,38 +327,46 @@
           if (clazz == null) {
             // Report missing class since we don't know if it is an interface.
             warnMissingType(encodedMethod.method, method.holder);
-
           } else if (clazz.isInterface()) {
             if (clazz.isLibraryClass()) {
               throw new CompilationError("Unexpected call to a private method " +
                   "defined in library class " + clazz.toSourceString(),
                   getMethodOrigin(encodedMethod.method));
             }
-
-            // This might be either private method call, or a call to default
-            // interface method made via invoke-direct.
-            DexEncodedMethod virtualTarget = null;
-            for (DexEncodedMethod candidate : clazz.virtualMethods()) {
-              if (candidate.method == method) {
-                virtualTarget = candidate;
-                break;
-              }
-            }
-
-            if (virtualTarget != null) {
-              // This is a invoke-direct call to a virtual method.
-              instructions.replaceCurrentInstruction(
-                  new InvokeStatic(defaultAsMethodOfCompanionClass(method),
-                      invokeDirect.outValue(), invokeDirect.arguments()));
-
-            } else {
-              // Otherwise this must be a private instance method call. Note that the referenced
+            DexEncodedMethod directTarget = appView.definitionFor(method);
+            if (directTarget != null) {
+              // This can be a private instance method call. Note that the referenced
               // method is expected to be in the current class since it is private, but desugaring
               // may move some methods or their code into other classes.
-
-              instructions.replaceCurrentInstruction(
-                  new InvokeStatic(privateAsMethodOfCompanionClass(method),
-                      invokeDirect.outValue(), invokeDirect.arguments()));
+              if (directTarget.isPrivateMethod()) {
+                instructions.replaceCurrentInstruction(
+                    new InvokeStatic(
+                        privateAsMethodOfCompanionClass(method),
+                        invokeDirect.outValue(),
+                        invokeDirect.arguments()));
+              } else {
+                instructions.replaceCurrentInstruction(
+                    new InvokeStatic(
+                        defaultAsMethodOfCompanionClass(method),
+                        invokeDirect.outValue(),
+                        invokeDirect.arguments()));
+              }
+            } else {
+              // The method can be a default method in the interface hierarchy.
+              DexEncodedMethod virtualTarget =
+                  appView.appInfo().lookupMaximallySpecificTarget(clazz, method);
+              if (virtualTarget != null) {
+                // This is a invoke-direct call to a virtual method.
+                instructions.replaceCurrentInstruction(
+                    new InvokeStatic(
+                        defaultAsMethodOfCompanionClass(virtualTarget.method),
+                        invokeDirect.outValue(),
+                        invokeDirect.arguments()));
+              } else {
+                // The below assert is here because a well-type program should have a target, but we
+                // cannot throw a compilation error, since we have no knowledge about the input.
+                assert false;
+              }
             }
           }
         }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java
index e019acd..3bc9825 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/StaticizingProcessor.java
@@ -6,6 +6,7 @@
 
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DebugLocalInfo;
+import com.android.tools.r8.graph.Descriptor;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
@@ -65,6 +66,7 @@
   private final Map<DexEncodedMethod, CandidateInfo> hostClassInits = new IdentityHashMap<>();
   private final Set<DexEncodedMethod> methodsToBeStaticized = Sets.newIdentityHashSet();
   private final Map<DexField, CandidateInfo> singletonFields = new IdentityHashMap<>();
+  private final Map<DexMethod, CandidateInfo> singletonGetters = new IdentityHashMap<>();
   private final Map<DexType, DexType> candidateToHostMapping = new IdentityHashMap<>();
 
   StaticizingProcessor(
@@ -94,7 +96,7 @@
                 .add(collectOptimizationInfo(feedback)));
 
     // Enqueue instance methods to be staticized (only remove references to 'this'). Intentionally
-    // not collection optimization info for these methods, since they will be reprocessed again
+    // not collecting optimization info for these methods, since they will be reprocessed again
     // below once staticized.
     enqueueMethodsWithCodeOptimizations(
         methodsToBeStaticized, optimizations -> optimizations.add(this::removeReferencesToThis));
@@ -203,19 +205,36 @@
       for (DexEncodedMethod method : info.referencedFrom) {
         IRCode code = method.buildIR(appView, appView.appInfo().originFor(method.method.holder));
         assert code != null;
-        List<StaticGet> singletonFieldReads =
+        List<Instruction> singletonUsers =
             Streams.stream(code.instructionIterator())
-                .filter(Instruction::isStaticGet)
-                .map(Instruction::asStaticGet)
-                .filter(get -> get.getField() == info.singletonField.field)
+                .filter(
+                    instruction -> {
+                      if (instruction.isStaticGet()
+                          && instruction.asStaticGet().getField() == info.singletonField.field) {
+                        return true;
+                      }
+                      DexEncodedMethod getter = info.getter.get();
+                      return getter != null
+                          && instruction.isInvokeStatic()
+                          && instruction.asInvokeStatic().getInvokedMethod() == getter.method;
+                    })
                 .collect(Collectors.toList());
         boolean fixableFieldReadsPerUsage = true;
-        for (StaticGet read : singletonFieldReads) {
-          Value dest = read.dest();
+        for (Instruction user : singletonUsers) {
+          if (user.outValue() == null) {
+            continue;
+          }
+          Value dest = user.outValue();
           visited.clear();
           trivialPhis.clear();
-          boolean onlyHasTrivialPhis = testAndCollectPhisComposedOfSameFieldRead(
-              visited, dest.uniquePhiUsers(), read.getField(), trivialPhis);
+          assert user.isInvokeStatic() || user.isStaticGet();
+          Descriptor member =
+              user.isStaticGet()
+                  ? user.asStaticGet().getField()
+                  : user.asInvokeStatic().getInvokedMethod();
+          boolean onlyHasTrivialPhis =
+              testAndCollectPhisComposedOfSameMember(
+                  visited, dest.uniquePhiUsers(), member, trivialPhis);
           if (dest.hasPhiUsers() && !onlyHasTrivialPhis) {
             fixableFieldReadsPerUsage = false;
             break;
@@ -255,6 +274,10 @@
         }
       }
       singletonFields.put(candidate.singletonField.field, candidate);
+      DexEncodedMethod getter = candidate.getter.get();
+      if (getter != null) {
+        singletonGetters.put(getter.method, candidate);
+      }
       referencingExtraMethods.addAll(candidate.referencedFrom);
     }
 
@@ -341,28 +364,38 @@
   }
 
   private void rewriteReferences(IRCode code) {
-    // Process all singleton field reads and rewrite their users.
-    List<StaticGet> singletonFieldReads =
+    // Fetch all instructions that reference singletons to avoid concurrent modifications to the
+    // instruction list that can arise from doing it directly in the iterator.
+    List<Instruction> singletonUsers =
         Streams.stream(code.instructionIterator())
-            .filter(Instruction::isStaticGet)
-            .map(Instruction::asStaticGet)
-            .filter(get -> singletonFields.containsKey(get.getField()))
+            .filter(
+                instruction ->
+                    (instruction.isStaticGet()
+                            && singletonFields.containsKey(
+                                instruction.asFieldInstruction().getField()))
+                        || (instruction.isInvokeStatic()
+                            && singletonGetters.containsKey(
+                                instruction.asInvokeStatic().getInvokedMethod())))
             .collect(Collectors.toList());
-
-    singletonFieldReads.forEach(
-        read -> {
-          DexField field = read.getField();
-          CandidateInfo candidateInfo = singletonFields.get(field);
-          assert candidateInfo != null;
-          Value value = read.dest();
-          if (value != null) {
-            fixupStaticizedFieldReadUsers(code, value, field);
-          }
-          if (!candidateInfo.preserveRead.get()) {
-            read.removeOrReplaceByDebugLocalRead(code);
-          }
-        });
-
+    for (Instruction singletonUser : singletonUsers) {
+      CandidateInfo candidateInfo;
+      Descriptor member;
+      if (singletonUser.isStaticGet()) {
+        candidateInfo = singletonFields.get(singletonUser.asStaticGet().getField());
+        member = singletonUser.asStaticGet().getField();
+      } else {
+        assert singletonUser.isInvokeStatic();
+        candidateInfo = singletonGetters.get(singletonUser.asInvokeStatic().getInvokedMethod());
+        member = singletonUser.asInvokeStatic().getInvokedMethod();
+      }
+      Value value = singletonUser.outValue();
+      if (value != null) {
+        fixupStaticizedFieldUsers(code, value, member);
+      }
+      if (!candidateInfo.preserveRead.get()) {
+        singletonUser.removeOrReplaceByDebugLocalRead(code);
+      }
+    }
     if (!candidateToHostMapping.isEmpty()) {
       remapMovedCandidates(code);
     }
@@ -429,7 +462,7 @@
   //    invoke-virtual { s1, ... } mtd1
   //    goto Exit
   //  b2:
-  //    s2 <- static-get singleton
+  //    s2 <- invoke-static getter()
   //    ...
   //    invoke-virtual { s2, ... } mtd1
   //    goto Exit
@@ -443,7 +476,7 @@
   //    ...
   //    goto Exit
   //  b2:
-  //    s2 <- static-get singleton
+  //    s2 <- invoke-static getter()
   //    ...
   //    goto Exit
   //  Exit:
@@ -454,8 +487,8 @@
   // From staticizer's viewpoint, `sp` is trivial in the sense that it is composed of values that
   // refer to the same singleton field. If so, we can safely relax the assertion; remove uses of
   // field reads; remove quasi-trivial phis; and then remove original field reads.
-  private boolean testAndCollectPhisComposedOfSameFieldRead(
-      Set<Phi> visited, Set<Phi> phisToCheck, DexField field, Set<Phi> trivialPhis) {
+  private boolean testAndCollectPhisComposedOfSameMember(
+      Set<Phi> visited, Set<Phi> phisToCheck, Descriptor dexMember, Set<Phi> trivialPhis) {
     for (Phi phi : phisToCheck) {
       if (!visited.add(phi)) {
         continue;
@@ -466,16 +499,20 @@
         if (v.isPhi()) {
           chainedPhis.add(operand.asPhi());
         } else {
-          if (!v.definition.isStaticGet()) {
+          Instruction definition = v.definition;
+          if (!definition.isStaticGet() && !definition.isInvokeStatic()) {
             return false;
           }
-          if (v.definition.asStaticGet().getField() != field) {
+          if (definition.isStaticGet() && definition.asStaticGet().getField() != dexMember) {
+            return false;
+          } else if (definition.isInvokeStatic()
+              && definition.asInvokeStatic().getInvokedMethod() != dexMember) {
             return false;
           }
         }
       }
       if (!chainedPhis.isEmpty()) {
-        if (!testAndCollectPhisComposedOfSameFieldRead(visited, chainedPhis, field, trivialPhis)) {
+        if (!testAndCollectPhisComposedOfSameMember(visited, chainedPhis, dexMember, trivialPhis)) {
           return false;
         }
       }
@@ -486,13 +523,14 @@
 
   // Fixup field read usages. Same as {@link #fixupStaticizedThisUsers} except this one determines
   // quasi-trivial phis, based on the original field.
-  private void fixupStaticizedFieldReadUsers(IRCode code, Value dest, DexField field) {
+  private void fixupStaticizedFieldUsers(IRCode code, Value dest, Descriptor member) {
     assert dest != null;
     // During the examine phase, field reads with any phi users have been invalidated, hence zero.
     // However, it may be not true if re-processing introduces phis after optimizing common suffix.
     Set<Phi> trivialPhis = Sets.newIdentityHashSet();
-    boolean onlyHasTrivialPhis = testAndCollectPhisComposedOfSameFieldRead(
-        Sets.newIdentityHashSet(), dest.uniquePhiUsers(), field, trivialPhis);
+    boolean onlyHasTrivialPhis =
+        testAndCollectPhisComposedOfSameMember(
+            Sets.newIdentityHashSet(), dest.uniquePhiUsers(), member, trivialPhis);
     assert !dest.hasPhiUsers() || onlyHasTrivialPhis;
     assert trivialPhis.isEmpty() || onlyHasTrivialPhis;
 
diff --git a/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java b/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
index 1a07b28..09aaea5 100644
--- a/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
@@ -133,7 +133,8 @@
     ClassNameMinifier classNameMinifier =
         new ClassNameMinifier(
             appView,
-            new ApplyMappingClassNamingStrategy(appView, mappedNames),
+            new ApplyMappingClassNamingStrategy(
+                appView, mappedNames, seedMapper.getMappedToDescriptorNames()),
             // The package naming strategy will actually not be used since all classes and methods
             // will be output with identity name if not found in mapping. However, there is a check
             // in the ClassNameMinifier that the strategy should produce a "fresh" name so we just
@@ -391,10 +392,13 @@
   static class ApplyMappingClassNamingStrategy extends MinificationClassNamingStrategy {
 
     private final Map<DexType, DexString> mappings;
+    private final Set<String> mappedNames;
 
-    ApplyMappingClassNamingStrategy(AppView<?> appView, Map<DexType, DexString> mappings) {
+    ApplyMappingClassNamingStrategy(
+        AppView<?> appView, Map<DexType, DexString> mappings, Set<String> mappedNames) {
       super(appView);
       this.mappings = mappings;
+      this.mappedNames = mappedNames;
     }
 
     @Override
@@ -405,7 +409,16 @@
         Predicate<DexString> isUsed) {
       assert !mappings.containsKey(type);
       assert appView.rootSet().mayBeMinified(type, appView);
-      return super.next(type, packagePrefix, state, isUsed);
+      return super.next(
+          type,
+          packagePrefix,
+          state,
+          candidate -> {
+            if (mappedNames.contains(candidate.toString())) {
+              return true;
+            }
+            return isUsed.test(candidate);
+          });
     }
 
     @Override
diff --git a/src/main/java/com/android/tools/r8/naming/SeedMapper.java b/src/main/java/com/android/tools/r8/naming/SeedMapper.java
index d7f36da..be69416 100644
--- a/src/main/java/com/android/tools/r8/naming/SeedMapper.java
+++ b/src/main/java/com/android/tools/r8/naming/SeedMapper.java
@@ -20,6 +20,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 
@@ -37,6 +38,7 @@
 
   static class Builder extends ProguardMap.Builder {
     final Map<String, ClassNamingForMapApplier.Builder> map = new HashMap<>();
+    final Set<String> mappedToDescriptorNames = new HashSet<>();
     private final Reporter reporter;
 
     private Builder(Reporter reporter) {
@@ -47,9 +49,11 @@
     ClassNamingForMapApplier.Builder classNamingBuilder(
         String renamedName, String originalName, Position position) {
       String originalDescriptor = javaTypeToDescriptor(originalName);
+      String renamedDescriptorName = javaTypeToDescriptor(renamedName);
+      mappedToDescriptorNames.add(renamedDescriptorName);
       ClassNamingForMapApplier.Builder classNamingBuilder =
           ClassNamingForMapApplier.builder(
-              javaTypeToDescriptor(renamedName), originalDescriptor, position, reporter);
+              renamedDescriptorName, originalDescriptor, position, reporter);
       if (map.put(originalDescriptor, classNamingBuilder) != null) {
         reporter.error(ProguardMapError.duplicateSourceClass(originalName, position));
       }
@@ -59,7 +63,7 @@
     @Override
     SeedMapper build() {
       reporter.failIfPendingErrors();
-      return new SeedMapper(ImmutableMap.copyOf(map), reporter);
+      return new SeedMapper(ImmutableMap.copyOf(map), mappedToDescriptorNames, reporter);
     }
   }
 
@@ -82,15 +86,20 @@
   }
 
   private final ImmutableMap<String, ClassNamingForMapApplier> mappings;
+  private final Set<String> mappedToDescriptorNames;
   private final Reporter reporter;
 
-  private SeedMapper(Map<String, ClassNamingForMapApplier.Builder> mappings, Reporter reporter) {
+  private SeedMapper(
+      Map<String, ClassNamingForMapApplier.Builder> mappings,
+      Set<String> mappedToDescriptorNames,
+      Reporter reporter) {
     this.reporter = reporter;
     ImmutableMap.Builder<String, ClassNamingForMapApplier> builder = ImmutableMap.builder();
     for(Map.Entry<String, ClassNamingForMapApplier.Builder> entry : mappings.entrySet()) {
       builder.put(entry.getKey(), entry.getValue().build());
     }
     this.mappings = builder.build();
+    this.mappedToDescriptorNames = mappedToDescriptorNames;
     verifyMappingsAreConflictFree();
   }
 
@@ -140,6 +149,10 @@
     return mappings.keySet();
   }
 
+  public Set<String> getMappedToDescriptorNames() {
+    return mappedToDescriptorNames;
+  }
+
   public ClassNamingForMapApplier getMapping(String key) {
     return mappings.get(key);
   }
diff --git a/src/main/java/com/android/tools/r8/utils/ArchiveBuilder.java b/src/main/java/com/android/tools/r8/utils/ArchiveBuilder.java
index 2276790..a47684f 100644
--- a/src/main/java/com/android/tools/r8/utils/ArchiveBuilder.java
+++ b/src/main/java/com/android/tools/r8/utils/ArchiveBuilder.java
@@ -86,14 +86,9 @@
   }
 
   /** Get or open the zip output stream. */
-  private synchronized ZipOutputStream getStream(DiagnosticsHandler handler) {
+  private synchronized ZipOutputStream getStream() throws IOException {
     assert !closed;
-    try {
-      getStreamRaw();
-    } catch (IOException e) {
-      handler.error(new ExceptionDiagnostic(e, origin));
-    }
-    return stream;
+    return getStreamRaw();
   }
 
   private void handleIOException(IOException e, DiagnosticsHandler handler) {
@@ -117,9 +112,9 @@
     }
     ZipEntry entry = new ZipEntry(name);
     entry.setTime(0);
-    ZipOutputStream zip = getStream(handler);
     synchronized (this) {
       try {
+        ZipOutputStream zip = getStream();
         zip.putNextEntry(entry);
         zip.closeEntry();
       } catch (IOException e) {
@@ -150,7 +145,7 @@
 
   private void writeFileNow(String name, ByteDataView content, DiagnosticsHandler handler) {
     try {
-      ZipUtils.writeToZipStream(getStream(handler), name, content, ZipEntry.DEFLATED);
+      ZipUtils.writeToZipStream(getStream(), name, content, ZipEntry.DEFLATED);
     } catch (IOException e) {
       handleIOException(e, handler);
     }
diff --git a/src/test/java/com/android/tools/r8/desugar/DefaultMethodWithAccessTest.java b/src/test/java/com/android/tools/r8/desugar/DefaultMethodWithAccessTest.java
new file mode 100644
index 0000000..0c778d0
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/DefaultMethodWithAccessTest.java
@@ -0,0 +1,96 @@
+// 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.desugar;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.transformers.ClassFileTransformer;
+import com.android.tools.r8.utils.BooleanUtils;
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.objectweb.asm.Opcodes;
+// This is a reproduction of b/153042496 in a java-only setting.
+
+@RunWith(Parameterized.class)
+public class DefaultMethodWithAccessTest extends TestBase {
+
+  private final TestParameters parameters;
+  private final boolean implementI0I1;
+
+  @Parameters(name = "{0}, implementI0I1: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.values());
+  }
+
+  public DefaultMethodWithAccessTest(TestParameters parameters, boolean implementI0I1) {
+    this.parameters = parameters;
+    this.implementI0I1 = implementI0I1;
+  }
+
+  @Test
+  public void testRuntime() throws ExecutionException, CompilationFailedException, IOException {
+    testForRuntime(parameters)
+        .addProgramClasses(I0.class, I1.class, Main.class, Impl.class)
+        .addProgramClassFileData(transformI2AccessToInvokeSpecial())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("Hello World!");
+  }
+
+  private byte[] transformI2AccessToInvokeSpecial() throws IOException {
+    ClassFileTransformer classFileTransformer =
+        transformer(I2.class)
+            .transformMethodInsnInMethod(
+                "access",
+                (opcode, owner, name, descriptor, isInterface, continuation) -> {
+                  continuation.apply(
+                      name.equals("print") ? Opcodes.INVOKESPECIAL : opcode,
+                      owner,
+                      name,
+                      descriptor,
+                      isInterface);
+                });
+    if (implementI0I1) {
+      classFileTransformer.setImplements(I0.class, I1.class);
+    }
+    return classFileTransformer.transform();
+  }
+
+  public interface I0 {
+    void print();
+  }
+
+  public interface I1 {
+    default void print() {
+      System.out.println("Hello World!");
+    }
+  }
+
+  public interface I2 extends /* I0, */ I1 {
+
+    static void access(I2 i2) {
+      /* invoke-special */ i2.print();
+    }
+  }
+
+  public static class Impl implements I2 {}
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      testPrint(new Impl());
+    }
+
+    public static void testPrint(I2 i) {
+      I2.access(i);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/PrivateMethodsInInterfaceTest.java b/src/test/java/com/android/tools/r8/desugar/PrivateMethodsInInterfaceTest.java
new file mode 100644
index 0000000..564f831
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/PrivateMethodsInInterfaceTest.java
@@ -0,0 +1,102 @@
+// 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.desugar;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.objectweb.asm.Opcodes;
+
+@RunWith(Parameterized.class)
+public class PrivateMethodsInInterfaceTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public PrivateMethodsInInterfaceTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testRuntime()
+      throws NoSuchMethodException, IOException, CompilationFailedException, ExecutionException {
+    testForRuntime(parameters)
+        .addProgramClasses(SubI.class, Impl.class, Main.class)
+        .addProgramClassFileData(transformIToPrivate())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("Hello World!", "Hello World!", "Hello World!");
+  }
+
+  private byte[] transformIToPrivate() throws NoSuchMethodException, IOException {
+    return transformer(I.class)
+        .setPrivate(I.class.getDeclaredMethod("bar"))
+        .setPrivate(I.class.getDeclaredMethod("baz", I.class))
+        .transformMethodInsnInMethod(
+            "foo",
+            ((opcode, owner, name, descriptor, isInterface, continuation) -> {
+              continuation.apply(
+                  name.equals("bar") ? Opcodes.INVOKESPECIAL : opcode,
+                  owner,
+                  name,
+                  descriptor,
+                  isInterface);
+            }))
+        .transformMethodInsnInMethod(
+            "baz",
+            ((opcode, owner, name, descriptor, isInterface, continuation) -> {
+              continuation.apply(
+                  name.equals("bar") ? Opcodes.INVOKESPECIAL : opcode,
+                  owner,
+                  name,
+                  descriptor,
+                  isInterface);
+            }))
+        .transform();
+  }
+
+  public interface I {
+
+    default void foo() {
+      bar();
+      I.qux(this);
+    }
+
+    /* private */ default void bar() {
+      System.out.println("Hello World!");
+    }
+
+    /* private */ static void baz(I i) {
+      i.bar();
+    }
+
+    static void qux(I i) {
+      baz(i);
+    }
+  }
+
+  public interface SubI extends I {}
+
+  public static class Impl implements SubI {}
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      Impl impl = new Impl();
+      impl.foo();
+      I.qux(impl);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java
index d0a4064..5cd6a9a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java
@@ -12,6 +12,7 @@
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 
+import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
@@ -50,11 +51,14 @@
 import com.android.tools.r8.ir.optimize.staticizer.trivial.TrivialTestClass;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.utils.InternalOptions;
+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.google.common.collect.Lists;
 import com.google.common.collect.Streams;
+import java.io.IOException;
 import java.util.List;
+import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -64,6 +68,37 @@
 public class ClassStaticizerTest extends TestBase {
   private final TestParameters parameters;
 
+  private static final String EXPECTED =
+      StringUtils.lines(
+          "Simple::bar(Simple::foo())",
+          "Simple::bar(0)",
+          "SimpleWithPhi$Companion::bar(SimpleWithPhi$Companion::foo()) true",
+          "SimpleWithSideEffects::<clinit>()",
+          "SimpleWithSideEffects::bar(SimpleWithSideEffects::foo())",
+          "SimpleWithSideEffects::bar(1)",
+          "SimpleWithParams::bar(SimpleWithParams::foo())",
+          "SimpleWithParams::bar(2)",
+          "SimpleWithGetter::bar(SimpleWithGetter::foo())",
+          "SimpleWithGetter::bar(3)",
+          "Simple::bar(Simple::foo())",
+          "Simple::bar(4)",
+          "Simple::bar(Simple::foo())",
+          "Simple::bar(5)");
+
+  private static final Class<?> main = TrivialTestClass.class;
+  private static final Class<?>[] classes = {
+    NeverInline.class,
+    TrivialTestClass.class,
+    Simple.class,
+    SimpleWithGetter.class,
+    SimpleWithLazyInit.class,
+    SimpleWithParams.class,
+    SimpleWithPhi.class,
+    SimpleWithPhi.Companion.class,
+    SimpleWithSideEffects.class,
+    SimpleWithThrowingGetter.class
+  };
+
   @Parameterized.Parameters(name = "{0}")
   public static TestParametersCollection data() {
     // TODO(b/112831361): support for class staticizer in CF backend.
@@ -75,21 +110,20 @@
   }
 
   @Test
+  public void testWithoutAccessModification()
+      throws ExecutionException, CompilationFailedException, IOException {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(classes)
+        .addKeepMainRule(main)
+        .addKeepAttributes("InnerClasses", "EnclosingMethod")
+        .addOptionsModification(this::configure)
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), main)
+        .assertSuccessWithOutput(EXPECTED);
+  }
+
+  @Test
   public void testTrivial() throws Exception {
-    Class<?> main = TrivialTestClass.class;
-    Class<?>[] classes = {
-        NeverInline.class,
-        TrivialTestClass.class,
-        Simple.class,
-        SimpleWithGetter.class,
-        SimpleWithLazyInit.class,
-        SimpleWithParams.class,
-        SimpleWithPhi.class,
-        SimpleWithPhi.Companion.class,
-        SimpleWithSideEffects.class,
-        SimpleWithThrowingGetter.class
-    };
-    String javaOutput = runOnJava(main);
     TestRunResult result =
         testForR8(parameters.getBackend())
             .addProgramClasses(classes)
@@ -101,7 +135,7 @@
             .allowAccessModification()
             .setMinApi(parameters.getApiLevel())
             .run(parameters.getRuntime(), main)
-            .assertSuccessWithOutput(javaOutput);
+            .assertSuccessWithOutput(EXPECTED);
 
     CodeInspector inspector = result.inspector();
     ClassSubject clazz = inspector.clazz(main);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/trivial/SimpleWithGetter.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/trivial/SimpleWithGetter.java
index 55487ac..6bc91b4 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/trivial/SimpleWithGetter.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/trivial/SimpleWithGetter.java
@@ -15,11 +15,11 @@
 
   @NeverInline
   String foo() {
-    return bar("Simple::foo()");
+    return bar("SimpleWithGetter::foo()");
   }
 
   @NeverInline
   String bar(String other) {
-    return "Simple::bar(" + other + ")";
+    return "SimpleWithGetter::bar(" + other + ")";
   }
 }
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingDesugarLambdaTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingDesugarLambdaTest.java
new file mode 100644
index 0000000..63fe00f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingDesugarLambdaTest.java
@@ -0,0 +1,120 @@
+package com.android.tools.r8.naming.applymapping;
+
+import static com.android.tools.r8.Collectors.toSingle;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertNotSame;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.FileUtils;
+import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+// This is a reproduction of b/152715309.
+@RunWith(Parameterized.class)
+public class ApplyMappingDesugarLambdaTest extends TestBase {
+
+  private static final String EXPECTED = "FOO";
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+  }
+
+  public ApplyMappingDesugarLambdaTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testR8() throws CompilationFailedException, IOException, ExecutionException {
+    // Create a dictionary to control the naming.
+    Path dictionary = temp.getRoot().toPath().resolve("dictionary.txt");
+    FileUtils.writeTextFile(dictionary, "e");
+
+    final String finalName = "com.android.tools.r8.naming.applymapping.e";
+
+    R8TestCompileResult libraryResult =
+        testForR8(parameters.getBackend())
+            .addProgramClasses(A.class)
+            .addKeepClassAndMembersRulesWithAllowObfuscation(A.class)
+            .setMinApi(parameters.getApiLevel())
+            .addKeepRules(
+                "-keeppackagenames", "-classobfuscationdictionary " + dictionary.toString())
+            .compile()
+            .inspect(
+                inspector -> {
+                  assertThat(inspector.clazz(A.class), isRenamed());
+                  assertEquals(finalName, inspector.clazz(A.class).getFinalName());
+                });
+
+    Path libraryPath = libraryResult.writeToZip();
+
+    // Ensure that the library works as supposed.
+    testForD8()
+        .addProgramClasses(I.class, Main.class)
+        .addClasspathFiles(libraryPath)
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), Main.class, EXPECTED)
+        .assertSuccessWithOutputLines(EXPECTED);
+
+    testForR8(parameters.getBackend())
+        .addClasspathClasses(A.class)
+        .addProgramClasses(I.class, Main.class)
+        .addKeepMainRule(Main.class)
+        .addKeepClassAndMembersRules(I.class)
+        .setMinApi(parameters.getApiLevel())
+        .addApplyMapping(libraryResult.getProguardMap())
+        .addOptionsModification(internalOptions -> internalOptions.enableClassInlining = false)
+        .addKeepRules("-classobfuscationdictionary " + dictionary.toString())
+        .compile()
+        .inspect(
+            inspector -> {
+              // Assert that there is a lambda class created.
+              assertEquals(3, inspector.allClasses().size());
+              FoundClassSubject lambdaClass =
+                  inspector.allClasses().stream()
+                      .filter(FoundClassSubject::isSynthetic)
+                      .collect(toSingle());
+              assertNotSame(finalName, lambdaClass.getFinalName());
+            })
+        .addRunClasspathFiles(libraryPath)
+        .run(parameters.getRuntime(), Main.class, EXPECTED)
+        .assertSuccessWithOutputLines(EXPECTED);
+  }
+
+  public static class A {
+
+    A(int bar) {
+      System.out.println(bar);
+    }
+  }
+
+  @FunctionalInterface
+  public interface I {
+
+    void doStuff();
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      processI(() -> System.out.println(args[0]));
+    }
+
+    public static void processI(I i) {
+      i.doStuff();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/regress/b152973695/CompileToInvalidFileTest.java b/src/test/java/com/android/tools/r8/regress/b152973695/CompileToInvalidFileTest.java
new file mode 100644
index 0000000..d635af8
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/regress/b152973695/CompileToInvalidFileTest.java
@@ -0,0 +1,104 @@
+// 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.regress.b152973695;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeFalse;
+
+import com.android.tools.r8.ClassFileConsumer;
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.DexIndexedConsumer.ArchiveConsumer;
+import com.android.tools.r8.ProgramConsumer;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.BooleanUtils;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class CompileToInvalidFileTest extends TestBase {
+
+  private static final Path INVALID_FILE = Paths.get("!@#/\\INVALID_FILE");
+
+  private final boolean classFileConsumer;
+
+  @Parameterized.Parameters(name = "{0}, classfileConsumer: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(getTestParameters().withNoneRuntime().build(), BooleanUtils.values());
+  }
+
+  public CompileToInvalidFileTest(TestParameters parameters, boolean classFileConsumer) {
+    this.classFileConsumer = classFileConsumer;
+  }
+
+  @Test
+  public void testCompileToInvalidFileD8() {
+    assumeFalse(classFileConsumer);
+    ensureInvalidFileIsInvalid();
+    ProgramConsumer programConsumer =
+        classFileConsumer
+            ? new ClassFileConsumer.ArchiveConsumer(INVALID_FILE)
+            : new ArchiveConsumer(INVALID_FILE);
+    try {
+      testForD8().addProgramClasses(Main.class).setProgramConsumer(programConsumer).compile();
+      fail("Expected a CompilationFailedException but the code succeeded");
+    } catch (CompilationFailedException ex) {
+      assertInvalidFileNotFound(ex);
+    } catch (Throwable t) {
+      fail("Expected a CompilationFailedException but got instead " + t);
+    }
+  }
+
+  @Test
+  public void testCompileToInvalidFileR8() {
+    ensureInvalidFileIsInvalid();
+    ProgramConsumer programConsumer =
+        classFileConsumer
+            ? new ClassFileConsumer.ArchiveConsumer(INVALID_FILE)
+            : new ArchiveConsumer(INVALID_FILE);
+    try {
+      testForR8(classFileConsumer ? Backend.CF : Backend.DEX)
+          .addProgramClasses(Main.class)
+          .addKeepMainRule(Main.class)
+          .setProgramConsumer(programConsumer)
+          .compile();
+      fail("Expected a CompilationFailedException but the code succeeded");
+    } catch (CompilationFailedException ex) {
+      assertInvalidFileNotFound(ex);
+    } catch (Throwable t) {
+      fail("Expected a CompilationFailedException but got instead " + t);
+    }
+  }
+
+  private void assertInvalidFileNotFound(CompilationFailedException ex) {
+    assertTrue(ex.getCause().getMessage().contains("File not found"));
+    assertTrue(ex.getCause().getMessage().contains(INVALID_FILE.toString()));
+  }
+
+  private void ensureInvalidFileIsInvalid() {
+    try {
+      Files.newOutputStream(
+          INVALID_FILE, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
+      fail("Expected an IOException but the code succeeded");
+    } catch (IOException ignored) {
+    } catch (Throwable t) {
+      fail("Expected an IOException but got instead " + t);
+    }
+  }
+
+  static class Main {
+    public static void main(String[] args) {
+      System.out.println("Hello world!");
+    }
+  }
+}