diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 58e68dc..70d4425 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -335,9 +335,7 @@
           // Mark dead proto extensions fields as neither being read nor written. This step must
           // run prior to the tree pruner.
           appView.withGeneratedExtensionRegistryShrinker(
-              shrinker -> {
-                shrinker.run(Mode.INITIAL_TREE_SHAKING);
-              });
+              shrinker -> shrinker.run(Mode.INITIAL_TREE_SHAKING));
 
           TreePruner pruner = new TreePruner(appViewWithLiveness);
           application = pruner.run(application);
diff --git a/src/main/java/com/android/tools/r8/dex/CodeToKeep.java b/src/main/java/com/android/tools/r8/dex/CodeToKeep.java
index 7a2c325..f327f21 100644
--- a/src/main/java/com/android/tools/r8/dex/CodeToKeep.java
+++ b/src/main/java/com/android/tools/r8/dex/CodeToKeep.java
@@ -43,25 +43,28 @@
   public static class DesugaredLibraryCodeToKeep extends CodeToKeep {
 
     private static class KeepStruct {
+
       Set<DexField> fields = Sets.newConcurrentHashSet();
       Set<DexMethod> methods = Sets.newConcurrentHashSet();
       boolean all = false;
     }
 
     private final NamingLens namingLens;
-    private final Set<DexType> emulatedInterfaces = Sets.newIdentityHashSet();
+    private final Set<DexType> potentialTypesToKeep = Sets.newIdentityHashSet();
     private final Map<DexType, KeepStruct> toKeep = new ConcurrentHashMap<>();
     private final InternalOptions options;
 
     public DesugaredLibraryCodeToKeep(NamingLens namingLens, InternalOptions options) {
-      emulatedInterfaces.addAll(
-          options.desugaredLibraryConfiguration.getEmulateLibraryInterface().values());
       this.namingLens = namingLens;
       this.options = options;
+      potentialTypesToKeep.addAll(
+          options.desugaredLibraryConfiguration.getEmulateLibraryInterface().values());
+      potentialTypesToKeep.addAll(
+          options.desugaredLibraryConfiguration.getCustomConversions().values());
     }
 
     private boolean shouldKeep(DexType type) {
-      return namingLens.prefixRewrittenType(type) != null || emulatedInterfaces.contains(type);
+      return namingLens.prefixRewrittenType(type) != null || potentialTypesToKeep.contains(type);
     }
 
     @Override
diff --git a/src/main/java/com/android/tools/r8/graph/FieldAccessInfo.java b/src/main/java/com/android/tools/r8/graph/FieldAccessInfo.java
index f573b76..328bd61 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldAccessInfo.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldAccessInfo.java
@@ -16,13 +16,19 @@
 
   DexField getField();
 
+  int getNumberOfWriteContexts();
+
   DexEncodedMethod getUniqueReadContext();
 
   void forEachIndirectAccess(Consumer<DexField> consumer);
 
   void forEachIndirectAccessWithContexts(BiConsumer<DexField, Set<DexEncodedMethod>> consumer);
 
-  void forEachReadContext(Consumer<DexMethod> consumer);
+  void forEachReadContext(Consumer<DexEncodedMethod> consumer);
+
+  void forEachWriteContext(Consumer<DexEncodedMethod> consumer);
+
+  boolean hasReflectiveAccess();
 
   boolean isRead();
 
diff --git a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollection.java b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollection.java
index 1f07f43..5b0ebc2 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollection.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollection.java
@@ -4,12 +4,17 @@
 
 package com.android.tools.r8.graph;
 
+import java.util.function.BiPredicate;
 import java.util.function.Consumer;
 
 /** Provides immutable access to {@link FieldAccessInfoCollectionImpl}. */
 public interface FieldAccessInfoCollection<T extends FieldAccessInfo> {
 
+  void flattenAccessContexts();
+
   T get(DexField field);
 
   void forEach(Consumer<T> consumer);
+
+  void removeIf(BiPredicate<DexField, FieldAccessInfoImpl> predicate);
 }
diff --git a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollectionImpl.java b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollectionImpl.java
index 3a307cf..47a9c30 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollectionImpl.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollectionImpl.java
@@ -16,6 +16,11 @@
   private Map<DexField, FieldAccessInfoImpl> infos = new IdentityHashMap<>();
 
   @Override
+  public void flattenAccessContexts() {
+    infos.values().forEach(FieldAccessInfoImpl::flattenAccessContexts);
+  }
+
+  @Override
   public FieldAccessInfoImpl get(DexField field) {
     return infos.get(field);
   }
@@ -32,6 +37,7 @@
     infos.values().forEach(consumer);
   }
 
+  @Override
   public void removeIf(BiPredicate<DexField, FieldAccessInfoImpl> predicate) {
     infos.entrySet().removeIf(entry -> predicate.test(entry.getKey(), entry.getValue()));
   }
diff --git a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java
index 5924435..99ad00f 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.graph;
 
+import com.android.tools.r8.errors.Unreachable;
 import com.google.common.collect.Sets;
 import java.util.IdentityHashMap;
 import java.util.Map;
@@ -24,6 +25,9 @@
   // A direct reference to the definition of the field.
   private DexField field;
 
+  // If this field has a reflective access.
+  private boolean hasReflectiveAccess;
+
   // Maps every direct and indirect reference in a read-context to the set of methods in which that
   // reference appears.
   private Map<DexField, Set<DexEncodedMethod>> readsWithContexts;
@@ -36,6 +40,29 @@
     this.field = field;
   }
 
+  void flattenAccessContexts() {
+    flattenAccessContexts(readsWithContexts);
+    flattenAccessContexts(writesWithContexts);
+  }
+
+  private void flattenAccessContexts(Map<DexField, Set<DexEncodedMethod>> accessesWithContexts) {
+    if (accessesWithContexts != null) {
+      Set<DexEncodedMethod> flattenedAccessContexts =
+          accessesWithContexts.computeIfAbsent(field, ignore -> Sets.newIdentityHashSet());
+      accessesWithContexts.forEach(
+          (access, contexts) -> {
+            if (access != field) {
+              flattenedAccessContexts.addAll(contexts);
+            }
+          });
+      accessesWithContexts.clear();
+      if (!flattenedAccessContexts.isEmpty()) {
+        accessesWithContexts.put(field, flattenedAccessContexts);
+      }
+      assert accessesWithContexts.size() <= 1;
+    }
+  }
+
   @Override
   public FieldAccessInfoImpl asMutable() {
     return this;
@@ -47,6 +74,19 @@
   }
 
   @Override
+  public int getNumberOfWriteContexts() {
+    if (writesWithContexts != null) {
+      if (writesWithContexts.size() == 1) {
+        return writesWithContexts.values().iterator().next().size();
+      } else {
+        throw new Unreachable(
+            "Should only be querying the number of write contexts after flattening");
+      }
+    }
+    return 0;
+  }
+
+  @Override
   public DexEncodedMethod getUniqueReadContext() {
     if (readsWithContexts != null && readsWithContexts.size() == 1) {
       Set<DexEncodedMethod> contexts = readsWithContexts.values().iterator().next();
@@ -110,22 +150,41 @@
   }
 
   @Override
-  public void forEachReadContext(Consumer<DexMethod> consumer) {
+  public void forEachReadContext(Consumer<DexEncodedMethod> consumer) {
+    forEachAccessContext(readsWithContexts, consumer);
+  }
+
+  @Override
+  public void forEachWriteContext(Consumer<DexEncodedMethod> consumer) {
+    forEachAccessContext(writesWithContexts, consumer);
+  }
+
+  private void forEachAccessContext(
+      Map<DexField, Set<DexEncodedMethod>> accessesWithContexts,
+      Consumer<DexEncodedMethod> consumer) {
     // There can be indirect reads and writes of the same field reference, so we need to keep track
     // of the previously-seen indirect accesses to avoid reporting duplicates.
-    Set<DexMethod> visited = Sets.newIdentityHashSet();
-    if (readsWithContexts != null) {
-      for (Set<DexEncodedMethod> encodedReadContexts : readsWithContexts.values()) {
-        for (DexEncodedMethod encodedReadContext : encodedReadContexts) {
-          DexMethod readContext = encodedReadContext.method;
-          if (visited.add(readContext)) {
-            consumer.accept(readContext);
+    Set<DexEncodedMethod> visited = Sets.newIdentityHashSet();
+    if (accessesWithContexts != null) {
+      for (Set<DexEncodedMethod> encodedAccessContexts : accessesWithContexts.values()) {
+        for (DexEncodedMethod encodedAccessContext : encodedAccessContexts) {
+          if (visited.add(encodedAccessContext)) {
+            consumer.accept(encodedAccessContext);
           }
         }
       }
     }
   }
 
+  @Override
+  public boolean hasReflectiveAccess() {
+    return hasReflectiveAccess;
+  }
+
+  public void setHasReflectiveAccess() {
+    hasReflectiveAccess = true;
+  }
+
   /** Returns true if this field is read by the program. */
   @Override
   public boolean isRead() {
@@ -208,6 +267,9 @@
 
   public FieldAccessInfoImpl rewrittenWithLens(DexDefinitionSupplier definitions, GraphLense lens) {
     FieldAccessInfoImpl rewritten = new FieldAccessInfoImpl(lens.lookupField(field));
+    if (hasReflectiveAccess) {
+      rewritten.setHasReflectiveAccess();
+    }
     if (readsWithContexts != null) {
       rewritten.readsWithContexts = new IdentityHashMap<>();
       readsWithContexts.forEach(
diff --git a/src/main/java/com/android/tools/r8/graph/GraphLense.java b/src/main/java/com/android/tools/r8/graph/GraphLense.java
index 09a9055..afac334 100644
--- a/src/main/java/com/android/tools/r8/graph/GraphLense.java
+++ b/src/main/java/com/android/tools/r8/graph/GraphLense.java
@@ -3,12 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.graph;
 
-import com.android.tools.r8.ir.code.ConstInstruction;
-import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Invoke.Type;
-import com.android.tools.r8.ir.code.Position;
-import com.android.tools.r8.utils.BooleanUtils;
-import com.android.tools.r8.utils.IteratorUtils;
 import com.google.common.collect.BiMap;
 import com.google.common.collect.HashBiMap;
 import com.google.common.collect.ImmutableList;
@@ -23,14 +18,11 @@
 import java.util.Deque;
 import java.util.HashSet;
 import java.util.IdentityHashMap;
-import java.util.LinkedList;
 import java.util.List;
-import java.util.ListIterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
-import java.util.function.Consumer;
 import java.util.function.Function;
 
 /**
@@ -73,270 +65,6 @@
     }
   }
 
-  public static class RewrittenPrototypeDescription {
-
-    public static class RemovedArgumentInfo {
-
-      public static class Builder {
-
-        private int argumentIndex = -1;
-        private boolean isAlwaysNull = false;
-        private DexType type = null;
-
-        public Builder setArgumentIndex(int argumentIndex) {
-          this.argumentIndex = argumentIndex;
-          return this;
-        }
-
-        public Builder setIsAlwaysNull() {
-          this.isAlwaysNull = true;
-          return this;
-        }
-
-        public Builder setType(DexType type) {
-          this.type = type;
-          return this;
-        }
-
-        public RemovedArgumentInfo build() {
-          assert argumentIndex >= 0;
-          assert type != null;
-          return new RemovedArgumentInfo(argumentIndex, isAlwaysNull, type);
-        }
-      }
-
-      private final int argumentIndex;
-      private final boolean isAlwaysNull;
-      private final DexType type;
-
-      private RemovedArgumentInfo(int argumentIndex, boolean isAlwaysNull, DexType type) {
-        this.argumentIndex = argumentIndex;
-        this.isAlwaysNull = isAlwaysNull;
-        this.type = type;
-      }
-
-      public static Builder builder() {
-        return new Builder();
-      }
-
-      public int getArgumentIndex() {
-        return argumentIndex;
-      }
-
-      public DexType getType() {
-        return type;
-      }
-
-      public boolean isAlwaysNull() {
-        return isAlwaysNull;
-      }
-
-      public boolean isNeverUsed() {
-        return !isAlwaysNull;
-      }
-
-      public RemovedArgumentInfo withArgumentIndex(int argumentIndex) {
-        return this.argumentIndex != argumentIndex
-            ? new RemovedArgumentInfo(argumentIndex, isAlwaysNull, type)
-            : this;
-      }
-    }
-
-    public static class RemovedArgumentsInfo {
-
-      private static final RemovedArgumentsInfo empty = new RemovedArgumentsInfo(null);
-
-      private final List<RemovedArgumentInfo> removedArguments;
-
-      public RemovedArgumentsInfo(List<RemovedArgumentInfo> removedArguments) {
-        assert verifyRemovedArguments(removedArguments);
-        this.removedArguments = removedArguments;
-      }
-
-      private static boolean verifyRemovedArguments(List<RemovedArgumentInfo> removedArguments) {
-        if (removedArguments != null && !removedArguments.isEmpty()) {
-          // Check that list is sorted by argument indices.
-          int lastArgumentIndex = removedArguments.get(0).getArgumentIndex();
-          for (int i = 1; i < removedArguments.size(); ++i) {
-            int currentArgumentIndex = removedArguments.get(i).getArgumentIndex();
-            assert lastArgumentIndex < currentArgumentIndex;
-            lastArgumentIndex = currentArgumentIndex;
-          }
-        }
-        return true;
-      }
-
-      public static RemovedArgumentsInfo empty() {
-        return empty;
-      }
-
-      public ListIterator<RemovedArgumentInfo> iterator() {
-        return removedArguments == null
-            ? Collections.emptyListIterator()
-            : removedArguments.listIterator();
-      }
-
-      public boolean hasRemovedArguments() {
-        return removedArguments != null && !removedArguments.isEmpty();
-      }
-
-      public boolean isArgumentRemoved(int argumentIndex) {
-        if (removedArguments != null) {
-          for (RemovedArgumentInfo info : removedArguments) {
-            if (info.getArgumentIndex() == argumentIndex) {
-              return true;
-            }
-          }
-        }
-        return false;
-      }
-
-      public int numberOfRemovedArguments() {
-        return removedArguments != null ? removedArguments.size() : 0;
-      }
-
-      public RemovedArgumentsInfo combine(RemovedArgumentsInfo info) {
-        assert info != null;
-        if (hasRemovedArguments()) {
-          if (!info.hasRemovedArguments()) {
-            return this;
-          }
-        } else {
-          return info;
-        }
-
-        List<RemovedArgumentInfo> newRemovedArguments = new LinkedList<>(removedArguments);
-        ListIterator<RemovedArgumentInfo> iterator = newRemovedArguments.listIterator();
-        int offset = 0;
-        for (RemovedArgumentInfo pending : info.removedArguments) {
-          RemovedArgumentInfo next = IteratorUtils.peekNext(iterator);
-          while (next != null && next.getArgumentIndex() <= pending.getArgumentIndex() + offset) {
-            iterator.next();
-            next = IteratorUtils.peekNext(iterator);
-            offset++;
-          }
-          iterator.add(pending.withArgumentIndex(pending.getArgumentIndex() + offset));
-        }
-        return new RemovedArgumentsInfo(newRemovedArguments);
-      }
-
-      public Consumer<DexEncodedMethod.Builder> createParameterAnnotationsRemover(
-          DexEncodedMethod method) {
-        if (numberOfRemovedArguments() > 0 && !method.parameterAnnotationsList.isEmpty()) {
-          return builder -> {
-            int firstArgumentIndex = BooleanUtils.intValue(!method.isStatic());
-            builder.removeParameterAnnotations(
-                oldIndex -> isArgumentRemoved(oldIndex + firstArgumentIndex));
-          };
-        }
-        return null;
-      }
-    }
-
-    private static final RewrittenPrototypeDescription none = new RewrittenPrototypeDescription();
-
-    private final boolean hasBeenChangedToReturnVoid;
-    private final boolean extraNullParameter;
-    private final RemovedArgumentsInfo removedArgumentsInfo;
-
-    private RewrittenPrototypeDescription() {
-      this(false, false, RemovedArgumentsInfo.empty());
-    }
-
-    public RewrittenPrototypeDescription(
-        boolean hasBeenChangedToReturnVoid,
-        boolean extraNullParameter,
-        RemovedArgumentsInfo removedArgumentsInfo) {
-      assert removedArgumentsInfo != null;
-      this.extraNullParameter = extraNullParameter;
-      this.hasBeenChangedToReturnVoid = hasBeenChangedToReturnVoid;
-      this.removedArgumentsInfo = removedArgumentsInfo;
-    }
-
-    public static RewrittenPrototypeDescription none() {
-      return none;
-    }
-
-    public boolean isEmpty() {
-      return !extraNullParameter
-          && !hasBeenChangedToReturnVoid
-          && !getRemovedArgumentsInfo().hasRemovedArguments();
-    }
-
-    public boolean hasExtraNullParameter() {
-      return extraNullParameter;
-    }
-
-    public boolean hasBeenChangedToReturnVoid() {
-      return hasBeenChangedToReturnVoid;
-    }
-
-    public RemovedArgumentsInfo getRemovedArgumentsInfo() {
-      return removedArgumentsInfo;
-    }
-
-    /**
-     * Returns the {@link ConstInstruction} that should be used to materialize the result of
-     * invocations to the method represented by this {@link RewrittenPrototypeDescription}.
-     *
-     * <p>This method should only be used for methods that return a constant value and whose return
-     * type has been changed to void.
-     *
-     * <p>Note that the current implementation always returns null at this point.
-     */
-    public ConstInstruction getConstantReturn(IRCode code, Position position) {
-      assert hasBeenChangedToReturnVoid;
-      ConstInstruction instruction = code.createConstNull();
-      instruction.setPosition(position);
-      return instruction;
-    }
-
-    public DexType rewriteReturnType(DexType returnType, DexItemFactory dexItemFactory) {
-      return hasBeenChangedToReturnVoid ? dexItemFactory.voidType : returnType;
-    }
-
-    public DexType[] rewriteParameters(DexType[] params) {
-      RemovedArgumentsInfo removedArgumentsInfo = getRemovedArgumentsInfo();
-      if (removedArgumentsInfo.hasRemovedArguments()) {
-        DexType[] newParams =
-            new DexType[params.length - removedArgumentsInfo.numberOfRemovedArguments()];
-        int newParamIndex = 0;
-        for (int oldParamIndex = 0; oldParamIndex < params.length; ++oldParamIndex) {
-          if (!removedArgumentsInfo.isArgumentRemoved(oldParamIndex)) {
-            newParams[newParamIndex] = params[oldParamIndex];
-            ++newParamIndex;
-          }
-        }
-        return newParams;
-      }
-      return params;
-    }
-
-    public DexProto rewriteProto(DexProto proto, DexItemFactory dexItemFactory) {
-      DexType newReturnType = rewriteReturnType(proto.returnType, dexItemFactory);
-      DexType[] newParameters = rewriteParameters(proto.parameters.values);
-      return dexItemFactory.createProto(newReturnType, newParameters);
-    }
-
-    public RewrittenPrototypeDescription withConstantReturn() {
-      return !hasBeenChangedToReturnVoid
-          ? new RewrittenPrototypeDescription(true, extraNullParameter, removedArgumentsInfo)
-          : this;
-    }
-
-    public RewrittenPrototypeDescription withRemovedArguments(RemovedArgumentsInfo other) {
-      return new RewrittenPrototypeDescription(
-          hasBeenChangedToReturnVoid, extraNullParameter, removedArgumentsInfo.combine(other));
-    }
-
-    public RewrittenPrototypeDescription withExtraNullParameter() {
-      return !extraNullParameter
-          ? new RewrittenPrototypeDescription(
-              hasBeenChangedToReturnVoid, true, removedArgumentsInfo)
-          : this;
-    }
-  }
-
   public static class Builder {
 
     protected Builder() {}
@@ -594,7 +322,7 @@
         if (isContextFreeForMethod(method)) {
           result.put(lookupMethod(method), entry.getBooleanValue());
         } else {
-          for (DexMethod candidate: lookupMethodInAllContexts(method)) {
+          for (DexMethod candidate : lookupMethodInAllContexts(method)) {
             result.put(candidate, entry.getBooleanValue());
           }
         }
diff --git a/src/main/java/com/android/tools/r8/graph/ResolutionResult.java b/src/main/java/com/android/tools/r8/graph/ResolutionResult.java
index 23f2a61..a25bab3 100644
--- a/src/main/java/com/android/tools/r8/graph/ResolutionResult.java
+++ b/src/main/java/com/android/tools/r8/graph/ResolutionResult.java
@@ -389,12 +389,7 @@
       //     public void bar() { }
       //   }
       //
-      if (resolvedMethod.hasCode()) {
-        DexProgramClass holder = resolvedHolder.asProgramClass();
-        if (appInfo.hasAnyInstantiatedLambdas(holder)) {
-          result.add(resolvedMethod);
-        }
-      }
+      addIfDefaultMethodWithLambdaInstantiations(appInfo, resolvedMethod, result);
 
       DexMethod method = resolvedMethod.method;
       Consumer<DexEncodedMethod> addIfNotAbstract =
@@ -404,10 +399,8 @@
             }
           };
       // Default methods are looked up when looking at a specific subtype that does not override
-      // them.
-      // Otherwise, we would look up default methods that are actually never used. However, we have
-      // to
-      // add bridge methods, otherwise we can remove a bridge that will be used.
+      // them. Otherwise, we would look up default methods that are actually never used. However, we
+      // have to add bridge methods, otherwise we can remove a bridge that will be used.
       Consumer<DexEncodedMethod> addIfNotAbstractAndBridge =
           m -> {
             if (!m.accessFlags.isAbstract() && m.accessFlags.isBridge()) {
@@ -422,7 +415,11 @@
         if (clazz.isInterface()) {
           ResolutionResult targetMethods = appInfo.resolveMethodOnInterface(clazz, method);
           if (targetMethods.isSingleResolution()) {
-            addIfNotAbstractAndBridge.accept(targetMethods.getSingleTarget());
+            // Sub-interfaces can have default implementations that override the resolved method.
+            // Therefore we have to add default methods in sub interfaces.
+            DexEncodedMethod singleTarget = targetMethods.getSingleTarget();
+            addIfDefaultMethodWithLambdaInstantiations(appInfo, singleTarget, result);
+            addIfNotAbstractAndBridge.accept(singleTarget);
           }
         } else {
           ResolutionResult targetMethods = appInfo.resolveMethodOnClass(clazz, method);
@@ -433,6 +430,19 @@
       }
       return result;
     }
+
+    private void addIfDefaultMethodWithLambdaInstantiations(
+        AppInfoWithSubtyping appInfo, DexEncodedMethod method, Set<DexEncodedMethod> result) {
+      if (method == null) {
+        return;
+      }
+      if (method.hasCode()) {
+        DexProgramClass holder = appInfo.definitionForProgramType(method.method.holder);
+        if (appInfo.hasAnyInstantiatedLambdas(holder)) {
+          result.add(method);
+        }
+      }
+    }
   }
 
   abstract static class EmptyResult extends ResolutionResult {
diff --git a/src/main/java/com/android/tools/r8/graph/RewrittenPrototypeDescription.java b/src/main/java/com/android/tools/r8/graph/RewrittenPrototypeDescription.java
new file mode 100644
index 0000000..5c22878
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/RewrittenPrototypeDescription.java
@@ -0,0 +1,289 @@
+// 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.graph;
+
+import com.android.tools.r8.ir.code.ConstInstruction;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.Position;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.IteratorUtils;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.function.Consumer;
+
+public class RewrittenPrototypeDescription {
+
+  public static class RemovedArgumentInfo {
+
+    public static class Builder {
+
+      private int argumentIndex = -1;
+      private boolean isAlwaysNull = false;
+      private DexType type = null;
+
+      public Builder setArgumentIndex(int argumentIndex) {
+        this.argumentIndex = argumentIndex;
+        return this;
+      }
+
+      public Builder setIsAlwaysNull() {
+        this.isAlwaysNull = true;
+        return this;
+      }
+
+      public Builder setType(DexType type) {
+        this.type = type;
+        return this;
+      }
+
+      public RemovedArgumentInfo build() {
+        assert argumentIndex >= 0;
+        assert type != null;
+        return new RemovedArgumentInfo(argumentIndex, isAlwaysNull, type);
+      }
+    }
+
+    private final int argumentIndex;
+    private final boolean isAlwaysNull;
+    private final DexType type;
+
+    private RemovedArgumentInfo(int argumentIndex, boolean isAlwaysNull, DexType type) {
+      this.argumentIndex = argumentIndex;
+      this.isAlwaysNull = isAlwaysNull;
+      this.type = type;
+    }
+
+    public static Builder builder() {
+      return new Builder();
+    }
+
+    public int getArgumentIndex() {
+      return argumentIndex;
+    }
+
+    public DexType getType() {
+      return type;
+    }
+
+    public boolean isAlwaysNull() {
+      return isAlwaysNull;
+    }
+
+    public boolean isNeverUsed() {
+      return !isAlwaysNull;
+    }
+
+    RemovedArgumentInfo withArgumentIndex(int argumentIndex) {
+      return this.argumentIndex != argumentIndex
+          ? new RemovedArgumentInfo(argumentIndex, isAlwaysNull, type)
+          : this;
+    }
+  }
+
+  public static class RemovedArgumentsInfo {
+
+    private static final RemovedArgumentsInfo empty = new RemovedArgumentsInfo(null);
+
+    private final List<RemovedArgumentInfo> removedArguments;
+
+    public RemovedArgumentsInfo(List<RemovedArgumentInfo> removedArguments) {
+      assert verifyRemovedArguments(removedArguments);
+      this.removedArguments = removedArguments;
+    }
+
+    private static boolean verifyRemovedArguments(List<RemovedArgumentInfo> removedArguments) {
+      if (removedArguments != null && !removedArguments.isEmpty()) {
+        // Check that list is sorted by argument indices.
+        int lastArgumentIndex = removedArguments.get(0).getArgumentIndex();
+        for (int i = 1; i < removedArguments.size(); ++i) {
+          int currentArgumentIndex = removedArguments.get(i).getArgumentIndex();
+          assert lastArgumentIndex < currentArgumentIndex;
+          lastArgumentIndex = currentArgumentIndex;
+        }
+      }
+      return true;
+    }
+
+    public static RemovedArgumentsInfo empty() {
+      return empty;
+    }
+
+    public ListIterator<RemovedArgumentInfo> iterator() {
+      return removedArguments == null
+          ? Collections.emptyListIterator()
+          : removedArguments.listIterator();
+    }
+
+    public boolean hasRemovedArguments() {
+      return removedArguments != null && !removedArguments.isEmpty();
+    }
+
+    public boolean isArgumentRemoved(int argumentIndex) {
+      if (removedArguments != null) {
+        for (RemovedArgumentInfo info : removedArguments) {
+          if (info.getArgumentIndex() == argumentIndex) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+
+    public DexType[] rewriteParameters(DexEncodedMethod encodedMethod) {
+      // Currently not allowed to remove the receiver of an instance method. This would involve
+      // changing invoke-direct/invoke-virtual into invoke-static.
+      assert encodedMethod.isStatic() || !isArgumentRemoved(0);
+      DexType[] params = encodedMethod.method.proto.parameters.values;
+      if (!hasRemovedArguments()) {
+        return params;
+      }
+      DexType[] newParams = new DexType[params.length - numberOfRemovedArguments()];
+      int offset = encodedMethod.isStatic() ? 0 : 1;
+      int newParamIndex = 0;
+      for (int oldParamIndex = 0; oldParamIndex < params.length; ++oldParamIndex) {
+        if (!isArgumentRemoved(oldParamIndex + offset)) {
+          newParams[newParamIndex++] = params[oldParamIndex];
+        }
+      }
+      return newParams;
+    }
+
+    public int numberOfRemovedArguments() {
+      return removedArguments != null ? removedArguments.size() : 0;
+    }
+
+    public RemovedArgumentsInfo combine(RemovedArgumentsInfo info) {
+      assert info != null;
+      if (hasRemovedArguments()) {
+        if (!info.hasRemovedArguments()) {
+          return this;
+        }
+      } else {
+        return info;
+      }
+
+      List<RemovedArgumentInfo> newRemovedArguments = new LinkedList<>(removedArguments);
+      ListIterator<RemovedArgumentInfo> iterator = newRemovedArguments.listIterator();
+      int offset = 0;
+      for (RemovedArgumentInfo pending : info.removedArguments) {
+        RemovedArgumentInfo next = IteratorUtils.peekNext(iterator);
+        while (next != null && next.getArgumentIndex() <= pending.getArgumentIndex() + offset) {
+          iterator.next();
+          next = IteratorUtils.peekNext(iterator);
+          offset++;
+        }
+        iterator.add(pending.withArgumentIndex(pending.getArgumentIndex() + offset));
+      }
+      return new RemovedArgumentsInfo(newRemovedArguments);
+    }
+
+    public Consumer<DexEncodedMethod.Builder> createParameterAnnotationsRemover(
+        DexEncodedMethod method) {
+      if (numberOfRemovedArguments() > 0 && !method.parameterAnnotationsList.isEmpty()) {
+        return builder -> {
+          int firstArgumentIndex = BooleanUtils.intValue(!method.isStatic());
+          builder.removeParameterAnnotations(
+              oldIndex -> isArgumentRemoved(oldIndex + firstArgumentIndex));
+        };
+      }
+      return null;
+    }
+  }
+
+  private static final RewrittenPrototypeDescription none = new RewrittenPrototypeDescription();
+
+  private final boolean hasBeenChangedToReturnVoid;
+  private final boolean extraNullParameter;
+  private final RemovedArgumentsInfo removedArgumentsInfo;
+
+  private RewrittenPrototypeDescription() {
+    this(false, false, RemovedArgumentsInfo.empty());
+  }
+
+  private RewrittenPrototypeDescription(
+      boolean hasBeenChangedToReturnVoid,
+      boolean extraNullParameter,
+      RemovedArgumentsInfo removedArgumentsInfo) {
+    assert removedArgumentsInfo != null;
+    this.extraNullParameter = extraNullParameter;
+    this.hasBeenChangedToReturnVoid = hasBeenChangedToReturnVoid;
+    this.removedArgumentsInfo = removedArgumentsInfo;
+  }
+
+  public static RewrittenPrototypeDescription createForUninstantiatedTypes(
+      boolean hasBeenChangedToReturnVoid, RemovedArgumentsInfo removedArgumentsInfo) {
+    return new RewrittenPrototypeDescription(
+        hasBeenChangedToReturnVoid, false, removedArgumentsInfo);
+  }
+
+  public static RewrittenPrototypeDescription none() {
+    return none;
+  }
+
+  public boolean isEmpty() {
+    return !extraNullParameter
+        && !hasBeenChangedToReturnVoid
+        && !getRemovedArgumentsInfo().hasRemovedArguments();
+  }
+
+  public boolean hasExtraNullParameter() {
+    return extraNullParameter;
+  }
+
+  public boolean hasBeenChangedToReturnVoid() {
+    return hasBeenChangedToReturnVoid;
+  }
+
+  public RemovedArgumentsInfo getRemovedArgumentsInfo() {
+    return removedArgumentsInfo;
+  }
+
+  /**
+   * Returns the {@link ConstInstruction} that should be used to materialize the result of
+   * invocations to the method represented by this {@link RewrittenPrototypeDescription}.
+   *
+   * <p>This method should only be used for methods that return a constant value and whose return
+   * type has been changed to void.
+   *
+   * <p>Note that the current implementation always returns null at this point.
+   */
+  public ConstInstruction getConstantReturn(IRCode code, Position position) {
+    assert hasBeenChangedToReturnVoid;
+    ConstInstruction instruction = code.createConstNull();
+    instruction.setPosition(position);
+    return instruction;
+  }
+
+  public DexProto rewriteProto(DexEncodedMethod encodedMethod, DexItemFactory dexItemFactory) {
+    if (isEmpty()) {
+      return encodedMethod.method.proto;
+    }
+    DexType newReturnType =
+        hasBeenChangedToReturnVoid
+            ? dexItemFactory.voidType
+            : encodedMethod.method.proto.returnType;
+    DexType[] newParameters = removedArgumentsInfo.rewriteParameters(encodedMethod);
+    return dexItemFactory.createProto(newReturnType, newParameters);
+  }
+
+  public RewrittenPrototypeDescription withConstantReturn() {
+    return !hasBeenChangedToReturnVoid
+        ? new RewrittenPrototypeDescription(true, extraNullParameter, removedArgumentsInfo)
+        : this;
+  }
+
+  public RewrittenPrototypeDescription withRemovedArguments(RemovedArgumentsInfo other) {
+    return new RewrittenPrototypeDescription(
+        hasBeenChangedToReturnVoid, extraNullParameter, removedArgumentsInfo.combine(other));
+  }
+
+  public RewrittenPrototypeDescription withExtraNullParameter() {
+    return !extraNullParameter
+        ? new RewrittenPrototypeDescription(hasBeenChangedToReturnVoid, true, removedArgumentsInfo)
+        : this;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java
new file mode 100644
index 0000000..b463c75
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java
@@ -0,0 +1,77 @@
+// 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.ir.analysis.fieldaccess;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.ir.code.FieldInstruction;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
+import com.android.tools.r8.ir.optimize.ClassInitializerDefaultsOptimization.ClassInitializerDefaultsResult;
+import com.android.tools.r8.ir.optimize.info.OptimizationFeedback;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.InternalOptions;
+
+public class FieldAccessAnalysis {
+
+  private final AppView<?> appView;
+  private final FieldAssignmentTracker fieldAssignmentTracker;
+  private final FieldBitAccessAnalysis fieldBitAccessAnalysis;
+
+  public FieldAccessAnalysis(AppView<AppInfoWithLiveness> appView) {
+    InternalOptions options = appView.options();
+    this.appView = appView;
+    this.fieldBitAccessAnalysis =
+        options.enableFieldBitAccessAnalysis ? new FieldBitAccessAnalysis() : null;
+    this.fieldAssignmentTracker =
+        options.enableFieldAssignmentTracker ? new FieldAssignmentTracker(appView) : null;
+  }
+
+  public FieldAccessAnalysis(
+      AppView<?> appView,
+      FieldAssignmentTracker fieldAssignmentTracker,
+      FieldBitAccessAnalysis fieldBitAccessAnalysis) {
+    this.appView = appView;
+    this.fieldAssignmentTracker = fieldAssignmentTracker;
+    this.fieldBitAccessAnalysis = fieldBitAccessAnalysis;
+  }
+
+  public static boolean enable(InternalOptions options) {
+    return options.enableFieldBitAccessAnalysis || options.enableFieldAssignmentTracker;
+  }
+
+  public FieldAssignmentTracker fieldAssignmentTracker() {
+    return fieldAssignmentTracker;
+  }
+
+  public void acceptClassInitializerDefaultsResult(
+      ClassInitializerDefaultsResult classInitializerDefaultsResult) {
+    if (fieldAssignmentTracker != null) {
+      fieldAssignmentTracker.acceptClassInitializerDefaultsResult(classInitializerDefaultsResult);
+    }
+  }
+
+  public void recordFieldAccesses(
+      IRCode code, OptimizationFeedback feedback, MethodProcessor methodProcessor) {
+    if (!code.metadata().mayHaveFieldInstruction() || !methodProcessor.isPrimary()) {
+      return;
+    }
+
+    Iterable<FieldInstruction> fieldInstructions =
+        code.instructions(Instruction::isFieldInstruction);
+    for (FieldInstruction fieldInstruction : fieldInstructions) {
+      DexEncodedField encodedField = appView.appInfo().resolveField(fieldInstruction.getField());
+      if (encodedField != null && encodedField.isProgramField(appView)) {
+        if (fieldAssignmentTracker != null) {
+          fieldAssignmentTracker.recordFieldAccess(fieldInstruction, encodedField, code.method);
+        }
+        if (fieldBitAccessAnalysis != null) {
+          fieldBitAccessAnalysis.recordFieldAccess(fieldInstruction, encodedField, feedback);
+        }
+      }
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java
new file mode 100644
index 0000000..0b0b542
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java
@@ -0,0 +1,142 @@
+// 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.ir.analysis.fieldaccess;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.FieldAccessInfoCollection;
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.code.FieldInstruction;
+import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.optimize.ClassInitializerDefaultsOptimization.ClassInitializerDefaultsResult;
+import com.android.tools.r8.ir.optimize.info.FieldOptimizationInfo;
+import com.android.tools.r8.ir.optimize.info.OptimizationFeedback;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.google.common.collect.Sets;
+import it.unimi.dsi.fastutil.objects.Reference2IntMap;
+import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+
+public class FieldAssignmentTracker {
+
+  private final AppView<AppInfoWithLiveness> appView;
+
+  // A field access graph with edges from methods to the fields that they access. Edges are removed
+  // from the graph as we process methods, such that we can conclude that all field writes have been
+  // processed when a field no longer has any incoming edges.
+  private final FieldAccessGraph fieldAccessGraph;
+
+  // The set of fields that may store a non-zero value.
+  private final Set<DexEncodedField> nonZeroFields = Sets.newConcurrentHashSet();
+
+  FieldAssignmentTracker(AppView<AppInfoWithLiveness> appView) {
+    this.appView = appView;
+    this.fieldAccessGraph = new FieldAccessGraph(appView);
+  }
+
+  private boolean isAlwaysZero(DexEncodedField field) {
+    return !appView.appInfo().isPinned(field.field) && !nonZeroFields.contains(field);
+  }
+
+  void acceptClassInitializerDefaultsResult(
+      ClassInitializerDefaultsResult classInitializerDefaultsResult) {
+    classInitializerDefaultsResult.forEachOptimizedField(
+        (field, value) -> {
+          if (!value.isDefault(field.field.type)) {
+            nonZeroFields.add(field);
+          }
+        });
+  }
+
+  void recordFieldAccess(
+      FieldInstruction instruction, DexEncodedField field, DexEncodedMethod context) {
+    if (instruction.isFieldPut()) {
+      recordFieldPut(field, instruction.value(), context);
+    }
+  }
+
+  private void recordFieldPut(DexEncodedField field, Value value, DexEncodedMethod context) {
+    assert verifyValueIsConsistentWithFieldOptimizationInfo(
+        value, field.getOptimizationInfo(), context);
+    if (!value.isZero()) {
+      nonZeroFields.add(field);
+    }
+  }
+
+  private void recordAllFieldPutsProcessed(DexEncodedField field, OptimizationFeedback feedback) {
+    if (isAlwaysZero(field)) {
+      feedback.recordFieldHasAbstractValue(
+          field, appView, appView.abstractValueFactory().createSingleNumberValue(0));
+    }
+  }
+
+  public void waveDone(Collection<DexEncodedMethod> wave, OptimizationFeedback feedback) {
+    for (DexEncodedMethod method : wave) {
+      fieldAccessGraph.markProcessed(method, field -> recordAllFieldPutsProcessed(field, feedback));
+    }
+  }
+
+  private boolean verifyValueIsConsistentWithFieldOptimizationInfo(
+      Value value, FieldOptimizationInfo optimizationInfo, DexEncodedMethod context) {
+    AbstractValue abstractValue = optimizationInfo.getAbstractValue();
+    if (abstractValue.isUnknown()) {
+      return true;
+    }
+    assert abstractValue == value.getAbstractValue(appView, context.method.holder);
+    return true;
+  }
+
+  static class FieldAccessGraph {
+
+    // The fields written by each method.
+    private final Map<DexEncodedMethod, List<DexEncodedField>> fieldWrites =
+        new IdentityHashMap<>();
+
+    // The number of writes that have not yet been processed per field.
+    private final Reference2IntMap<DexEncodedField> pendingFieldWrites =
+        new Reference2IntOpenHashMap<>();
+
+    FieldAccessGraph(AppView<AppInfoWithLiveness> appView) {
+      FieldAccessInfoCollection<?> fieldAccessInfoCollection =
+          appView.appInfo().getFieldAccessInfoCollection();
+      fieldAccessInfoCollection.flattenAccessContexts();
+      fieldAccessInfoCollection.forEach(
+          info -> {
+            DexEncodedField field = appView.appInfo().resolveField(info.getField());
+            if (field == null) {
+              assert false;
+              return;
+            }
+            if (!info.hasReflectiveAccess()) {
+              info.forEachWriteContext(
+                  context ->
+                      fieldWrites.computeIfAbsent(context, ignore -> new ArrayList<>()).add(field));
+              pendingFieldWrites.put(field, info.getNumberOfWriteContexts());
+            }
+          });
+    }
+
+    void markProcessed(DexEncodedMethod method, Consumer<DexEncodedField> allWritesSeenConsumer) {
+      List<DexEncodedField> fieldWritesInMethod = fieldWrites.get(method);
+      if (fieldWritesInMethod != null) {
+        for (DexEncodedField field : fieldWritesInMethod) {
+          int numberOfPendingFieldWrites = pendingFieldWrites.removeInt(field) - 1;
+          if (numberOfPendingFieldWrites > 0) {
+            pendingFieldWrites.put(field, numberOfPendingFieldWrites);
+          } else {
+            allWritesSeenConsumer.accept(field);
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessAnalysis.java
index deabda7..a178a69 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessAnalysis.java
@@ -4,13 +4,9 @@
 
 package com.android.tools.r8.ir.analysis.fieldaccess;
 
-import com.android.tools.r8.graph.AppInfoWithSubtyping;
-import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexEncodedField;
-import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.ir.code.And;
 import com.android.tools.r8.ir.code.FieldInstruction;
-import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.LogicalBinop;
 import com.android.tools.r8.ir.code.Value;
@@ -19,39 +15,18 @@
 
 public class FieldBitAccessAnalysis {
 
-  private final AppView<? extends AppInfoWithSubtyping> appView;
-
-  public FieldBitAccessAnalysis(AppView<? extends AppInfoWithSubtyping> appView) {
-    assert appView.enableWholeProgramOptimizations();
-    this.appView = appView;
-  }
-
-  public void recordFieldAccesses(IRCode code, OptimizationFeedback feedback) {
-    if (!code.metadata().mayHaveFieldInstruction()) {
+  public void recordFieldAccess(
+      FieldInstruction instruction, DexEncodedField field, OptimizationFeedback feedback) {
+    if (!field.field.type.isIntType()) {
       return;
     }
 
-    for (Instruction instruction : code.instructions()) {
-      if (instruction.isFieldInstruction()) {
-        FieldInstruction fieldInstruction = instruction.asFieldInstruction();
-        DexField field = fieldInstruction.getField();
-        if (!field.type.isIntType()) {
-          continue;
-        }
+    if (BitAccessInfo.allBitsRead(field.getOptimizationInfo().getReadBits())) {
+      return;
+    }
 
-        DexEncodedField encodedField = appView.appInfo().resolveField(field);
-        if (encodedField == null || !encodedField.isProgramField(appView)) {
-          continue;
-        }
-
-        if (BitAccessInfo.allBitsRead(encodedField.getOptimizationInfo().getReadBits())) {
-          continue;
-        }
-
-        if (fieldInstruction.isFieldGet()) {
-          feedback.markFieldBitsRead(encodedField, computeBitsRead(fieldInstruction, encodedField));
-        }
-      }
+    if (instruction.isFieldGet()) {
+      feedback.markFieldBitsRead(field, computeBitsRead(instruction, field));
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/proto/GeneratedExtensionRegistryShrinker.java b/src/main/java/com/android/tools/r8/ir/analysis/proto/GeneratedExtensionRegistryShrinker.java
index 0b4bb94..4de5c39 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/proto/GeneratedExtensionRegistryShrinker.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/proto/GeneratedExtensionRegistryShrinker.java
@@ -99,6 +99,7 @@
    */
   public TreePrunerConfiguration run(Enqueuer.Mode mode) {
     forEachDeadProtoExtensionField(this::recordDeadProtoExtensionField);
+    appView.appInfo().getFieldAccessInfoCollection().removeIf((field, info) -> wasRemoved(field));
     return createTreePrunerConfiguration(mode);
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/proto/schema/ProtoEnqueuerExtension.java b/src/main/java/com/android/tools/r8/ir/analysis/proto/schema/ProtoEnqueuerExtension.java
index 820789a..4ff6283 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/proto/schema/ProtoEnqueuerExtension.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/proto/schema/ProtoEnqueuerExtension.java
@@ -350,13 +350,13 @@
             // (i) optimize field reads into loading the default value of the field or (ii) remove
             // field writes to proto fields that could be read using reflection by the proto
             // library.
-            enqueuer.registerFieldAccess(valueStorage.field, dynamicMethod);
+            enqueuer.registerReflectiveFieldAccess(valueStorage.field, dynamicMethod);
           }
           valueStorageIsLive = true;
         } else if (reachesMapOrRequiredField(protoFieldInfo)) {
           // Map/required fields cannot be removed. Therefore, we mark such fields as both read and
           // written such that we cannot optimize any field reads or writes.
-          enqueuer.registerFieldAccess(valueStorage.field, dynamicMethod);
+          enqueuer.registerReflectiveFieldAccess(valueStorage.field, dynamicMethod);
           worklist.enqueueMarkReachableFieldAction(
               clazz, valueStorage, KeepReason.reflectiveUseIn(dynamicMethod));
           valueStorageIsLive = true;
@@ -411,12 +411,12 @@
               writer -> writer != defaultInitializer && writer != dynamicMethod;
           if (enqueuer.isFieldWrittenInMethodSatisfying(
               newlyLiveField, neitherDefaultConstructorNorDynamicMethod)) {
-            enqueuer.registerFieldRead(newlyLiveField.field, dynamicMethod);
+            enqueuer.registerReflectiveFieldRead(newlyLiveField.field, dynamicMethod);
           }
 
           // Unconditionally register the hazzer and one-of proto fields as written from
           // dynamicMethod().
-          if (enqueuer.registerFieldWrite(newlyLiveField.field, dynamicMethod)) {
+          if (enqueuer.registerReflectiveFieldWrite(newlyLiveField.field, dynamicMethod)) {
             worklist.enqueueMarkReachableFieldAction(
                 clazz, newlyLiveField, KeepReason.reflectiveUseIn(dynamicMethod));
           }
@@ -527,7 +527,7 @@
       return;
     }
 
-    if (enqueuer.registerFieldWrite(encodedOneOfField.field, dynamicMethod)) {
+    if (enqueuer.registerReflectiveFieldWrite(encodedOneOfField.field, dynamicMethod)) {
       worklist.enqueueMarkReachableFieldAction(
           clazz.asProgramClass(), encodedOneOfField, KeepReason.reflectiveUseIn(dynamicMethod));
     }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java
index 2bd87e0..c70ff33 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java
@@ -8,6 +8,10 @@
 
   public abstract boolean isNonTrivial();
 
+  public boolean isZero() {
+    return false;
+  }
+
   /**
    * Returns true if this abstract value represents a single concrete value (i.e., the
    * concretization of this abstract value has size 1).
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java b/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java
index 9a43d23..4a5ad60 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java
@@ -25,6 +25,11 @@
   }
 
   @Override
+  public boolean isZero() {
+    return value == 0;
+  }
+
+  @Override
   public boolean isSingleNumberValue() {
     return true;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/DexSourceCode.java b/src/main/java/com/android/tools/r8/ir/conversion/DexSourceCode.java
index 2e5467c..01dcf5d 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/DexSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/DexSourceCode.java
@@ -40,8 +40,8 @@
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.GraphLense.RewrittenPrototypeDescription.RemovedArgumentInfo;
-import com.android.tools.r8.graph.GraphLense.RewrittenPrototypeDescription.RemovedArgumentsInfo;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription.RemovedArgumentInfo;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription.RemovedArgumentsInfo;
 import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.code.CanonicalPositions;
@@ -158,7 +158,8 @@
       int register,
       DexEncodedMethod method,
       BiConsumer<Integer, DexType> writeCallback) {
-    RemovedArgumentsInfo removedArgumentsInfo = builder.prototypeChanges.getRemovedArgumentsInfo();
+    RemovedArgumentsInfo removedArgumentsInfo =
+        builder.getPrototypeChanges().getRemovedArgumentsInfo();
     ListIterator<RemovedArgumentInfo> removedArgumentIterator = removedArgumentsInfo.iterator();
     RemovedArgumentInfo nextRemovedArgument =
         removedArgumentIterator.hasNext() ? removedArgumentIterator.next() : null;
@@ -186,7 +187,7 @@
         type =
             TypeLatticeElement.fromDexType(
                 nextRemovedArgument.getType(), Nullability.maybeNull(), builder.appView);
-        builder.addConstantOrUnusedArgument(register);
+        builder.addConstantOrUnusedArgument(register, nextRemovedArgument);
         nextRemovedArgument =
             removedArgumentIterator.hasNext() ? removedArgumentIterator.next() : null;
       } else {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
index 42728d4..3d0fed3 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
@@ -34,8 +34,8 @@
 import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.GraphLense;
-import com.android.tools.r8.graph.GraphLense.RewrittenPrototypeDescription;
-import com.android.tools.r8.graph.GraphLense.RewrittenPrototypeDescription.RemovedArgumentInfo;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription.RemovedArgumentInfo;
 import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.PrimitiveTypeLatticeElement;
 import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
@@ -113,7 +113,6 @@
 import com.android.tools.r8.naming.dexitembasedstring.NameComputationInfo;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.AndroidApiLevel;
-import com.android.tools.r8.utils.IteratorUtils;
 import com.android.tools.r8.utils.Pair;
 import com.google.common.collect.Sets;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceAVLTreeMap;
@@ -133,7 +132,6 @@
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.ListIterator;
 import java.util.Map;
 import java.util.Queue;
 import java.util.Set;
@@ -392,9 +390,7 @@
   private DexEncodedMethod context;
   public final AppView<?> appView;
   private final Origin origin;
-  final RewrittenPrototypeDescription prototypeChanges;
-  private ListIterator<RemovedArgumentInfo> removedArgumentsIterator;
-  private int argumentCount = 0;
+  private final RewrittenPrototypeDescription prototypeChanges;
   private Value receiverValue;
   private List<Value> argumentValues;
 
@@ -461,7 +457,6 @@
                 + method.toSourceString());
       }
     }
-    this.removedArgumentsIterator = this.prototypeChanges.getRemovedArgumentsInfo().iterator();
   }
 
   private static boolean verifyMethodSignature(DexEncodedMethod method, GraphLense graphLense) {
@@ -476,6 +471,10 @@
     return method;
   }
 
+  public RewrittenPrototypeDescription getPrototypeChanges() {
+    return prototypeChanges;
+  }
+
   public boolean isDebugMode() {
     return appView.options().debug || method.getOptimizationInfo().isReachabilitySensitive();
   }
@@ -854,16 +853,6 @@
     addInstruction(ir);
   }
 
-  private RemovedArgumentInfo getRemovedArgumentInfo() {
-    RemovedArgumentInfo removedArgumentInfo = IteratorUtils.peekNext(removedArgumentsIterator);
-    if (removedArgumentInfo != null && removedArgumentInfo.getArgumentIndex() == argumentCount) {
-      argumentCount++;
-      return removedArgumentsIterator.next();
-    }
-    argumentCount++;
-    return null;
-  }
-
   void addThisArgument(int register) {
     boolean receiverCouldBeNull = context != null && context != method;
     Nullability nullability = receiverCouldBeNull ? maybeNull() : definitelyNotNull();
@@ -873,8 +862,6 @@
   }
 
   public void addThisArgument(int register, TypeLatticeElement receiverType) {
-    RemovedArgumentInfo removedArgumentInfo = getRemovedArgumentInfo();
-    assert removedArgumentInfo == null; // Removal of receiver not yet supported.
     DebugLocalInfo local = getOutgoingLocal(register);
     Value value = writeRegister(register, receiverType, ThrowingInfo.NO_THROW, local);
     addInstruction(new Argument(value, false));
@@ -883,25 +870,15 @@
   }
 
   public void addNonThisArgument(int register, TypeLatticeElement typeLattice) {
-    RemovedArgumentInfo removedArgumentInfo = getRemovedArgumentInfo();
-    if (removedArgumentInfo == null) {
       DebugLocalInfo local = getOutgoingLocal(register);
       Value value = writeRegister(register, typeLattice, ThrowingInfo.NO_THROW, local);
       addNonThisArgument(new Argument(value, false));
-    } else {
-      handleConstantOrUnusedArgument(register, removedArgumentInfo);
-    }
   }
 
   public void addBooleanNonThisArgument(int register) {
-    RemovedArgumentInfo removedArgumentInfo = getRemovedArgumentInfo();
-    if (removedArgumentInfo == null) {
       DebugLocalInfo local = getOutgoingLocal(register);
       Value value = writeRegister(register, getInt(), ThrowingInfo.NO_THROW, local);
       addNonThisArgument(new Argument(value, true));
-    } else {
-      assert removedArgumentInfo.isNeverUsed();
-    }
   }
 
   private void addNonThisArgument(Argument argument) {
@@ -912,8 +889,8 @@
     argumentValues.add(argument.outValue());
   }
 
-  public void addConstantOrUnusedArgument(int register) {
-    handleConstantOrUnusedArgument(register, getRemovedArgumentInfo());
+  public void addConstantOrUnusedArgument(int register, RemovedArgumentInfo info) {
+    handleConstantOrUnusedArgument(register, info);
   }
 
   private void handleConstantOrUnusedArgument(
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index 2c9a53c..7800639 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -26,7 +26,7 @@
 import com.android.tools.r8.graph.GraphLense;
 import com.android.tools.r8.ir.analysis.TypeChecker;
 import com.android.tools.r8.ir.analysis.constant.SparseConditionalConstantPropagation;
-import com.android.tools.r8.ir.analysis.fieldaccess.FieldBitAccessAnalysis;
+import com.android.tools.r8.ir.analysis.fieldaccess.FieldAccessAnalysis;
 import com.android.tools.r8.ir.analysis.fieldvalueanalysis.FieldValueAnalysis;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.code.AlwaysMaterializingDefinition;
@@ -128,7 +128,7 @@
   private final Timing timing;
   private final Outliner outliner;
   private final ClassInitializerDefaultsOptimization classInitializerDefaultsOptimization;
-  private final FieldBitAccessAnalysis fieldBitAccessAnalysis;
+  private final FieldAccessAnalysis fieldAccessAnalysis;
   private final LibraryMethodOptimizer libraryMethodOptimizer;
   private final LibraryMethodOverrideAnalysis libraryMethodOverrideAnalysis;
   private final StringConcatRewriter stringConcatRewriter;
@@ -232,7 +232,7 @@
       this.dynamicTypeOptimization = null;
       this.classInliner = null;
       this.classStaticizer = null;
-      this.fieldBitAccessAnalysis = null;
+      this.fieldAccessAnalysis = null;
       this.libraryMethodOptimizer = null;
       this.libraryMethodOverrideAnalysis = null;
       this.inliner = null;
@@ -290,10 +290,8 @@
       if (dynamicTypeOptimization != null) {
         assumers.add(dynamicTypeOptimization);
       }
-      this.fieldBitAccessAnalysis =
-          options.enableFieldBitAccessAnalysis
-              ? new FieldBitAccessAnalysis(appViewWithLiveness)
-              : null;
+      this.fieldAccessAnalysis =
+          FieldAccessAnalysis.enable(options) ? new FieldAccessAnalysis(appViewWithLiveness) : null;
       this.libraryMethodOptimizer = new LibraryMethodOptimizer(appViewWithLiveness);
       this.libraryMethodOverrideAnalysis =
           options.enableTreeShakingOfLibraryMethodOverrides
@@ -331,7 +329,7 @@
       this.classInliner = null;
       this.classStaticizer = null;
       this.dynamicTypeOptimization = null;
-      this.fieldBitAccessAnalysis = null;
+      this.fieldAccessAnalysis = null;
       this.libraryMethodOptimizer = null;
       this.libraryMethodOverrideAnalysis = null;
       this.inliner = null;
@@ -805,12 +803,14 @@
     return builder.build();
   }
 
-  private void waveStart(Collection<DexEncodedMethod> wave, ExecutorService executorService)
-      throws ExecutionException {
+  private void waveStart(Collection<DexEncodedMethod> wave) {
     onWaveDoneActions = Collections.synchronizedList(new ArrayList<>());
   }
 
-  private void waveDone() {
+  private void waveDone(Collection<DexEncodedMethod> wave) {
+    if (options.enableFieldAssignmentTracker) {
+      fieldAccessAnalysis.fieldAssignmentTracker().waveDone(wave, delayedOptimizationFeedback);
+    }
     delayedOptimizationFeedback.updateVisibleOptimizationInfo();
     onWaveDoneActions.forEach(com.android.tools.r8.utils.Action::execute);
     onWaveDoneActions = null;
@@ -1143,6 +1143,8 @@
     // we will return with finalizeEmptyThrowingCode() above.
     assert code.verifyTypes(appView);
 
+    assertionsRewriter.run(method, code, timing);
+
     if (serviceLoaderRewriter != null) {
       assert appView.appInfo().hasLiveness();
       timing.begin("Rewrite service loaders");
@@ -1170,8 +1172,6 @@
       timing.end();
     }
 
-    assertionsRewriter.run(method, code, timing);
-
     previous = printMethod(code, "IR after disable assertions (SSA)", previous);
 
     timing.begin("Insert assume instructions");
@@ -1493,9 +1493,12 @@
         timing.end();
       }
 
-      if (fieldBitAccessAnalysis != null) {
-        timing.begin("Record field access");
-        fieldBitAccessAnalysis.recordFieldAccesses(code, feedback);
+      if (fieldAccessAnalysis != null) {
+        timing.begin("Analyze field accesses");
+        fieldAccessAnalysis.recordFieldAccesses(code, feedback, methodProcessor);
+        if (classInitializerDefaultsResult != null) {
+          fieldAccessAnalysis.acceptClassInitializerDefaultsResult(classInitializerDefaultsResult);
+        }
         timing.end();
       }
 
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
index b65b164..246d865 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
@@ -27,9 +27,9 @@
 import com.android.tools.r8.graph.DexValue.DexValueType;
 import com.android.tools.r8.graph.GraphLense;
 import com.android.tools.r8.graph.GraphLense.GraphLenseLookupResult;
-import com.android.tools.r8.graph.GraphLense.RewrittenPrototypeDescription;
-import com.android.tools.r8.graph.GraphLense.RewrittenPrototypeDescription.RemovedArgumentsInfo;
 import com.android.tools.r8.graph.ResolutionResult;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription.RemovedArgumentsInfo;
 import com.android.tools.r8.graph.UseRegistry.MethodHandleUse;
 import com.android.tools.r8.graph.classmerging.VerticallyMergedClasses;
 import com.android.tools.r8.ir.analysis.type.DestructivePhiTypeUpdater;
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java
index 6c42599..acba17d 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java
@@ -10,7 +10,6 @@
 import com.android.tools.r8.ir.conversion.CallGraphBuilderBase.CycleEliminator;
 import com.android.tools.r8.logging.Log;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.Action;
 import com.android.tools.r8.utils.IROrdering;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.ThreadUtils;
@@ -35,8 +34,7 @@
 
   interface WaveStartAction {
 
-    void notifyWaveStart(Collection<DexEncodedMethod> wave, ExecutorService executorService)
-        throws ExecutionException;
+    void notifyWaveStart(Collection<DexEncodedMethod> wave);
   }
 
   private final CallSiteInformation callSiteInformation;
@@ -141,7 +139,7 @@
   <E extends Exception> void forEachMethod(
       ThrowingFunction<DexEncodedMethod, Timing, E> consumer,
       WaveStartAction waveStartAction,
-      Action waveDone,
+      Consumer<Collection<DexEncodedMethod>> waveDone,
       Timing timing,
       ExecutorService executorService)
       throws ExecutionException {
@@ -150,7 +148,7 @@
     while (!waves.isEmpty()) {
       wave = waves.removeFirst();
       assert wave.size() > 0;
-      waveStartAction.notifyWaveStart(wave, executorService);
+      waveStartAction.notifyWaveStart(wave);
       merger.add(
           ThreadUtils.processItemsWithResults(
               wave,
@@ -160,7 +158,7 @@
                 return time;
               },
               executorService));
-      waveDone.execute();
+      waveDone.accept(wave);
     }
     merger.end();
   }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/NestedPrivateMethodLense.java b/src/main/java/com/android/tools/r8/ir/desugar/NestedPrivateMethodLense.java
index 9fca058..78d5702 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/NestedPrivateMethodLense.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/NestedPrivateMethodLense.java
@@ -10,6 +10,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.GraphLense;
 import com.android.tools.r8.graph.GraphLense.NestedGraphLense;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription;
 import com.android.tools.r8.ir.code.Invoke;
 import com.google.common.collect.ImmutableMap;
 import java.util.IdentityHashMap;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java b/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java
index 52d047e..e35087a 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java
@@ -56,6 +56,7 @@
 import java.util.IdentityHashMap;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.BiConsumer;
 import java.util.stream.Collectors;
 
 public class ClassInitializerDefaultsOptimization {
@@ -75,6 +76,12 @@
       return EMPTY;
     }
 
+    public void forEachOptimizedField(BiConsumer<DexEncodedField, DexValue> consumer) {
+      if (fieldsWithStaticValues != null) {
+        fieldsWithStaticValues.forEach(consumer);
+      }
+    }
+
     public boolean hasStaticValue(DexEncodedField field) {
       if (field.isStatic()) {
         return (fieldsWithStaticValues != null && fieldsWithStaticValues.containsKey(field))
@@ -86,14 +93,14 @@
 
   private class WaveDoneAction implements Action {
 
-    private final Map<DexEncodedField, DexValue> fieldsWithStaticValues;
-    private final Set<DexField> noLongerWrittenFields;
+    private final Map<DexEncodedField, DexValue> fieldsWithStaticValues = new IdentityHashMap<>();
+    private final Set<DexField> noLongerWrittenFields = Sets.newIdentityHashSet();
 
     public WaveDoneAction(
         Map<DexEncodedField, DexValue> fieldsWithStaticValues,
         Set<DexField> noLongerWrittenFields) {
-      this.fieldsWithStaticValues = fieldsWithStaticValues;
-      this.noLongerWrittenFields = noLongerWrittenFields;
+      this.fieldsWithStaticValues.putAll(fieldsWithStaticValues);
+      this.noLongerWrittenFields.addAll(noLongerWrittenFields);
     }
 
     public synchronized void join(
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
index e17e419..ea419cc 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
@@ -1469,6 +1469,8 @@
 
     @Override
     public void buildPrelude(IRBuilder builder) {
+      // If the assertion fails, check DexSourceCode#buildArgumentsWithUnusedArgumentStubs.
+      assert builder.getPrototypeChanges().isEmpty();
       // Fill in the Argument instructions in the argument block.
       for (int i = 0; i < outline.argumentTypes.size(); i++) {
         if (outline.argumentTypes.get(i).isBooleanType()) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java b/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java
index 5088d99..b871461 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java
@@ -19,9 +19,9 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.GraphLense;
 import com.android.tools.r8.graph.GraphLense.NestedGraphLense;
-import com.android.tools.r8.graph.GraphLense.RewrittenPrototypeDescription;
-import com.android.tools.r8.graph.GraphLense.RewrittenPrototypeDescription.RemovedArgumentInfo;
-import com.android.tools.r8.graph.GraphLense.RewrittenPrototypeDescription.RemovedArgumentsInfo;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription.RemovedArgumentInfo;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription.RemovedArgumentsInfo;
 import com.android.tools.r8.graph.TopDownClassHierarchyTraversal;
 import com.android.tools.r8.ir.analysis.AbstractError;
 import com.android.tools.r8.ir.analysis.TypeChecker;
@@ -160,9 +160,8 @@
       // This achieved by faking that there is already a method with the given signature.
       for (DexEncodedMethod virtualMethod : clazz.virtualMethods()) {
         RewrittenPrototypeDescription prototypeChanges =
-            new RewrittenPrototypeDescription(
+            RewrittenPrototypeDescription.createForUninstantiatedTypes(
                 virtualMethod.method.proto.returnType.isAlwaysNull(appView),
-                false,
                 getRemovedArgumentsInfo(virtualMethod, ALLOW_ARGUMENT_REMOVAL));
         if (!prototypeChanges.isEmpty()) {
           DexMethod newMethod = getNewMethodSignature(virtualMethod, prototypeChanges);
@@ -296,9 +295,8 @@
         || appView.appInfo().keepConstantArguments.contains(encodedMethod.method)) {
       return RewrittenPrototypeDescription.none();
     }
-    return new RewrittenPrototypeDescription(
+    return RewrittenPrototypeDescription.createForUninstantiatedTypes(
         encodedMethod.method.proto.returnType.isAlwaysNull(appView),
-        false,
         getRemovedArgumentsInfo(encodedMethod, strategy));
   }
 
@@ -333,41 +331,10 @@
   private DexMethod getNewMethodSignature(
       DexEncodedMethod encodedMethod, RewrittenPrototypeDescription prototypeChanges) {
     DexItemFactory dexItemFactory = appView.dexItemFactory();
-
     DexMethod method = encodedMethod.method;
-    RemovedArgumentsInfo removedArgumentsInfo = prototypeChanges.getRemovedArgumentsInfo();
+    DexProto newProto = prototypeChanges.rewriteProto(encodedMethod, dexItemFactory);
 
-    if (prototypeChanges.isEmpty()) {
-      return method;
-    }
-
-    DexType newReturnType =
-        prototypeChanges.hasBeenChangedToReturnVoid()
-            ? dexItemFactory.voidType
-            : method.proto.returnType;
-
-    DexType[] newParameters;
-    if (removedArgumentsInfo.hasRemovedArguments()) {
-      // Currently not allowed to remove the receiver of an instance method. This would involve
-      // changing invoke-direct/invoke-virtual into invoke-static.
-      assert encodedMethod.isStatic() || !removedArgumentsInfo.isArgumentRemoved(0);
-      newParameters =
-          new DexType
-              [method.proto.parameters.size() - removedArgumentsInfo.numberOfRemovedArguments()];
-      int offset = encodedMethod.isStatic() ? 0 : 1;
-      int newParametersIndex = 0;
-      for (int argumentIndex = 0; argumentIndex < method.proto.parameters.size(); ++argumentIndex) {
-        if (!removedArgumentsInfo.isArgumentRemoved(argumentIndex + offset)) {
-          newParameters[newParametersIndex] = method.proto.parameters.values[argumentIndex];
-          newParametersIndex++;
-        }
-      }
-    } else {
-      newParameters = method.proto.parameters.values;
-    }
-
-    return dexItemFactory.createMethod(
-        method.holder, dexItemFactory.createProto(newReturnType, newParameters), method.name);
+    return dexItemFactory.createMethod(method.holder, newProto, method.name);
   }
 
   public void rewrite(IRCode code) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/UnusedArgumentsCollector.java b/src/main/java/com/android/tools/r8/ir/optimize/UnusedArgumentsCollector.java
index aec5219..705b2bd 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/UnusedArgumentsCollector.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/UnusedArgumentsCollector.java
@@ -16,8 +16,9 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.GraphLense;
 import com.android.tools.r8.graph.GraphLense.NestedGraphLense;
-import com.android.tools.r8.graph.GraphLense.RewrittenPrototypeDescription.RemovedArgumentInfo;
-import com.android.tools.r8.graph.GraphLense.RewrittenPrototypeDescription.RemovedArgumentsInfo;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription.RemovedArgumentInfo;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription.RemovedArgumentsInfo;
 import com.android.tools.r8.ir.optimize.MemberPoolCollection.MemberPool;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.MethodSignatureEquivalence;
@@ -329,25 +330,8 @@
 
   private DexProto createProtoWithRemovedArguments(
       DexEncodedMethod encodedMethod, RemovedArgumentsInfo unused) {
-    DexMethod method = encodedMethod.method;
-
-    int firstArgumentIndex = encodedMethod.isStatic() ? 0 : 1;
-    int numberOfParameters = method.proto.parameters.size() - unused.numberOfRemovedArguments();
-    if (!encodedMethod.isStatic() && unused.isArgumentRemoved(0)) {
-      numberOfParameters++;
-    }
-
-    DexType[] parameters = new DexType[numberOfParameters];
-    if (numberOfParameters > 0) {
-      int newIndex = 0;
-      for (int oldIndex = 0; oldIndex < method.proto.parameters.size(); oldIndex++) {
-        if (!unused.isArgumentRemoved(oldIndex + firstArgumentIndex)) {
-          parameters[newIndex++] = method.proto.parameters.values[oldIndex];
-        }
-      }
-      assert newIndex == parameters.length;
-    }
-    return appView.dexItemFactory().createProto(method.proto.returnType, parameters);
+    DexType[] parameters = unused.rewriteParameters(encodedMethod);
+    return appView.dexItemFactory().createProto(encodedMethod.method.proto.returnType, parameters);
   }
 
   private static class CollectUsedArguments extends ArgumentUse {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryMethodOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryMethodOptimizer.java
index 91e952a..67a7588 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryMethodOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/library/LibraryMethodOptimizer.java
@@ -32,6 +32,7 @@
   public LibraryMethodOptimizer(AppView<? extends AppInfoWithSubtyping> appView) {
     this.appView = appView;
     register(new BooleanMethodOptimizer(appView));
+    register(new StringMethodOptimizer(appView));
 
     if (LogMethodOptimizer.isEnabled(appView)) {
       register(new LogMethodOptimizer(appView));
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/library/StringMethodOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/library/StringMethodOptimizer.java
new file mode 100644
index 0000000..5e4033b
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/library/StringMethodOptimizer.java
@@ -0,0 +1,93 @@
+// 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.ir.optimize.library;
+
+import com.android.tools.r8.graph.AppInfoWithSubtyping;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexReference;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.code.DexItemBasedConstString;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.code.InstructionListIterator;
+import com.android.tools.r8.ir.code.InvokeMethod;
+import com.android.tools.r8.ir.code.Value;
+import java.util.Set;
+
+public class StringMethodOptimizer implements LibraryMethodModelCollection {
+
+  private final AppView<? extends AppInfoWithSubtyping> appView;
+  private final DexItemFactory dexItemFactory;
+
+  StringMethodOptimizer(AppView<? extends AppInfoWithSubtyping> appView) {
+    this.appView = appView;
+    this.dexItemFactory = appView.dexItemFactory();
+  }
+
+  @Override
+  public DexType getType() {
+    return dexItemFactory.stringType;
+  }
+
+  @Override
+  public void optimize(
+      IRCode code,
+      InstructionListIterator instructionIterator,
+      InvokeMethod invoke,
+      DexEncodedMethod singleTarget,
+      Set<Value> affectedValues) {
+    if (singleTarget.method == dexItemFactory.stringMethods.equals) {
+      optimizeEquals(code, instructionIterator, invoke);
+    }
+  }
+
+  private void optimizeEquals(
+      IRCode code, InstructionListIterator instructionIterator, InvokeMethod invoke) {
+    if (appView.appInfo().hasLiveness()) {
+      DexType context = code.method.method.holder;
+      Value first = invoke.arguments().get(0).getAliasedValue();
+      Value second = invoke.arguments().get(1).getAliasedValue();
+      if (isPrunedClassNameComparison(first, second, context)
+          || isPrunedClassNameComparison(second, first, context)) {
+        instructionIterator.replaceCurrentInstructionWithConstInt(appView, code, 0);
+      }
+    }
+  }
+
+  /**
+   * Returns true if {@param classNameValue} is defined by calling {@link Class#getName()} and
+   * {@param constStringValue} is a constant string that is identical to the name of a class that
+   * has been pruned by the {@link com.android.tools.r8.shaking.Enqueuer}.
+   */
+  private boolean isPrunedClassNameComparison(
+      Value classNameValue, Value constStringValue, DexType context) {
+    if (classNameValue.isPhi() || constStringValue.isPhi()) {
+      return false;
+    }
+
+    Instruction classNameDefinition = classNameValue.definition;
+    if (!classNameDefinition.isInvokeVirtual()) {
+      return false;
+    }
+
+    DexEncodedMethod singleTarget =
+        classNameDefinition.asInvokeVirtual().lookupSingleTarget(appView, context);
+    if (singleTarget == null || singleTarget.method != dexItemFactory.classMethods.getName) {
+      return false;
+    }
+
+    if (!constStringValue.definition.isDexItemBasedConstString()) {
+      return false;
+    }
+
+    DexItemBasedConstString constString = constStringValue.definition.asDexItemBasedConstString();
+    DexReference reference = constString.getItem();
+    return reference.isDexType()
+        && appView.appInfo().withLiveness().wasPruned(reference.asDexType())
+        && !constString.getNameComputationInfo().needsToComputeName();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java b/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java
index 8b662b9..00b5315 100644
--- a/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java
@@ -10,6 +10,7 @@
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.desugar.LambdaDescriptor;
 import com.android.tools.r8.naming.MethodNameMinifier.State;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.DisjointSets;
@@ -241,6 +242,7 @@
 
     private final Set<DexCallSite> callSites = new HashSet<>();
     private final Map<DexMethod, Set<InterfaceReservationState>> methodStates = new HashMap<>();
+    private final List<DexMethod> callSiteCollidingMethods = new ArrayList<>();
 
     void addState(DexMethod method, InterfaceReservationState interfaceState) {
       methodStates.computeIfAbsent(method, m -> new HashSet<>()).add(interfaceState);
@@ -248,6 +250,7 @@
 
     void appendMethodGroupState(InterfaceMethodGroupState state) {
       callSites.addAll(state.callSites);
+      callSiteCollidingMethods.addAll(state.callSiteCollidingMethods);
       for (DexMethod key : state.methodStates.keySet()) {
         methodStates.computeIfAbsent(key, k -> new HashSet<>()).addAll(state.methodStates.get(key));
       }
@@ -455,6 +458,37 @@
             groupState.addCallSite(callSite);
             callSiteMethods.add(wrapped);
           }
+          if (callSiteMethods.isEmpty()) {
+            return;
+          }
+          // For intersection types, we have to iterate all the multiple interfaces to look for
+          // methods with the same signature.
+          List<DexType> implementedInterfaces =
+              LambdaDescriptor.getInterfaces(callSite, appView.appInfo());
+          if (implementedInterfaces != null) {
+            for (int i = 1; i < implementedInterfaces.size(); i++) {
+              // Add the merging state for all additional implemented interfaces into the state
+              // for the group, if the name is different, to ensure that we do not pick the same
+              // name.
+              DexClass iface = appView.definitionFor(implementedInterfaces.get(i));
+              assert iface.isInterface();
+              for (DexEncodedMethod implementedMethod : implementedMethods) {
+                for (DexEncodedMethod virtualMethod : iface.virtualMethods()) {
+                  boolean differentName =
+                      !implementedMethod.method.name.equals(virtualMethod.method.name);
+                  if (differentName
+                      && MethodJavaSignatureEquivalence.getEquivalenceIgnoreName()
+                          .equivalent(implementedMethod.method, virtualMethod.method)) {
+                    InterfaceMethodGroupState interfaceMethodGroupState =
+                        globalStateMap.computeIfAbsent(
+                            equivalence.wrap(implementedMethod.method),
+                            k -> new InterfaceMethodGroupState());
+                    interfaceMethodGroupState.callSiteCollidingMethods.add(virtualMethod.method);
+                  }
+                }
+              }
+            }
+          }
           if (callSiteMethods.size() > 1) {
             // Implemented interfaces have different protos. Unify them.
             Wrapper<DexMethod> mainKey = callSiteMethods.iterator().next();
@@ -545,6 +579,27 @@
         callSiteRenamings.put(callSite, newName);
       }
     }
+
+    // After all naming is completed for callsites, we must ensure to rename all interface methods
+    // that can collide with the callsite method name.
+    for (Wrapper<DexMethod> interfaceMethodGroup : nonReservedMethodGroups) {
+      InterfaceMethodGroupState groupState = globalStateMap.get(interfaceMethodGroup);
+      if (groupState.callSiteCollidingMethods.isEmpty()) {
+        continue;
+      }
+      DexMethod key = interfaceMethodGroup.get();
+      MethodNamingState<?> keyNamingState = minifierState.getNamingState(key.holder);
+      DexString existingRenaming = keyNamingState.newOrReservedNameFor(key);
+      assert existingRenaming != null;
+      for (DexMethod collidingMethod : groupState.callSiteCollidingMethods) {
+        DexString newNameInGroup = newNameInGroup(collidingMethod, keyNamingState, groupState);
+        minifierState.putRenaming(collidingMethod, newNameInGroup);
+        MethodNamingState<?> methodNamingState =
+            minifierState.getNamingState(collidingMethod.holder);
+        methodNamingState.addRenaming(newNameInGroup, collidingMethod);
+        keyNamingState.addRenaming(newNameInGroup, collidingMethod);
+      }
+    }
     timing.end();
 
     timing.end(); // end compute timing
@@ -563,6 +618,12 @@
     return newName;
   }
 
+  private DexString newNameInGroup(
+      DexMethod method, MethodNamingState<?> namingState, InterfaceMethodGroupState groupState) {
+    // Check if the name is available in all states.
+    return namingState.nextName(method, (candidate, ignore) -> groupState.isAvailable(candidate));
+  }
+
   private void patchUpChildrenInReservationStates() {
     for (Map.Entry<DexType, InterfaceReservationState> entry : interfaceStateMap.entrySet()) {
       for (DexType parent : entry.getValue().iface.interfaces.values) {
diff --git a/src/main/java/com/android/tools/r8/naming/MethodNamingState.java b/src/main/java/com/android/tools/r8/naming/MethodNamingState.java
index 7926de0..85c2f0f 100644
--- a/src/main/java/com/android/tools/r8/naming/MethodNamingState.java
+++ b/src/main/java/com/android/tools/r8/naming/MethodNamingState.java
@@ -62,8 +62,12 @@
         return candidate;
       }
     }
+    return nextName(method, isAvailable);
+  }
+
+  DexString nextName(DexMethod method, BiPredicate<DexString, DexMethod> isAvailable) {
     InternalNewNameState internalState = getOrCreateInternalState(method);
-    newName = namingStrategy.next(method, internalState, isAvailable);
+    DexString newName = namingStrategy.next(method, internalState, isAvailable);
     assert newName != null;
     return newName;
   }
diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index b90d37e..cd9db29 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -113,7 +113,6 @@
 import java.util.function.BiConsumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
-import java.util.stream.Collectors;
 import org.objectweb.asm.Opcodes;
 
 /**
@@ -411,34 +410,6 @@
     }
   }
 
-  private Set<DexField> getNonPinnedWrittenFields(Predicate<DexEncodedField> predicate) {
-    Set<DexField> result = Sets.newIdentityHashSet();
-    fieldAccessInfoCollection.forEach(
-        info -> {
-          if (info == MISSING_FIELD_ACCESS_INFO) {
-            return;
-          }
-          // Note that it is safe to use definitionFor() here, and not lookupField(), since the
-          // field held by `info` is a direct reference to the definition of the field.
-          DexEncodedField encodedField = appView.definitionFor(info.getField());
-          if (encodedField == null) {
-            assert false;
-            return;
-          }
-          if (encodedField.isProgramField(appInfo)
-              && info.isWritten()
-              && predicate.test(encodedField)) {
-            result.add(encodedField.field);
-          }
-        });
-    result.removeAll(
-        pinnedItems.stream()
-            .filter(DexReference::isDexField)
-            .map(DexReference::asDexField)
-            .collect(Collectors.toSet()));
-    return result;
-  }
-
   private static <T> SetWithReason<T> newSetWithoutReasonReporter() {
     return new SetWithReason<>((f, r) -> {});
   }
@@ -570,20 +541,29 @@
   }
 
   public boolean registerFieldRead(DexField field, DexEncodedMethod context) {
-    return registerFieldAccess(field, context, true);
+    return registerFieldAccess(field, context, true, false);
+  }
+
+  public boolean registerReflectiveFieldRead(DexField field, DexEncodedMethod context) {
+    return registerFieldAccess(field, context, true, true);
   }
 
   public boolean registerFieldWrite(DexField field, DexEncodedMethod context) {
-    return registerFieldAccess(field, context, false);
+    return registerFieldAccess(field, context, false, false);
   }
 
-  public boolean registerFieldAccess(DexField field, DexEncodedMethod context) {
-    boolean changed = registerFieldAccess(field, context, true);
-    changed |= registerFieldAccess(field, context, false);
+  public boolean registerReflectiveFieldWrite(DexField field, DexEncodedMethod context) {
+    return registerFieldAccess(field, context, false, true);
+  }
+
+  public boolean registerReflectiveFieldAccess(DexField field, DexEncodedMethod context) {
+    boolean changed = registerFieldAccess(field, context, true, true);
+    changed |= registerFieldAccess(field, context, false, true);
     return changed;
   }
 
-  private boolean registerFieldAccess(DexField field, DexEncodedMethod context, boolean isRead) {
+  private boolean registerFieldAccess(
+      DexField field, DexEncodedMethod context, boolean isRead, boolean isReflective) {
     FieldAccessInfoImpl info = fieldAccessInfoCollection.get(field);
     if (info == null) {
       DexEncodedField encodedField = appInfo.resolveField(field);
@@ -612,6 +592,9 @@
     } else if (info == MISSING_FIELD_ACCESS_INFO) {
       return false;
     }
+    if (isReflective) {
+      info.setHasReflectiveAccess();
+    }
     return isRead ? info.recordRead(field, context) : info.recordWrite(field, context);
   }
 
@@ -1740,8 +1723,8 @@
     }
     assert clazz.accessFlags.isInterface();
     transitionReachableVirtualMethods(clazz, seen.newNestedScope());
-    for (DexType subInterface : clazz.interfaces.values) {
-      transitionDefaultMethodsForInstantiatedClass(subInterface, seen);
+    for (DexType superInterface : clazz.interfaces.values) {
+      transitionDefaultMethodsForInstantiatedClass(superInterface, seen);
     }
   }
 
@@ -2100,6 +2083,7 @@
       return;
     }
 
+    // TODO(mkroghj): Remove pinnedItems check here.
     if (instantiatedTypes.contains(clazz)
         || instantiatedInterfaceTypes.contains(clazz)
         || pinnedItems.contains(clazz.type)) {
@@ -2118,8 +2102,8 @@
         if (currentClass == null || currentClass.lookupVirtualMethod(possibleTarget) != null) {
           continue;
         }
-        // TODO(zerny): Why does not not confer with lambdas and pinned too?
-        if (instantiatedTypes.contains(currentClass)) {
+        if (instantiatedTypes.contains(currentClass)
+            || instantiatedInterfaceTypes.contains(currentClass)) {
           markVirtualMethodAsLive(
               clazz,
               encodedPossibleTarget,
diff --git a/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java b/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
index f27bd26..1cfd120 100644
--- a/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
+++ b/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
@@ -1281,9 +1281,6 @@
             String message =
                 "Proguard configuration rule does not match anything: `" + rule.toString() + "`";
             StringDiagnostic diagnostic = new StringDiagnostic(message, rule.getOrigin());
-            if (!options.testing.allowUnusedProguardConfigurationRules) {
-              throw options.reporter.fatalError(diagnostic);
-            }
             if (options.testing.reportUnusedProguardConfigurationRules) {
               options.reporter.info(diagnostic);
             }
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 6ab0836..36a7030 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
@@ -31,6 +31,7 @@
 import com.android.tools.r8.graph.ParameterAnnotationsList;
 import com.android.tools.r8.graph.PresortedComparable;
 import com.android.tools.r8.graph.ResolutionResult;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription;
 import com.android.tools.r8.graph.TopDownClassHierarchyTraversal;
 import com.android.tools.r8.graph.UseRegistry;
 import com.android.tools.r8.graph.classmerging.VerticallyMergedClasses;
@@ -897,10 +898,10 @@
 
       for (DexEncodedMethod directMethod : source.directMethods()) {
         if (directMethod.isInstanceInitializer()) {
-          add(
-              directMethods,
-              renameConstructor(directMethod, availableMethodSignatures),
-              MethodSignatureEquivalence.get());
+          DexEncodedMethod resultingConstructor =
+              renameConstructor(directMethod, availableMethodSignatures);
+          add(directMethods, resultingConstructor, MethodSignatureEquivalence.get());
+          blockRedirectionOfSuperCalls(resultingConstructor.method);
         } else {
           DexEncodedMethod resultingDirectMethod =
               renameMethod(
diff --git a/src/main/java/com/android/tools/r8/utils/AndroidApp.java b/src/main/java/com/android/tools/r8/utils/AndroidApp.java
index c565c4e..cccaa07 100644
--- a/src/main/java/com/android/tools/r8/utils/AndroidApp.java
+++ b/src/main/java/com/android/tools/r8/utils/AndroidApp.java
@@ -896,9 +896,12 @@
       return this;
     }
 
-    /**
-     * Add Java-bytecode program data.
-     */
+    /** Add Java-bytecode program data. */
+    public Builder addClassProgramData(byte[]... data) {
+      return addClassProgramData(Arrays.asList(data));
+    }
+
+    /** Add Java-bytecode program data. */
     public Builder addClassProgramData(Collection<byte[]> data) {
       for (byte[] datum : data) {
         addClassProgramData(datum, Origin.unknown());
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index 9eb8b6c..d0a4fb1 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -192,6 +192,7 @@
 
   // Optimization-related flags. These should conform to -dontoptimize and disableAllOptimizations.
   public boolean enableDynamicTypeOptimization = true;
+  public boolean enableFieldAssignmentTracker = true;
   public boolean enableFieldBitAccessAnalysis =
       System.getProperty("com.android.tools.r8.fieldBitAccessAnalysis") != null;
   public boolean enableHorizontalClassMerging = true;
@@ -1005,7 +1006,6 @@
     public boolean allowInvokeErrors = false;
     public boolean disableL8AnnotationRemoval = false;
     public boolean allowClassInlinerGracefulExit = true;
-    public boolean allowUnusedProguardConfigurationRules = true;
     public boolean reportUnusedProguardConfigurationRules = false;
     public boolean alwaysUsePessimisticRegisterAllocation = false;
     public boolean enableCheckCastAndInstanceOfRemoval = true;
diff --git a/src/test/java/com/android/tools/r8/D8TestCompileResult.java b/src/test/java/com/android/tools/r8/D8TestCompileResult.java
index 117ca7b..80b23ac 100644
--- a/src/test/java/com/android/tools/r8/D8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/D8TestCompileResult.java
@@ -24,6 +24,16 @@
   }
 
   @Override
+  public String getStdout() {
+    return state.getStdout();
+  }
+
+  @Override
+  public String getStderr() {
+    return state.getStderr();
+  }
+
+  @Override
   public D8TestRunResult createRunResult(TestRuntime runtime, ProcessResult result) {
     return new D8TestRunResult(app, runtime, result);
   }
diff --git a/src/test/java/com/android/tools/r8/DXTestCompileResult.java b/src/test/java/com/android/tools/r8/DXTestCompileResult.java
index 3cf9b73..e362f78 100644
--- a/src/test/java/com/android/tools/r8/DXTestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/DXTestCompileResult.java
@@ -4,6 +4,7 @@
 package com.android.tools.r8;
 
 import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.errors.Unimplemented;
 import com.android.tools.r8.utils.AndroidApp;
 
 public class DXTestCompileResult extends TestCompileResult<DXTestCompileResult, DXTestRunResult> {
@@ -23,6 +24,16 @@
   }
 
   @Override
+  public String getStdout() {
+    throw new Unimplemented("Unexpected attempt to access stdout from dx");
+  }
+
+  @Override
+  public String getStderr() {
+    throw new Unimplemented("Unexpected attempt to access stderr from dx");
+  }
+
+  @Override
   public DXTestRunResult createRunResult(TestRuntime runtime, ProcessResult result) {
     return new DXTestRunResult(app, runtime, result);
   }
diff --git a/src/test/java/com/android/tools/r8/DumpInputsTest.java b/src/test/java/com/android/tools/r8/DumpInputsTest.java
index e7f2ef8..84febed 100644
--- a/src/test/java/com/android/tools/r8/DumpInputsTest.java
+++ b/src/test/java/com/android/tools/r8/DumpInputsTest.java
@@ -3,12 +3,12 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8;
 
+import static org.hamcrest.CoreMatchers.containsString;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 import com.android.tools.r8.TestRuntime.CfVm;
 import com.android.tools.r8.utils.DescriptorUtils;
-import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.ZipUtils;
 import java.io.IOException;
 import java.nio.file.Files;
@@ -24,8 +24,6 @@
 @RunWith(Parameterized.class)
 public class DumpInputsTest extends TestBase {
 
-  static final String EXPECTED = StringUtils.lines("Hello, world");
-
   private final TestParameters parameters;
 
   @Parameterized.Parameters(name = "{0}")
@@ -62,6 +60,9 @@
         .addLibraryFiles(ToolHelper.getJava8RuntimeJar())
         .addKeepMainRule(TestClass.class)
         .addOptionsModification(options -> options.dumpInputToDirectory = dumpDir.toString())
+        .allowDiagnosticInfoMessages()
+        .compile()
+        .assertAllInfoMessagesMatch(containsString("Dumped compilation inputs to:"))
         .run(parameters.getRuntime(), TestClass.class)
         .assertSuccessWithOutputLines("Hello, world");
     assertTrue(Files.isDirectory(dumpDir));
diff --git a/src/test/java/com/android/tools/r8/ExternalR8TestCompileResult.java b/src/test/java/com/android/tools/r8/ExternalR8TestCompileResult.java
index 04a37fa..75cd5526 100644
--- a/src/test/java/com/android/tools/r8/ExternalR8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/ExternalR8TestCompileResult.java
@@ -5,6 +5,7 @@
 package com.android.tools.r8;
 
 import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.errors.Unimplemented;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import java.io.IOException;
@@ -58,6 +59,16 @@
   }
 
   @Override
+  public String getStdout() {
+    throw new Unimplemented("Unexpected attempt to access stdout from external R8");
+  }
+
+  @Override
+  public String getStderr() {
+    throw new Unimplemented("Unexpected attempt to access stderr from external R8");
+  }
+
+  @Override
   public CodeInspector inspector() throws IOException, ExecutionException {
     return new CodeInspector(app, proguardMap);
   }
diff --git a/src/test/java/com/android/tools/r8/ProguardTestCompileResult.java b/src/test/java/com/android/tools/r8/ProguardTestCompileResult.java
index fbb8282..dbb3c6e 100644
--- a/src/test/java/com/android/tools/r8/ProguardTestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/ProguardTestCompileResult.java
@@ -4,6 +4,7 @@
 package com.android.tools.r8;
 
 import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.errors.Unimplemented;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import java.io.IOException;
@@ -37,6 +38,16 @@
   }
 
   @Override
+  public String getStdout() {
+    throw new Unimplemented("Unexpected attempt to access stdout from Proguard");
+  }
+
+  @Override
+  public String getStderr() {
+    throw new Unimplemented("Unexpected attempt to access stderr from Proguard");
+  }
+
+  @Override
   public CodeInspector inspector() throws IOException, ExecutionException {
     return new CodeInspector(app, proguardMap);
   }
diff --git a/src/test/java/com/android/tools/r8/R8TestBuilder.java b/src/test/java/com/android/tools/r8/R8TestBuilder.java
index 1dca05c..d80f7cd 100644
--- a/src/test/java/com/android/tools/r8/R8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/R8TestBuilder.java
@@ -3,9 +3,12 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8;
 
+import static org.hamcrest.CoreMatchers.containsString;
+
 import com.android.tools.r8.R8Command.Builder;
 import com.android.tools.r8.TestBase.Backend;
 import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase.KeepRuleConsumer;
+import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.experimental.graphinfo.GraphConsumer;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.shaking.CollectingGraphConsumer;
@@ -26,14 +29,24 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
+import org.hamcrest.core.IsAnything;
 
 public abstract class R8TestBuilder<T extends R8TestBuilder<T>>
     extends TestShrinkerBuilder<R8Command, Builder, R8TestCompileResult, R8TestRunResult, T> {
 
+  enum AllowedDiagnosticMessages {
+    ALL,
+    INFO,
+    NONE,
+    WARNING
+  }
+
   R8TestBuilder(TestState state, Builder builder, Backend backend) {
     super(state, builder, backend);
   }
 
+  private AllowedDiagnosticMessages allowedDiagnosticMessages = AllowedDiagnosticMessages.NONE;
+  private boolean allowUnusedProguardConfigurationRules = false;
   private boolean enableInliningAnnotations = false;
   private boolean enableNeverClassInliningAnnotations = false;
   private boolean enableMergeAnnotations = false;
@@ -105,14 +118,47 @@
         builder.build(),
         optionsConsumer.andThen(
             options -> box.proguardConfiguration = options.getProguardConfiguration()));
-    return new R8TestCompileResult(
-        getState(),
-        getOutputMode(),
-        app.get(),
-        box.proguardConfiguration,
-        box.syntheticProguardRules,
-        proguardMapBuilder.toString(),
-        graphConsumer);
+    R8TestCompileResult compileResult =
+        new R8TestCompileResult(
+            getState(),
+            getOutputMode(),
+            app.get(),
+            box.proguardConfiguration,
+            box.syntheticProguardRules,
+            proguardMapBuilder.toString(),
+            graphConsumer);
+    switch (allowedDiagnosticMessages) {
+      case ALL:
+        compileResult.assertDiagnosticMessageThatMatches(new IsAnything<>());
+        break;
+      case INFO:
+        compileResult.assertOnlyInfos();
+        break;
+      case NONE:
+        if (allowUnusedProguardConfigurationRules) {
+          compileResult
+              .assertAllInfoMessagesMatch(
+                  containsString("Proguard configuration rule does not match anything"))
+              .assertNoErrorMessages()
+              .assertNoWarningMessages();
+        } else {
+          compileResult.assertNoMessages();
+        }
+        break;
+      case WARNING:
+        compileResult.assertOnlyWarnings();
+        break;
+      default:
+        throw new Unreachable();
+    }
+    if (allowUnusedProguardConfigurationRules) {
+      compileResult.assertInfoMessageThatMatches(
+          containsString("Proguard configuration rule does not match anything"));
+    } else {
+      compileResult.assertNoInfoMessageThatMatches(
+          containsString("Proguard configuration rule does not match anything"));
+    }
+    return compileResult;
   }
 
   public Builder getBuilder() {
@@ -201,9 +247,45 @@
     return addOptionsModification(options -> options.testing.allowClassInlinerGracefulExit = true);
   }
 
+  public T allowDiagnosticMessages() {
+    assert allowedDiagnosticMessages == AllowedDiagnosticMessages.NONE;
+    allowedDiagnosticMessages = AllowedDiagnosticMessages.ALL;
+    return self();
+  }
+
+  public T allowDiagnosticInfoMessages() {
+    return allowDiagnosticInfoMessages(true);
+  }
+
+  public T allowDiagnosticInfoMessages(boolean condition) {
+    if (condition) {
+      assert allowedDiagnosticMessages == AllowedDiagnosticMessages.NONE;
+      allowedDiagnosticMessages = AllowedDiagnosticMessages.INFO;
+    }
+    return self();
+  }
+
+  public T allowDiagnosticWarningMessages() {
+    return allowDiagnosticWarningMessages(true);
+  }
+
+  public T allowDiagnosticWarningMessages(boolean condition) {
+    if (condition) {
+      assert allowedDiagnosticMessages == AllowedDiagnosticMessages.NONE;
+      allowedDiagnosticMessages = AllowedDiagnosticMessages.WARNING;
+    }
+    return self();
+  }
+
   public T allowUnusedProguardConfigurationRules() {
-    return addOptionsModification(
-        options -> options.testing.allowUnusedProguardConfigurationRules = true);
+    return allowUnusedProguardConfigurationRules(true);
+  }
+
+  public T allowUnusedProguardConfigurationRules(boolean condition) {
+    if (condition) {
+      allowUnusedProguardConfigurationRules = true;
+    }
+    return self();
   }
 
   public T enableAlwaysInliningAnnotations() {
diff --git a/src/test/java/com/android/tools/r8/R8TestCompileResult.java b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
index c4ec2aa..ae6fc69 100644
--- a/src/test/java/com/android/tools/r8/R8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
@@ -53,6 +53,16 @@
   }
 
   @Override
+  public String getStdout() {
+    return state.getStdout();
+  }
+
+  @Override
+  public String getStderr() {
+    return state.getStderr();
+  }
+
+  @Override
   public CodeInspector inspector() throws IOException, ExecutionException {
     return new CodeInspector(app, proguardMap);
   }
diff --git a/src/test/java/com/android/tools/r8/TestBuilderMinAndroidJarTest.java b/src/test/java/com/android/tools/r8/TestBuilderMinAndroidJarTest.java
index 8d6b8d2..06cba56 100644
--- a/src/test/java/com/android/tools/r8/TestBuilderMinAndroidJarTest.java
+++ b/src/test/java/com/android/tools/r8/TestBuilderMinAndroidJarTest.java
@@ -4,7 +4,9 @@
 
 package com.android.tools.r8;
 
+import static org.hamcrest.CoreMatchers.anyOf;
 import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assume.assumeFalse;
 import static org.junit.Assume.assumeTrue;
 
@@ -57,8 +59,16 @@
             : containsString("AbstractMethodError");
     testForR8(parameters.getBackend())
         .addProgramClasses(Main.class)
+        .allowDiagnosticWarningMessages(
+            parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.O))
         .setMinApi(parameters.getApiLevel())
         .addKeepMainRule(Main.class)
+        .compile()
+        .assertAllWarningMessagesMatch(
+            anyOf(
+                equalTo(
+                    "Lambda expression implements missing interface `java.util.function.Supplier`"),
+                containsString("required for default or static interface methods desugaring")))
         .run(parameters.getRuntime(), Main.class)
         .assertFailureWithErrorThatMatches(expectedError);
   }
diff --git a/src/test/java/com/android/tools/r8/TestCompileResult.java b/src/test/java/com/android/tools/r8/TestCompileResult.java
index e04a2c1..87cc650 100644
--- a/src/test/java/com/android/tools/r8/TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/TestCompileResult.java
@@ -5,7 +5,10 @@
 
 import static com.android.tools.r8.TestBase.Backend.DEX;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.ClassFileConsumer.ArchiveConsumer;
 import com.android.tools.r8.TestBase.Backend;
@@ -78,6 +81,15 @@
 
   public abstract TestDiagnosticMessages getDiagnosticMessages();
 
+  public CR inspectDiagnosticMessages(Consumer<TestDiagnosticMessages> consumer) {
+    consumer.accept(getDiagnosticMessages());
+    return self();
+  }
+
+  public abstract String getStdout();
+
+  public abstract String getStderr();
+
   public OutputMode getOutputMode() {
     return outputMode;
   }
@@ -268,21 +280,55 @@
     return self();
   }
 
+  public CR assertDiagnosticMessageThatMatches(Matcher<String> matcher) {
+    getDiagnosticMessages().assertDiagnosticMessageThatMatches(matcher);
+    return self();
+  }
+
   public CR assertInfoMessageThatMatches(Matcher<String> matcher) {
     getDiagnosticMessages().assertInfoMessageThatMatches(matcher);
     return self();
   }
 
+  public CR assertAllInfoMessagesMatch(Matcher<String> matcher) {
+    return assertNoInfoMessageThatMatches(not(matcher));
+  }
+
   public CR assertNoInfoMessageThatMatches(Matcher<String> matcher) {
     getDiagnosticMessages().assertNoInfoMessageThatMatches(matcher);
     return self();
   }
 
+  public CR assertAtLeastOneInfoMessage() {
+    assertTrue(getDiagnosticMessages().getInfos().size() >= 1);
+    return self();
+  }
+
+  public CR assertInfosCount(int count) {
+    getDiagnosticMessages().assertInfosCount(count);
+    return self();
+  }
+
+  public CR assertNoInfoMessages() {
+    getDiagnosticMessages().assertInfosCount(0);
+    return self();
+  }
+
   public CR assertWarningMessageThatMatches(Matcher<String> matcher) {
     getDiagnosticMessages().assertWarningMessageThatMatches(matcher);
     return self();
   }
 
+  public CR assertAllWarningMessagesMatch(Matcher<String> matcher) {
+    getDiagnosticMessages().assertNoWarningMessageThatMatches(not(matcher));
+    return self();
+  }
+
+  public CR assertNoWarningMessages() {
+    getDiagnosticMessages().assertWarningsCount(0);
+    return self();
+  }
+
   public CR assertNoWarningMessageThatMatches(Matcher<String> matcher) {
     getDiagnosticMessages().assertNoWarningMessageThatMatches(matcher);
     return self();
@@ -293,11 +339,36 @@
     return self();
   }
 
+  public CR assertNoErrorMessages() {
+    getDiagnosticMessages().assertErrorsCount(0);
+    return self();
+  }
+
   public CR assertNoErrorMessageThatMatches(Matcher<String> matcher) {
     getDiagnosticMessages().assertNoErrorMessageThatMatches(matcher);
     return self();
   }
 
+  public CR assertNoStdout() {
+    assertEquals("", getStdout());
+    return self();
+  }
+
+  public CR assertStdoutThatMatches(Matcher<String> matcher) {
+    assertThat(getStdout(), matcher);
+    return self();
+  }
+
+  public CR assertNoStderr() {
+    assertEquals("", getStderr());
+    return self();
+  }
+
+  public CR assertStderrThatMatches(Matcher<String> matcher) {
+    assertThat(getStderr(), matcher);
+    return self();
+  }
+
   public CR disassemble(PrintStream ps) throws IOException, ExecutionException {
     ToolHelper.disassemble(app, ps);
     return self();
diff --git a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
index 8c6e7c2..628e9c5 100644
--- a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
@@ -10,8 +10,10 @@
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.AndroidAppConsumers;
+import com.android.tools.r8.utils.ForwardingOutputStream;
 import com.android.tools.r8.utils.InternalOptions;
 import com.google.common.base.Suppliers;
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.PrintStream;
 import java.nio.file.Path;
@@ -35,20 +37,22 @@
   public static final Consumer<InternalOptions> DEFAULT_OPTIONS =
       options -> {
         options.testing.allowClassInlinerGracefulExit = false;
-        options.testing.allowUnusedProguardConfigurationRules = false;
         options.testing.reportUnusedProguardConfigurationRules = true;
       };
 
   final Backend backend;
 
   // Default initialized setup. Can be overwritten if needed.
+  private boolean allowStdoutMessages = false;
+  private boolean allowStderrMessages = false;
   private boolean useDefaultRuntimeLibrary = true;
   private final List<Path> additionalRunClassPath = new ArrayList<>();
   private ProgramConsumer programConsumer;
   private StringConsumer mainDexListConsumer;
   private AndroidApiLevel defaultMinApiLevel = ToolHelper.getMinApiLevelForDexVm();
   private Consumer<InternalOptions> optionsConsumer = DEFAULT_OPTIONS;
-  private PrintStream stdout = null;
+  private ByteArrayOutputStream stdout = null;
+  private ByteArrayOutputStream stderr = null;
   protected OutputMode outputMode = OutputMode.DexIndexed;
 
   TestCompilerBuilder(TestState state, B builder, Backend backend) {
@@ -92,16 +96,32 @@
       }
     }
     PrintStream oldOut = System.out;
+    PrintStream oldErr = System.err;
+    CR cr = null;
     try {
       if (stdout != null) {
-        System.setOut(stdout);
+        System.setOut(new PrintStream(new ForwardingOutputStream(stdout, System.out)));
       }
-      CR cr = internalCompile(builder, optionsConsumer, Suppliers.memoize(sink::build));
+      if (stderr != null) {
+        System.setErr(new PrintStream(new ForwardingOutputStream(stderr, System.err)));
+      }
+      cr = internalCompile(builder, optionsConsumer, Suppliers.memoize(sink::build));
       cr.addRunClasspathFiles(additionalRunClassPath);
       return cr;
     } finally {
       if (stdout != null) {
+        getState().setStdout(stdout.toString());
         System.setOut(oldOut);
+        if (cr != null && !allowStdoutMessages) {
+          cr.assertNoStdout();
+        }
+      }
+      if (stderr != null) {
+        getState().setStderr(stderr.toString());
+        System.setErr(oldErr);
+        if (cr != null && !allowStderrMessages) {
+          cr.assertNoStderr();
+        }
       }
     }
   }
@@ -288,12 +308,28 @@
     return self();
   }
 
-  public T redirectStdOut(PrintStream printStream) {
-    assert stdout == null;
-    stdout = printStream;
+  public T allowStdoutMessages() {
+    allowStdoutMessages = true;
     return self();
   }
 
+  public T collectStdout() {
+    assert stdout == null;
+    stdout = new ByteArrayOutputStream();
+    return allowStdoutMessages();
+  }
+
+  public T allowStderrMessages() {
+    allowStdoutMessages = true;
+    return self();
+  }
+
+  public T collectStderr() {
+    assert stderr == null;
+    stderr = new ByteArrayOutputStream();
+    return allowStderrMessages();
+  }
+
   public T enableCoreLibraryDesugaring(AndroidApiLevel minAPILevel) {
     return enableCoreLibraryDesugaring(minAPILevel, null);
   }
diff --git a/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java b/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java
index 702815a..0dd7e67 100644
--- a/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java
+++ b/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java
@@ -9,35 +9,41 @@
 
 public interface TestDiagnosticMessages {
 
-  public List<Diagnostic> getInfos();
+  List<Diagnostic> getInfos();
 
-  public List<Diagnostic> getWarnings();
+  List<Diagnostic> getWarnings();
 
-  public List<Diagnostic> getErrors();
+  List<Diagnostic> getErrors();
 
-  public TestDiagnosticMessages assertNoMessages();
+  TestDiagnosticMessages assertNoMessages();
 
-  public TestDiagnosticMessages assertOnlyInfos();
+  TestDiagnosticMessages assertOnlyInfos();
 
-  public TestDiagnosticMessages assertOnlyWarnings();
+  TestDiagnosticMessages assertOnlyWarnings();
 
-  public TestDiagnosticMessages assertOnlyErrors();
+  TestDiagnosticMessages assertOnlyErrors();
 
-  public TestDiagnosticMessages assertInfosCount(int count);
+  TestDiagnosticMessages assertInfosCount(int count);
 
-  public TestDiagnosticMessages assertWarningsCount(int count);
+  TestDiagnosticMessages assertWarningsCount(int count);
 
-  public TestDiagnosticMessages assertErrorsCount(int count);
+  TestDiagnosticMessages assertErrorsCount(int count);
 
-  public TestDiagnosticMessages assertInfoMessageThatMatches(Matcher<String> matcher);
+  TestDiagnosticMessages assertDiagnosticMessageThatMatches(Matcher<String> matcher);
 
-  public TestDiagnosticMessages assertNoInfoMessageThatMatches(Matcher<String> matcher);
+  TestDiagnosticMessages assertInfoMessageThatMatches(Matcher<String> matcher);
 
-  public TestDiagnosticMessages assertWarningMessageThatMatches(Matcher<String> matcher);
+  TestDiagnosticMessages assertAllInfoMessagesMatch(Matcher<String> matcher);
 
-  public TestDiagnosticMessages assertNoWarningMessageThatMatches(Matcher<String> matcher);
+  TestDiagnosticMessages assertNoInfoMessageThatMatches(Matcher<String> matcher);
 
-  public TestDiagnosticMessages assertErrorMessageThatMatches(Matcher<String> matcher);
+  TestDiagnosticMessages assertWarningMessageThatMatches(Matcher<String> matcher);
 
-  public TestDiagnosticMessages assertNoErrorMessageThatMatches(Matcher<String> matcher);
+  TestDiagnosticMessages assertAllWarningMessagesMatch(Matcher<String> matcher);
+
+  TestDiagnosticMessages assertNoWarningMessageThatMatches(Matcher<String> matcher);
+
+  TestDiagnosticMessages assertErrorMessageThatMatches(Matcher<String> matcher);
+
+  TestDiagnosticMessages assertNoErrorMessageThatMatches(Matcher<String> matcher);
 }
diff --git a/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java b/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java
index 478a60d..44f046b 100644
--- a/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java
+++ b/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java
@@ -4,11 +4,13 @@
 
 package com.android.tools.r8;
 
+import static org.hamcrest.CoreMatchers.not;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.fail;
 
 import com.android.tools.r8.utils.ListUtils;
+import com.google.common.collect.Iterables;
 import java.util.ArrayList;
 import java.util.List;
 import org.hamcrest.Matcher;
@@ -122,22 +124,24 @@
   }
 
   private TestDiagnosticMessages assertMessageThatMatches(
-      List<Diagnostic> diagnostics, String tag, Matcher<String> matcher) {
-    assertNotEquals(0, diagnostics.size());
-    for (int i = 0; i < diagnostics.size(); i++) {
-      if (matcher.matches(diagnostics.get(i).getDiagnosticMessage())) {
+      Iterable<Diagnostic> diagnostics, String tag, Matcher<String> matcher) {
+    int numberOfDiagnostics = 0;
+    for (Diagnostic diagnostic : diagnostics) {
+      if (matcher.matches(diagnostic.getDiagnosticMessage())) {
         return this;
       }
+      numberOfDiagnostics++;
     }
+    assertNotEquals(0, numberOfDiagnostics);
     StringBuilder builder = new StringBuilder("No " + tag + " matches " + matcher.toString());
     builder.append(System.lineSeparator());
     if (getWarnings().size() == 0) {
       builder.append("There were no " + tag + "s.");
     } else {
-      builder.append("There were " + diagnostics.size() + " "+ tag + "s:");
+      builder.append("There were " + numberOfDiagnostics + " " + tag + "s:");
       builder.append(System.lineSeparator());
-      for (int i = 0; i < diagnostics.size(); i++) {
-        builder.append(diagnostics.get(i).getDiagnosticMessage());
+      for (Diagnostic diagnostic : diagnostics) {
+        builder.append(diagnostic.getDiagnosticMessage());
         builder.append(System.lineSeparator());
       }
     }
@@ -156,18 +160,38 @@
     return this;
   }
 
+  @Override
+  public TestDiagnosticMessages assertDiagnosticMessageThatMatches(Matcher<String> matcher) {
+    return assertMessageThatMatches(
+        Iterables.concat(getInfos(), getWarnings(), getErrors()), "diagnostic message", matcher);
+  }
+
+  @Override
   public TestDiagnosticMessages assertInfoMessageThatMatches(Matcher<String> matcher) {
     return assertMessageThatMatches(getInfos(), "info", matcher);
   }
 
+  @Override
+  public TestDiagnosticMessages assertAllInfoMessagesMatch(Matcher<String> matcher) {
+    return assertNoInfoMessageThatMatches(not(matcher));
+  }
+
+  @Override
   public TestDiagnosticMessages assertNoInfoMessageThatMatches(Matcher<String> matcher) {
     return assertNoMessageThatMatches(getInfos(), "info", matcher);
   }
 
+  @Override
   public TestDiagnosticMessages assertWarningMessageThatMatches(Matcher<String> matcher) {
     return assertMessageThatMatches(getWarnings(), "warning", matcher);
   }
 
+  @Override
+  public TestDiagnosticMessages assertAllWarningMessagesMatch(Matcher<String> matcher) {
+    return assertNoWarningMessageThatMatches(not(matcher));
+  }
+
+  @Override
   public TestDiagnosticMessages assertNoWarningMessageThatMatches(Matcher<String> matcher) {
     return assertNoMessageThatMatches(getWarnings(), "warning", matcher);
   }
diff --git a/src/test/java/com/android/tools/r8/TestParametersBuilder.java b/src/test/java/com/android/tools/r8/TestParametersBuilder.java
index 35d37cc..b29d851 100644
--- a/src/test/java/com/android/tools/r8/TestParametersBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestParametersBuilder.java
@@ -160,6 +160,10 @@
     return withApiFilter(api -> true);
   }
 
+  public TestParametersBuilder withApiLevel(AndroidApiLevel api) {
+    return withApiFilter(api::equals);
+  }
+
   public TestParametersBuilder withApiLevelsStartingAtIncluding(AndroidApiLevel startInclusive) {
     return withApiFilter(api -> startInclusive.getLevel() <= api.getLevel());
   }
diff --git a/src/test/java/com/android/tools/r8/TestState.java b/src/test/java/com/android/tools/r8/TestState.java
index bdb4e2f..78388bc 100644
--- a/src/test/java/com/android/tools/r8/TestState.java
+++ b/src/test/java/com/android/tools/r8/TestState.java
@@ -12,6 +12,9 @@
   private final TemporaryFolder temp;
   private final TestDiagnosticMessagesImpl messages = new TestDiagnosticMessagesImpl();
 
+  private String stdout;
+  private String stderr;
+
   public TestState(TemporaryFolder temp) {
     this.temp = temp;
   }
@@ -27,4 +30,20 @@
   public TestDiagnosticMessages getDiagnosticsMessages() {
     return messages;
   }
+
+  public String getStdout() {
+    return stdout;
+  }
+
+  void setStdout(String stdout) {
+    this.stdout = stdout;
+  }
+
+  public String getStderr() {
+    return stderr;
+  }
+
+  void setStderr(String stderr) {
+    this.stderr = stderr;
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java b/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java
index ddb0608..1bde24a 100644
--- a/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java
+++ b/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapCurrentEqualityTest.java
@@ -5,6 +5,7 @@
 
 import static com.android.tools.r8.utils.FileUtils.JAR_EXTENSION;
 import static com.google.common.io.ByteStreams.toByteArray;
+import static org.hamcrest.CoreMatchers.anyOf;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -103,7 +104,14 @@
           .setMode(mode)
           .addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR)
           .addKeepRuleFiles(MAIN_KEEP)
+          .allowDiagnosticInfoMessages(mode == CompilationMode.DEBUG)
           .compile()
+          .assertAllInfoMessagesMatch(
+              anyOf(
+                  containsString("Stripped invalid locals information from 1 method."),
+                  containsString("Methods with invalid locals information:"),
+                  containsString(
+                      "Some warnings are typically a sign of using an outdated Java toolchain.")))
           .apply(c -> FileUtils.writeTextFile(map, c.getProguardMap()))
           .writeToZip(jar);
     }
diff --git a/src/test/java/com/android/tools/r8/classlookup/LibraryClassExtendsProgramClassTest.java b/src/test/java/com/android/tools/r8/classlookup/LibraryClassExtendsProgramClassTest.java
index 5cbb40d..363008d 100644
--- a/src/test/java/com/android/tools/r8/classlookup/LibraryClassExtendsProgramClassTest.java
+++ b/src/test/java/com/android/tools/r8/classlookup/LibraryClassExtendsProgramClassTest.java
@@ -180,13 +180,12 @@
         .addProgramClassFileData(junitClasses)
         .addKeepAllClassesRule()
         .addOptionsModification(options -> options.lookupLibraryBeforeProgram = false)
-        .compileWithExpectedDiagnostics(
+        .allowDiagnosticWarningMessages(libraryContainsJUnit())
+        .compile()
+        .inspectDiagnosticMessages(
             diagnostics -> {
               if (libraryContainsJUnit()) {
-                diagnostics.assertOnlyWarnings();
                 checkDiagnostics(diagnostics.getWarnings());
-              } else {
-                diagnostics.assertNoMessages();
               }
             })
         .inspect(this::testCaseClassInResult);
diff --git a/src/test/java/com/android/tools/r8/classmerging/B141942381.java b/src/test/java/com/android/tools/r8/classmerging/B141942381.java
index 2c47534..36f320b 100644
--- a/src/test/java/com/android/tools/r8/classmerging/B141942381.java
+++ b/src/test/java/com/android/tools/r8/classmerging/B141942381.java
@@ -28,7 +28,7 @@
 
   @Parameterized.Parameters(name = "{0}")
   public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimes().build();
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
   }
 
   public B141942381(TestParameters parameters) {
@@ -49,7 +49,7 @@
     testForR8(parameters.getBackend())
         .addInnerClasses(B141942381.class)
         .addKeepMainRule(TestClass.class)
-        .setMinApi(parameters.getRuntime())
+        .setMinApi(parameters.getApiLevel())
         .addKeepAttributes("Signatures")
         .enableNeverClassInliningAnnotations()
         .noMinification()
diff --git a/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerTest.java b/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerTest.java
index 09489c9..6ccae1f 100644
--- a/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerTest.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.OutputMode;
 import com.android.tools.r8.ProgramResourceProvider;
+import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.StringConsumer.FileConsumer;
 import com.android.tools.r8.TestBase;
@@ -140,14 +141,17 @@
             "classmerging.ArrayTypeCollisionTest$A",
             "classmerging.ArrayTypeCollisionTest$B");
     runTest(
+        testForR8(Backend.DEX)
+            .addKeepRules(
+                getProguardConfig(
+                    EXAMPLE_KEEP,
+                    "-neverinline public class classmerging.ArrayTypeCollisionTest {",
+                    "  static void method(...);",
+                    "}"))
+            .allowUnusedProguardConfigurationRules(),
         main,
         programFiles,
-        preservedClassNames::contains,
-        getProguardConfig(
-            EXAMPLE_KEEP,
-            "-neverinline public class classmerging.ArrayTypeCollisionTest {",
-            "  static void method(...);",
-            "}"));
+        preservedClassNames::contains);
   }
 
   /**
@@ -199,17 +203,18 @@
 
     // Run test.
     runTestOnInput(
+        testForR8(Backend.DEX)
+            .addKeepRules(
+                "-keep class " + main + " {",
+                "  public static void main(...);",
+                "}",
+                "-neverinline class " + main + " {",
+                "  static classmerging.A[] method(...);",
+                "  static classmerging.B[] method(...);",
+                "}"),
         main,
         jasminBuilder.build(),
-        preservedClassNames::contains,
-        StringUtils.joinLines(
-            "-keep class " + main + " {",
-            "  public static void main(...);",
-            "}",
-            "-neverinline class " + main + " {",
-            "  static classmerging.A[] method(...);",
-            "  static classmerging.B[] method(...);",
-            "}"));
+        preservedClassNames::contains);
   }
 
   // This test has a cycle in the call graph consisting of the methods A.<init> and B.<init>.
@@ -231,7 +236,13 @@
     Set<String> preservedClassNames =
         ImmutableSet.of("classmerging.CallGraphCycleTest", "classmerging.CallGraphCycleTest$B");
     for (int i = 0; i < 5; i++) {
-      runTest(main, programFiles, preservedClassNames::contains);
+      runTest(
+          testForR8(Backend.DEX)
+              .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+              .allowUnusedProguardConfigurationRules(),
+          main,
+          programFiles,
+          preservedClassNames::contains);
     }
   }
 
@@ -250,10 +261,12 @@
             "classmerging.ConflictInGeneratedNameTest$B");
     CodeInspector inspector =
         runTestOnInput(
+            testForR8(Backend.DEX)
+                .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+                .allowUnusedProguardConfigurationRules(),
             main,
             readProgramFiles(programFiles),
             preservedClassNames::contains,
-            getProguardConfig(EXAMPLE_KEEP),
             options -> {
               configure(options);
               // Avoid that direct methods in B get inlined.
@@ -321,7 +334,13 @@
         ImmutableSet.of(
             "classmerging.FieldCollisionTest",
             "classmerging.FieldCollisionTest$B");
-    runTest(main, programFiles, preservedClassNames::contains);
+    runTest(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
+        main,
+        programFiles,
+        preservedClassNames::contains);
   }
 
   @Test
@@ -342,10 +361,12 @@
             "classmerging.LambdaRewritingTest$FunctionImpl",
             "classmerging.LambdaRewritingTest$InterfaceImpl");
     runTestOnInput(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(JAVA8_EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
         main,
         readProgramFiles(programFiles),
         name -> preservedClassNames.contains(name) || name.contains("$Lambda$"),
-        getProguardConfig(JAVA8_EXAMPLE_KEEP),
         options -> {
           this.configure(options);
           options.enableClassInlining = false;
@@ -367,10 +388,12 @@
             "classmerging.ConflictingInterfaceSignaturesTest",
             "classmerging.ConflictingInterfaceSignaturesTest$InterfaceImpl");
     runTestOnInput(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
         main,
         readProgramFiles(programFiles),
         preservedClassNames::contains,
-        getProguardConfig(EXAMPLE_KEEP),
         options -> {
           this.configure(options);
           options.enableInlining = false;
@@ -399,7 +422,13 @@
             "classmerging.MethodCollisionTest$B",
             "classmerging.MethodCollisionTest$C",
             "classmerging.MethodCollisionTest$D");
-    runTest(main, programFiles, preservedClassNames::contains);
+    runTest(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
+        main,
+        programFiles,
+        preservedClassNames::contains);
   }
 
   @Test
@@ -418,7 +447,12 @@
             "classmerging.NestedDefaultInterfaceMethodsTest$B",
             "classmerging.NestedDefaultInterfaceMethodsTest$C");
     runTest(
-        main, programFiles, preservedClassNames::contains, getProguardConfig(JAVA8_EXAMPLE_KEEP));
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(JAVA8_EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
+        main,
+        programFiles,
+        preservedClassNames::contains);
   }
 
   @Test
@@ -436,14 +470,16 @@
             "classmerging.NestedDefaultInterfaceMethodsTest$B",
             "classmerging.NestedDefaultInterfaceMethodsTest$C");
     runTestOnInput(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(JAVA8_EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
         main,
         AndroidApp.builder()
             .addProgramFiles(programFiles)
             .addClassProgramData(
                 NestedDefaultInterfaceMethodsTestDump.CDump.dump(), Origin.unknown())
             .build(),
-        preservedClassNames::contains,
-        getProguardConfig(JAVA8_EXAMPLE_KEEP));
+        preservedClassNames::contains);
   }
 
   @Test
@@ -463,10 +499,12 @@
             "classmerging.PinnedParameterTypesTest$InterfaceImpl",
             "classmerging.PinnedParameterTypesTest$TestClass");
     runTest(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(EXAMPLE_KEEP, "-keepparameternames"))
+            .allowUnusedProguardConfigurationRules(),
         main,
         programFiles,
-        preservedClassNames::contains,
-        getProguardConfig(EXAMPLE_KEEP, "-keepparameternames"));
+        preservedClassNames::contains);
   }
 
   @Test
@@ -486,10 +524,12 @@
             "classmerging.PinnedArrayParameterTypesTest$InterfaceImpl",
             "classmerging.PinnedArrayParameterTypesTest$TestClass");
     runTest(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(EXAMPLE_KEEP, "-keepparameternames"))
+            .allowUnusedProguardConfigurationRules(),
         main,
         programFiles,
-        preservedClassNames::contains,
-        getProguardConfig(EXAMPLE_KEEP, "-keepparameternames"));
+        preservedClassNames::contains);
   }
 
   @Test
@@ -515,10 +555,12 @@
                 "    1:1:void <init>():20:20 -> <init>",
                 "    1:1:void test():23:23 -> test");
     runTestOnInput(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
         main,
         readProgramFiles(programFiles),
         Predicates.alwaysTrue(),
-        getProguardConfig(EXAMPLE_KEEP),
         options -> {
           configure(options);
           options.enableVerticalClassMerging = false;
@@ -546,10 +588,12 @@
     Set<String> preservedClassNames =
         ImmutableSet.of("classmerging.ProguardFieldMapTest", "classmerging.ProguardFieldMapTest$B");
     runTestOnInput(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
         main,
         readProgramFiles(programFiles),
         preservedClassNames::contains,
-        getProguardConfig(EXAMPLE_KEEP),
         options -> {
           configure(options);
           options.testing.validInliningReasons = ImmutableSet.of(Reason.FORCE);
@@ -583,10 +627,12 @@
                 "    1:1:void <init>():22:22 -> <init>",
                 "    1:2:void method():26:27 -> method");
     runTestOnInput(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
         main,
         readProgramFiles(programFiles),
         Predicates.alwaysTrue(),
-        getProguardConfig(EXAMPLE_KEEP),
         options -> {
           configure(options);
           options.enableVerticalClassMerging = false;
@@ -617,10 +663,12 @@
         ImmutableSet.of(
             "classmerging.ProguardMethodMapTest", "classmerging.ProguardMethodMapTest$B");
     runTestOnInput(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
         main,
         readProgramFiles(programFiles),
         preservedClassNames::contains,
-        getProguardConfig(EXAMPLE_KEEP),
         options -> {
           configure(options);
           options.testing.validInliningReasons = ImmutableSet.of(Reason.FORCE);
@@ -655,12 +703,16 @@
                 "    2:2:void classmerging.ProguardMethodMapTest$A.method():17:17 -> method",
                 "    2:2:void method():27 -> method");
     runTestOnInput(
+        testForR8(Backend.DEX)
+            .addKeepRules(
+                getProguardConfig(
+                    EXAMPLE_KEEP,
+                    "-forceinline class classmerging.ProguardMethodMapTest$A { public void"
+                        + " method(); }"))
+            .allowUnusedProguardConfigurationRules(),
         main,
         readProgramFiles(programFiles),
         Predicates.alwaysTrue(),
-        getProguardConfig(
-            EXAMPLE_KEEP,
-            "-forceinline class classmerging.ProguardMethodMapTest$A { public void method(); }"),
         options -> {
           configure(options);
           options.enableVerticalClassMerging = false;
@@ -688,12 +740,16 @@
         ImmutableSet.of(
             "classmerging.ProguardMethodMapTest", "classmerging.ProguardMethodMapTest$B");
     runTestOnInput(
+        testForR8(Backend.DEX)
+            .addKeepRules(
+                getProguardConfig(
+                    EXAMPLE_KEEP,
+                    "-forceinline class classmerging.ProguardMethodMapTest$A { public void"
+                        + " method(); }"))
+            .allowUnusedProguardConfigurationRules(),
         main,
         readProgramFiles(programFiles),
         preservedClassNames::contains,
-        getProguardConfig(
-            EXAMPLE_KEEP,
-            "-forceinline class classmerging.ProguardMethodMapTest$A { public void method(); }"),
         options -> {
           configure(options);
           options.testing.validInliningReasons = ImmutableSet.of(Reason.FORCE);
@@ -717,7 +773,13 @@
         ImmutableSet.of(
             "classmerging.SubClassThatReferencesSuperMethod",
             "classmerging.SuperCallRewritingTest");
-    runTest(main, programFiles, preservedClassNames::contains);
+    runTest(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
+        main,
+        programFiles,
+        preservedClassNames::contains);
   }
 
   // When a subclass A has been merged into its subclass B, we rewrite invoke-super calls that hit
@@ -924,10 +986,11 @@
 
     // Run test.
     runTestOnInput(
+        testForR8(Backend.DEX)
+            .addKeepRules(String.format("-keep class %s { public static void main(...); }", main)),
         main,
         appBuilder.build(),
-        preservedClassNames::contains,
-        String.format("-keep class %s { public static void main(...); }", main));
+        preservedClassNames::contains);
   }
 
   @Test
@@ -953,10 +1016,12 @@
               "classmerging.SyntheticBridgeSignaturesTest$ASub",
               "classmerging.SyntheticBridgeSignaturesTest$BSub");
       runTestOnInput(
+          testForR8(Backend.DEX)
+              .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+              .allowUnusedProguardConfigurationRules(),
           main,
           readProgramFiles(programFiles),
           preservedClassNames::contains,
-          getProguardConfig(EXAMPLE_KEEP),
           options -> {
             this.configure(options);
             if (!allowInlining) {
@@ -989,7 +1054,13 @@
         ImmutableSet.of(
             "classmerging.ConflictingInterfaceSignaturesTest",
             "classmerging.ConflictingInterfaceSignaturesTest$InterfaceImpl");
-    runTest(main, programFiles, preservedClassNames::contains);
+    runTest(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
+        main,
+        programFiles,
+        preservedClassNames::contains);
   }
 
   // If an exception class A is merged into another exception class B, then all exception tables
@@ -1010,7 +1081,14 @@
             "classmerging.ExceptionTest",
             "classmerging.ExceptionTest$ExceptionB",
             "classmerging.ExceptionTest$Exception2");
-    CodeInspector inspector = runTest(main, programFiles, preservedClassNames::contains);
+    CodeInspector inspector =
+        runTest(
+            testForR8(Backend.DEX)
+                .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+                .allowUnusedProguardConfigurationRules(),
+            main,
+            programFiles,
+            preservedClassNames::contains);
 
     ClassSubject mainClass = inspector.clazz(main);
     assertThat(mainClass, isPresent());
@@ -1061,7 +1139,13 @@
         method.getMethod().getCode().asCfCode().toString(),
         containsString("invokeinterface classmerging.MergeDefaultMethodIntoClassTest$A.f()V"));
 
-    runTestOnInput(main, app, preservedClassNames::contains, getProguardConfig(JAVA8_EXAMPLE_KEEP));
+    runTestOnInput(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(JAVA8_EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
+        main,
+        app,
+        preservedClassNames::contains);
   }
 
   @Test
@@ -1079,7 +1163,13 @@
             "classmerging.ClassWithNativeMethodTest",
             "classmerging.ClassWithNativeMethodTest$A",
             "classmerging.ClassWithNativeMethodTest$B");
-    runTest(main, programFiles, preservedClassNames::contains);
+    runTest(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
+        main,
+        programFiles,
+        preservedClassNames::contains);
   }
 
   @Test
@@ -1104,7 +1194,13 @@
             "classmerging.SimpleInterfaceAccessTest$OtherSimpleInterfaceImpl",
             "classmerging.pkg.SimpleInterfaceImplRetriever",
             "classmerging.pkg.SimpleInterfaceImplRetriever$SimpleInterfaceImpl");
-    runTest(main, programFiles, preservedClassNames::contains);
+    runTest(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
+        main,
+        programFiles,
+        preservedClassNames::contains);
   }
 
   @Test
@@ -1130,13 +1226,16 @@
     // Allow access modifications (and prevent SimpleInterfaceImplRetriever from being removed as
     // a result of inlining).
     runTest(
+        testForR8(Backend.DEX)
+            .addKeepRules(
+                getProguardConfig(
+                    EXAMPLE_KEEP,
+                    "-allowaccessmodification",
+                    "-keep public class classmerging.pkg.SimpleInterfaceImplRetriever"))
+            .allowUnusedProguardConfigurationRules(),
         main,
         programFiles,
-        preservedClassNames::contains,
-        getProguardConfig(
-            EXAMPLE_KEEP,
-            "-allowaccessmodification",
-            "-keep public class classmerging.pkg.SimpleInterfaceImplRetriever"));
+        preservedClassNames::contains);
   }
 
   // TODO(christofferqa): This test checks that the invoke-super instruction in B is not rewritten
@@ -1158,11 +1257,14 @@
             "classmerging.RewritePinnedMethodTest$A",
             "classmerging.RewritePinnedMethodTest$C");
     runTest(
+        testForR8(Backend.DEX)
+            .addKeepRules(
+                getProguardConfig(
+                    EXAMPLE_KEEP, "-keep class classmerging.RewritePinnedMethodTest$A { *; }"))
+            .allowUnusedProguardConfigurationRules(),
         main,
         programFiles,
-        preservedClassNames::contains,
-        getProguardConfig(
-            EXAMPLE_KEEP, "-keep class classmerging.RewritePinnedMethodTest$A { *; }"));
+        preservedClassNames::contains);
   }
 
   @Test
@@ -1177,57 +1279,60 @@
     Set<String> preservedClassNames =
         ImmutableSet.of(
             "classmerging.TemplateMethodTest", "classmerging.TemplateMethodTest$AbstractClassImpl");
-    runTest(main, programFiles, preservedClassNames::contains);
+    runTest(
+        testForR8(Backend.DEX)
+            .addKeepRules(getProguardConfig(EXAMPLE_KEEP))
+            .allowUnusedProguardConfigurationRules(),
+        main,
+        programFiles,
+        preservedClassNames::contains);
   }
 
   private CodeInspector runTest(
-      String main, Path[] programFiles, Predicate<String> preservedClassNames) throws Throwable {
-    return runTest(main, programFiles, preservedClassNames, getProguardConfig(EXAMPLE_KEEP));
-  }
-
-  private CodeInspector runTest(
+      R8FullTestBuilder builder,
       String main,
       Path[] programFiles,
-      Predicate<String> preservedClassNames,
-      String proguardConfig)
+      Predicate<String> preservedClassNames)
       throws Throwable {
-    return runTestOnInput(
-        main, readProgramFiles(programFiles), preservedClassNames, proguardConfig);
+    return runTestOnInput(builder, main, readProgramFiles(programFiles), preservedClassNames);
   }
 
   private CodeInspector runTestOnInput(
-      String main, AndroidApp input, Predicate<String> preservedClassNames, String proguardConfig)
+      R8FullTestBuilder builder,
+      String main,
+      AndroidApp input,
+      Predicate<String> preservedClassNames)
       throws Throwable {
-    return runTestOnInput(main, input, preservedClassNames, proguardConfig, this::configure);
+    return runTestOnInput(builder, main, input, preservedClassNames, this::configure);
   }
 
   private CodeInspector runTestOnInput(
+      R8FullTestBuilder builder,
       String main,
       AndroidApp input,
       Predicate<String> preservedClassNames,
-      String proguardConfig,
       Consumer<InternalOptions> optionsConsumer)
       throws Throwable {
     return runTestOnInput(
+        builder,
         main,
         input,
         preservedClassNames,
-        proguardConfig,
         optionsConsumer,
         new VerticalClassMergerDebugTest(main));
   }
 
   private CodeInspector runTestOnInput(
+      R8FullTestBuilder builder,
       String main,
       AndroidApp input,
       Predicate<String> preservedClassNames,
-      String proguardConfig,
       Consumer<InternalOptions> optionsConsumer,
       VerticalClassMergerDebugTest debugTestRunner)
       throws Throwable {
     Path proguardMapPath = File.createTempFile("mapping", ".txt", temp.getRoot()).toPath();
     R8TestCompileResult compileResult =
-        testForR8(Backend.DEX)
+        builder
             .apply(
                 b -> {
                   // Some tests add DEX inputs, so circumvent the check by adding directly to the
@@ -1238,12 +1343,10 @@
                   }
                 })
             .noMinification()
-            .addKeepRules(proguardConfig)
             .enableProguardTestOptions()
             .addOptionsModification(
                 o -> {
                   optionsConsumer.accept(o);
-                  o.testing.allowUnusedProguardConfigurationRules = true;
                   o.proguardMapConsumer = new FileConsumer(proguardMapPath, o.proguardMapConsumer);
                 })
             .compile();
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionForwardingTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionForwardingTest.java
index edaf321..8334f1d 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionForwardingTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionForwardingTest.java
@@ -62,6 +62,25 @@
             StringUtils.lines("false", "false", "false", "false", "false", "false"));
   }
 
+  @Test
+  public void testCustomCollectionR8() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+    testForR8(parameters.getBackend())
+        .addInnerClasses(CustomCollectionForwardingTest.class)
+        .addKeepMainRule(Executor.class)
+        .setMinApi(parameters.getApiLevel())
+        .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+        .compile()
+        .addDesugaredCoreLibraryRunClassPath(
+            this::buildDesugaredLibrary,
+            parameters.getApiLevel(),
+            keepRuleConsumer.get(),
+            shrinkDesugaredLibrary)
+        .run(parameters.getRuntime(), Executor.class)
+        .assertSuccessWithOutput(
+            StringUtils.lines("false", "false", "false", "false", "false", "false"));
+  }
+
   private void assertForwardingMethods(CodeInspector inspector) {
     if (parameters.getApiLevel().getLevel() >= AndroidApiLevel.N.getLevel()) {
       return;
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
index 61296c9..628fbfe 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
@@ -16,7 +16,9 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestDiagnosticMessagesImpl;
 import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.AndroidApiLevel;
@@ -30,6 +32,26 @@
 
 public class DesugaredLibraryTestBase extends TestBase {
 
+  // For conversions tests, we need DexRuntimes where classes to convert are present (DexRuntimes
+  // above N and O depending if Stream or Time APIs are used), but we need to compile the program
+  // with a minAPI below to force the use of conversions.
+  protected static TestParametersCollection getConversionParametersUpToExcluding(
+      AndroidApiLevel apiLevel) {
+    if (apiLevel == AndroidApiLevel.N) {
+      return getTestParameters()
+          .withDexRuntimesStartingFromIncluding(Version.V7_0_0)
+          .withApiLevelsEndingAtExcluding(AndroidApiLevel.N)
+          .build();
+    }
+    if (apiLevel == AndroidApiLevel.O) {
+      return getTestParameters()
+          .withDexRuntimesStartingFromIncluding(Version.V8_1_0)
+          .withApiLevelsEndingAtExcluding(AndroidApiLevel.O)
+          .build();
+    }
+    throw new Error("Unsupported conversion parameters");
+  }
+
   protected boolean requiresEmulatedInterfaceCoreLibDesugaring(TestParameters parameters) {
     return parameters.getApiLevel().getLevel() < AndroidApiLevel.N.getLevel();
   }
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilFunctionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilFunctionTest.java
index 7ca5301..e345069 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaUtilFunctionTest.java
@@ -80,10 +80,7 @@
   @Test
   public void testJavaUtilFunctionR8() throws Exception {
     KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
-    // TODO(b/139398549): Enable test on API 26+.
-    Assume.assumeTrue(parameters.getApiLevel().getLevel() < 26);
     testForR8(parameters.getBackend())
-        // Following two for checkRewrittenArguments.
         .enableInliningAnnotations()
         .noMinification()
         .addKeepMainRule(TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/APIConversionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/APIConversionTest.java
index 1cb8f74..579b6f6 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/APIConversionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/APIConversionTest.java
@@ -7,15 +7,16 @@
 import static org.hamcrest.core.StringContains.containsString;
 
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.ToolHelper.DexVm.Version;
 import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
 import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.StringUtils;
 import java.util.Arrays;
+import java.util.List;
 import java.util.Random;
 import java.util.function.IntUnaryOperator;
 import java.util.stream.IntStream;
+import org.junit.Assume;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -25,21 +26,27 @@
 public class APIConversionTest extends DesugaredLibraryTestBase {
 
   private final TestParameters parameters;
+  private final boolean shrinkDesugaredLibrary;
 
-  @Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters()
-        .withDexRuntimesStartingFromIncluding(Version.V7_0_0)
-        .withApiLevelsEndingAtExcluding(AndroidApiLevel.M)
-        .build();
+  private static final AndroidApiLevel MIN_SUPPORTED = AndroidApiLevel.N;
+  private static final String EXPECTED_RESULT =
+      StringUtils.lines(
+          "[5, 6, 7]", "$r8$wrapper$java$util$stream$IntStream$-V-WRP", "IntSummaryStatistics");
+
+  @Parameters(name = "{0}, shrinkDesugaredLibrary: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getConversionParametersUpToExcluding(MIN_SUPPORTED), BooleanUtils.values());
   }
 
-  public APIConversionTest(TestParameters parameters) {
+  public APIConversionTest(TestParameters parameters, boolean shrinkDesugaredLibrary) {
+    this.shrinkDesugaredLibrary = shrinkDesugaredLibrary;
     this.parameters = parameters;
   }
 
   @Test
   public void testAPIConversionNoDesugaring() throws Exception {
+    Assume.assumeTrue("No need to test twice", shrinkDesugaredLibrary);
     testForD8()
         .addInnerClasses(APIConversionTest.class)
         .setMinApi(parameters.getApiLevel())
@@ -54,20 +61,41 @@
   }
 
   @Test
-  public void testAPIConversionDesugaring() throws Exception {
+  public void testAPIConversionDesugaringD8() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
     testForD8()
         .addInnerClasses(APIConversionTest.class)
         .setMinApi(parameters.getApiLevel())
-        .enableCoreLibraryDesugaring(parameters.getApiLevel())
+        .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
         .compile()
         .assertNoMessages()
-        .addDesugaredCoreLibraryRunClassPath(this::buildDesugaredLibrary, parameters.getApiLevel())
+        .addDesugaredCoreLibraryRunClassPath(
+            this::buildDesugaredLibrary,
+            parameters.getApiLevel(),
+            keepRuleConsumer.get(),
+            shrinkDesugaredLibrary)
         .run(parameters.getRuntime(), Executor.class)
-        .assertSuccessWithOutput(
-            StringUtils.lines(
-                "[5, 6, 7]",
-                "$r8$wrapper$java$util$stream$IntStream$-V-WRP",
-                "IntSummaryStatistics"));
+        .assertSuccessWithOutput(EXPECTED_RESULT);
+  }
+
+  @Test
+  public void testAPIConversionDesugaringR8() throws Exception {
+    Assume.assumeTrue("Invalid runtime library (missing applyAsInt)", false);
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+    testForR8(parameters.getBackend())
+        .addInnerClasses(APIConversionTest.class)
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Executor.class)
+        .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+        .compile()
+        .assertNoMessages()
+        .addDesugaredCoreLibraryRunClassPath(
+            this::buildDesugaredLibrary,
+            parameters.getApiLevel(),
+            keepRuleConsumer.get(),
+            shrinkDesugaredLibrary)
+        .run(parameters.getRuntime(), Executor.class)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
   }
 
   static class Executor {
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/AllOptionalConversionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/AllOptionalConversionTest.java
index ef30ad1..75d46fe 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/AllOptionalConversionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/AllOptionalConversionTest.java
@@ -4,40 +4,99 @@
 
 package com.android.tools.r8.desugar.desugaredlibrary.conversiontests;
 
-import com.android.tools.r8.TestRuntime.DexRuntime;
-import com.android.tools.r8.ToolHelper.DexVm;
+import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
 import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.StringUtils;
 import java.nio.file.Path;
+import java.util.List;
 import java.util.Optional;
 import java.util.OptionalDouble;
 import java.util.OptionalInt;
 import java.util.OptionalLong;
+import org.junit.BeforeClass;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
 
+@RunWith(Parameterized.class)
 public class AllOptionalConversionTest extends DesugaredLibraryTestBase {
 
+  private final TestParameters parameters;
+  private final boolean shrinkDesugaredLibrary;
+
+  private static final AndroidApiLevel MIN_SUPPORTED = AndroidApiLevel.N;
+  private static final String EXPECTED_RESULT =
+      StringUtils.lines(
+          "Optional[value]",
+          "OptionalDouble[1.0]",
+          "OptionalInt[1]",
+          "OptionalLong[1]",
+          "Optional[value]",
+          "value");
+
+  private static Path CUSTOM_LIB;
+
+  @Parameters(name = "{0}, shrinkDesugaredLibrary: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getConversionParametersUpToExcluding(MIN_SUPPORTED), BooleanUtils.values());
+  }
+
+  public AllOptionalConversionTest(TestParameters parameters, boolean shrinkDesugaredLibrary) {
+    this.shrinkDesugaredLibrary = shrinkDesugaredLibrary;
+    this.parameters = parameters;
+  }
+
+  @BeforeClass
+  public static void compileCustomLib() throws Exception {
+    CUSTOM_LIB =
+        testForD8(getStaticTemp())
+            .addProgramClasses(CustomLibClass.class)
+            .setMinApi(MIN_SUPPORTED)
+            .compile()
+            .writeToZip();
+  }
+
   @Test
-  public void testRewrittenAPICalls() throws Exception {
-    Path customLib = testForD8().addProgramClasses(CustomLibClass.class).compile().writeToZip();
+  public void testRewrittenAPICallsD8() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
     testForD8()
-        .setMinApi(AndroidApiLevel.B)
+        .setMinApi(parameters.getApiLevel())
         .addProgramClasses(Executor.class)
         .addLibraryClasses(CustomLibClass.class)
-        .enableCoreLibraryDesugaring(AndroidApiLevel.B)
+        .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
         .compile()
-        .addDesugaredCoreLibraryRunClassPath(this::buildDesugaredLibrary, AndroidApiLevel.B)
-        .addRunClasspathFiles(customLib)
-        .run(new DexRuntime(DexVm.ART_9_0_0_HOST), Executor.class)
-        .assertSuccessWithOutput(
-            StringUtils.lines(
-                "Optional[value]",
-                "OptionalDouble[1.0]",
-                "OptionalInt[1]",
-                "OptionalLong[1]",
-                "Optional[value]",
-                "value"));
+        .addDesugaredCoreLibraryRunClassPath(
+            this::buildDesugaredLibrary,
+            parameters.getApiLevel(),
+            keepRuleConsumer.get(),
+            shrinkDesugaredLibrary)
+        .addRunClasspathFiles(CUSTOM_LIB)
+        .run(parameters.getRuntime(), Executor.class)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
+  }
+
+  @Test
+  public void testRewrittenAPICallsR8() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+    testForR8(parameters.getBackend())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Executor.class)
+        .addProgramClasses(Executor.class)
+        .addLibraryClasses(CustomLibClass.class)
+        .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+        .compile()
+        .addDesugaredCoreLibraryRunClassPath(
+            this::buildDesugaredLibrary,
+            parameters.getApiLevel(),
+            keepRuleConsumer.get(),
+            shrinkDesugaredLibrary)
+        .addRunClasspathFiles(CUSTOM_LIB)
+        .run(parameters.getRuntime(), Executor.class)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
   }
 
   static class Executor {
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/AllTimeConversionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/AllTimeConversionTest.java
index db5c661..5a03f73 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/AllTimeConversionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/AllTimeConversionTest.java
@@ -7,12 +7,11 @@
 import static junit.framework.TestCase.assertEquals;
 import static junit.framework.TestCase.assertTrue;
 
-import com.android.tools.r8.D8TestCompileResult;
 import com.android.tools.r8.TestDiagnosticMessages;
-import com.android.tools.r8.TestRuntime.DexRuntime;
-import com.android.tools.r8.ToolHelper.DexVm;
+import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
 import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.StringUtils;
 import java.nio.file.Path;
 import java.time.Duration;
@@ -21,35 +20,94 @@
 import java.time.MonthDay;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
+import java.util.List;
+import org.junit.BeforeClass;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
 
+@RunWith(Parameterized.class)
 public class AllTimeConversionTest extends DesugaredLibraryTestBase {
 
+  private final TestParameters parameters;
+  private final boolean shrinkDesugaredLibrary;
+
+  private static final AndroidApiLevel MIN_SUPPORTED = AndroidApiLevel.O;
+  private static final String EXPECTED_RESULT =
+      StringUtils.lines(
+          "1970-01-02T00:00Z[GMT]",
+          "PT0.000012345S",
+          "GMT",
+          "--03-02",
+          "-1000000000-01-01T00:00:00.999999999Z",
+          "GMT",
+          "GMT");
+
+  private static Path CUSTOM_LIB;
+
+  @Parameters(name = "{0}, shrinkDesugaredLibrary: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getConversionParametersUpToExcluding(MIN_SUPPORTED), BooleanUtils.values());
+  }
+
+  public AllTimeConversionTest(TestParameters parameters, boolean shrinkDesugaredLibrary) {
+    this.shrinkDesugaredLibrary = shrinkDesugaredLibrary;
+    this.parameters = parameters;
+  }
+
+  @BeforeClass
+  public static void compileCustomLib() throws Exception {
+    CUSTOM_LIB =
+        testForD8(getStaticTemp())
+            .addProgramClasses(CustomLibClass.class)
+            .setMinApi(MIN_SUPPORTED)
+            .compile()
+            .writeToZip();
+  }
+
   @Test
-  public void testRewrittenAPICalls() throws Exception {
-    Path customLib = testForD8().addProgramClasses(CustomLibClass.class).compile().writeToZip();
-    D8TestCompileResult compileResult =
-        testForD8()
-            .setMinApi(AndroidApiLevel.B)
-            .addProgramClasses(Executor.class)
-            .addLibraryClasses(CustomLibClass.class)
-            .addOptionsModification(options -> options.testing.trackDesugaredAPIConversions = true)
-            .enableCoreLibraryDesugaring(AndroidApiLevel.B)
-            .compile();
-    compileResult
-        .addDesugaredCoreLibraryRunClassPath(this::buildDesugaredLibrary, AndroidApiLevel.B)
-        .addRunClasspathFiles(customLib)
-        .run(new DexRuntime(DexVm.ART_9_0_0_HOST), Executor.class)
-        .assertSuccessWithOutput(
-            StringUtils.lines(
-                "1970-01-02T00:00Z[GMT]",
-                "PT0.000012345S",
-                "GMT",
-                "--03-02",
-                "-1000000000-01-01T00:00:00.999999999Z",
-                "GMT",
-                "GMT"));
-    assertTrackedAPIS(compileResult.getDiagnosticMessages());
+  public void testRewrittenAPICallsD8() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+    testForD8()
+        .setMinApi(parameters.getApiLevel())
+        .addProgramClasses(Executor.class)
+        .addLibraryClasses(CustomLibClass.class)
+        .addOptionsModification(options -> options.testing.trackDesugaredAPIConversions = true)
+        .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+        .compile()
+        .inspectDiagnosticMessages(this::assertTrackedAPIS)
+        .addDesugaredCoreLibraryRunClassPath(
+            this::buildDesugaredLibrary,
+            parameters.getApiLevel(),
+            keepRuleConsumer.get(),
+            shrinkDesugaredLibrary)
+        .addRunClasspathFiles(CUSTOM_LIB)
+        .run(parameters.getRuntime(), Executor.class)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
+  }
+
+  @Test
+  public void testRewrittenAPICallsR8() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+    testForR8(parameters.getBackend())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Executor.class)
+        .addProgramClasses(Executor.class)
+        .addLibraryClasses(CustomLibClass.class)
+        .allowDiagnosticWarningMessages()
+        .addOptionsModification(options -> options.testing.trackDesugaredAPIConversions = true)
+        .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+        .compile()
+        .addDesugaredCoreLibraryRunClassPath(
+            this::buildDesugaredLibrary,
+            parameters.getApiLevel(),
+            keepRuleConsumer.get(),
+            shrinkDesugaredLibrary)
+        .addRunClasspathFiles(CUSTOM_LIB)
+        .run(parameters.getRuntime(), Executor.class)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
   }
 
   private void assertTrackedAPIS(TestDiagnosticMessages diagnosticMessages) {
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/BasicLongDoubleConversionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/BasicLongDoubleConversionTest.java
index f31ad69..4ac3ccc 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/BasicLongDoubleConversionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/BasicLongDoubleConversionTest.java
@@ -4,33 +4,92 @@
 
 package com.android.tools.r8.desugar.desugaredlibrary.conversiontests;
 
-import com.android.tools.r8.TestRuntime.DexRuntime;
-import com.android.tools.r8.ToolHelper.DexVm;
+import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
 import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.StringUtils;
 import java.nio.file.Path;
 import java.time.MonthDay;
+import java.util.List;
+import org.junit.BeforeClass;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
 
 // Longs and double take two stack indexes, this had to be dealt with in
 // CfAPIConverter*WrapperCodeProvider (See stackIndex vs index), this class tests that the
 // synthetic Cf code is correct.
+@RunWith(Parameterized.class)
 public class BasicLongDoubleConversionTest extends DesugaredLibraryTestBase {
 
+  private final TestParameters parameters;
+  private final boolean shrinkDesugaredLibrary;
+
+  private static final AndroidApiLevel MIN_SUPPORTED = AndroidApiLevel.O;
+  private static final String EXPECTED_RESULT = StringUtils.lines("--01-16");
+
+  private static Path CUSTOM_LIB;
+
+  @Parameters(name = "{0}, shrinkDesugaredLibrary: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getConversionParametersUpToExcluding(MIN_SUPPORTED), BooleanUtils.values());
+  }
+
+  public BasicLongDoubleConversionTest(TestParameters parameters, boolean shrinkDesugaredLibrary) {
+    this.shrinkDesugaredLibrary = shrinkDesugaredLibrary;
+    this.parameters = parameters;
+  }
+
+  @BeforeClass
+  public static void compileCustomLib() throws Exception {
+    CUSTOM_LIB =
+        testForD8(getStaticTemp())
+            .addProgramClasses(CustomLibClass.class)
+            .setMinApi(MIN_SUPPORTED)
+            .compile()
+            .writeToZip();
+  }
+
   @Test
-  public void testRewrittenAPICalls() throws Exception {
-    Path customLib = testForD8().addProgramClasses(CustomLibClass.class).compile().writeToZip();
+  public void testRewrittenAPICallsD8() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
     testForD8()
-        .setMinApi(AndroidApiLevel.B)
+        .setMinApi(parameters.getApiLevel())
         .addProgramClasses(Executor.class)
         .addLibraryClasses(CustomLibClass.class)
-        .enableCoreLibraryDesugaring(AndroidApiLevel.B)
+        .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
         .compile()
-        .addDesugaredCoreLibraryRunClassPath(this::buildDesugaredLibrary, AndroidApiLevel.B)
-        .addRunClasspathFiles(customLib)
-        .run(new DexRuntime(DexVm.ART_9_0_0_HOST), Executor.class)
-        .assertSuccessWithOutput(StringUtils.lines("--01-16"));
+        .addDesugaredCoreLibraryRunClassPath(
+            this::buildDesugaredLibrary,
+            parameters.getApiLevel(),
+            keepRuleConsumer.get(),
+            shrinkDesugaredLibrary)
+        .addRunClasspathFiles(CUSTOM_LIB)
+        .run(parameters.getRuntime(), Executor.class)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
+  }
+
+  @Test
+  public void testRewrittenAPICallsR8() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+    testForR8(parameters.getBackend())
+        .setMinApi(parameters.getApiLevel())
+        .addProgramClasses(Executor.class)
+        .addKeepMainRule(Executor.class)
+        .addLibraryClasses(CustomLibClass.class)
+        .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+        .compile()
+        .addDesugaredCoreLibraryRunClassPath(
+            this::buildDesugaredLibrary,
+            parameters.getApiLevel(),
+            keepRuleConsumer.get(),
+            shrinkDesugaredLibrary)
+        .addRunClasspathFiles(CUSTOM_LIB)
+        .run(parameters.getRuntime(), Executor.class)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
   }
 
   static class Executor {
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/BasicTimeConversionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/BasicTimeConversionTest.java
index 1e66f26..bb728fb 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/BasicTimeConversionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/BasicTimeConversionTest.java
@@ -4,62 +4,85 @@
 
 package com.android.tools.r8.desugar.desugaredlibrary.conversiontests;
 
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static junit.framework.TestCase.assertEquals;
 import static junit.framework.TestCase.assertTrue;
-import static org.hamcrest.MatcherAssert.assertThat;
 
-import com.android.tools.r8.L8Command;
-import com.android.tools.r8.OutputMode;
-import com.android.tools.r8.StringResource;
-import com.android.tools.r8.TestDiagnosticMessagesImpl;
-import com.android.tools.r8.TestRuntime.DexRuntime;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.DexVm;
+import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
 import com.android.tools.r8.utils.AndroidApiLevel;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import java.nio.file.Path;
 import java.time.ZoneId;
+import java.util.List;
 import java.util.TimeZone;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
 
+@RunWith(Parameterized.class)
 public class BasicTimeConversionTest extends DesugaredLibraryTestBase {
 
-  @Test
-  public void testTimeGeneratedDex() throws Exception {
-    TestDiagnosticMessagesImpl diagnosticsHandler = new TestDiagnosticMessagesImpl();
-    Path desugaredLib = temp.newFolder().toPath().resolve("conversion_dex.zip");
-    L8Command.Builder l8Builder =
-        L8Command.builder(diagnosticsHandler)
-            .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P))
-            .addProgramFiles(ToolHelper.DESUGAR_LIB_CONVERSIONS)
-            .addDesugaredLibraryConfiguration(
-                StringResource.fromFile(ToolHelper.DESUGAR_LIB_JSON_FOR_TESTING))
-            .setMinApiLevel(AndroidApiLevel.B.getLevel())
-            .setOutput(desugaredLib, OutputMode.DexIndexed);
-    ToolHelper.runL8(l8Builder.build(), x -> {});
-    this.checkTimeConversionGeneratedDex(new CodeInspector(desugaredLib));
+  private final TestParameters parameters;
+  private final boolean shrinkDesugaredLibrary;
+  private static final String GMT = StringUtils.lines("GMT");
+
+  @Parameters(name = "{0}, shrinkDesugaredLibrary: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getConversionParametersUpToExcluding(AndroidApiLevel.O), BooleanUtils.values());
   }
 
-  private void checkTimeConversionGeneratedDex(CodeInspector inspector) {
-    ClassSubject clazz = inspector.clazz("j$.time.TimeConversions");
-    assertThat(clazz, isPresent());
-    assertEquals(13, clazz.allMethods().size());
+  public BasicTimeConversionTest(TestParameters parameters, boolean shrinkDesugaredLibrary) {
+    this.shrinkDesugaredLibrary = shrinkDesugaredLibrary;
+    this.parameters = parameters;
   }
 
   @Test
-  public void testRewrittenAPICalls() throws Exception {
+  public void testRewrittenAPICallsD8() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
     testForD8()
-        .setMinApi(AndroidApiLevel.B)
+        .setMinApi(parameters.getApiLevel())
         .addInnerClasses(BasicTimeConversionTest.class)
-        .enableCoreLibraryDesugaring(AndroidApiLevel.B)
+        .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
         .compile()
+        .addDesugaredCoreLibraryRunClassPath(
+            this::buildDesugaredLibrary,
+            parameters.getApiLevel(),
+            keepRuleConsumer.get(),
+            shrinkDesugaredLibrary)
         .inspect(this::checkAPIRewritten)
-        .addDesugaredCoreLibraryRunClassPath(this::buildDesugaredLibrary, AndroidApiLevel.B)
-        .run(new DexRuntime(DexVm.ART_9_0_0_HOST), Executor.class);
+        .run(parameters.getRuntime(), Executor.class)
+        .assertSuccessWithOutput(GMT);
+    if (shrinkDesugaredLibrary) {
+      checkKeepRules(keepRuleConsumer.get());
+    }
+  }
+
+  private void checkKeepRules(String keepRules) {
+    assertTrue(keepRules.contains("TimeConversion"));
+  }
+
+  @Test
+  public void testRewrittenAPICallsR8() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+    testForR8(parameters.getBackend())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Executor.class)
+        .addInnerClasses(BasicTimeConversionTest.class)
+        .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+        .compile()
+        .addDesugaredCoreLibraryRunClassPath(
+            this::buildDesugaredLibrary,
+            parameters.getApiLevel(),
+            keepRuleConsumer.get(),
+            shrinkDesugaredLibrary)
+        .run(parameters.getRuntime(), Executor.class)
+        .assertSuccessWithOutput(GMT);
+    if (shrinkDesugaredLibrary) {
+      checkKeepRules(keepRuleConsumer.get());
+    }
   }
 
   private void checkAPIRewritten(CodeInspector inspector) {
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/ConversionsPresentTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/ConversionsPresentTest.java
new file mode 100644
index 0000000..43d5b9a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/ConversionsPresentTest.java
@@ -0,0 +1,77 @@
+// 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.desugaredlibrary.conversiontests;
+
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertTrue;
+
+import com.android.tools.r8.L8Command;
+import com.android.tools.r8.OutputMode;
+import com.android.tools.r8.StringResource;
+import com.android.tools.r8.TestDiagnosticMessagesImpl;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ConversionsPresentTest extends DesugaredLibraryTestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+  }
+
+  public ConversionsPresentTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testConversionsDex() throws Exception {
+    TestDiagnosticMessagesImpl diagnosticsHandler = new TestDiagnosticMessagesImpl();
+    Path desugaredLib = temp.newFolder().toPath().resolve("conversion_dex.zip");
+    L8Command.Builder l8Builder =
+        L8Command.builder(diagnosticsHandler)
+            .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P))
+            .addProgramFiles(ToolHelper.DESUGAR_LIB_CONVERSIONS)
+            .addDesugaredLibraryConfiguration(
+                StringResource.fromFile(ToolHelper.DESUGAR_LIB_JSON_FOR_TESTING))
+            .setMinApiLevel(parameters.getApiLevel().getLevel())
+            .setOutput(desugaredLib, OutputMode.DexIndexed);
+    ToolHelper.runL8(l8Builder.build(), x -> {});
+    this.checkConversionGeneratedDex(new CodeInspector(desugaredLib));
+  }
+
+  private void checkConversionGeneratedDex(CodeInspector inspector) {
+    List<FoundClassSubject> conversionsClasses =
+        inspector.allClasses().stream()
+            .filter(c -> c.getOriginalName().contains("Conversions"))
+            .collect(Collectors.toList());
+    if (parameters.getApiLevel().isLessThan(AndroidApiLevel.N)) {
+      assertEquals(5, conversionsClasses.size());
+      assertTrue(inspector.clazz("j$.util.OptionalConversions").isPresent());
+      assertTrue(inspector.clazz("j$.time.TimeConversions").isPresent());
+      assertTrue(inspector.clazz("j$.util.LongSummaryStatisticsConversions").isPresent());
+      assertTrue(inspector.clazz("j$.util.IntSummaryStatisticsConversions").isPresent());
+      assertTrue(inspector.clazz("j$.util.DoubleSummaryStatisticsConversions").isPresent());
+    } else if (parameters.getApiLevel().isLessThan(AndroidApiLevel.O)) {
+      assertEquals(1, conversionsClasses.size());
+      assertTrue(inspector.clazz("j$.time.TimeConversions").isPresent());
+    } else {
+      assertEquals(0, inspector.allClasses().size());
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java
index dbdc654..a79ccf7 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java
@@ -5,6 +5,7 @@
 package com.android.tools.r8.desugar.nestaccesscontrol;
 
 import static junit.framework.TestCase.assertTrue;
+import static org.hamcrest.CoreMatchers.containsString;
 
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
@@ -50,7 +51,9 @@
         .addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR_11)
         .addKeepRuleFiles(MAIN_KEEP)
         .addOptionsModification(opt -> opt.ignoreMissingClasses = true)
+        .allowDiagnosticWarningMessages()
         .compile()
+        .assertAllWarningMessagesMatch(containsString("Missing class:"))
         .inspect(this::assertNotEmpty)
         .inspect(Java11R8CompilationTest::assertNoNests);
   }
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java
index 48fe91b..75982e9 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java
@@ -69,7 +69,11 @@
   }
 
   private TestCompileResult compileOnlyClassesMatching(
-      Matcher<String> matcher, boolean d8, boolean ignoreMissingClasses) throws Exception {
+      Matcher<String> matcher,
+      boolean d8,
+      boolean allowDiagnosticWarningMessages,
+      boolean ignoreMissingClasses)
+      throws Exception {
     List<Path> matchingClasses =
         CLASS_NAMES.stream()
             .filter(matcher::matches)
@@ -93,6 +97,7 @@
                 options.enableNestBasedAccessDesugaring = true;
                 options.ignoreMissingClasses = ignoreMissingClasses;
               })
+          .allowDiagnosticWarningMessages(allowDiagnosticWarningMessages)
           .compile();
     }
   }
@@ -101,7 +106,7 @@
     try {
       Matcher<String> innerClassMatcher =
           containsString("BasicNestHostWithInnerClassMethods$BasicNestedClass");
-      compileOnlyClassesMatching(innerClassMatcher, false, false);
+      compileOnlyClassesMatching(innerClassMatcher, false, false, false);
       fail("Should have raised an exception for missing nest host");
     } catch (Exception e) {
       assertTrue(e.getCause().getCause().getMessage().contains("requires its nest host"));
@@ -111,7 +116,7 @@
   private void testIncompleteNestError() {
     try {
       Matcher<String> innerClassMatcher = endsWith("BasicNestHostWithInnerClassMethods");
-      compileOnlyClassesMatching(innerClassMatcher, false, false);
+      compileOnlyClassesMatching(innerClassMatcher, false, false, false);
       fail("Should have raised an exception for incomplete nest");
     } catch (Exception e) {
       assertTrue(e.getCause().getCause().getMessage().contains("requires its nest mates"));
@@ -121,7 +126,7 @@
   private void testMissingNestHostWarning(boolean d8, boolean desugarWarning) throws Exception {
     Matcher<String> innerClassMatcher =
         containsString("BasicNestHostWithInnerClassMethods$BasicNestedClass");
-    TestCompileResult compileResult = compileOnlyClassesMatching(innerClassMatcher, d8, true);
+    TestCompileResult compileResult = compileOnlyClassesMatching(innerClassMatcher, d8, !d8, true);
     assertTrue(compileResult.getDiagnosticMessages().getWarnings().size() >= 1);
     if (desugarWarning) {
       assertTrue(
@@ -137,7 +142,7 @@
 
   private void testIncompleteNestWarning(boolean d8, boolean desugarWarning) throws Exception {
     Matcher<String> innerClassMatcher = endsWith("BasicNestHostWithInnerClassMethods");
-    TestCompileResult compileResult = compileOnlyClassesMatching(innerClassMatcher, d8, true);
+    TestCompileResult compileResult = compileOnlyClassesMatching(innerClassMatcher, d8, !d8, true);
     assertTrue(compileResult.getDiagnosticMessages().getWarnings().size() >= 1);
     if (desugarWarning) {
       assertTrue(
@@ -145,9 +150,7 @@
               .anyMatch(warn -> warn instanceof IncompleteNestNestDesugarDiagnosic));
     } else if (!d8) {
       // R8 should raise extra warning when cleaning the nest.
-      assertTrue(
-          compileResult.getDiagnosticMessages().getWarnings().stream()
-              .anyMatch(warn -> warn.getDiagnosticMessage().contains("requires its nest mates")));
+      compileResult.assertWarningMessageThatMatches(containsString("requires its nest mates"));
     }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/FailingEnumUnboxingAnalysisTest.java b/src/test/java/com/android/tools/r8/enumunboxing/FailingEnumUnboxingAnalysisTest.java
index 247e8a1..9c4872f 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/FailingEnumUnboxingAnalysisTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/FailingEnumUnboxingAnalysisTest.java
@@ -59,6 +59,7 @@
             .enableInliningAnnotations()
             .addKeepRules(KEEP_ENUM)
             .addOptionsModification(this::enableEnumOptions)
+            .allowDiagnosticInfoMessages()
             .setMinApi(parameters.getApiLevel())
             .compile()
             .inspect(this::assertEnumsAsExpected);
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingAnalysisTest.java b/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingAnalysisTest.java
index 762380a..e4f7bd1 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingAnalysisTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingAnalysisTest.java
@@ -8,7 +8,6 @@
 import static org.junit.Assert.assertEquals;
 
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
@@ -46,16 +45,13 @@
 
   @Test
   public void testEnumUnboxingFailure() throws Exception {
-    R8FullTestBuilder r8FullTestBuilder =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(FailingMethodEnumUnboxingAnalysisTest.class);
-    for (Class<?> failure : FAILURES) {
-      r8FullTestBuilder.addKeepMainRule(failure);
-    }
     R8TestCompileResult compile =
-        r8FullTestBuilder
+        testForR8(parameters.getBackend())
+            .addInnerClasses(FailingMethodEnumUnboxingAnalysisTest.class)
+            .addKeepMainRules(FAILURES)
             .addKeepRules(KEEP_ENUM)
             .addOptionsModification(this::enableEnumOptions)
+            .allowDiagnosticInfoMessages()
             .enableInliningAnnotations()
             .addOptionsModification(
                 // Disabled to avoid toString() being removed.
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/FieldPutEnumUnboxingAnalysisTest.java b/src/test/java/com/android/tools/r8/enumunboxing/FieldPutEnumUnboxingAnalysisTest.java
index 2841689..8811ee5 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/FieldPutEnumUnboxingAnalysisTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/FieldPutEnumUnboxingAnalysisTest.java
@@ -40,6 +40,7 @@
             .addKeepMainRules(INPUTS)
             .addKeepRules(KEEP_ENUM)
             .addOptionsModification(this::enableEnumOptions)
+            .allowDiagnosticInfoMessages()
             .enableInliningAnnotations()
             .setMinApi(parameters.getApiLevel())
             .noMinification()
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/OrdinalEnumUnboxingAnalysisTest.java b/src/test/java/com/android/tools/r8/enumunboxing/OrdinalEnumUnboxingAnalysisTest.java
index 079c9f7..2570a12 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/OrdinalEnumUnboxingAnalysisTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/OrdinalEnumUnboxingAnalysisTest.java
@@ -37,6 +37,7 @@
             .addKeepMainRule(classToTest)
             .addKeepRules(KEEP_ENUM)
             .addOptionsModification(this::enableEnumOptions)
+            .allowDiagnosticInfoMessages()
             .setMinApi(parameters.getApiLevel())
             .compile()
             .inspectDiagnosticMessages(
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/PhiEnumUnboxingAnalysisTest.java b/src/test/java/com/android/tools/r8/enumunboxing/PhiEnumUnboxingAnalysisTest.java
index 87cacd5..2abd358 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/PhiEnumUnboxingAnalysisTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/PhiEnumUnboxingAnalysisTest.java
@@ -39,6 +39,7 @@
             .addKeepRules(KEEP_ENUM)
             .enableInliningAnnotations()
             .addOptionsModification(this::enableEnumOptions)
+            .allowDiagnosticInfoMessages()
             .setMinApi(parameters.getApiLevel())
             .compile()
             .inspectDiagnosticMessages(
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingAnalysisTest.java b/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingAnalysisTest.java
index 699c72d..53cddc6 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingAnalysisTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingAnalysisTest.java
@@ -39,6 +39,7 @@
             .addKeepRules(KEEP_ENUM)
             .enableInliningAnnotations()
             .addOptionsModification(this::enableEnumOptions)
+            .allowDiagnosticInfoMessages()
             .setMinApi(parameters.getApiLevel())
             .compile()
             .inspectDiagnosticMessages(
diff --git a/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java b/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java
index 6bf5d8f..0788985 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java
@@ -5,6 +5,8 @@
 package com.android.tools.r8.internal.proto;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertTrue;
@@ -91,10 +93,15 @@
                   options.enableStringSwitchConversion = true;
                 })
             .allowAccessModification()
+            .allowDiagnosticMessages()
             .allowUnusedProguardConfigurationRules()
             .enableInliningAnnotations()
             .setMinApi(parameters.getApiLevel())
             .compile()
+            .assertAllInfoMessagesMatch(
+                containsString("Proguard configuration rule does not match anything"))
+            .assertAllWarningMessagesMatch(
+                equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
             .inspect(this::inspect);
 
     for (String main : mains) {
diff --git a/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java b/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java
index 558664f..1473e03 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java
@@ -5,6 +5,9 @@
 package com.android.tools.r8.internal.proto;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
@@ -88,10 +91,15 @@
                   options.enableStringSwitchConversion = true;
                 })
             .allowAccessModification(allowAccessModification)
+            .allowDiagnosticMessages()
             .allowUnusedProguardConfigurationRules()
             .minification(enableMinification)
             .setMinApi(parameters.getApiLevel())
             .compile()
+            .assertAllInfoMessagesMatch(
+                containsString("Proguard configuration rule does not match anything"))
+            .assertAllWarningMessagesMatch(
+                equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
             .inspect(
                 outputInspector -> {
                   verifyMapAndRequiredFieldsAreKept(inputInspector, outputInspector);
@@ -356,10 +364,17 @@
               options.protoShrinking().enableGeneratedMessageLiteShrinking = true;
             })
         .allowAccessModification(allowAccessModification)
+        .allowDiagnosticMessages()
         .allowUnusedProguardConfigurationRules()
         .minification(enableMinification)
         .setMinApi(parameters.getApiLevel())
         .compile()
+        .assertAllInfoMessagesMatch(
+            containsString("Proguard configuration rule does not match anything"))
+        .assertAllWarningMessagesMatch(
+            anyOf(
+                equalTo("Resource 'META-INF/MANIFEST.MF' already exists."),
+                containsString("required for default or static interface methods desugaring")))
         .inspect(
             inspector ->
                 assertRewrittenProtoSchemasMatch(new CodeInspector(PROGRAM_FILES), inspector));
diff --git a/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java b/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java
index faa91e5..7a261ff 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java
@@ -5,6 +5,9 @@
 package com.android.tools.r8.internal.proto;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
@@ -64,10 +67,14 @@
               options.enableStringSwitchConversion = true;
             })
         .allowAccessModification(allowAccessModification)
+        .allowDiagnosticMessages()
         .allowUnusedProguardConfigurationRules()
         .minification(enableMinification)
         .setMinApi(parameters.getApiLevel())
         .compile()
+        .assertAllInfoMessagesMatch(
+            containsString("Proguard configuration rule does not match anything"))
+        .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
         .inspect(
             outputInspector -> {
               verifyUnusedFieldsAreRemoved(inputInspector, outputInspector);
@@ -113,10 +120,17 @@
               options.protoShrinking().enableGeneratedMessageLiteShrinking = true;
             })
         .allowAccessModification(allowAccessModification)
+        .allowDiagnosticMessages()
         .allowUnusedProguardConfigurationRules()
         .minification(enableMinification)
-        .setMinApi(parameters.getRuntime())
+        .setMinApi(parameters.getApiLevel())
         .compile()
+        .assertAllInfoMessagesMatch(
+            containsString("Proguard configuration rule does not match anything"))
+        .assertAllWarningMessagesMatch(
+            anyOf(
+                equalTo("Resource 'META-INF/MANIFEST.MF' already exists."),
+                containsString("required for default or static interface methods desugaring")))
         .inspect(
             inspector ->
                 assertRewrittenProtoSchemasMatch(new CodeInspector(PROGRAM_FILES), inspector));
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java b/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java
index 02395ef..979de40 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java
@@ -24,6 +24,7 @@
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackIgnore;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.AndroidApp;
@@ -81,14 +82,16 @@
   public void testOptimizationInfo() throws Exception {
     AppView<AppInfoWithSubtyping> appView = buildApp();
     OptimizationFeedbackMock feedback = new OptimizationFeedbackMock();
-    FieldBitAccessAnalysis fieldBitAccessAnalysis = new FieldBitAccessAnalysis(appView);
+    FieldBitAccessAnalysis fieldBitAccessAnalysis = new FieldBitAccessAnalysis();
+    FieldAccessAnalysis fieldAccessAnalysis =
+        new FieldAccessAnalysis(appView, null, fieldBitAccessAnalysis);
 
     DexProgramClass clazz = appView.appInfo().classes().iterator().next();
     assertEquals(TestClass.class.getTypeName(), clazz.type.toSourceString());
 
     for (DexEncodedMethod method : clazz.methods()) {
       IRCode code = method.buildIR(appView, Origin.unknown());
-      fieldBitAccessAnalysis.recordFieldAccesses(code, feedback);
+      fieldAccessAnalysis.recordFieldAccesses(code, feedback, new MethodProcessorMock());
     }
 
     int bitsReadInBitField = feedback.bitsReadPerField.getInt(uniqueFieldByName(clazz, "bitField"));
@@ -205,6 +208,19 @@
     }
   }
 
+  static class MethodProcessorMock implements MethodProcessor {
+
+    @Override
+    public Phase getPhase() {
+      return Phase.PRIMARY;
+    }
+
+    @Override
+    public boolean isProcessedConcurrently(DexEncodedMethod method) {
+      return false;
+    }
+  }
+
   static class OptimizationFeedbackMock extends OptimizationFeedbackIgnore {
 
     Reference2IntMap<DexEncodedField> bitsReadPerField = new Reference2IntOpenHashMap<>();
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/MissingClassesJoinTest.java b/src/test/java/com/android/tools/r8/ir/analysis/type/MissingClassesJoinTest.java
index 901a577..41ce8a8 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/MissingClassesJoinTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/MissingClassesJoinTest.java
@@ -5,19 +5,20 @@
 package com.android.tools.r8.ir.analysis.type;
 
 import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.D8TestCompileResult;
 import com.android.tools.r8.NeverMerge;
-import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.google.common.base.Throwables;
-import java.nio.file.Path;
 import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -35,7 +36,8 @@
 
   @Parameters(name = "{1}, allow type errors: {0}")
   public static List<Object[]> data() {
-    return buildParameters(BooleanUtils.values(), getTestParameters().withAllRuntimes().build());
+    return buildParameters(
+        BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
   }
 
   public MissingClassesJoinTest(boolean allowTypeErrors, TestParameters parameters) {
@@ -45,57 +47,63 @@
 
   @Test
   public void test() throws Exception {
-    Path classpathFile =
-        testForD8()
-            .addProgramClasses(ASub2.class)
-            .setMinApi(parameters.getRuntime())
-            .compile()
-            .writeToZip();
-
     if (parameters.isDexRuntime() && !allowTypeErrors) {
-      testForD8()
-          // Intentionally not adding ASub2 as a program class.
-          .addProgramClasses(A.class, ASub1.class, Box.class, TestClass.class)
-          .setMinApi(parameters.getRuntime())
-          .compile()
-          .addRunClasspathFiles(classpathFile)
+      D8TestCompileResult compileResult =
+          testForD8()
+              // Intentionally not adding ASub2 as a program class.
+              .addProgramClasses(A.class, ASub1.class, Box.class, TestClass.class)
+              .setMinApi(parameters.getApiLevel())
+              .compile();
+
+      testForRuntime(parameters)
+          .addProgramFiles(compileResult.writeToZip())
+          .addProgramClasses(ASub2.class)
           .run(parameters.getRuntime(), TestClass.class)
           .assertSuccessWithOutput(expectedOutput);
     }
 
     try {
-      R8TestRunResult result =
+      R8TestCompileResult compileResult =
           testForR8(parameters.getBackend())
               // Intentionally not adding ASub2 as a program class.
               .addProgramClasses(A.class, ASub1.class, Box.class, TestClass.class)
               .addKeepAllClassesRule()
               .addOptionsModification(options -> options.testing.allowTypeErrors = allowTypeErrors)
+              .allowDiagnosticWarningMessages()
               .enableMergeAnnotations()
-              .setMinApi(parameters.getRuntime())
+              .setMinApi(parameters.getApiLevel())
               .compile()
-              .addRunClasspathFiles(classpathFile)
-              .run(parameters.getRuntime(), TestClass.class);
+              .assertAllWarningMessagesMatch(
+                  equalTo(
+                      "The method `void "
+                          + TestClass.class.getTypeName()
+                          + ".main(java.lang.String[])` does not type check and will be assumed to"
+                          + " be unreachable."));
 
       // Compilation fails unless type errors are allowed.
       assertTrue(allowTypeErrors);
 
-      // TestClass.main() does not type check, so it should have been replaced by `throw null`.
-      // Note that, even if we do not replace the body of main() with `throw null`, the code would
-      // still not work for the CF backend:
-      //
-      //     java.lang.VerifyError: Bad type on operand stack
-      //     Exception Details:
-      //       Location:
-      //         MissingClassesJoinTest$TestClass.main([Ljava/lang/String;)V @28: putstatic
-      //       Reason:
-      //         Type 'java/lang/Object' (current frame, stack[0]) is not assignable to
-      //         'com/android/tools/r8/ir/analysis/type/MissingClassesJoinTest$A'
-      //       Current Frame:
-      //         bci: @28
-      //         flags: { }
-      //         locals: { 'java/lang/Object' }
-      //         stack: { 'java/lang/Object' }
-      result.assertFailureWithErrorThatMatches(containsString("NullPointerException"));
+      testForRuntime(parameters)
+          .addProgramFiles(compileResult.writeToZip())
+          .addProgramClasses(ASub2.class)
+          .run(parameters.getRuntime(), TestClass.class)
+          // TestClass.main() does not type check, so it should have been replaced by `throw null`.
+          // Note that, even if we do not replace the body of main() with `throw null`, the code
+          // would still not work for the CF backend:
+          //
+          //     java.lang.VerifyError: Bad type on operand stack
+          //     Exception Details:
+          //       Location:
+          //         MissingClassesJoinTest$TestClass.main([Ljava/lang/String;)V @28: putstatic
+          //       Reason:
+          //         Type 'java/lang/Object' (current frame, stack[0]) is not assignable to
+          //         'com/android/tools/r8/ir/analysis/type/MissingClassesJoinTest$A'
+          //       Current Frame:
+          //         bci: @28
+          //         flags: { }
+          //         locals: { 'java/lang/Object' }
+          //         stack: { 'java/lang/Object' }
+          .assertFailureWithErrorThatMatches(containsString("NullPointerException"));
     } catch (CompilationFailedException e) {
       // Compilation should only fail when type errors are not allowed.
       assertFalse(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithInheritanceTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithInheritanceTest.java
index a1042ce..73d694e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithInheritanceTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/BuilderWithInheritanceTest.java
@@ -40,10 +40,9 @@
         testForR8(parameters.getBackend())
             .addInnerClasses(BuilderWithInheritanceTest.class)
             .addKeepMainRule(TestClass.class)
-            // TODO(b/145090972): Should never need to exit gracefully during testing.
-            .allowClassInlinerGracefulExit()
             .enableInliningAnnotations()
             .enableMergeAnnotations()
+            .setMinApi(parameters.getApiLevel())
             .run(parameters.getRuntime(), TestClass.class)
             .assertSuccessWithOutput("42")
             .inspector();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInaccessibleStaticGetTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInaccessibleStaticGetTest.java
index 6d70ba5..34e9d5d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInaccessibleStaticGetTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInaccessibleStaticGetTest.java
@@ -40,7 +40,6 @@
             ClassInlineInstanceInitializerWithInaccessibleStaticGetTest.class,
             ClassInlineInstanceInitializerWithInaccessibleStaticGetTestClasses.class)
         .addKeepMainRule(TestClass.class)
-        .allowClassInlinerGracefulExit()
         .enableInliningAnnotations()
         .enableMergeAnnotations()
         .setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java
index 08d4f85..98a6e9e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java
@@ -4,25 +4,21 @@
 
 package com.android.tools.r8.ir.optimize.inliner;
 
-import static junit.framework.TestCase.assertTrue;
+import static org.hamcrest.CoreMatchers.containsString;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
 
 import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.smali.SmaliBuilder;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.google.common.collect.Streams;
-import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 
-
 @RunWith(Parameterized.class)
 public class Regress131349148 extends TestBase {
 
@@ -60,12 +56,18 @@
   public void testNoInlineNonExistingCatchPreL() throws Exception {
     R8TestRunResult result =
         testForR8(parameters.getBackend())
-            .addProgramClasses(TestClassCallingMethodWithNonExisting.class,
-                ClassWithCatchNonExisting.class, ExistingException.class)
+            .addProgramClasses(
+                TestClassCallingMethodWithNonExisting.class,
+                ClassWithCatchNonExisting.class,
+                ExistingException.class)
             .addKeepMainRule(TestClassCallingMethodWithNonExisting.class)
             .addKeepRules("-dontwarn " + NonExistingException.class.getTypeName())
+            .allowDiagnosticWarningMessages(
+                parameters.isCfRuntime() || parameters.getApiLevel().isLessThan(AndroidApiLevel.N))
             .setMinApi(parameters.getApiLevel())
             .compile()
+            .assertAllWarningMessagesMatch(
+                containsString("required for default or static interface methods desugaring"))
             .run(parameters.getRuntime(), TestClassCallingMethodWithNonExisting.class)
             .assertSuccess();
     ClassSubject classSubject =
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/PrunedClassNameComparisonTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/PrunedClassNameComparisonTest.java
new file mode 100644
index 0000000..5dc83d0
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/PrunedClassNameComparisonTest.java
@@ -0,0 +1,90 @@
+// 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.ir.optimize.library;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class PrunedClassNameComparisonTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public PrunedClassNameComparisonTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(PrunedClassNameComparisonTest.class)
+        .addKeepMainRule(TestClass.class)
+        .enableInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("Live!");
+  }
+
+  private void inspect(CodeInspector inspector) {
+    ClassSubject testClassSubject = inspector.clazz(TestClass.class);
+    assertThat(testClassSubject, isPresent());
+    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) {
+      if (get()
+          .getClass()
+          .getName()
+          .equals("com.android.tools.r8.ir.optimize.library.PrunedClassNameComparisonTest$C")) {
+        dead();
+      } else {
+        live();
+      }
+    }
+
+    static I get() {
+      return System.currentTimeMillis() >= 0 ? new A() : new B();
+    }
+
+    @NeverInline
+    static void live() {
+      System.out.println("Live!");
+    }
+
+    @NeverInline
+    static void dead() {
+      System.out.println("Dead!");
+    }
+  }
+
+  interface I {}
+
+  static class A implements I {}
+
+  static class B implements I {}
+
+  static class C implements I {}
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWithDefaultValueAssignmentTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWithDefaultValueAssignmentTest.java
new file mode 100644
index 0000000..3eb649a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWithDefaultValueAssignmentTest.java
@@ -0,0 +1,88 @@
+// 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.ir.optimize.membervaluepropagation;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class FieldWithDefaultValueAssignmentTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public FieldWithDefaultValueAssignmentTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(FieldWithDefaultValueAssignmentTest.class)
+        .addKeepMainRule(TestClass.class)
+        .enableInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(this::inspect)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("Live!");
+  }
+
+  private void inspect(CodeInspector inspector) {
+    ClassSubject testClassSubject = inspector.clazz(TestClass.class);
+    assertThat(testClassSubject, isPresent());
+    assertThat(testClassSubject.uniqueMethodWithName("live"), isPresent());
+    assertThat(testClassSubject.uniqueMethodWithName("dead"), not(isPresent()));
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) {
+      Config config = Config.create();
+      if (config.alwaysFalse) {
+        dead();
+      } else {
+        live();
+      }
+    }
+
+    @NeverInline
+    static void live() {
+      System.out.println("Live!");
+    }
+
+    @NeverInline
+    static void dead() {
+      System.out.println("Dead!");
+    }
+  }
+
+  static class Config {
+
+    boolean alwaysFalse;
+
+    @NeverInline
+    static Config create() {
+      Config config = new Config();
+      config.alwaysFalse = false;
+      return config;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/InstanceFieldLoadsSeparatedByInvokeCustomTest.java b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/InstanceFieldLoadsSeparatedByInvokeCustomTest.java
index 4e4624a..86745e5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/InstanceFieldLoadsSeparatedByInvokeCustomTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/InstanceFieldLoadsSeparatedByInvokeCustomTest.java
@@ -4,10 +4,13 @@
 
 package com.android.tools.r8.ir.optimize.redundantfieldloadelimination;
 
+import static org.hamcrest.CoreMatchers.containsString;
+
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.utils.AndroidApiLevel;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -28,6 +31,7 @@
     return getTestParameters()
         .withCfRuntimes()
         .withDexRuntimesStartingFromIncluding(Version.V8_1_0)
+        .withApiLevelsStartingAtIncluding(AndroidApiLevel.O)
         .build();
   }
 
@@ -40,8 +44,10 @@
     testForR8(parameters.getBackend())
         .addProgramClassFileData(InstanceFieldLoadsSeparatedByInvokeCustomTestClassGenerator.dump())
         .addKeepAllClassesRule()
-        .setMinApi(parameters.getRuntime())
+        .allowDiagnosticWarningMessages()
+        .setMinApi(parameters.getApiLevel())
         .compile()
+        .assertAllWarningMessagesMatch(containsString("Unknown bootstrap method"))
         .run(parameters.getRuntime(), "InstanceFieldLoadsSeparatedByInvokeCustomTestClass")
         .assertSuccess();
   }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/reflection/InnerClassNameTestRunner.java b/src/test/java/com/android/tools/r8/ir/optimize/reflection/InnerClassNameTestRunner.java
index 8896197..8b33acb 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/reflection/InnerClassNameTestRunner.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/reflection/InnerClassNameTestRunner.java
@@ -143,7 +143,7 @@
   @Parameters(name = "{0} minify:{1} {2}")
   public static Collection<Object[]> parameters() {
     return buildParameters(
-        getTestParameters().withAllRuntimes().build(),
+        getTestParameters().withAllRuntimesAndApiLevels().build(),
         BooleanUtils.values(),
         TestNamingConfig.values());
   }
@@ -159,6 +159,23 @@
     this.config = config;
   }
 
+  public boolean hasMalformedInnerClassAttribute() {
+    switch (config) {
+      case DEFAULT:
+      case OUTER_ENDS_WITH_DOLLAR:
+      case $_$_$:
+      case DOLLAR2_SEPARATOR:
+        return false;
+      case EMTPY_SEPARATOR:
+      case UNDERBAR_SEPARATOR:
+      case NON_NESTED_INNER:
+      case WRONG_REPACKAGE:
+        return true;
+      default:
+        throw new Unreachable("Unexpected test configuration: " + config);
+    }
+  }
+
   private void checkWarningsAboutMalformedAttribute(TestCompileResult<?, ?> result) {
     switch (config) {
       case DEFAULT:
@@ -188,7 +205,7 @@
         testForD8()
             .addProgramClassFileData(InnerClassNameTestDump.dump(config, parameters))
             .addOptionsModification(InternalOptions::disableNameReflectionOptimization)
-            .setMinApi(parameters.getRuntime())
+            .setMinApi(parameters.getApiLevel())
             .compile();
     checkWarningsAboutMalformedAttribute(d8CompileResult);
     D8TestRunResult d8RunResult = d8CompileResult.run(parameters.getRuntime(), MAIN_CLASS);
@@ -211,11 +228,13 @@
             .addKeepRules("-keep,allowobfuscation class * { *; }")
             .addKeepRules("-keepattributes InnerClasses,EnclosingMethod")
             .addProgramClassFileData(InnerClassNameTestDump.dump(config, parameters))
+            .allowDiagnosticInfoMessages(hasMalformedInnerClassAttribute())
             .minification(minify)
             .addOptionsModification(InternalOptions::disableNameReflectionOptimization)
-            .setMinApi(parameters.getRuntime())
-            .compile();
-    checkWarningsAboutMalformedAttribute(r8CompileResult);
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .apply(this::checkWarningsAboutMalformedAttribute);
+
     CodeInspector inspector = r8CompileResult.inspector();
     R8TestRunResult r8RunResult = r8CompileResult.run(parameters.getRuntime(), MAIN_CLASS);
     switch (config) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringLengthTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringLengthTest.java
index c13b942..c8d3f1c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringLengthTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringLengthTest.java
@@ -10,6 +10,7 @@
 
 import com.android.tools.r8.D8TestRunResult;
 import com.android.tools.r8.ForceInline;
+import com.android.tools.r8.JvmTestRunResult;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestBase;
@@ -22,28 +23,21 @@
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
 @RunWith(Parameterized.class)
 public class StringLengthTest extends TestBase {
-  private static final String JAVA_OUTPUT = StringUtils.lines(
-      "4",
-      "6",
-      "Shared",
-      "14",
-      "Another_shared",
-      "2",
-      "1",
-      "𐀀", // Different output in Windows.
-      "3"
-  );
+  private static final String JAVA_OUTPUT =
+      StringUtils.lines("4", "6", "Shared", "14", "Another_shared", "2", "1", "🂡", "3");
   private static final Class<?> MAIN = TestClass.class;
 
   @Parameterized.Parameters(name = "{0}")
   public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimes().build();
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
   }
 
   private final TestParameters parameters;
@@ -55,12 +49,10 @@
   @Test
   public void testJVMOutput() throws Exception {
     assumeTrue("Only run JVM reference on CF runtimes", parameters.isCfRuntime());
-    // TODO(b/119097175)
+    JvmTestRunResult run = testForJvm().addTestClasspath().run(parameters.getRuntime(), MAIN);
+    // TODO(b/119097175): Fix test
     if (!ToolHelper.isWindows()) {
-      testForJvm()
-          .addTestClasspath()
-          .run(parameters.getRuntime(), MAIN)
-          .assertSuccessWithOutput(JAVA_OUTPUT);
+      run.assertSuccessWithOutput(JAVA_OUTPUT);
     }
   }
 
@@ -83,30 +75,23 @@
   @Test
   public void testD8() throws Exception {
     assumeTrue("Only run D8 for Dex backend", parameters.isDexRuntime());
-
     D8TestRunResult result =
         testForD8()
             .release()
             .addProgramClasses(MAIN)
-            .setMinApi(parameters.getRuntime())
+            .setMinApi(parameters.getApiLevel())
             .run(parameters.getRuntime(), MAIN);
-    // TODO(b/119097175)
-    if (!ToolHelper.isWindows()) {
-      result.assertSuccessWithOutput(JAVA_OUTPUT);
-    }
-    test(result, 1, 4);
+    result.assertSuccessWithOutput(JAVA_OUTPUT);
+    test(result, 1, 5);
 
     result =
         testForD8()
             .debug()
             .addProgramClasses(MAIN)
-            .setMinApi(parameters.getRuntime())
+            .setMinApi(parameters.getApiLevel())
             .run(parameters.getRuntime(), MAIN);
-    // TODO(b/119097175)
-    if (!ToolHelper.isWindows()) {
-      result.assertSuccessWithOutput(JAVA_OUTPUT);
-    }
-    test(result, 6, 0);
+    result.assertSuccessWithOutput(JAVA_OUTPUT);
+    test(result, 6, 1);
   }
 
   @Test
@@ -116,16 +101,16 @@
             .addProgramClasses(MAIN)
             .enableInliningAnnotations()
             .addKeepMainRule(MAIN)
-            .setMinApi(parameters.getRuntime())
+            .setMinApi(parameters.getApiLevel())
             .run(parameters.getRuntime(), MAIN);
-    // TODO(b/119097175)
+    // TODO(b/119097175): Fix test
     if (!ToolHelper.isWindows()) {
       result.assertSuccessWithOutput(JAVA_OUTPUT);
+      test(result, 0, parameters.isDexRuntime() ? 6 : 7);
     }
-    test(result, 0, parameters.isDexRuntime() ? 5 : 6);
   }
 
-  static class TestClass {
+  public static class TestClass {
 
     @ForceInline
     static String simpleInlineable() {
@@ -139,7 +124,7 @@
       return n.length();
     }
 
-    public static void main(String[] args) {
+    public static void main(String[] args) throws UnsupportedEncodingException {
       String s1 = "GONE";
       // Can be computed at compile time: constCount++
       System.out.println(s1.length());
@@ -155,12 +140,14 @@
       System.out.println(s4.length());
       System.out.println(s4);
 
-      String s5 = "\uD800\uDC00";  // U+10000
+      String s5 = "\uD83C\uDCA1"; // U+1F0A1
       // Can be computed at compile time: constCount++
       System.out.println(s5.length());
       // Even reusable: should not increase any counts.
       System.out.println(s5.codePointCount(0, s5.length()));
-      System.out.println(s5);
+      // The true below will add to the constant count.
+      PrintStream ps = new PrintStream(System.out, true, "UTF-8");
+      ps.println(s5);
 
       // Make sure this is not optimized in DEBUG mode.
       int l = "ABC".length();
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java
index 1c46c19..4062cb0 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java
@@ -4,7 +4,9 @@
 package com.android.tools.r8.kotlin.lambda;
 
 import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static org.hamcrest.CoreMatchers.allOf;
 import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assume.assumeTrue;
 
 import com.android.tools.r8.TestParameters;
@@ -54,11 +56,14 @@
         .addLibraryFiles(ToolHelper.getKotlinStdlibJar())
         .addProgramFiles(ktClasses)
         .addKeepMainRule("**.B143165163Kt")
+        .allowDiagnosticInfoMessages()
         .setMinApi(parameters.getApiLevel())
         .compile()
         // TODO(b/143165163): better not output info like this.
-        .assertInfoMessageThatMatches(containsString("Unrecognized Kotlin lambda"))
-        .assertInfoMessageThatMatches(containsString("unexpected static method"))
+        .assertAllInfoMessagesMatch(
+            allOf(
+                containsString("Unrecognized Kotlin lambda"),
+                containsString("unexpected static method")))
         .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar())
         .run(parameters.getRuntime(), pkg + ".B143165163Kt")
         .assertSuccessWithOutputLines("outer foo bar", "outer foo default");
@@ -80,11 +85,15 @@
         .addProgramFiles(ToolHelper.getKotlinStdlibJar())
         .addProgramFiles(ktClasses)
         .addKeepMainRule("**.B143165163Kt")
+        .allowDiagnosticMessages()
         .setMinApi(parameters.getApiLevel())
         .compile()
         // TODO(b/143165163): better not output info like this.
-        .assertInfoMessageThatMatches(containsString("Unrecognized Kotlin lambda"))
-        .assertInfoMessageThatMatches(containsString("does not implement any interfaces"))
+        .assertAllInfoMessagesMatch(
+            allOf(
+                containsString("Unrecognized Kotlin lambda"),
+                containsString("does not implement any interfaces")))
+        .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
         .run(parameters.getRuntime(), pkg + ".B143165163Kt")
         .assertSuccessWithOutputLines("outer foo bar", "outer foo default");
   }
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java b/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java
index d866cca..562fdbb 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java
@@ -13,7 +13,6 @@
     super(targetVersion);
   }
 
-  static final String PKG_PREFIX =
-      DescriptorUtils.getBinaryNameFromJavaType(
-          KotlinMetadataTestBase.class.getPackage().getName());
+  static final String PKG = KotlinMetadataTestBase.class.getPackage().getName();
+  static final String PKG_PREFIX = DescriptorUtils.getBinaryNameFromJavaType(PKG);
 }
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInClasspathTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInClasspathTypeTest.java
deleted file mode 100644
index e785965..0000000
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInClasspathTypeTest.java
+++ /dev/null
@@ -1,191 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.kotlin.metadata;
-
-import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertTrue;
-
-import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.shaking.ProguardKeepAttributes;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmFunctionSubject;
-import com.android.tools.r8.utils.codeinspector.KmPackageSubject;
-import java.nio.file.Path;
-import java.util.Collection;
-import java.util.List;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class MetadataRenameInClasspathTypeTest extends KotlinMetadataTestBase {
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0} target: {1}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
-  }
-
-  public MetadataRenameInClasspathTypeTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion) {
-    super(targetVersion);
-    this.parameters = parameters;
-  }
-
-  private static Path baseLibJar;
-  private static Path extLibJar;
-
-  @BeforeClass
-  public static void createLibJar() throws Exception {
-    String baseLibFolder = PKG_PREFIX + "/classpath_lib_base";
-    baseLibJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addSourceFiles(getKotlinFileInTest(baseLibFolder, "itf"))
-            .compile();
-    String extLibFolder = PKG_PREFIX + "/classpath_lib_ext";
-    extLibJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(baseLibJar)
-            .addSourceFiles(getKotlinFileInTest(extLibFolder, "impl"))
-            .compile();
-  }
-
-  @Test
-  public void testMetadataInClasspathType_merged() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addClasspathFiles(baseLibJar)
-            .addProgramFiles(extLibJar)
-            // Keep the Extra class and its interface (which has the method).
-            .addKeepRules("-keep class **.Extra")
-            // Keep the ImplKt extension method which requires metadata
-            // to be called with Kotlin syntax from other kotlin code.
-            .addKeepRules("-keep class **.ImplKt { <methods>; }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String implClassName = pkg + ".classpath_lib_ext.Impl";
-    final String implKtClassName = pkg + ".classpath_lib_ext.ImplKt";
-    final String extraClassName = pkg + ".classpath_lib_ext.Extra";
-    compileResult.inspect(inspector -> {
-      assertThat(inspector.clazz(implClassName), not(isPresent()));
-
-      ClassSubject implKt = inspector.clazz(implKtClassName);
-      assertThat(implKt, isPresent());
-      assertThat(implKt, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmPackageSubject kmPackage = implKt.getKmPackage();
-      assertThat(kmPackage, isPresent());
-
-      KmFunctionSubject kmFunction = kmPackage.kmFunctionExtensionWithUniqueName("fooExt");
-      assertThat(kmFunction, isPresent());
-
-      ClassSubject extra = inspector.clazz(extraClassName);
-      assertThat(extra, isPresent());
-      assertThat(extra, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = extra.getKmClass();
-      assertThat(kmClass, isPresent());
-      List<ClassSubject> superTypes = kmClass.getSuperTypes();
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("Impl")));
-      // Can't build ClassSubject with Itf in classpath. Instead, check if the reference to Itf is
-      // not altered via descriptors.
-      List<String> superTypeDescriptors = kmClass.getSuperTypeDescriptors();
-      assertTrue(superTypeDescriptors.stream().noneMatch(supertype -> supertype.contains("Impl")));
-      assertTrue(superTypeDescriptors.stream().anyMatch(supertype -> supertype.contains("Itf")));
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/classpath_app";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(baseLibJar, libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), baseLibJar, libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".classpath_app.MainKt")
-        .assertSuccessWithOutputLines("Impl::foo");
-  }
-
-  @Test
-  public void testMetadataInClasspathType_renamed() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addClasspathFiles(baseLibJar)
-            .addProgramFiles(extLibJar)
-            // Keep the Extra class and its interface (which has the method).
-            .addKeepRules("-keep class **.Extra")
-            // Keep Super, but allow minification.
-            .addKeepRules("-keep,allowobfuscation class **.Impl")
-            // Keep the ImplKt extension method which requires metadata
-            // to be called with Kotlin syntax from other kotlin code.
-            .addKeepRules("-keep class **.ImplKt { <methods>; }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String implClassName = pkg + ".classpath_lib_ext.Impl";
-    final String implKtClassName = pkg + ".classpath_lib_ext.ImplKt";
-    final String extraClassName = pkg + ".classpath_lib_ext.Extra";
-    compileResult.inspect(inspector -> {
-      ClassSubject impl = inspector.clazz(implClassName);
-      assertThat(impl, isRenamed());
-
-      ClassSubject implKt = inspector.clazz(implKtClassName);
-      assertThat(implKt, isPresent());
-      assertThat(implKt, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmPackageSubject kmPackage = implKt.getKmPackage();
-      assertThat(kmPackage, isPresent());
-
-      KmFunctionSubject kmFunction = kmPackage.kmFunctionExtensionWithUniqueName("fooExt");
-      assertThat(kmFunction, isExtensionFunction());
-
-      ClassSubject extra = inspector.clazz(extraClassName);
-      assertThat(extra, isPresent());
-      assertThat(extra, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = extra.getKmClass();
-      assertThat(kmClass, isPresent());
-      List<ClassSubject> superTypes = kmClass.getSuperTypes();
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("Impl")));
-      assertTrue(superTypes.stream().anyMatch(
-          supertype -> supertype.getFinalDescriptor().equals(impl.getFinalDescriptor())));
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/classpath_app";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(baseLibJar, libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), baseLibJar, libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".classpath_app.MainKt")
-        .assertSuccessWithOutputLines("Impl::foo");
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInCompanionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInCompanionTest.java
deleted file mode 100644
index a5c01a5..0000000
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInCompanionTest.java
+++ /dev/null
@@ -1,126 +0,0 @@
-// 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.kotlin.metadata;
-
-import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertTrue;
-
-import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.shaking.ProguardKeepAttributes;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmClassSubject;
-import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import java.nio.file.Path;
-import java.util.Collection;
-import java.util.List;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class MetadataRenameInCompanionTest extends KotlinMetadataTestBase {
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0} target: {1}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
-  }
-
-  public MetadataRenameInCompanionTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion) {
-    super(targetVersion);
-    this.parameters = parameters;
-  }
-
-  private static Path companionLibJar;
-
-  @BeforeClass
-  public static void createLibJar() throws Exception {
-    String companionLibFolder = PKG_PREFIX + "/companion_lib";
-    companionLibJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addSourceFiles(getKotlinFileInTest(companionLibFolder, "lib"))
-            .compile();
-  }
-
-  @Test
-  public void testMetadataInCompanion_renamed() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(companionLibJar)
-            // Keep the B class and its interface (which has the doStuff method).
-            .addKeepRules("-keep class **.B")
-            .addKeepRules("-keep class **.I { <methods>; }")
-            // Keep getters for B$Companion.(singleton|foo) which will be referenced at the app.
-            .addKeepRules("-keepclassmembers class **.B$* { *** get*(...); }")
-            // No rule for Super, but will be kept and renamed.
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String superClassName = pkg + ".companion_lib.Super";
-    final String bClassName = pkg + ".companion_lib.B";
-    final String companionClassName = pkg + ".companion_lib.B$Companion";
-    compileResult.inspect(inspector -> {
-      ClassSubject sup = inspector.clazz(superClassName);
-      assertThat(sup, isRenamed());
-
-      ClassSubject impl = inspector.clazz(bClassName);
-      assertThat(impl, isPresent());
-      assertThat(impl, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = impl.getKmClass();
-      assertThat(kmClass, isPresent());
-      List<ClassSubject> superTypes = kmClass.getSuperTypes();
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("Super")));
-      assertTrue(superTypes.stream().anyMatch(
-          supertype -> supertype.getFinalDescriptor().equals(sup.getFinalDescriptor())));
-
-      // Bridge for the property in the companion that needs a backing field.
-      MethodSubject singletonBridge = impl.uniqueMethodWithName("access$getSingleton$cp");
-      assertThat(singletonBridge, isRenamed());
-
-      // For B$Companion.foo, no backing field needed, hence no bridge.
-      MethodSubject fooBridge = impl.uniqueMethodWithName("access$getFoo$cp");
-      assertThat(fooBridge, not(isPresent()));
-
-      ClassSubject companion = inspector.clazz(companionClassName);
-      assertThat(companion, isRenamed());
-
-      MethodSubject singletonGetter = companion.uniqueMethodWithName("getSingleton");
-      assertThat(singletonGetter, isPresent());
-
-      MethodSubject fooGetter = companion.uniqueMethodWithName("getFoo");
-      assertThat(fooGetter, isPresent());
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/companion_app";
-    ProcessResult kotlinTestCompileResult =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            // TODO(b/143687784): update to just .compile() once fixed.
-            .compileRaw();
-
-    // TODO(b/70169921): should be able to compile!
-    assertNotEquals(0, kotlinTestCompileResult.exitCode);
-    assertThat(kotlinTestCompileResult.stderr, containsString("unresolved reference: singleton"));
-    assertThat(kotlinTestCompileResult.stderr, containsString("unresolved reference: foo"));
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInExtensionFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInExtensionFunctionTest.java
deleted file mode 100644
index 0f124e4..0000000
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInExtensionFunctionTest.java
+++ /dev/null
@@ -1,180 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.kotlin.metadata;
-
-import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertTrue;
-
-import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.shaking.ProguardKeepAttributes;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmFunctionSubject;
-import com.android.tools.r8.utils.codeinspector.KmPackageSubject;
-import java.nio.file.Path;
-import java.util.Collection;
-import java.util.List;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class MetadataRenameInExtensionFunctionTest extends KotlinMetadataTestBase {
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0} target: {1}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
-  }
-
-  public MetadataRenameInExtensionFunctionTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion) {
-    super(targetVersion);
-    this.parameters = parameters;
-  }
-
-  private static Path extLibJar;
-
-  @BeforeClass
-  public static void createLibJar() throws Exception {
-    String extLibFolder = PKG_PREFIX + "/extension_function_lib";
-    extLibJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addSourceFiles(getKotlinFileInTest(extLibFolder, "B"))
-            .compile();
-  }
-
-  @Test
-  public void testMetadataInExtensionFunction_merged() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(extLibJar)
-            // Keep the B class and its interface (which has the doStuff method).
-            .addKeepRules("-keep class **.B")
-            .addKeepRules("-keep class **.I { <methods>; }")
-            // Keep the BKt extension function which requires metadata
-            // to be called with Kotlin syntax from other kotlin code.
-            .addKeepRules("-keep class **.BKt { <methods>; }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String superClassName = pkg + ".extension_function_lib.Super";
-    final String bClassName = pkg + ".extension_function_lib.B";
-    final String bKtClassName = pkg + ".extension_function_lib.BKt";
-    compileResult.inspect(inspector -> {
-      assertThat(inspector.clazz(superClassName), not(isPresent()));
-
-      ClassSubject impl = inspector.clazz(bClassName);
-      assertThat(impl, isPresent());
-      assertThat(impl, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = impl.getKmClass();
-      assertThat(kmClass, isPresent());
-      List<ClassSubject> superTypes = kmClass.getSuperTypes();
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("Super")));
-
-      ClassSubject bKt = inspector.clazz(bKtClassName);
-      assertThat(bKt, isPresent());
-      assertThat(bKt, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmPackageSubject kmPackage = bKt.getKmPackage();
-      assertThat(kmPackage, isPresent());
-
-      KmFunctionSubject kmFunction = kmPackage.kmFunctionExtensionWithUniqueName("extension");
-      assertThat(kmFunction, isExtensionFunction());
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/extension_function_app";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".extension_function_app.MainKt")
-        .assertSuccessWithOutputLines("do stuff", "do stuff");
-  }
-
-  @Test
-  public void testMetadataInExtensionFunction_renamed() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(extLibJar)
-            // Keep the B class and its interface (which has the doStuff method).
-            .addKeepRules("-keep class **.B")
-            .addKeepRules("-keep class **.I { <methods>; }")
-            // Keep Super, but allow minification.
-            .addKeepRules("-keep,allowobfuscation class **.Super")
-            // Keep the BKt extension function which requires metadata
-            // to be called with Kotlin syntax from other kotlin code.
-            .addKeepRules("-keep class **.BKt { <methods>; }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String superClassName = pkg + ".extension_function_lib.Super";
-    final String bClassName = pkg + ".extension_function_lib.B";
-    final String bKtClassName = pkg + ".extension_function_lib.BKt";
-    compileResult.inspect(inspector -> {
-      ClassSubject sup = inspector.clazz(superClassName);
-      assertThat(sup, isPresent());
-      assertThat(sup, isRenamed());
-
-      ClassSubject impl = inspector.clazz(bClassName);
-      assertThat(impl, isPresent());
-      assertThat(impl, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = impl.getKmClass();
-      assertThat(kmClass, isPresent());
-      List<ClassSubject> superTypes = kmClass.getSuperTypes();
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("Super")));
-      assertTrue(superTypes.stream().anyMatch(
-          supertype -> supertype.getFinalDescriptor().equals(sup.getFinalDescriptor())));
-
-      ClassSubject bKt = inspector.clazz(bKtClassName);
-      assertThat(bKt, isPresent());
-      assertThat(bKt, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmPackageSubject kmPackage = bKt.getKmPackage();
-      assertThat(kmPackage, isPresent());
-
-      KmFunctionSubject kmFunction = kmPackage.kmFunctionExtensionWithUniqueName("extension");
-      assertThat(kmFunction, isExtensionFunction());
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/extension_function_app";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".extension_function_app.MainKt")
-        .assertSuccessWithOutputLines("do stuff", "do stuff");
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInExtensionPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInExtensionPropertyTest.java
deleted file mode 100644
index 84d9dd2..0000000
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInExtensionPropertyTest.java
+++ /dev/null
@@ -1,187 +0,0 @@
-// 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.kotlin.metadata;
-
-import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionProperty;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.shaking.ProguardKeepAttributes;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmFunctionSubject;
-import com.android.tools.r8.utils.codeinspector.KmPackageSubject;
-import com.android.tools.r8.utils.codeinspector.KmPropertySubject;
-import java.nio.file.Path;
-import java.util.Collection;
-import java.util.List;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class MetadataRenameInExtensionPropertyTest extends KotlinMetadataTestBase {
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0} target: {1}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
-  }
-
-  public MetadataRenameInExtensionPropertyTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion) {
-    super(targetVersion);
-    this.parameters = parameters;
-  }
-
-  private static Path extLibJar;
-
-  @BeforeClass
-  public static void createLibJar() throws Exception {
-    String extLibFolder = PKG_PREFIX + "/extension_property_lib";
-    extLibJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addSourceFiles(getKotlinFileInTest(extLibFolder, "B"))
-            .compile();
-  }
-
-  @Test
-  public void testMetadataInExtensionProperty_merged() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(extLibJar)
-            // Keep the B class and its interface (which has the doStuff method).
-            .addKeepRules("-keep class **.B")
-            .addKeepRules("-keep class **.I { <methods>; }")
-            // Keep the BKt extension property which requires metadata
-            // to be called with Kotlin syntax from other kotlin code.
-            .addKeepRules("-keep class **.BKt { <methods>; }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String superClassName = pkg + ".extension_property_lib.Super";
-    final String bClassName = pkg + ".extension_property_lib.B";
-    final String bKtClassName = pkg + ".extension_property_lib.BKt";
-    compileResult.inspect(inspector -> {
-      assertThat(inspector.clazz(superClassName), not(isPresent()));
-
-      ClassSubject impl = inspector.clazz(bClassName);
-      assertThat(impl, isPresent());
-      assertThat(impl, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = impl.getKmClass();
-      assertThat(kmClass, isPresent());
-      List<ClassSubject> superTypes = kmClass.getSuperTypes();
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("Super")));
-      KmFunctionSubject kmFunction = kmClass.kmFunctionWithUniqueName("doStuff");
-      assertThat(kmFunction, isPresent());
-      assertThat(kmFunction, not(isExtensionFunction()));
-
-      ClassSubject bKt = inspector.clazz(bKtClassName);
-      assertThat(bKt, isPresent());
-      assertThat(bKt, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmPackageSubject kmPackage = bKt.getKmPackage();
-      assertThat(kmPackage, isPresent());
-
-      KmPropertySubject kmProperty = kmPackage.kmPropertyExtensionWithUniqueName("asI");
-      assertThat(kmProperty, isExtensionProperty());
-      assertNotNull(kmProperty.getterSignature());
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/extension_property_app";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".extension_property_app.MainKt")
-        .assertSuccessWithOutputLines("do stuff", "do stuff");
-  }
-
-  @Test
-  public void testMetadataInExtensionProperty_renamed() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(extLibJar)
-            // Keep the B class and its interface (which has the doStuff method).
-            .addKeepRules("-keep class **.B")
-            .addKeepRules("-keep class **.I { <methods>; }")
-            // Keep Super, but allow minification.
-            .addKeepRules("-keep,allowobfuscation class **.Super")
-            // Keep the BKt extension property which requires metadata
-            // to be called with Kotlin syntax from other kotlin code.
-            .addKeepRules("-keep class **.BKt { <methods>; }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String superClassName = pkg + ".extension_property_lib.Super";
-    final String bClassName = pkg + ".extension_property_lib.B";
-    final String bKtClassName = pkg + ".extension_property_lib.BKt";
-    compileResult.inspect(inspector -> {
-      ClassSubject sup = inspector.clazz(superClassName);
-      assertThat(sup, isRenamed());
-
-      ClassSubject impl = inspector.clazz(bClassName);
-      assertThat(impl, isPresent());
-      assertThat(impl, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = impl.getKmClass();
-      assertThat(kmClass, isPresent());
-      List<ClassSubject> superTypes = kmClass.getSuperTypes();
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("Super")));
-      assertTrue(superTypes.stream().anyMatch(
-          supertype -> supertype.getFinalDescriptor().equals(sup.getFinalDescriptor())));
-
-      ClassSubject bKt = inspector.clazz(bKtClassName);
-      assertThat(bKt, isPresent());
-      assertThat(bKt, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmPackageSubject kmPackage = bKt.getKmPackage();
-      assertThat(kmPackage, isPresent());
-
-      KmPropertySubject kmProperty = kmPackage.kmPropertyExtensionWithUniqueName("asI");
-      assertThat(kmProperty, isExtensionProperty());
-      assertNotNull(kmProperty.getterSignature());
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/extension_property_app";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".extension_property_app.MainKt")
-        .assertSuccessWithOutputLines("do stuff", "do stuff");
-  }
-}
\ No newline at end of file
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInFunctionTest.java
deleted file mode 100644
index c0a1092..0000000
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInFunctionTest.java
+++ /dev/null
@@ -1,179 +0,0 @@
-// 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.kotlin.metadata;
-
-import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertTrue;
-
-import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.shaking.ProguardKeepAttributes;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmFunctionSubject;
-import com.android.tools.r8.utils.codeinspector.KmPackageSubject;
-import java.nio.file.Path;
-import java.util.Collection;
-import java.util.List;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class MetadataRenameInFunctionTest extends KotlinMetadataTestBase {
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0} target: {1}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
-  }
-
-  public MetadataRenameInFunctionTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion) {
-    super(targetVersion);
-    this.parameters = parameters;
-  }
-
-  private static Path funLibJar;
-
-  @BeforeClass
-  public static void createLibJar() throws Exception {
-    String funLibFolder = PKG_PREFIX + "/function_lib";
-    funLibJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addSourceFiles(getKotlinFileInTest(funLibFolder, "B"))
-            .compile();
-  }
-
-  @Test
-  public void testMetadataInFunction_merged() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(funLibJar)
-            // Keep the B class and its interface (which has the doStuff method).
-            .addKeepRules("-keep class **.B")
-            .addKeepRules("-keep class **.I { <methods>; }")
-            // Keep the BKt method, which will be called from other kotlin code.
-            .addKeepRules("-keep class **.BKt { <methods>; }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String superClassName = pkg + ".function_lib.Super";
-    final String bClassName = pkg + ".function_lib.B";
-    final String bKtClassName = pkg + ".function_lib.BKt";
-    compileResult.inspect(inspector -> {
-      assertThat(inspector.clazz(superClassName), not(isPresent()));
-
-      ClassSubject impl = inspector.clazz(bClassName);
-      assertThat(impl, isPresent());
-      assertThat(impl, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = impl.getKmClass();
-      assertThat(kmClass, isPresent());
-      List<ClassSubject> superTypes = kmClass.getSuperTypes();
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("Super")));
-
-      ClassSubject bKt = inspector.clazz(bKtClassName);
-      assertThat(bKt, isPresent());
-      assertThat(bKt, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmPackageSubject kmPackage = bKt.getKmPackage();
-      assertThat(kmPackage, isPresent());
-
-      KmFunctionSubject kmFunction = kmPackage.kmFunctionWithUniqueName("fun");
-      assertThat(kmFunction, isPresent());
-      assertThat(kmFunction, not(isExtensionFunction()));
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/function_app";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".function_app.MainKt")
-        .assertSuccessWithOutputLines("do stuff", "do stuff");
-  }
-
-  @Test
-  public void testMetadataInFunction_renamed() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(funLibJar)
-            // Keep the B class and its interface (which has the doStuff method).
-            .addKeepRules("-keep class **.B")
-            .addKeepRules("-keep class **.I { <methods>; }")
-            // Keep Super, but allow minification.
-            .addKeepRules("-keep,allowobfuscation class **.Super")
-            // Keep the BKt method, which will be called from other kotlin code.
-            .addKeepRules("-keep class **.BKt { <methods>; }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String superClassName = pkg + ".function_lib.Super";
-    final String bClassName = pkg + ".function_lib.B";
-    final String bKtClassName = pkg + ".function_lib.BKt";
-    compileResult.inspect(inspector -> {
-      ClassSubject sup = inspector.clazz(superClassName);
-      assertThat(sup, isRenamed());
-
-      ClassSubject impl = inspector.clazz(bClassName);
-      assertThat(impl, isPresent());
-      assertThat(impl, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = impl.getKmClass();
-      assertThat(kmClass, isPresent());
-      List<ClassSubject> superTypes = kmClass.getSuperTypes();
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("Super")));
-      assertTrue(superTypes.stream().anyMatch(
-          supertype -> supertype.getFinalDescriptor().equals(sup.getFinalDescriptor())));
-
-      ClassSubject bKt = inspector.clazz(bKtClassName);
-      assertThat(bKt, isPresent());
-      assertThat(bKt, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmPackageSubject kmPackage = bKt.getKmPackage();
-      assertThat(kmPackage, isPresent());
-
-      KmFunctionSubject kmFunction = kmPackage.kmFunctionWithUniqueName("fun");
-      assertThat(kmFunction, isPresent());
-      assertThat(kmFunction, not(isExtensionFunction()));
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/function_app";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".function_app.MainKt")
-        .assertSuccessWithOutputLines("do stuff", "do stuff");
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInLibraryTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInLibraryTypeTest.java
deleted file mode 100644
index 8917ebe..0000000
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInLibraryTypeTest.java
+++ /dev/null
@@ -1,109 +0,0 @@
-// 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.kotlin.metadata;
-
-import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertTrue;
-
-import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.shaking.ProguardKeepAttributes;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmPackageSubject;
-import java.nio.file.Path;
-import java.util.Collection;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class MetadataRenameInLibraryTypeTest extends KotlinMetadataTestBase {
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0} target: {1}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
-  }
-
-  public MetadataRenameInLibraryTypeTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion) {
-    super(targetVersion);
-    this.parameters = parameters;
-  }
-
-  private static Path baseLibJar;
-  private static Path extLibJar;
-  private static Path appJar;
-
-  @BeforeClass
-  public static void createLibJar() throws Exception {
-    String baseLibFolder = PKG_PREFIX + "/libtype_lib_base";
-    baseLibJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addSourceFiles(getKotlinFileInTest(baseLibFolder, "base"))
-            .compile();
-    String extLibFolder = PKG_PREFIX + "/libtype_lib_ext";
-    extLibJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(baseLibJar)
-            .addSourceFiles(getKotlinFileInTest(extLibFolder, "ext"))
-            .compile();
-    String appFolder = PKG_PREFIX + "/libtype_app";
-    appJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(baseLibJar)
-            .addClasspathFiles(extLibJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .compile();
-  }
-
-  @Test
-  public void testR8() throws Exception {
-    String pkg = getClass().getPackage().getName();
-    String main = pkg + ".libtype_app.MainKt";
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            // Intentionally not providing basLibJar as lib file nor classpath file.
-            .addProgramFiles(extLibJar, appJar)
-            // Keep Ext extension method which requires metadata to be called with Kotlin syntax
-            // from other kotlin code.
-            .addKeepRules("-keep class **.ExtKt { <methods>; }")
-            // Keep the main entry.
-            .addKeepMainRule(main)
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            // -dontoptimize so that basic code structure is kept.
-            .noOptimization()
-            .compile();
-    final String extClassName = pkg + ".libtype_lib_ext.ExtKt";
-    compileResult.inspect(inspector -> {
-      ClassSubject ext = inspector.clazz(extClassName);
-      assertThat(ext, isPresent());
-      assertThat(ext, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmPackageSubject kmPackage = ext.getKmPackage();
-      assertThat(kmPackage, isPresent());
-      // Type appearance of library type, Base, should be kept, even if it's not provided.
-      // Note that the resulting ClassSubject for Base is an absent one as we don't provide it, and
-      // thus we can't use `getReturnTypesInFunctions`, which filters out absent class subject.
-      assertTrue(kmPackage.getReturnTypeDescriptorsInFunctions().stream().anyMatch(
-          returnType -> returnType.contains("Base")));
-    });
-
-    Path out = compileResult.writeToZip();
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), baseLibJar)
-        .addClasspath(out)
-        .run(parameters.getRuntime(), main)
-        .assertSuccessWithOutputLines("Sub::foo", "Sub::boo", "true");
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInMultifileClassTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInMultifileClassTest.java
deleted file mode 100644
index 327878a..0000000
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInMultifileClassTest.java
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.kotlin.metadata;
-
-import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertNotEquals;
-
-import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.shaking.ProguardKeepAttributes;
-import com.android.tools.r8.utils.codeinspector.AnnotationSubject;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import java.nio.file.Path;
-import java.util.Collection;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class MetadataRenameInMultifileClassTest extends KotlinMetadataTestBase {
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0} target: {1}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
-  }
-
-  public MetadataRenameInMultifileClassTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion) {
-    super(targetVersion);
-    this.parameters = parameters;
-  }
-
-  private static Path multifileLibJar;
-
-  @BeforeClass
-  public static void createLibJar() throws Exception {
-    String multifileLibFolder = PKG_PREFIX + "/multifileclass_lib";
-    multifileLibJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addSourceFiles(
-                getKotlinFileInTest(multifileLibFolder, "signed"),
-                getKotlinFileInTest(multifileLibFolder, "unsigned"))
-            .compile();
-  }
-
-  @Test
-  public void testMetadataInMultifileClass_merged() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(multifileLibJar)
-            // Keep UtilKt#comma*Join*(). Let R8 optimize (inline) others, such as joinOf*(String).
-            .addKeepRules("-keep class **.UtilKt")
-            .addKeepRules("-keepclassmembers class * { ** comma*Join*(...); }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String utilClassName = pkg + ".multifileclass_lib.UtilKt";
-    final String signedClassName = pkg + ".multifileclass_lib.UtilKt__SignedKt";
-    compileResult.inspect(inspector -> {
-      ClassSubject util = inspector.clazz(utilClassName);
-      assertThat(util, isPresent());
-      assertThat(util, not(isRenamed()));
-      MethodSubject commaJoinOfInt = util.uniqueMethodWithName("commaSeparatedJoinOfInt");
-      assertThat(commaJoinOfInt, isPresent());
-      assertThat(commaJoinOfInt, not(isRenamed()));
-      MethodSubject joinOfInt = util.uniqueMethodWithName("joinOfInt");
-      assertThat(joinOfInt, not(isPresent()));
-      // API entry is kept, hence the presence of Metadata.
-      AnnotationSubject annotationSubject = util.annotation(METADATA_TYPE);
-      assertThat(annotationSubject, isPresent());
-      // TODO(b/70169921): need further inspection.
-
-      ClassSubject signed = inspector.clazz(signedClassName);
-      assertThat(signed, isRenamed());
-      commaJoinOfInt = signed.uniqueMethodWithName("commaSeparatedJoinOfInt");
-      assertThat(commaJoinOfInt, isPresent());
-      assertThat(commaJoinOfInt, not(isRenamed()));
-      joinOfInt = signed.uniqueMethodWithName("joinOfInt");
-      assertThat(joinOfInt, isRenamed());
-      // API entry is kept, hence the presence of Metadata.
-      annotationSubject = util.annotation(METADATA_TYPE);
-      assertThat(annotationSubject, isPresent());
-      // TODO(b/70169921): need further inspection.
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/multifileclass_app";
-    ProcessResult kotlinTestCompileResult =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            // TODO(b/143687784): update to just .compile() once fixed.
-            .compileRaw();
-    // TODO(b/70169921): should be able to compile!
-    assertNotEquals(0, kotlinTestCompileResult.exitCode);
-    assertThat(kotlinTestCompileResult.stderr, containsString("unresolved reference: join"));
-  }
-
-  @Test
-  public void testMetadataInMultifileClass_renamed() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(multifileLibJar)
-            // Keep UtilKt#comma*Join*().
-            .addKeepRules("-keep class **.UtilKt")
-            .addKeepRules("-keepclassmembers class * { ** comma*Join*(...); }")
-            // Keep yet rename joinOf*(String).
-            .addKeepRules(
-                "-keepclassmembers,allowobfuscation class * { ** joinOf*(...); }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String utilClassName = pkg + ".multifileclass_lib.UtilKt";
-    final String signedClassName = pkg + ".multifileclass_lib.UtilKt__SignedKt";
-    compileResult.inspect(inspector -> {
-      ClassSubject util = inspector.clazz(utilClassName);
-      assertThat(util, isPresent());
-      assertThat(util, not(isRenamed()));
-      MethodSubject commaJoinOfInt = util.uniqueMethodWithName("commaSeparatedJoinOfInt");
-      assertThat(commaJoinOfInt, isPresent());
-      assertThat(commaJoinOfInt, not(isRenamed()));
-      MethodSubject joinOfInt = util.uniqueMethodWithName("joinOfInt");
-      assertThat(joinOfInt, isPresent());
-      assertThat(joinOfInt, isRenamed());
-      // API entry is kept, hence the presence of Metadata.
-      AnnotationSubject annotationSubject = util.annotation(METADATA_TYPE);
-      assertThat(annotationSubject, isPresent());
-      // TODO(b/70169921): need further inspection.
-
-      ClassSubject signed = inspector.clazz(signedClassName);
-      assertThat(signed, isRenamed());
-      commaJoinOfInt = signed.uniqueMethodWithName("commaSeparatedJoinOfInt");
-      assertThat(commaJoinOfInt, isPresent());
-      assertThat(commaJoinOfInt, not(isRenamed()));
-      joinOfInt = signed.uniqueMethodWithName("joinOfInt");
-      assertThat(joinOfInt, isRenamed());
-      // API entry is kept, hence the presence of Metadata.
-      annotationSubject = util.annotation(METADATA_TYPE);
-      assertThat(annotationSubject, isPresent());
-      // TODO(b/70169921): need further inspection.
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/multifileclass_app";
-    ProcessResult kotlinTestCompileResult =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            // TODO(b/143687784): update to just .compile() once fixed.
-            .compileRaw();
-    // TODO(b/70169921): should be able to compile!
-    assertNotEquals(0, kotlinTestCompileResult.exitCode);
-    assertThat(kotlinTestCompileResult.stderr, containsString("unresolved reference: join"));
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInParameterTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInParameterTypeTest.java
deleted file mode 100644
index d75ec09..0000000
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInParameterTypeTest.java
+++ /dev/null
@@ -1,106 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.kotlin.metadata;
-
-import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertTrue;
-
-import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.shaking.ProguardKeepAttributes;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmClassSubject;
-import java.nio.file.Path;
-import java.util.Collection;
-import java.util.List;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class MetadataRenameInParameterTypeTest extends KotlinMetadataTestBase {
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0} target: {1}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
-  }
-
-  public MetadataRenameInParameterTypeTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion) {
-    super(targetVersion);
-    this.parameters = parameters;
-  }
-
-  private static Path parameterTypeLibJar;
-
-  @BeforeClass
-  public static void createLibJar() throws Exception {
-    String parameterTypeLibFolder = PKG_PREFIX + "/parametertype_lib";
-    parameterTypeLibJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addSourceFiles(getKotlinFileInTest(parameterTypeLibFolder, "lib"))
-            .compile();
-  }
-
-  @Test
-  public void testMetadataInParameterType_renamed() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(parameterTypeLibJar)
-            // Keep non-private members of Impl
-            .addKeepRules("-keep public class **.Impl { !private *; }")
-            // Keep Itf, but allow minification.
-            .addKeepRules("-keep,allowobfuscation class **.Itf")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String itfClassName = pkg + ".parametertype_lib.Itf";
-    final String implClassName = pkg + ".parametertype_lib.Impl";
-    compileResult.inspect(inspector -> {
-      ClassSubject itf = inspector.clazz(itfClassName);
-      assertThat(itf, isRenamed());
-
-      ClassSubject impl = inspector.clazz(implClassName);
-      assertThat(impl, isPresent());
-      assertThat(impl, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = impl.getKmClass();
-      assertThat(kmClass, isPresent());
-      List<ClassSubject> superTypes = kmClass.getSuperTypes();
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("Itf")));
-      assertTrue(superTypes.stream().anyMatch(
-          supertype -> supertype.getFinalDescriptor().equals(itf.getFinalDescriptor())));
-      List<ClassSubject> parameterTypes = kmClass.getParameterTypesInFunctions();
-      assertTrue(parameterTypes.stream().anyMatch(
-          parameterType -> parameterType.getFinalDescriptor().equals(itf.getFinalDescriptor())));
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/parametertype_app";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".parametertype_app.MainKt")
-        .assertSuccessWithOutputLines("Impl::bar", "Program::bar");
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInPropertyTest.java
deleted file mode 100644
index 556780c..0000000
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInPropertyTest.java
+++ /dev/null
@@ -1,178 +0,0 @@
-// 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.kotlin.metadata;
-
-import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionProperty;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-
-import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.shaking.ProguardKeepAttributes;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmPropertySubject;
-import java.nio.file.Path;
-import java.util.Collection;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class MetadataRenameInPropertyTest extends KotlinMetadataTestBase {
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0} target: {1}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
-  }
-
-  public MetadataRenameInPropertyTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion) {
-    super(targetVersion);
-    this.parameters = parameters;
-  }
-
-  private static Path propertyTypeLibJar;
-
-  @BeforeClass
-  public static void createLibJar() throws Exception {
-    String propertyTypeLibFolder = PKG_PREFIX + "/fragile_property_lib";
-    propertyTypeLibJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addSourceFiles(getKotlinFileInTest(propertyTypeLibFolder, "lib"))
-            .compile();
-  }
-
-  @Test
-  public void testMetadataInProperty_getterOnly() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(propertyTypeLibJar)
-            // Keep property getters
-            .addKeepRules("-keep class **.Person { <init>(...); }")
-            .addKeepRules("-keepclassmembers class **.Person { *** get*(); }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String personClassName = pkg + ".fragile_property_lib.Person";
-    compileResult.inspect(inspector -> {
-      ClassSubject person = inspector.clazz(personClassName);
-      assertThat(person, isPresent());
-      assertThat(person, not(isRenamed()));
-
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = person.getKmClass();
-      assertThat(kmClass, isPresent());
-
-      KmPropertySubject name = kmClass.kmPropertyWithUniqueName("name");
-      assertThat(name, isPresent());
-      assertThat(name, not(isExtensionProperty()));
-      assertNotNull(name.fieldSignature());
-      assertNotNull(name.getterSignature());
-      assertNull(name.setterSignature());
-
-      KmPropertySubject familyName = kmClass.kmPropertyWithUniqueName("familyName");
-      assertThat(familyName, isPresent());
-      assertThat(familyName, not(isExtensionProperty()));
-      // No backing field for property `familyName`
-      assertNull(familyName.fieldSignature());
-      assertNotNull(familyName.getterSignature());
-      // No setter for property `familyName`
-      assertNull(familyName.setterSignature());
-
-      KmPropertySubject age = kmClass.kmPropertyWithUniqueName("age");
-      assertThat(age, isPresent());
-      assertThat(age, not(isExtensionProperty()));
-      assertNotNull(age.fieldSignature());
-      assertNotNull(age.getterSignature());
-      assertNull(name.setterSignature());
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/fragile_property_only_getter";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "getter_user"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".fragile_property_only_getter.Getter_userKt")
-        .assertSuccessWithOutputLines("true", "false", "Hey");
-  }
-
-  @Test
-  public void testMetadataInProperty_setterOnly() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(propertyTypeLibJar)
-            // Keep property setters (and users)
-            .addKeepRules("-keep class **.Person { <init>(...); }")
-            .addKeepRules("-keepclassmembers class **.Person { void set*(...); }")
-            .addKeepRules("-keepclassmembers class **.Person { void aging(); }")
-            .addKeepRules("-keepclassmembers class **.Person { void change*(...); }")
-            // Keep LibKt extension methods
-            .addKeepRules("-keep class **.LibKt { <methods>; }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String personClassName = pkg + ".fragile_property_lib.Person";
-    compileResult.inspect(inspector -> {
-      ClassSubject person = inspector.clazz(personClassName);
-      assertThat(person, isPresent());
-      assertThat(person, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = person.getKmClass();
-      assertThat(kmClass, isPresent());
-
-      KmPropertySubject name = kmClass.kmPropertyWithUniqueName("name");
-      assertThat(name, isPresent());
-      assertThat(name, not(isExtensionProperty()));
-      assertNull(name.fieldSignature());
-      assertNull(name.getterSignature());
-      assertNotNull(name.setterSignature());
-
-      KmPropertySubject familyName = kmClass.kmPropertyWithUniqueName("familyName");
-      assertThat(familyName, not(isPresent()));
-
-      KmPropertySubject age = kmClass.kmPropertyWithUniqueName("age");
-      assertThat(age, isPresent());
-      assertThat(age, not(isExtensionProperty()));
-      assertNotNull(age.fieldSignature());
-      assertNull(age.getterSignature());
-      assertNotNull(age.setterSignature());
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/fragile_property_only_setter";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "setter_user"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".fragile_property_only_setter.Setter_userKt")
-        .assertSuccessWithOutputLines();
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInPropertyTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInPropertyTypeTest.java
deleted file mode 100644
index 78a1514..0000000
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInPropertyTypeTest.java
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.kotlin.metadata;
-
-import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertTrue;
-
-import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.shaking.ProguardKeepAttributes;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmClassSubject;
-import java.nio.file.Path;
-import java.util.Collection;
-import java.util.List;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class MetadataRenameInPropertyTypeTest extends KotlinMetadataTestBase {
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0} target: {1}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
-  }
-
-  public MetadataRenameInPropertyTypeTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion) {
-    super(targetVersion);
-    this.parameters = parameters;
-  }
-
-  private static Path propertyTypeLibJar;
-
-  @BeforeClass
-  public static void createLibJar() throws Exception {
-    String propertyTypeLibFolder = PKG_PREFIX + "/propertytype_lib";
-    propertyTypeLibJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addSourceFiles(getKotlinFileInTest(propertyTypeLibFolder, "lib"))
-            .compile();
-  }
-
-  @Test
-  public void testMetadataInProperty_renamed() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(propertyTypeLibJar)
-            // Keep non-private members of Impl
-            .addKeepRules("-keep public class **.Impl { !private *; }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String itfClassName = pkg + ".propertytype_lib.Itf";
-    final String implClassName = pkg + ".propertytype_lib.Impl";
-    compileResult.inspect(inspector -> {
-      ClassSubject itf = inspector.clazz(itfClassName);
-      assertThat(itf, isRenamed());
-
-      ClassSubject impl = inspector.clazz(implClassName);
-      assertThat(impl, isPresent());
-      assertThat(impl, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = impl.getKmClass();
-      assertThat(kmClass, isPresent());
-      List<ClassSubject> superTypes = kmClass.getSuperTypes();
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("Itf")));
-      assertTrue(superTypes.stream().anyMatch(
-          supertype -> supertype.getFinalDescriptor().equals(itf.getFinalDescriptor())));
-      List<ClassSubject> propertyReturnTypes = kmClass.getReturnTypesInProperties();
-      assertTrue(propertyReturnTypes.stream().anyMatch(
-          propertyType -> propertyType.getFinalDescriptor().equals(itf.getFinalDescriptor())));
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/propertytype_app";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".propertytype_app.MainKt")
-        .assertSuccessWithOutputLines("Impl::8");
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInReturnTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInReturnTypeTest.java
deleted file mode 100644
index 4f24442..0000000
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInReturnTypeTest.java
+++ /dev/null
@@ -1,106 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.kotlin.metadata;
-
-import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertTrue;
-
-import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.shaking.ProguardKeepAttributes;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmClassSubject;
-import java.nio.file.Path;
-import java.util.Collection;
-import java.util.List;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class MetadataRenameInReturnTypeTest extends KotlinMetadataTestBase {
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0} target: {1}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
-  }
-
-  public MetadataRenameInReturnTypeTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion) {
-    super(targetVersion);
-    this.parameters = parameters;
-  }
-
-  private static Path returnTypeLibJar;
-
-  @BeforeClass
-  public static void createLibJar() throws Exception {
-    String returnTypeLibFolder = PKG_PREFIX + "/returntype_lib";
-    returnTypeLibJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addSourceFiles(getKotlinFileInTest(returnTypeLibFolder, "lib"))
-            .compile();
-  }
-
-  @Test
-  public void testMetadataInReturnType_renamed() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(returnTypeLibJar)
-            // Keep non-private members of Impl
-            .addKeepRules("-keep public class **.Impl { !private *; }")
-            // Keep Itf, but allow minification.
-            .addKeepRules("-keep,allowobfuscation class **.Itf")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String itfClassName = pkg + ".returntype_lib.Itf";
-    final String implClassName = pkg + ".returntype_lib.Impl";
-    compileResult.inspect(inspector -> {
-      ClassSubject itf = inspector.clazz(itfClassName);
-      assertThat(itf, isRenamed());
-
-      ClassSubject impl = inspector.clazz(implClassName);
-      assertThat(impl, isPresent());
-      assertThat(impl, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = impl.getKmClass();
-      assertThat(kmClass, isPresent());
-      List<ClassSubject> superTypes = kmClass.getSuperTypes();
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("Itf")));
-      assertTrue(superTypes.stream().anyMatch(
-          supertype -> supertype.getFinalDescriptor().equals(itf.getFinalDescriptor())));
-      List<ClassSubject> functionReturnTypes = kmClass.getReturnTypesInFunctions();
-      assertTrue(functionReturnTypes.stream().anyMatch(
-          returnType -> returnType.getFinalDescriptor().equals(itf.getFinalDescriptor())));
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/returntype_app";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".returntype_app.MainKt")
-        .assertSuccessWithOutputLines("Impl::foo", "Program::foo", "true");
-  }
-}
-
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInSealedClassTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInSealedClassTest.java
deleted file mode 100644
index a2d4fa1..0000000
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInSealedClassTest.java
+++ /dev/null
@@ -1,183 +0,0 @@
-// 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.kotlin.metadata;
-
-import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
-import static com.android.tools.r8.utils.DescriptorUtils.descriptorToJavaType;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertTrue;
-
-import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.shaking.ProguardKeepAttributes;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmFunctionSubject;
-import com.android.tools.r8.utils.codeinspector.KmPackageSubject;
-import java.nio.file.Path;
-import java.util.Collection;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class MetadataRenameInSealedClassTest extends KotlinMetadataTestBase {
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0} target: {1}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
-  }
-
-  public MetadataRenameInSealedClassTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion) {
-    super(targetVersion);
-    this.parameters = parameters;
-  }
-
-  private static Path sealedLibJar;
-
-  @BeforeClass
-  public static void createLibJar() throws Exception {
-    String sealedLibFolder = PKG_PREFIX + "/sealed_lib";
-    sealedLibJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addSourceFiles(getKotlinFileInTest(sealedLibFolder, "lib"))
-            .compile();
-  }
-
-  @Test
-  public void testMetadataInSealedClass_valid() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(sealedLibJar)
-            // Keep the Expr class
-            .addKeepRules("-keep class **.Expr")
-            // Keep the extension function
-            .addKeepRules("-keep class **.LibKt { <methods>; }")
-            // Keep the factory object and utils
-            .addKeepRules("-keep class **.ExprFactory { *; }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String numClassName = pkg + ".sealed_lib.Num";
-    final String exprClassName = pkg + ".sealed_lib.Expr";
-    final String libClassName = pkg + ".sealed_lib.LibKt";
-    compileResult.inspect(inspector -> {
-      ClassSubject num = inspector.clazz(numClassName);
-      assertThat(num, isRenamed());
-
-      ClassSubject expr = inspector.clazz(exprClassName);
-      assertThat(expr, isPresent());
-      assertThat(expr, not(isRenamed()));
-
-      KmClassSubject kmClass = expr.getKmClass();
-      assertThat(kmClass, isPresent());
-
-      kmClass.getSealedSubclassDescriptors().forEach(sealedSubclassDescriptor -> {
-        ClassSubject sealedSubclass =
-            inspector.clazz(descriptorToJavaType(sealedSubclassDescriptor));
-        assertThat(sealedSubclass, isRenamed());
-        assertEquals(sealedSubclassDescriptor, sealedSubclass.getFinalDescriptor());
-      });
-
-      ClassSubject libKt = inspector.clazz(libClassName);
-      assertThat(expr, isPresent());
-      assertThat(expr, not(isRenamed()));
-
-      KmPackageSubject kmPackage = libKt.getKmPackage();
-      assertThat(kmPackage, isPresent());
-
-      KmFunctionSubject eval = kmPackage.kmFunctionExtensionWithUniqueName("eval");
-      assertThat(eval, isPresent());
-      assertThat(eval, isExtensionFunction());
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/sealed_app";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "valid"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".sealed_app.ValidKt")
-        .assertSuccessWithOutputLines("6");
-  }
-
-  @Test
-  public void testMetadataInSealedClass_invalid() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(sealedLibJar)
-            // Keep the Expr class
-            .addKeepRules("-keep class **.Expr")
-            // Keep the extension function
-            .addKeepRules("-keep class **.LibKt { <methods>; }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String exprClassName = pkg + ".sealed_lib.Expr";
-    final String numClassName = pkg + ".sealed_lib.Num";
-    final String libClassName = pkg + ".sealed_lib.LibKt";
-    compileResult.inspect(inspector -> {
-      // Without any specific keep rule and no instantiation point, it's not necessary to keep
-      // sub classes of Expr.
-      ClassSubject num = inspector.clazz(numClassName);
-      assertThat(num, not(isPresent()));
-
-      ClassSubject expr = inspector.clazz(exprClassName);
-      assertThat(expr, isPresent());
-      assertThat(expr, not(isRenamed()));
-
-      KmClassSubject kmClass = expr.getKmClass();
-      assertThat(kmClass, isPresent());
-
-      assertTrue(kmClass.getSealedSubclassDescriptors().isEmpty());
-
-      ClassSubject libKt = inspector.clazz(libClassName);
-      assertThat(expr, isPresent());
-      assertThat(expr, not(isRenamed()));
-
-      KmPackageSubject kmPackage = libKt.getKmPackage();
-      assertThat(kmPackage, isPresent());
-
-      KmFunctionSubject eval = kmPackage.kmFunctionExtensionWithUniqueName("eval");
-      assertThat(eval, isPresent());
-      assertThat(eval, isExtensionFunction());
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/sealed_app";
-    ProcessResult kotlinTestCompileResult =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "invalid"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compileRaw();
-
-    assertNotEquals(0, kotlinTestCompileResult.exitCode);
-    assertThat(kotlinTestCompileResult.stderr, containsString("cannot access"));
-    assertThat(kotlinTestCompileResult.stderr, containsString("private in 'Expr'"));
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInSuperTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInSuperTypeTest.java
deleted file mode 100644
index 722004a..0000000
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInSuperTypeTest.java
+++ /dev/null
@@ -1,152 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.kotlin.metadata;
-
-import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertTrue;
-
-import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.shaking.ProguardKeepAttributes;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.KmClassSubject;
-import java.nio.file.Path;
-import java.util.Collection;
-import java.util.List;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class MetadataRenameInSuperTypeTest extends KotlinMetadataTestBase {
-
-  private final TestParameters parameters;
-
-  @Parameterized.Parameters(name = "{0} target: {1}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
-  }
-
-  public MetadataRenameInSuperTypeTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion) {
-    super(targetVersion);
-    this.parameters = parameters;
-  }
-
-  private static Path superTypeLibJar;
-
-  @BeforeClass
-  public static void createLibJar() throws Exception {
-    String superTypeLibFolder = PKG_PREFIX + "/supertype_lib";
-    superTypeLibJar =
-        kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addSourceFiles(
-                getKotlinFileInTest(superTypeLibFolder, "impl"),
-                getKotlinFileInTest(superTypeLibFolder + "/internal", "itf"))
-            .compile();
-  }
-
-  @Test
-  public void b143687784_merged() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(superTypeLibJar)
-            // Keep non-private members except for ones in `internal` definitions.
-            .addKeepRules("-keep public class !**.internal.**, * { !private *; }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String itfClassName = pkg + ".supertype_lib.internal.Itf";
-    final String implClassName = pkg + ".supertype_lib.Impl";
-    compileResult.inspect(inspector -> {
-      assertThat(inspector.clazz(itfClassName), not(isPresent()));
-
-      ClassSubject impl = inspector.clazz(implClassName);
-      assertThat(impl, isPresent());
-      assertThat(impl, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = impl.getKmClass();
-      assertThat(kmClass, isPresent());
-      List<ClassSubject> superTypes = kmClass.getSuperTypes();
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("internal")));
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("Itf")));
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/supertype_app";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".supertype_app.MainKt")
-        .assertSuccessWithOutputLines("Impl::foo", "Program::foo");
-  }
-
-  @Test
-  public void b143687784_renamed() throws Exception {
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramFiles(superTypeLibJar)
-            // Keep non-private members except for ones in `internal` definitions.
-            .addKeepRules("-keep public class !**.internal.**, * { !private *; }")
-            // Keep `internal` definitions, but allow minification.
-            .addKeepRules("-keep,allowobfuscation class **.internal.** { *; }")
-            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
-            .compile();
-    String pkg = getClass().getPackage().getName();
-    final String itfClassName = pkg + ".supertype_lib.internal.Itf";
-    final String implClassName = pkg + ".supertype_lib.Impl";
-    compileResult.inspect(inspector -> {
-      ClassSubject itf = inspector.clazz(itfClassName);
-      assertThat(itf, isRenamed());
-
-      ClassSubject impl = inspector.clazz(implClassName);
-      assertThat(impl, isPresent());
-      assertThat(impl, not(isRenamed()));
-      // API entry is kept, hence the presence of Metadata.
-      KmClassSubject kmClass = impl.getKmClass();
-      assertThat(kmClass, isPresent());
-      List<ClassSubject> superTypes = kmClass.getSuperTypes();
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("internal")));
-      assertTrue(superTypes.stream().noneMatch(
-          supertype -> supertype.getFinalDescriptor().contains("Itf")));
-      assertTrue(superTypes.stream().anyMatch(
-          supertype -> supertype.getFinalDescriptor().equals(itf.getFinalDescriptor())));
-    });
-
-    Path libJar = compileResult.writeToZip();
-
-    String appFolder = PKG_PREFIX + "/supertype_app";
-    Path output =
-        kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
-            .addClasspathFiles(libJar)
-            .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
-            .setOutputPath(temp.newFolder().toPath())
-            .compile();
-
-    testForJvm()
-        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
-        .addClasspath(output)
-        .run(parameters.getRuntime(), pkg + ".supertype_app.MainKt")
-        .assertSuccessWithOutputLines("Impl::foo", "Program::foo");
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java
new file mode 100644
index 0000000..d03fcd1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java
@@ -0,0 +1,199 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
+import com.android.tools.r8.utils.codeinspector.KmFunctionSubject;
+import com.android.tools.r8.utils.codeinspector.KmPackageSubject;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInClasspathTypeTest extends KotlinMetadataTestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0} target: {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+  }
+
+  public MetadataRewriteInClasspathTypeTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
+    super(targetVersion);
+    this.parameters = parameters;
+  }
+
+  private static final Map<KotlinTargetVersion, Path> baseLibJarMap = new HashMap<>();
+  private static final Map<KotlinTargetVersion, Path> extLibJarMap = new HashMap<>();
+
+  @BeforeClass
+  public static void createLibJar() throws Exception {
+    String baseLibFolder = PKG_PREFIX + "/classpath_lib_base";
+    String extLibFolder = PKG_PREFIX + "/classpath_lib_ext";
+    for (KotlinTargetVersion targetVersion : KotlinTargetVersion.values()) {
+      Path baseLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addSourceFiles(getKotlinFileInTest(baseLibFolder, "itf"))
+              .compile();
+      Path extLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addClasspathFiles(baseLibJar)
+              .addSourceFiles(getKotlinFileInTest(extLibFolder, "impl"))
+              .compile();
+      baseLibJarMap.put(targetVersion, baseLibJar);
+      extLibJarMap.put(targetVersion, extLibJar);
+    }
+  }
+
+  @Test
+  public void testMetadataInClasspathType_merged() throws Exception {
+    Path baseLibJar = baseLibJarMap.get(targetVersion);
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addClasspathFiles(baseLibJar)
+            .addProgramFiles(extLibJarMap.get(targetVersion))
+            // Keep the Extra class and its interface (which has the method).
+            .addKeepRules("-keep class **.Extra")
+            // Keep the ImplKt extension method which requires metadata
+            // to be called with Kotlin syntax from other kotlin code.
+            .addKeepRules("-keep class **.ImplKt { <methods>; }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectMerged)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(baseLibJar, libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/classpath_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), baseLibJar, libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".classpath_app.MainKt")
+        .assertSuccessWithOutputLines("Impl::foo");
+  }
+
+  private void inspectMerged(CodeInspector inspector) {
+    String implClassName = PKG + ".classpath_lib_ext.Impl";
+    String implKtClassName = PKG + ".classpath_lib_ext.ImplKt";
+    String extraClassName = PKG + ".classpath_lib_ext.Extra";
+
+    assertThat(inspector.clazz(implClassName), not(isPresent()));
+
+    ClassSubject implKt = inspector.clazz(implKtClassName);
+    assertThat(implKt, isPresent());
+    assertThat(implKt, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmPackageSubject kmPackage = implKt.getKmPackage();
+    assertThat(kmPackage, isPresent());
+
+    KmFunctionSubject kmFunction = kmPackage.kmFunctionExtensionWithUniqueName("fooExt");
+    assertThat(kmFunction, isPresent());
+
+    ClassSubject extra = inspector.clazz(extraClassName);
+    assertThat(extra, isPresent());
+    assertThat(extra, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = extra.getKmClass();
+    assertThat(kmClass, isPresent());
+    List<ClassSubject> superTypes = kmClass.getSuperTypes();
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("Impl")));
+    // Can't build ClassSubject with Itf in classpath. Instead, check if the reference to Itf is
+    // not altered via descriptors.
+    List<String> superTypeDescriptors = kmClass.getSuperTypeDescriptors();
+    assertTrue(superTypeDescriptors.stream().noneMatch(supertype -> supertype.contains("Impl")));
+    assertTrue(superTypeDescriptors.stream().anyMatch(supertype -> supertype.contains("Itf")));
+  }
+
+  @Test
+  public void testMetadataInClasspathType_renamed() throws Exception {
+    Path baseLibJar = baseLibJarMap.get(targetVersion);
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addClasspathFiles(baseLibJar)
+            .addProgramFiles(extLibJarMap.get(targetVersion))
+            // Keep the Extra class and its interface (which has the method).
+            .addKeepRules("-keep class **.Extra")
+            // Keep Super, but allow minification.
+            .addKeepRules("-keep,allowobfuscation class **.Impl")
+            // Keep the ImplKt extension method which requires metadata
+            // to be called with Kotlin syntax from other kotlin code.
+            .addKeepRules("-keep class **.ImplKt { <methods>; }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectRenamed)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(baseLibJar, libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/classpath_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), baseLibJar, libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".classpath_app.MainKt")
+        .assertSuccessWithOutputLines("Impl::foo");
+  }
+
+  private void inspectRenamed(CodeInspector inspector) {
+    String implClassName = PKG + ".classpath_lib_ext.Impl";
+    String implKtClassName = PKG + ".classpath_lib_ext.ImplKt";
+    String extraClassName = PKG + ".classpath_lib_ext.Extra";
+
+    ClassSubject impl = inspector.clazz(implClassName);
+    assertThat(impl, isRenamed());
+
+    ClassSubject implKt = inspector.clazz(implKtClassName);
+    assertThat(implKt, isPresent());
+    assertThat(implKt, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmPackageSubject kmPackage = implKt.getKmPackage();
+    assertThat(kmPackage, isPresent());
+
+    KmFunctionSubject kmFunction = kmPackage.kmFunctionExtensionWithUniqueName("fooExt");
+    assertThat(kmFunction, isExtensionFunction());
+
+    ClassSubject extra = inspector.clazz(extraClassName);
+    assertThat(extra, isPresent());
+    assertThat(extra, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = extra.getKmClass();
+    assertThat(kmClass, isPresent());
+    List<ClassSubject> superTypes = kmClass.getSuperTypes();
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("Impl")));
+    assertTrue(superTypes.stream().anyMatch(
+        supertype -> supertype.getFinalDescriptor().equals(impl.getFinalDescriptor())));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
new file mode 100644
index 0000000..5059a1e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
@@ -0,0 +1,131 @@
+// 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.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInCompanionTest extends KotlinMetadataTestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0} target: {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+  }
+
+  public MetadataRewriteInCompanionTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
+    super(targetVersion);
+    this.parameters = parameters;
+  }
+
+  private static Map<KotlinTargetVersion, Path> companionLibJarMap = new HashMap<>();
+
+  @BeforeClass
+  public static void createLibJar() throws Exception {
+    String companionLibFolder = PKG_PREFIX + "/companion_lib";
+    for (KotlinTargetVersion targetVersion : KotlinTargetVersion.values()) {
+      Path companionLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addSourceFiles(getKotlinFileInTest(companionLibFolder, "lib"))
+              .compile();
+      companionLibJarMap.put(targetVersion, companionLibJar);
+    }
+  }
+
+  @Test
+  public void testMetadataInCompanion_renamed() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(companionLibJarMap.get(targetVersion))
+            // Keep the B class and its interface (which has the doStuff method).
+            .addKeepRules("-keep class **.B")
+            .addKeepRules("-keep class **.I { <methods>; }")
+            // Keep getters for B$Companion.(singleton|foo) which will be referenced at the app.
+            .addKeepRules("-keepclassmembers class **.B$* { *** get*(...); }")
+            // No rule for Super, but will be kept and renamed.
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspect)
+            .writeToZip();
+
+    ProcessResult kotlinTestCompileResult =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/companion_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            // TODO(b/70169921): update to just .compile() once fixed.
+            .compileRaw();
+
+    // TODO(b/70169921): should be able to compile!
+    assertNotEquals(0, kotlinTestCompileResult.exitCode);
+    assertThat(kotlinTestCompileResult.stderr, containsString("unresolved reference: singleton"));
+    assertThat(kotlinTestCompileResult.stderr, containsString("unresolved reference: foo"));
+  }
+
+  private void inspect(CodeInspector inspector) {
+    final String superClassName = PKG + ".companion_lib.Super";
+    final String bClassName = PKG + ".companion_lib.B";
+    final String companionClassName = PKG + ".companion_lib.B$Companion";
+
+    ClassSubject sup = inspector.clazz(superClassName);
+    assertThat(sup, isRenamed());
+
+    ClassSubject impl = inspector.clazz(bClassName);
+    assertThat(impl, isPresent());
+    assertThat(impl, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = impl.getKmClass();
+    assertThat(kmClass, isPresent());
+    List<ClassSubject> superTypes = kmClass.getSuperTypes();
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("Super")));
+    assertTrue(superTypes.stream().anyMatch(
+        supertype -> supertype.getFinalDescriptor().equals(sup.getFinalDescriptor())));
+
+    // Bridge for the property in the companion that needs a backing field.
+    MethodSubject singletonBridge = impl.uniqueMethodWithName("access$getSingleton$cp");
+    assertThat(singletonBridge, isRenamed());
+
+    // For B$Companion.foo, no backing field needed, hence no bridge.
+    MethodSubject fooBridge = impl.uniqueMethodWithName("access$getFoo$cp");
+    assertThat(fooBridge, not(isPresent()));
+
+    ClassSubject companion = inspector.clazz(companionClassName);
+    assertThat(companion, isRenamed());
+
+    MethodSubject singletonGetter = companion.uniqueMethodWithName("getSingleton");
+    assertThat(singletonGetter, isPresent());
+
+    MethodSubject fooGetter = companion.uniqueMethodWithName("getFoo");
+    assertThat(fooGetter, isPresent());
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
new file mode 100644
index 0000000..917ede7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
@@ -0,0 +1,185 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
+import com.android.tools.r8.utils.codeinspector.KmFunctionSubject;
+import com.android.tools.r8.utils.codeinspector.KmPackageSubject;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInExtensionFunctionTest extends KotlinMetadataTestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0} target: {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+  }
+
+  public MetadataRewriteInExtensionFunctionTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
+    super(targetVersion);
+    this.parameters = parameters;
+  }
+
+  private static final Map<KotlinTargetVersion, Path> extLibJarMap = new HashMap<>();
+
+  @BeforeClass
+  public static void createLibJar() throws Exception {
+    String extLibFolder = PKG_PREFIX + "/extension_function_lib";
+    for (KotlinTargetVersion targetVersion : KotlinTargetVersion.values()) {
+      Path extLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addSourceFiles(getKotlinFileInTest(extLibFolder, "B"))
+              .compile();
+      extLibJarMap.put(targetVersion, extLibJar);
+    }
+  }
+
+  @Test
+  public void testMetadataInExtensionFunction_merged() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(extLibJarMap.get(targetVersion))
+            // Keep the B class and its interface (which has the doStuff method).
+            .addKeepRules("-keep class **.B")
+            .addKeepRules("-keep class **.I { <methods>; }")
+            // Keep the BKt extension function which requires metadata
+            // to be called with Kotlin syntax from other kotlin code.
+            .addKeepRules("-keep class **.BKt { <methods>; }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectMerged)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/extension_function_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".extension_function_app.MainKt")
+        .assertSuccessWithOutputLines("do stuff", "do stuff");
+  }
+
+  private void inspectMerged(CodeInspector inspector) {
+    String superClassName = PKG + ".extension_function_lib.Super";
+    String bClassName = PKG + ".extension_function_lib.B";
+    String bKtClassName = PKG + ".extension_function_lib.BKt";
+
+    assertThat(inspector.clazz(superClassName), not(isPresent()));
+
+    ClassSubject impl = inspector.clazz(bClassName);
+    assertThat(impl, isPresent());
+    assertThat(impl, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = impl.getKmClass();
+    assertThat(kmClass, isPresent());
+    List<ClassSubject> superTypes = kmClass.getSuperTypes();
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("Super")));
+
+    ClassSubject bKt = inspector.clazz(bKtClassName);
+    assertThat(bKt, isPresent());
+    assertThat(bKt, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmPackageSubject kmPackage = bKt.getKmPackage();
+    assertThat(kmPackage, isPresent());
+
+    KmFunctionSubject kmFunction = kmPackage.kmFunctionExtensionWithUniqueName("extension");
+    assertThat(kmFunction, isExtensionFunction());
+  }
+
+  @Test
+  public void testMetadataInExtensionFunction_renamed() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(extLibJarMap.get(targetVersion))
+            // Keep the B class and its interface (which has the doStuff method).
+            .addKeepRules("-keep class **.B")
+            .addKeepRules("-keep class **.I { <methods>; }")
+            // Keep Super, but allow minification.
+            .addKeepRules("-keep,allowobfuscation class **.Super")
+            // Keep the BKt extension function which requires metadata
+            // to be called with Kotlin syntax from other kotlin code.
+            .addKeepRules("-keep class **.BKt { <methods>; }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectRenamed)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/extension_function_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".extension_function_app.MainKt")
+        .assertSuccessWithOutputLines("do stuff", "do stuff");
+  }
+
+  private void inspectRenamed(CodeInspector inspector) {
+    String superClassName = PKG + ".extension_function_lib.Super";
+    String bClassName = PKG + ".extension_function_lib.B";
+    String bKtClassName = PKG + ".extension_function_lib.BKt";
+
+    ClassSubject sup = inspector.clazz(superClassName);
+    assertThat(sup, isPresent());
+    assertThat(sup, isRenamed());
+
+    ClassSubject impl = inspector.clazz(bClassName);
+    assertThat(impl, isPresent());
+    assertThat(impl, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = impl.getKmClass();
+    assertThat(kmClass, isPresent());
+    List<ClassSubject> superTypes = kmClass.getSuperTypes();
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("Super")));
+    assertTrue(superTypes.stream().anyMatch(
+        supertype -> supertype.getFinalDescriptor().equals(sup.getFinalDescriptor())));
+
+    ClassSubject bKt = inspector.clazz(bKtClassName);
+    assertThat(bKt, isPresent());
+    assertThat(bKt, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmPackageSubject kmPackage = bKt.getKmPackage();
+    assertThat(kmPackage, isPresent());
+
+    KmFunctionSubject kmFunction = kmPackage.kmFunctionExtensionWithUniqueName("extension");
+    assertThat(kmFunction, isExtensionFunction());
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java
new file mode 100644
index 0000000..5fb5150
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java
@@ -0,0 +1,192 @@
+// 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.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionProperty;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
+import com.android.tools.r8.utils.codeinspector.KmFunctionSubject;
+import com.android.tools.r8.utils.codeinspector.KmPackageSubject;
+import com.android.tools.r8.utils.codeinspector.KmPropertySubject;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInExtensionPropertyTest extends KotlinMetadataTestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0} target: {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+  }
+
+  public MetadataRewriteInExtensionPropertyTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
+    super(targetVersion);
+    this.parameters = parameters;
+  }
+
+  private static final Map<KotlinTargetVersion, Path> extLibJarMap = new HashMap<>();
+
+  @BeforeClass
+  public static void createLibJar() throws Exception {
+    String extLibFolder = PKG_PREFIX + "/extension_property_lib";
+    for (KotlinTargetVersion targetVersion : KotlinTargetVersion.values()) {
+      Path extLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addSourceFiles(getKotlinFileInTest(extLibFolder, "B"))
+              .compile();
+      extLibJarMap.put(targetVersion, extLibJar);
+    }
+  }
+
+  @Test
+  public void testMetadataInExtensionProperty_merged() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(extLibJarMap.get(targetVersion))
+            // Keep the B class and its interface (which has the doStuff method).
+            .addKeepRules("-keep class **.B")
+            .addKeepRules("-keep class **.I { <methods>; }")
+            // Keep the BKt extension property which requires metadata
+            // to be called with Kotlin syntax from other kotlin code.
+            .addKeepRules("-keep class **.BKt { <methods>; }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectMerged)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/extension_property_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".extension_property_app.MainKt")
+        .assertSuccessWithOutputLines("do stuff", "do stuff");
+  }
+
+  private void inspectMerged(CodeInspector inspector) {
+    String superClassName = PKG + ".extension_property_lib.Super";
+    String bClassName = PKG + ".extension_property_lib.B";
+    String bKtClassName = PKG + ".extension_property_lib.BKt";
+
+    assertThat(inspector.clazz(superClassName), not(isPresent()));
+
+    ClassSubject impl = inspector.clazz(bClassName);
+    assertThat(impl, isPresent());
+    assertThat(impl, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = impl.getKmClass();
+    assertThat(kmClass, isPresent());
+    List<ClassSubject> superTypes = kmClass.getSuperTypes();
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("Super")));
+    KmFunctionSubject kmFunction = kmClass.kmFunctionWithUniqueName("doStuff");
+    assertThat(kmFunction, isPresent());
+    assertThat(kmFunction, not(isExtensionFunction()));
+
+    ClassSubject bKt = inspector.clazz(bKtClassName);
+    assertThat(bKt, isPresent());
+    assertThat(bKt, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmPackageSubject kmPackage = bKt.getKmPackage();
+    assertThat(kmPackage, isPresent());
+
+    KmPropertySubject kmProperty = kmPackage.kmPropertyExtensionWithUniqueName("asI");
+    assertThat(kmProperty, isExtensionProperty());
+    assertNotNull(kmProperty.getterSignature());
+  }
+
+  @Test
+  public void testMetadataInExtensionProperty_renamed() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(extLibJarMap.get(targetVersion))
+            // Keep the B class and its interface (which has the doStuff method).
+            .addKeepRules("-keep class **.B")
+            .addKeepRules("-keep class **.I { <methods>; }")
+            // Keep Super, but allow minification.
+            .addKeepRules("-keep,allowobfuscation class **.Super")
+            // Keep the BKt extension property which requires metadata
+            // to be called with Kotlin syntax from other kotlin code.
+            .addKeepRules("-keep class **.BKt { <methods>; }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectRenamed)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/extension_property_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".extension_property_app.MainKt")
+        .assertSuccessWithOutputLines("do stuff", "do stuff");
+  }
+
+  private void inspectRenamed(CodeInspector inspector) {
+    String superClassName = PKG + ".extension_property_lib.Super";
+    String bClassName = PKG + ".extension_property_lib.B";
+    String bKtClassName = PKG + ".extension_property_lib.BKt";
+
+    ClassSubject sup = inspector.clazz(superClassName);
+    assertThat(sup, isRenamed());
+
+    ClassSubject impl = inspector.clazz(bClassName);
+    assertThat(impl, isPresent());
+    assertThat(impl, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = impl.getKmClass();
+    assertThat(kmClass, isPresent());
+    List<ClassSubject> superTypes = kmClass.getSuperTypes();
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("Super")));
+    assertTrue(superTypes.stream().anyMatch(
+        supertype -> supertype.getFinalDescriptor().equals(sup.getFinalDescriptor())));
+
+    ClassSubject bKt = inspector.clazz(bKtClassName);
+    assertThat(bKt, isPresent());
+    assertThat(bKt, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmPackageSubject kmPackage = bKt.getKmPackage();
+    assertThat(kmPackage, isPresent());
+
+    KmPropertySubject kmProperty = kmPackage.kmPropertyExtensionWithUniqueName("asI");
+    assertThat(kmProperty, isExtensionProperty());
+    assertNotNull(kmProperty.getterSignature());
+  }
+}
\ No newline at end of file
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
new file mode 100644
index 0000000..f6649b7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
@@ -0,0 +1,184 @@
+// 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.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
+import com.android.tools.r8.utils.codeinspector.KmFunctionSubject;
+import com.android.tools.r8.utils.codeinspector.KmPackageSubject;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInFunctionTest extends KotlinMetadataTestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0} target: {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+  }
+
+  public MetadataRewriteInFunctionTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
+    super(targetVersion);
+    this.parameters = parameters;
+  }
+
+  private static final Map<KotlinTargetVersion, Path> funLibJarMap = new HashMap<>();
+
+  @BeforeClass
+  public static void createLibJar() throws Exception {
+    String funLibFolder = PKG_PREFIX + "/function_lib";
+    for (KotlinTargetVersion targetVersion : KotlinTargetVersion.values()) {
+      Path funLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addSourceFiles(getKotlinFileInTest(funLibFolder, "B"))
+              .compile();
+      funLibJarMap.put(targetVersion, funLibJar);
+    }
+  }
+
+  @Test
+  public void testMetadataInFunction_merged() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(funLibJarMap.get(targetVersion))
+            // Keep the B class and its interface (which has the doStuff method).
+            .addKeepRules("-keep class **.B")
+            .addKeepRules("-keep class **.I { <methods>; }")
+            // Keep the BKt method, which will be called from other kotlin code.
+            .addKeepRules("-keep class **.BKt { <methods>; }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectMerged)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/function_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".function_app.MainKt")
+        .assertSuccessWithOutputLines("do stuff", "do stuff");
+  }
+
+  private void inspectMerged(CodeInspector inspector) {
+    String superClassName = PKG + ".function_lib.Super";
+    String bClassName = PKG + ".function_lib.B";
+    String bKtClassName = PKG + ".function_lib.BKt";
+
+    assertThat(inspector.clazz(superClassName), not(isPresent()));
+
+    ClassSubject impl = inspector.clazz(bClassName);
+    assertThat(impl, isPresent());
+    assertThat(impl, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = impl.getKmClass();
+    assertThat(kmClass, isPresent());
+    List<ClassSubject> superTypes = kmClass.getSuperTypes();
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("Super")));
+
+    ClassSubject bKt = inspector.clazz(bKtClassName);
+    assertThat(bKt, isPresent());
+    assertThat(bKt, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmPackageSubject kmPackage = bKt.getKmPackage();
+    assertThat(kmPackage, isPresent());
+
+    KmFunctionSubject kmFunction = kmPackage.kmFunctionWithUniqueName("fun");
+    assertThat(kmFunction, isPresent());
+    assertThat(kmFunction, not(isExtensionFunction()));
+  }
+
+  @Test
+  public void testMetadataInFunction_renamed() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(funLibJarMap.get(targetVersion))
+            // Keep the B class and its interface (which has the doStuff method).
+            .addKeepRules("-keep class **.B")
+            .addKeepRules("-keep class **.I { <methods>; }")
+            // Keep Super, but allow minification.
+            .addKeepRules("-keep,allowobfuscation class **.Super")
+            // Keep the BKt method, which will be called from other kotlin code.
+            .addKeepRules("-keep class **.BKt { <methods>; }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectRenamed)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/function_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".function_app.MainKt")
+        .assertSuccessWithOutputLines("do stuff", "do stuff");
+  }
+
+  private void inspectRenamed(CodeInspector inspector) {
+    String superClassName = PKG + ".function_lib.Super";
+    String bClassName = PKG + ".function_lib.B";
+    String bKtClassName = PKG + ".function_lib.BKt";
+
+    ClassSubject sup = inspector.clazz(superClassName);
+    assertThat(sup, isRenamed());
+
+    ClassSubject impl = inspector.clazz(bClassName);
+    assertThat(impl, isPresent());
+    assertThat(impl, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = impl.getKmClass();
+    assertThat(kmClass, isPresent());
+    List<ClassSubject> superTypes = kmClass.getSuperTypes();
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("Super")));
+    assertTrue(superTypes.stream().anyMatch(
+        supertype -> supertype.getFinalDescriptor().equals(sup.getFinalDescriptor())));
+
+    ClassSubject bKt = inspector.clazz(bKtClassName);
+    assertThat(bKt, isPresent());
+    assertThat(bKt, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmPackageSubject kmPackage = bKt.getKmPackage();
+    assertThat(kmPackage, isPresent());
+
+    KmFunctionSubject kmFunction = kmPackage.kmFunctionWithUniqueName("fun");
+    assertThat(kmFunction, isPresent());
+    assertThat(kmFunction, not(isExtensionFunction()));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInLibraryTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInLibraryTypeTest.java
new file mode 100644
index 0000000..ba6b08f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInLibraryTypeTest.java
@@ -0,0 +1,124 @@
+// 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.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.KmPackageSubject;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInLibraryTypeTest extends KotlinMetadataTestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0} target: {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+  }
+
+  public MetadataRewriteInLibraryTypeTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
+    super(targetVersion);
+    this.parameters = parameters;
+  }
+
+  private static final Map<KotlinTargetVersion, Path> baseLibJarMap = new HashMap<>();
+  private static final Map<KotlinTargetVersion, Path> extLibJarMap = new HashMap<>();
+  private static final Map<KotlinTargetVersion, Path> appJarMap = new HashMap<>();
+
+  @BeforeClass
+  public static void createLibJar() throws Exception {
+    String baseLibFolder = PKG_PREFIX + "/libtype_lib_base";
+    String extLibFolder = PKG_PREFIX + "/libtype_lib_ext";
+    String appFolder = PKG_PREFIX + "/libtype_app";
+    for (KotlinTargetVersion targetVersion : KotlinTargetVersion.values()) {
+      Path baseLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addSourceFiles(getKotlinFileInTest(baseLibFolder, "base"))
+              .compile();
+      Path extLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addClasspathFiles(baseLibJar)
+              .addSourceFiles(getKotlinFileInTest(extLibFolder, "ext"))
+              .compile();
+      Path appJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addClasspathFiles(baseLibJar)
+              .addClasspathFiles(extLibJar)
+              .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
+              .compile();
+      baseLibJarMap.put(targetVersion, baseLibJar);
+      extLibJarMap.put(targetVersion, extLibJar);
+      appJarMap.put(targetVersion, appJar);
+    }
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    String main = PKG + ".libtype_app.MainKt";
+    Path out =
+        testForR8(parameters.getBackend())
+            // Intentionally not providing basLibJar as lib file nor classpath file.
+            .addProgramFiles(extLibJarMap.get(targetVersion), appJarMap.get(targetVersion))
+            // Keep Ext extension method which requires metadata to be called with Kotlin syntax
+            // from other kotlin code.
+            .addKeepRules("-keep class **.ExtKt { <methods>; }")
+            // Keep the main entry.
+            .addKeepMainRule(main)
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .allowDiagnosticWarningMessages()
+            // -dontoptimize so that basic code structure is kept.
+            .noOptimization()
+            .compile()
+            .inspect(this::inspect)
+            .assertAllWarningMessagesMatch(
+                anyOf(
+                    equalTo("Resource 'META-INF/MANIFEST.MF' already exists."),
+                    equalTo("Resource 'META-INF/main.kotlin_module' already exists.")))
+            .writeToZip();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), baseLibJarMap.get(targetVersion))
+        .addClasspath(out)
+        .run(parameters.getRuntime(), main)
+        .assertSuccessWithOutputLines("Sub::foo", "Sub::boo", "true");
+  }
+
+  private void inspect(CodeInspector inspector) {
+    String extClassName = PKG + ".libtype_lib_ext.ExtKt";
+    ClassSubject ext = inspector.clazz(extClassName);
+    assertThat(ext, isPresent());
+    assertThat(ext, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmPackageSubject kmPackage = ext.getKmPackage();
+    assertThat(kmPackage, isPresent());
+    // Type appearance of library type, Base, should be kept, even if it's not provided.
+    // Note that the resulting ClassSubject for Base is an absent one as we don't provide it, and
+    // thus we can't use `getReturnTypesInFunctions`, which filters out absent class subject.
+    assertTrue(kmPackage.getReturnTypeDescriptorsInFunctions().stream().anyMatch(
+        returnType -> returnType.contains("Base")));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java
new file mode 100644
index 0000000..2dc57bf
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java
@@ -0,0 +1,177 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertNotEquals;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.AnnotationSubject;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInMultifileClassTest extends KotlinMetadataTestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0} target: {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+  }
+
+  public MetadataRewriteInMultifileClassTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
+    super(targetVersion);
+    this.parameters = parameters;
+  }
+
+  private static final Map<KotlinTargetVersion, Path> multifileLibJarMap = new HashMap<>();
+
+  @BeforeClass
+  public static void createLibJar() throws Exception {
+    String multifileLibFolder = PKG_PREFIX + "/multifileclass_lib";
+    for (KotlinTargetVersion targetVersion : KotlinTargetVersion.values()) {
+      Path multifileLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addSourceFiles(
+                  getKotlinFileInTest(multifileLibFolder, "signed"),
+                  getKotlinFileInTest(multifileLibFolder, "unsigned"))
+              .compile();
+      multifileLibJarMap.put(targetVersion, multifileLibJar);
+    }
+  }
+
+  @Test
+  public void testMetadataInMultifileClass_merged() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(multifileLibJarMap.get(targetVersion))
+            // Keep UtilKt#comma*Join*(). Let R8 optimize (inline) others, such as joinOf*(String).
+            .addKeepRules("-keep class **.UtilKt")
+            .addKeepRules("-keepclassmembers class * { ** comma*Join*(...); }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectMerged)
+            .writeToZip();
+
+    ProcessResult kotlinTestCompileResult =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/multifileclass_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            // TODO(b/70169921): update to just .compile() once fixed.
+            .compileRaw();
+    // TODO(b/70169921): should be able to compile!
+    assertNotEquals(0, kotlinTestCompileResult.exitCode);
+    assertThat(kotlinTestCompileResult.stderr, containsString("unresolved reference: join"));
+  }
+
+  private void inspectMerged(CodeInspector inspector) {
+    String utilClassName = PKG + ".multifileclass_lib.UtilKt";
+    String signedClassName = PKG + ".multifileclass_lib.UtilKt__SignedKt";
+
+    ClassSubject util = inspector.clazz(utilClassName);
+    assertThat(util, isPresent());
+    assertThat(util, not(isRenamed()));
+    MethodSubject commaJoinOfInt = util.uniqueMethodWithName("commaSeparatedJoinOfInt");
+    assertThat(commaJoinOfInt, isPresent());
+    assertThat(commaJoinOfInt, not(isRenamed()));
+    MethodSubject joinOfInt = util.uniqueMethodWithName("joinOfInt");
+    assertThat(joinOfInt, not(isPresent()));
+    // API entry is kept, hence the presence of Metadata.
+    AnnotationSubject annotationSubject = util.annotation(METADATA_TYPE);
+    assertThat(annotationSubject, isPresent());
+    // TODO(b/70169921): need further inspection.
+
+    ClassSubject signed = inspector.clazz(signedClassName);
+    assertThat(signed, isRenamed());
+    commaJoinOfInt = signed.uniqueMethodWithName("commaSeparatedJoinOfInt");
+    assertThat(commaJoinOfInt, isPresent());
+    assertThat(commaJoinOfInt, not(isRenamed()));
+    joinOfInt = signed.uniqueMethodWithName("joinOfInt");
+    assertThat(joinOfInt, isRenamed());
+    // API entry is kept, hence the presence of Metadata.
+    annotationSubject = util.annotation(METADATA_TYPE);
+    assertThat(annotationSubject, isPresent());
+    // TODO(b/70169921): need further inspection.
+  }
+
+  @Test
+  public void testMetadataInMultifileClass_renamed() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(multifileLibJarMap.get(targetVersion))
+            // Keep UtilKt#comma*Join*().
+            .addKeepRules("-keep class **.UtilKt")
+            .addKeepRules("-keepclassmembers class * { ** comma*Join*(...); }")
+            // Keep yet rename joinOf*(String).
+            .addKeepRules(
+                "-keepclassmembers,allowobfuscation class * { ** joinOf*(...); }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectRenamed)
+            .writeToZip();
+
+    ProcessResult kotlinTestCompileResult =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/multifileclass_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            // TODO(b/70169921): update to just .compile() once fixed.
+            .compileRaw();
+    // TODO(b/70169921): should be able to compile!
+    assertNotEquals(0, kotlinTestCompileResult.exitCode);
+    assertThat(kotlinTestCompileResult.stderr, containsString("unresolved reference: join"));
+  }
+
+  private void inspectRenamed(CodeInspector inspector) {
+    String utilClassName = PKG + ".multifileclass_lib.UtilKt";
+    String signedClassName = PKG + ".multifileclass_lib.UtilKt__SignedKt";
+
+    ClassSubject util = inspector.clazz(utilClassName);
+    assertThat(util, isPresent());
+    assertThat(util, not(isRenamed()));
+    MethodSubject commaJoinOfInt = util.uniqueMethodWithName("commaSeparatedJoinOfInt");
+    assertThat(commaJoinOfInt, isPresent());
+    assertThat(commaJoinOfInt, not(isRenamed()));
+    MethodSubject joinOfInt = util.uniqueMethodWithName("joinOfInt");
+    assertThat(joinOfInt, isPresent());
+    assertThat(joinOfInt, isRenamed());
+    // API entry is kept, hence the presence of Metadata.
+    AnnotationSubject annotationSubject = util.annotation(METADATA_TYPE);
+    assertThat(annotationSubject, isPresent());
+    // TODO(b/70169921): need further inspection.
+
+    ClassSubject signed = inspector.clazz(signedClassName);
+    assertThat(signed, isRenamed());
+    commaJoinOfInt = signed.uniqueMethodWithName("commaSeparatedJoinOfInt");
+    assertThat(commaJoinOfInt, isPresent());
+    assertThat(commaJoinOfInt, not(isRenamed()));
+    joinOfInt = signed.uniqueMethodWithName("joinOfInt");
+    assertThat(joinOfInt, isRenamed());
+    // API entry is kept, hence the presence of Metadata.
+    annotationSubject = util.annotation(METADATA_TYPE);
+    assertThat(annotationSubject, isPresent());
+    // TODO(b/70169921): need further inspection.
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java
new file mode 100644
index 0000000..6dcbc1a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java
@@ -0,0 +1,111 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInParameterTypeTest extends KotlinMetadataTestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0} target: {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+  }
+
+  public MetadataRewriteInParameterTypeTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
+    super(targetVersion);
+    this.parameters = parameters;
+  }
+
+  private static final Map<KotlinTargetVersion, Path> parameterTypeLibJarMap = new HashMap<>();
+
+  @BeforeClass
+  public static void createLibJar() throws Exception {
+    String parameterTypeLibFolder = PKG_PREFIX + "/parametertype_lib";
+    for (KotlinTargetVersion targetVersion : KotlinTargetVersion.values()) {
+      Path parameterTypeLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addSourceFiles(getKotlinFileInTest(parameterTypeLibFolder, "lib"))
+              .compile();
+      parameterTypeLibJarMap.put(targetVersion, parameterTypeLibJar);
+    }
+  }
+
+  @Test
+  public void testMetadataInParameterType_renamed() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(parameterTypeLibJarMap.get(targetVersion))
+            // Keep non-private members of Impl
+            .addKeepRules("-keep public class **.Impl { !private *; }")
+            // Keep Itf, but allow minification.
+            .addKeepRules("-keep,allowobfuscation class **.Itf")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspect)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/parametertype_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".parametertype_app.MainKt")
+        .assertSuccessWithOutputLines("Impl::bar", "Program::bar");
+  }
+
+  private void inspect(CodeInspector inspector) {
+    String itfClassName = PKG + ".parametertype_lib.Itf";
+    String implClassName = PKG + ".parametertype_lib.Impl";
+
+    ClassSubject itf = inspector.clazz(itfClassName);
+    assertThat(itf, isRenamed());
+
+    ClassSubject impl = inspector.clazz(implClassName);
+    assertThat(impl, isPresent());
+    assertThat(impl, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = impl.getKmClass();
+    assertThat(kmClass, isPresent());
+    List<ClassSubject> superTypes = kmClass.getSuperTypes();
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("Itf")));
+    assertTrue(superTypes.stream().anyMatch(
+        supertype -> supertype.getFinalDescriptor().equals(itf.getFinalDescriptor())));
+    List<ClassSubject> parameterTypes = kmClass.getParameterTypesInFunctions();
+    assertTrue(parameterTypes.stream().anyMatch(
+        parameterType -> parameterType.getFinalDescriptor().equals(itf.getFinalDescriptor())));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
new file mode 100644
index 0000000..d8b230d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
@@ -0,0 +1,183 @@
+// 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.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionProperty;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
+import com.android.tools.r8.utils.codeinspector.KmPropertySubject;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInPropertyTest extends KotlinMetadataTestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0} target: {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+  }
+
+  public MetadataRewriteInPropertyTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
+    super(targetVersion);
+    this.parameters = parameters;
+  }
+
+  private static final Map<KotlinTargetVersion, Path> propertyTypeLibJarMap = new HashMap<>();
+
+  @BeforeClass
+  public static void createLibJar() throws Exception {
+    String propertyTypeLibFolder = PKG_PREFIX + "/fragile_property_lib";
+    for (KotlinTargetVersion targetVersion : KotlinTargetVersion.values()) {
+      Path propertyTypeLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addSourceFiles(getKotlinFileInTest(propertyTypeLibFolder, "lib"))
+              .compile();
+      propertyTypeLibJarMap.put(targetVersion, propertyTypeLibJar);
+    }
+  }
+
+  @Test
+  public void testMetadataInProperty_getterOnly() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(propertyTypeLibJarMap.get(targetVersion))
+            // Keep property getters
+            .addKeepRules("-keep class **.Person { <init>(...); }")
+            .addKeepRules("-keepclassmembers class **.Person { *** get*(); }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectGetterOnly)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(
+                getKotlinFileInTest(PKG_PREFIX + "/fragile_property_only_getter", "getter_user"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".fragile_property_only_getter.Getter_userKt")
+        .assertSuccessWithOutputLines("true", "false", "Hey");
+  }
+
+  private void inspectGetterOnly(CodeInspector inspector) {
+    String personClassName = PKG + ".fragile_property_lib.Person";
+    ClassSubject person = inspector.clazz(personClassName);
+    assertThat(person, isPresent());
+    assertThat(person, not(isRenamed()));
+
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = person.getKmClass();
+    assertThat(kmClass, isPresent());
+
+    KmPropertySubject name = kmClass.kmPropertyWithUniqueName("name");
+    assertThat(name, isPresent());
+    assertThat(name, not(isExtensionProperty()));
+    assertNotNull(name.fieldSignature());
+    assertNotNull(name.getterSignature());
+    assertNull(name.setterSignature());
+
+    KmPropertySubject familyName = kmClass.kmPropertyWithUniqueName("familyName");
+    assertThat(familyName, isPresent());
+    assertThat(familyName, not(isExtensionProperty()));
+    // No backing field for property `familyName`
+    assertNull(familyName.fieldSignature());
+    assertNotNull(familyName.getterSignature());
+    // No setter for property `familyName`
+    assertNull(familyName.setterSignature());
+
+    KmPropertySubject age = kmClass.kmPropertyWithUniqueName("age");
+    assertThat(age, isPresent());
+    assertThat(age, not(isExtensionProperty()));
+    assertNotNull(age.fieldSignature());
+    assertNotNull(age.getterSignature());
+    assertNull(name.setterSignature());
+  }
+
+  @Test
+  public void testMetadataInProperty_setterOnly() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(propertyTypeLibJarMap.get(targetVersion))
+            // Keep property setters (and users)
+            .addKeepRules("-keep class **.Person { <init>(...); }")
+            .addKeepRules("-keepclassmembers class **.Person { void set*(...); }")
+            .addKeepRules("-keepclassmembers class **.Person { void aging(); }")
+            .addKeepRules("-keepclassmembers class **.Person { void change*(...); }")
+            // Keep LibKt extension methods
+            .addKeepRules("-keep class **.LibKt { <methods>; }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectSetterOnly)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(
+                getKotlinFileInTest(PKG_PREFIX + "/fragile_property_only_setter", "setter_user"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".fragile_property_only_setter.Setter_userKt")
+        .assertSuccessWithOutputLines();
+  }
+
+  private void inspectSetterOnly(CodeInspector inspector) {
+    String personClassName = PKG + ".fragile_property_lib.Person";
+    ClassSubject person = inspector.clazz(personClassName);
+    assertThat(person, isPresent());
+    assertThat(person, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = person.getKmClass();
+    assertThat(kmClass, isPresent());
+
+    KmPropertySubject name = kmClass.kmPropertyWithUniqueName("name");
+    assertThat(name, isPresent());
+    assertThat(name, not(isExtensionProperty()));
+    assertNull(name.fieldSignature());
+    assertNull(name.getterSignature());
+    assertNotNull(name.setterSignature());
+
+    KmPropertySubject familyName = kmClass.kmPropertyWithUniqueName("familyName");
+    assertThat(familyName, not(isPresent()));
+
+    KmPropertySubject age = kmClass.kmPropertyWithUniqueName("age");
+    assertThat(age, isPresent());
+    assertThat(age, not(isExtensionProperty()));
+    assertNotNull(age.fieldSignature());
+    assertNull(age.getterSignature());
+    assertNotNull(age.setterSignature());
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java
new file mode 100644
index 0000000..8aba4f7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java
@@ -0,0 +1,109 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInPropertyTypeTest extends KotlinMetadataTestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0} target: {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+  }
+
+  public MetadataRewriteInPropertyTypeTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
+    super(targetVersion);
+    this.parameters = parameters;
+  }
+
+  private static final Map<KotlinTargetVersion, Path> propertyTypeLibJarMap = new HashMap<>();
+
+  @BeforeClass
+  public static void createLibJar() throws Exception {
+    String propertyTypeLibFolder = PKG_PREFIX + "/propertytype_lib";
+    for (KotlinTargetVersion targetVersion : KotlinTargetVersion.values()) {
+      Path propertyTypeLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addSourceFiles(getKotlinFileInTest(propertyTypeLibFolder, "lib"))
+              .compile();
+      propertyTypeLibJarMap.put(targetVersion, propertyTypeLibJar);
+    }
+  }
+
+  @Test
+  public void testMetadataInProperty_renamed() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(propertyTypeLibJarMap.get(targetVersion))
+            // Keep non-private members of Impl
+            .addKeepRules("-keep public class **.Impl { !private *; }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspect)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/propertytype_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".propertytype_app.MainKt")
+        .assertSuccessWithOutputLines("Impl::8");
+  }
+
+  private void inspect(CodeInspector inspector) {
+    String itfClassName = PKG + ".propertytype_lib.Itf";
+    String implClassName = PKG + ".propertytype_lib.Impl";
+
+    ClassSubject itf = inspector.clazz(itfClassName);
+    assertThat(itf, isRenamed());
+
+    ClassSubject impl = inspector.clazz(implClassName);
+    assertThat(impl, isPresent());
+    assertThat(impl, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = impl.getKmClass();
+    assertThat(kmClass, isPresent());
+    List<ClassSubject> superTypes = kmClass.getSuperTypes();
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("Itf")));
+    assertTrue(superTypes.stream().anyMatch(
+        supertype -> supertype.getFinalDescriptor().equals(itf.getFinalDescriptor())));
+    List<ClassSubject> propertyReturnTypes = kmClass.getReturnTypesInProperties();
+    assertTrue(propertyReturnTypes.stream().anyMatch(
+        propertyType -> propertyType.getFinalDescriptor().equals(itf.getFinalDescriptor())));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java
new file mode 100644
index 0000000..1e33e7c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java
@@ -0,0 +1,111 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInReturnTypeTest extends KotlinMetadataTestBase {
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0} target: {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+  }
+
+  public MetadataRewriteInReturnTypeTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
+    super(targetVersion);
+    this.parameters = parameters;
+  }
+
+  private static final Map<KotlinTargetVersion, Path> returnTypeLibJarMap = new HashMap<>();
+
+  @BeforeClass
+  public static void createLibJar() throws Exception {
+    String returnTypeLibFolder = PKG_PREFIX + "/returntype_lib";
+    for (KotlinTargetVersion targetVersion : KotlinTargetVersion.values()) {
+      Path returnTypeLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addSourceFiles(getKotlinFileInTest(returnTypeLibFolder, "lib"))
+              .compile();
+      returnTypeLibJarMap.put(targetVersion, returnTypeLibJar);
+    }
+  }
+
+  @Test
+  public void testMetadataInReturnType_renamed() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(returnTypeLibJarMap.get(targetVersion))
+            // Keep non-private members of Impl
+            .addKeepRules("-keep public class **.Impl { !private *; }")
+            // Keep Itf, but allow minification.
+            .addKeepRules("-keep,allowobfuscation class **.Itf")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspect)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/returntype_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".returntype_app.MainKt")
+        .assertSuccessWithOutputLines("Impl::foo", "Program::foo", "true");
+  }
+
+  private void inspect(CodeInspector inspector) {
+    String itfClassName = PKG + ".returntype_lib.Itf";
+    String implClassName = PKG + ".returntype_lib.Impl";
+
+    ClassSubject itf = inspector.clazz(itfClassName);
+    assertThat(itf, isRenamed());
+
+    ClassSubject impl = inspector.clazz(implClassName);
+    assertThat(impl, isPresent());
+    assertThat(impl, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = impl.getKmClass();
+    assertThat(kmClass, isPresent());
+    List<ClassSubject> superTypes = kmClass.getSuperTypes();
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("Itf")));
+    assertTrue(superTypes.stream().anyMatch(
+        supertype -> supertype.getFinalDescriptor().equals(itf.getFinalDescriptor())));
+    List<ClassSubject> functionReturnTypes = kmClass.getReturnTypesInFunctions();
+    assertTrue(functionReturnTypes.stream().anyMatch(
+        returnType -> returnType.getFinalDescriptor().equals(itf.getFinalDescriptor())));
+  }
+}
+
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassTest.java
new file mode 100644
index 0000000..6cd1034
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassTest.java
@@ -0,0 +1,188 @@
+// 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.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static com.android.tools.r8.utils.DescriptorUtils.descriptorToJavaType;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
+import com.android.tools.r8.utils.codeinspector.KmFunctionSubject;
+import com.android.tools.r8.utils.codeinspector.KmPackageSubject;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInSealedClassTest extends KotlinMetadataTestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0} target: {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+  }
+
+  public MetadataRewriteInSealedClassTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
+    super(targetVersion);
+    this.parameters = parameters;
+  }
+
+  private static final Map<KotlinTargetVersion, Path> sealedLibJarMap = new HashMap<>();
+
+  @BeforeClass
+  public static void createLibJar() throws Exception {
+    String sealedLibFolder = PKG_PREFIX + "/sealed_lib";
+    for (KotlinTargetVersion targetVersion : KotlinTargetVersion.values()) {
+      Path sealedLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addSourceFiles(getKotlinFileInTest(sealedLibFolder, "lib"))
+              .compile();
+      sealedLibJarMap.put(targetVersion, sealedLibJar);
+    }
+  }
+
+  @Test
+  public void testMetadataInSealedClass_valid() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(sealedLibJarMap.get(targetVersion))
+            // Keep the Expr class
+            .addKeepRules("-keep class **.Expr")
+            // Keep the extension function
+            .addKeepRules("-keep class **.LibKt { <methods>; }")
+            // Keep the factory object and utils
+            .addKeepRules("-keep class **.ExprFactory { *; }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectValid)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/sealed_app", "valid"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".sealed_app.ValidKt")
+        .assertSuccessWithOutputLines("6");
+  }
+
+  private void inspectValid(CodeInspector inspector) {
+    String numClassName = PKG + ".sealed_lib.Num";
+    String exprClassName = PKG + ".sealed_lib.Expr";
+    String libClassName = PKG + ".sealed_lib.LibKt";
+
+    ClassSubject num = inspector.clazz(numClassName);
+    assertThat(num, isRenamed());
+
+    ClassSubject expr = inspector.clazz(exprClassName);
+    assertThat(expr, isPresent());
+    assertThat(expr, not(isRenamed()));
+
+    KmClassSubject kmClass = expr.getKmClass();
+    assertThat(kmClass, isPresent());
+
+    kmClass.getSealedSubclassDescriptors().forEach(sealedSubclassDescriptor -> {
+      ClassSubject sealedSubclass =
+          inspector.clazz(descriptorToJavaType(sealedSubclassDescriptor));
+      assertThat(sealedSubclass, isRenamed());
+      assertEquals(sealedSubclassDescriptor, sealedSubclass.getFinalDescriptor());
+    });
+
+    ClassSubject libKt = inspector.clazz(libClassName);
+    assertThat(expr, isPresent());
+    assertThat(expr, not(isRenamed()));
+
+    KmPackageSubject kmPackage = libKt.getKmPackage();
+    assertThat(kmPackage, isPresent());
+
+    KmFunctionSubject eval = kmPackage.kmFunctionExtensionWithUniqueName("eval");
+    assertThat(eval, isPresent());
+    assertThat(eval, isExtensionFunction());
+  }
+
+  @Test
+  public void testMetadataInSealedClass_invalid() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(sealedLibJarMap.get(targetVersion))
+            // Keep the Expr class
+            .addKeepRules("-keep class **.Expr")
+            // Keep the extension function
+            .addKeepRules("-keep class **.LibKt { <methods>; }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectInvalid)
+            .writeToZip();
+
+    ProcessResult kotlinTestCompileResult =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/sealed_app", "invalid"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compileRaw();
+
+    assertNotEquals(0, kotlinTestCompileResult.exitCode);
+    assertThat(kotlinTestCompileResult.stderr, containsString("cannot access"));
+    assertThat(kotlinTestCompileResult.stderr, containsString("private in 'Expr'"));
+  }
+
+  private void inspectInvalid(CodeInspector inspector) {
+    String exprClassName = PKG + ".sealed_lib.Expr";
+    String numClassName = PKG + ".sealed_lib.Num";
+    String libClassName = PKG + ".sealed_lib.LibKt";
+
+    // Without any specific keep rule and no instantiation point, it's not necessary to keep
+    // sub classes of Expr.
+    ClassSubject num = inspector.clazz(numClassName);
+    assertThat(num, not(isPresent()));
+
+    ClassSubject expr = inspector.clazz(exprClassName);
+    assertThat(expr, isPresent());
+    assertThat(expr, not(isRenamed()));
+
+    KmClassSubject kmClass = expr.getKmClass();
+    assertThat(kmClass, isPresent());
+
+    assertTrue(kmClass.getSealedSubclassDescriptors().isEmpty());
+
+    ClassSubject libKt = inspector.clazz(libClassName);
+    assertThat(expr, isPresent());
+    assertThat(expr, not(isRenamed()));
+
+    KmPackageSubject kmPackage = libKt.getKmPackage();
+    assertThat(kmPackage, isPresent());
+
+    KmFunctionSubject eval = kmPackage.kmFunctionExtensionWithUniqueName("eval");
+    assertThat(eval, isPresent());
+    assertThat(eval, isExtensionFunction());
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSuperTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSuperTypeTest.java
new file mode 100644
index 0000000..ba59f4b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSuperTypeTest.java
@@ -0,0 +1,157 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInSuperTypeTest extends KotlinMetadataTestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0} target: {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+  }
+
+  public MetadataRewriteInSuperTypeTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
+    super(targetVersion);
+    this.parameters = parameters;
+  }
+
+  private static final Map<KotlinTargetVersion, Path> superTypeLibJarMap = new HashMap<>();
+
+  @BeforeClass
+  public static void createLibJar() throws Exception {
+    String superTypeLibFolder = PKG_PREFIX + "/supertype_lib";
+    for (KotlinTargetVersion targetVersion : KotlinTargetVersion.values()) {
+      Path superTypeLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addSourceFiles(
+                  getKotlinFileInTest(superTypeLibFolder, "impl"),
+                  getKotlinFileInTest(superTypeLibFolder + "/internal", "itf"))
+              .compile();
+      superTypeLibJarMap.put(targetVersion, superTypeLibJar);
+    }
+  }
+
+  @Test
+  public void testMetadataInSupertype_merged() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(superTypeLibJarMap.get(targetVersion))
+            // Keep non-private members except for ones in `internal` definitions.
+            .addKeepRules("-keep public class !**.internal.**, * { !private *; }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectMerged)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/supertype_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".supertype_app.MainKt")
+        .assertSuccessWithOutputLines("Impl::foo", "Program::foo");
+  }
+
+  private void inspectMerged(CodeInspector inspector) {
+    String itfClassName = PKG + ".supertype_lib.internal.Itf";
+    String implClassName = PKG + ".supertype_lib.Impl";
+
+    assertThat(inspector.clazz(itfClassName), not(isPresent()));
+
+    ClassSubject impl = inspector.clazz(implClassName);
+    assertThat(impl, isPresent());
+    assertThat(impl, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = impl.getKmClass();
+    assertThat(kmClass, isPresent());
+    List<ClassSubject> superTypes = kmClass.getSuperTypes();
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("internal")));
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("Itf")));
+  }
+
+  @Test
+  public void testMetadataInSupertype_renamed() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(superTypeLibJarMap.get(targetVersion))
+            // Keep non-private members except for ones in `internal` definitions.
+            .addKeepRules("-keep public class !**.internal.**, * { !private *; }")
+            // Keep `internal` definitions, but allow minification.
+            .addKeepRules("-keep,allowobfuscation class **.internal.** { *; }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspectRenamed)
+            .writeToZip();
+
+    Path output =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/supertype_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            .compile();
+
+    testForJvm()
+        .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
+        .addClasspath(output)
+        .run(parameters.getRuntime(), PKG + ".supertype_app.MainKt")
+        .assertSuccessWithOutputLines("Impl::foo", "Program::foo");
+  }
+
+  private void inspectRenamed(CodeInspector inspector) {
+    String itfClassName = PKG + ".supertype_lib.internal.Itf";
+    String implClassName = PKG + ".supertype_lib.Impl";
+
+    ClassSubject itf = inspector.clazz(itfClassName);
+    assertThat(itf, isRenamed());
+
+    ClassSubject impl = inspector.clazz(implClassName);
+    assertThat(impl, isPresent());
+    assertThat(impl, not(isRenamed()));
+    // API entry is kept, hence the presence of Metadata.
+    KmClassSubject kmClass = impl.getKmClass();
+    assertThat(kmClass, isPresent());
+    List<ClassSubject> superTypes = kmClass.getSuperTypes();
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("internal")));
+    assertTrue(superTypes.stream().noneMatch(
+        supertype -> supertype.getFinalDescriptor().contains("Itf")));
+    assertTrue(superTypes.stream().anyMatch(
+        supertype -> supertype.getFinalDescriptor().equals(itf.getFinalDescriptor())));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
new file mode 100644
index 0000000..8b9f276
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
@@ -0,0 +1,112 @@
+// 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.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertNotEquals;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.KmPackageSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRewriteInTypeAliasTest extends KotlinMetadataTestBase {
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0} target: {1}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+  }
+
+  public MetadataRewriteInTypeAliasTest(
+      TestParameters parameters, KotlinTargetVersion targetVersion) {
+    super(targetVersion);
+    this.parameters = parameters;
+  }
+
+  private static final Map<KotlinTargetVersion, Path> typeAliasLibJarMap = new HashMap<>();
+
+  @BeforeClass
+  public static void createLibJar() throws Exception {
+    String typeAliasLibFolder = PKG_PREFIX + "/typealias_lib";
+    for (KotlinTargetVersion targetVersion : KotlinTargetVersion.values()) {
+      Path typeAliasLibJar =
+          kotlinc(KOTLINC, targetVersion)
+              .addSourceFiles(getKotlinFileInTest(typeAliasLibFolder, "lib"))
+              .compile();
+      typeAliasLibJarMap.put(targetVersion, typeAliasLibJar);
+    }
+  }
+
+  @Test
+  public void testMetadataInTypeAlias_renamed() throws Exception {
+    Path libJar =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(typeAliasLibJarMap.get(targetVersion))
+            // Keep non-private members of Impl
+            .addKeepRules("-keep class **.Impl { !private *; }")
+            // Keep Itf, but allow minification.
+            .addKeepRules("-keep,allowobfuscation class **.Itf")
+            // Keep LibKt that contains the type-aliases and utils.
+            .addKeepRules("-keep class **.LibKt { *; }")
+            .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+            .compile()
+            .inspect(this::inspect)
+            .writeToZip();
+
+    ProcessResult kotlinTestCompileResult =
+        kotlinc(parameters.getRuntime().asCf(), KOTLINC, targetVersion)
+            .addClasspathFiles(libJar)
+            .addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/typealias_app", "main"))
+            .setOutputPath(temp.newFolder().toPath())
+            // TODO(b/70169921): update to just .compile() once fixed.
+            .compileRaw();
+    // TODO(b/70169921): should be able to compile!
+    assertNotEquals(0, kotlinTestCompileResult.exitCode);
+    assertThat(
+        kotlinTestCompileResult.stderr,
+        containsString(
+            "type mismatch: inferred type is ProgramClass but API /* = Itf */ was expected"));
+  }
+
+  private void inspect(CodeInspector inspector) {
+    String itfClassName = PKG + ".typealias_lib.Itf";
+    String libKtClassName = PKG + ".typealias_lib.LibKt";
+
+    ClassSubject itf = inspector.clazz(itfClassName);
+    assertThat(itf, isRenamed());
+
+    ClassSubject libKt = inspector.clazz(libKtClassName);
+    assertThat(libKt, isPresent());
+    assertThat(libKt, not(isRenamed()));
+
+    MethodSubject seq = libKt.uniqueMethodWithName("seq");
+    assertThat(seq, isPresent());
+    assertThat(seq, not(isRenamed()));
+
+    // API entry is kept, hence the presence of Metadata.
+    KmPackageSubject kmPackage = libKt.getKmPackage();
+    assertThat(kmPackage, isPresent());
+    // TODO(b/70169921): need further inspection: many kinds of type appearances in typealias.
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
index 35dd597..f93179f 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
@@ -5,6 +5,7 @@
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 
@@ -51,9 +52,11 @@
             .addKeepMainRule(mainClassName)
             .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
             .addKeepRules("-keep class kotlin.Metadata")
-            // TODO(b/145090972): Should never need to exit gracefully during testing.
-            .allowClassInlinerGracefulExit()
+            .allowDiagnosticWarningMessages()
             .setMinApi(parameters.getApiLevel())
+            .compile()
+            .assertAllWarningMessagesMatch(
+                equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
             .run(parameters.getRuntime(), mainClassName);
     CodeInspector inspector = result.inspector();
     ClassSubject clazz = inspector.clazz(mainClassName);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/typealias_app/main.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/typealias_app/main.kt
new file mode 100644
index 0000000..f0ddbf7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/typealias_app/main.kt
@@ -0,0 +1,25 @@
+// 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.kotlin.metadata.typealias_app
+
+import com.android.tools.r8.kotlin.metadata.typealias_lib.API
+import com.android.tools.r8.kotlin.metadata.typealias_lib.Impl
+import com.android.tools.r8.kotlin.metadata.typealias_lib.seq
+
+class ProgramClass : Impl() {
+  override fun foo(): API {
+    super.foo()
+    println("Program::foo")
+    return this
+  }
+}
+
+fun main() {
+  val instance = ProgramClass()
+  val l = seq(instance)
+  for (api in l) {
+    println(api == api.foo())
+    println(api.hey())
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/typealias_lib/lib.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/typealias_lib/lib.kt
new file mode 100644
index 0000000..82ba761
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/typealias_lib/lib.kt
@@ -0,0 +1,64 @@
+// 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.kotlin.metadata.typealias_lib
+
+// TypeAlias {
+//   name: "Jude"
+//   underlyingType {
+//     classifier: "kotlin/Long"
+//   }
+// }
+typealias Jude = Long
+
+interface Itf {
+  fun foo() : Itf
+  fun hey() : Jude
+}
+
+// TypeAlias {
+//   name: "API"
+//   underlyingType {
+//     classifier: ".../Itf"
+//   }
+// }
+typealias API = Itf
+// TypeAlias {
+//   typeParameters { KmTypeParameter { name = "T" ... } }
+//   name: "myAliasedList"
+//   underlyingType {
+//     classifier: "kotlin/Array"
+//   }
+//   expandedType == underlyingType
+// }
+typealias myAliasedArray<T> = Array<T>
+// TypeAlias {
+//   underlyingType {
+//     classifier: ".../myAliasedArray"
+//     arguments {
+//       KmTypeProjection { ... type = ".../API" }
+//     }
+//   }
+//   expandedType {
+//     classifier: "kotlin/Array"
+//     arguments {
+//       KmTypeProjection { ... type = ".../Itf" }
+//     }
+//   }
+// }
+typealias APIs = myAliasedArray<API>
+
+open class Impl : API {
+  override fun foo() : API {
+    println("Impl::foo")
+    return this
+  }
+
+  override fun hey(): Jude {
+    return 42L
+  }
+}
+
+fun seq(vararg itfs : Itf) : APIs {
+  return arrayOf(*itfs)
+}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
index 3806c05..8bc0e79 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
@@ -8,6 +8,7 @@
 import static com.android.tools.r8.utils.FileUtils.ZIP_EXTENSION;
 import static com.android.tools.r8.utils.FileUtils.withNativeFileSeparators;
 import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
 
 import com.android.tools.r8.GenerateMainDexList;
 import com.android.tools.r8.GenerateMainDexListCommand;
@@ -328,12 +329,14 @@
         .addKeepRules("-keepattributes *Annotation*")
         .addMainDexRuleFiles(mainDexRules)
         .addOptionsModification(optionsConsumer)
+        .allowDiagnosticWarningMessages()
         .assumeAllMethodsMayHaveSideEffects()
         .setMinApi(minSdk)
         .noMinification()
         .noTreeShaking()
         .setMainDexListConsumer(ToolHelper.consumeString(r8MainDexListOutput::set))
         .compile()
+        .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
         .writeToZip(out);
 
     List<String> r8MainDexList =
diff --git a/src/test/java/com/android/tools/r8/maindexlist/warnings/MainDexWarningsTest.java b/src/test/java/com/android/tools/r8/maindexlist/warnings/MainDexWarningsTest.java
index 3778392..bf33b1c 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/warnings/MainDexWarningsTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/warnings/MainDexWarningsTest.java
@@ -48,6 +48,7 @@
         .addKeepMainRule(mainClass)
         // Include explicit main dex entry for class Static.
         .addMainDexListClasses(Static.class)
+        .allowDiagnosticWarningMessages()
         .compile()
         .inspect(this::classStaticGone)
         .assertOnlyWarnings()
@@ -66,6 +67,7 @@
         .addMainDexListClasses(Main.class, Static.class)
         // Include main dex rule for class Static2.
         .addMainDexClassRules(Static2.class)
+        .allowDiagnosticWarningMessages()
         .compile()
         .inspect(this::classStaticGone)
         .assertOnlyWarnings()
diff --git a/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java b/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
index d56ae8e..7e15524 100644
--- a/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
@@ -4,6 +4,7 @@
 package com.android.tools.r8.naming;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 
@@ -33,7 +34,7 @@
   @Parameterized.Parameters(name = "{0} target: {1} minify: {2}")
   public static Collection<Object[]> data() {
     return buildParameters(
-        getTestParameters().withAllRuntimes().build(),
+        getTestParameters().withAllRuntimesAndApiLevels().build(),
         KotlinTargetVersion.values(),
         BooleanUtils.values());
   }
@@ -52,8 +53,12 @@
             .addProgramFiles(getKotlinJarFile(FOLDER))
             .addProgramFiles(getJavaJarFile(FOLDER))
             .addKeepMainRule(MAIN_CLASS_NAME)
+            .allowDiagnosticWarningMessages()
             .minification(minify)
-            .setMinApi(parameters.getRuntime())
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .assertAllWarningMessagesMatch(
+                equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
             .run(parameters.getRuntime(), MAIN_CLASS_NAME)
             .inspector();
     ClassSubject enumClass = inspector.clazz(ENUM_CLASS_NAME);
diff --git a/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java b/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java
index e9383ef..1c7c5bc 100644
--- a/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java
+++ b/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java
@@ -6,6 +6,7 @@
 import static com.android.tools.r8.utils.DescriptorUtils.descriptorToJavaType;
 import static com.android.tools.r8.utils.DescriptorUtils.isValidJavaType;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
@@ -46,6 +47,7 @@
   private final String appFileName;
   private final List<String> keepRulesFiles;
   private final BiConsumer<TestParameters, CodeInspector> inspection;
+  private final String test;
 
   public IdentifierMinifierTest(
       TestParameters parameters,
@@ -56,18 +58,23 @@
     this.appFileName = ToolHelper.EXAMPLES_BUILD_DIR + test + FileUtils.JAR_EXTENSION;
     this.keepRulesFiles = keepRulesFiles;
     this.inspection = inspection;
+    this.test = test;
   }
 
   @Test
   public void identiferMinifierTest() throws Exception {
+    boolean hasWarning =
+        test.equals("identifiernamestring") && keepRulesFiles.get(0).endsWith("keep-rules-2.txt");
     CodeInspector codeInspector =
         testForR8(parameters.getBackend())
             .addProgramFiles(Paths.get(appFileName))
             .addKeepRuleFiles(ListUtils.map(keepRulesFiles, Paths::get))
-            .allowUnusedProguardConfigurationRules()
+            .allowDiagnosticWarningMessages(hasWarning)
             .enableProguardTestOptions()
-            .setMinApi(parameters.getRuntime())
+            .setMinApi(parameters.getApiLevel())
             .compile()
+            .assertAllWarningMessagesMatch(
+                containsString("Cannot determine what identifier string flows to"))
             .inspector();
     inspection.accept(parameters, codeInspector);
   }
@@ -95,7 +102,7 @@
     Collection<Object[]> parameters = NamingTestBase.createTests(tests, inspections);
 
     List<Object[]> parametersWithBackend = new ArrayList<>();
-    for (TestParameters testParameter : getTestParameters().withAllRuntimes().build()) {
+    for (TestParameters testParameter : getTestParameters().withAllRuntimesAndApiLevels().build()) {
       for (Object[] row : parameters) {
         Object[] newRow = new Object[row.length + 1];
         newRow[0] = testParameter;
@@ -315,5 +322,4 @@
             });
     return result;
   }
-
 }
diff --git a/src/test/java/com/android/tools/r8/naming/IdentifierNameStringMarkerTest.java b/src/test/java/com/android/tools/r8/naming/IdentifierNameStringMarkerTest.java
index 2b06482..e9ce1d8 100644
--- a/src/test/java/com/android/tools/r8/naming/IdentifierNameStringMarkerTest.java
+++ b/src/test/java/com/android/tools/r8/naming/IdentifierNameStringMarkerTest.java
@@ -3,11 +3,15 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.naming;
 
+import static org.hamcrest.CoreMatchers.containsString;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.ThrowableConsumer;
 import com.android.tools.r8.code.AputObject;
 import com.android.tools.r8.code.Const4;
 import com.android.tools.r8.code.ConstClass;
@@ -53,7 +57,7 @@
         "-keep class " + CLASS_NAME,
         "-keepclassmembers,allowobfuscation class " + CLASS_NAME + " { !static <fields>; }",
         "-dontoptimize");
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -86,7 +90,7 @@
         "-keep class " + CLASS_NAME,
         "-keepclassmembers,allowobfuscation class " + CLASS_NAME + " { !static <fields>; }",
         "-dontoptimize");
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -129,7 +133,7 @@
         "-keepclassmembers,allowobfuscation class " + CLASS_NAME + " { !static <fields>; }",
         "-keep,allowobfuscation class " + BOO,
         "-dontoptimize");
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -167,7 +171,7 @@
         "-keep class " + CLASS_NAME,
         "-keepclassmembers,allowobfuscation class " + CLASS_NAME + " { static <fields>; }",
         "-dontoptimize");
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -199,7 +203,7 @@
         "-keep class " + CLASS_NAME,
         "-keepclassmembers,allowobfuscation class " + CLASS_NAME + " { static <fields>; }",
         "-dontoptimize");
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -238,7 +242,7 @@
         "-keepclassmembers,allowobfuscation class " + CLASS_NAME + " { static <fields>; }",
         "-keep,allowobfuscation class " + BOO,
         "-dontoptimize");
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -268,7 +272,7 @@
         "-identifiernamestring class " + CLASS_NAME + " { static java.lang.String sClassName; }",
         "-keep class " + CLASS_NAME + " { static java.lang.String sClassName; }",
         "-dontshrink");
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -290,7 +294,7 @@
         "-keep class " + CLASS_NAME + " { static java.lang.String sClassName; }",
         "-keep,allowobfuscation class " + BOO,
         "-dontshrink");
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -314,7 +318,7 @@
         "-keep class " + CLASS_NAME + " { static java.lang.String sFieldName; }",
         "-keep,allowobfuscation class " + BOO + " { <fields>; }",
         "-dontshrink");
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -338,7 +342,7 @@
         "-keep class " + CLASS_NAME + " { static java.lang.String sMethodName; }",
         "-keep,allowobfuscation class " + BOO + " { <methods>; }",
         "-dontshrink");
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -365,10 +369,20 @@
         "invoke-static {v0, v1}, LExample;->foo(Ljava/lang/String;Ljava/lang/String;)V",
         "return-void");
 
-    List<String> pgConfigs = ImmutableList.of(
-        "-identifiernamestring class " + CLASS_NAME + " { static void foo(...); }",
-        "-keep class " + CLASS_NAME);
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector =
+        compileWithR8(
+                builder,
+                testBuilder ->
+                    testBuilder
+                        .addKeepRules(
+                            "-identifiernamestring class "
+                                + CLASS_NAME
+                                + " { static void foo(...); }",
+                            "-keep class " + CLASS_NAME)
+                        .allowDiagnosticWarningMessages())
+            .assertAllWarningMessagesMatch(
+                containsString("Cannot determine what 'Mixed/form.Boo' refers to"))
+            .inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -410,7 +424,7 @@
     List<String> pgConfigs = ImmutableList.of(
         "-identifiernamestring class " + CLASS_NAME + " { static void foo(...); }",
         "-keep class " + CLASS_NAME);
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -456,7 +470,7 @@
         "-identifiernamestring class " + CLASS_NAME + " { static void foo(...); }",
         "-keep class " + CLASS_NAME,
         "-keep,allowobfuscation class " + BOO);
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -510,7 +524,7 @@
             + "}",
         "-keep class " + CLASS_NAME,
         "-keep class R { *; }");
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -560,7 +574,7 @@
             + "}",
         "-keep class " + CLASS_NAME,
         "-keep,allowobfuscation class R { *; }");
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -617,7 +631,7 @@
             + "}",
         "-keep class " + CLASS_NAME,
         "-keep class R { *; }");
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -678,7 +692,7 @@
             + "}",
         "-keep class " + CLASS_NAME,
         "-keep,allowobfuscation class R { *; }");
-    CodeInspector inspector = getInspectorAfterRunR8(builder, pgConfigs);
+    CodeInspector inspector = compileWithR8(builder, pgConfigs).inspector();
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
     assertTrue(clazz.isPresent());
@@ -702,13 +716,17 @@
     assertNotEquals("foo", constString.getString().toString());
   }
 
-  private CodeInspector getInspectorAfterRunR8(
+  private R8TestCompileResult compileWithR8(
       SmaliBuilder builder, List<String> proguardConfigurations) throws Exception {
+    return compileWithR8(builder, testBuilder -> testBuilder.addKeepRules(proguardConfigurations));
+  }
+
+  private R8TestCompileResult compileWithR8(
+      SmaliBuilder builder, ThrowableConsumer<R8FullTestBuilder> configuration) throws Exception {
     return testForR8(Backend.DEX)
         .addProgramDexFileData(builder.compile())
-        .addKeepRules(proguardConfigurations)
+        .apply(configuration)
         .debug()
-        .compile()
-        .inspector();
+        .compile();
   }
 }
diff --git a/src/test/java/com/android/tools/r8/naming/IntersectionLambdaTest.java b/src/test/java/com/android/tools/r8/naming/IntersectionLambdaTest.java
new file mode 100644
index 0000000..9a55cee
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/IntersectionLambdaTest.java
@@ -0,0 +1,84 @@
+// 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.naming;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.NeverMerge;
+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;
+
+@RunWith(Parameterized.class)
+public class IntersectionLambdaTest extends TestBase {
+
+  private static final String[] EXPECTED = new String[] {"Lambda.foo", "J.bar", "K.baz"};
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public IntersectionLambdaTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testRuntime() throws IOException, CompilationFailedException, ExecutionException {
+    testForRuntime(parameters)
+        .addInnerClasses(IntersectionLambdaTest.class)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(EXPECTED);
+  }
+
+  @Test
+  public void testR8() throws IOException, CompilationFailedException, ExecutionException {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(IntersectionLambdaTest.class)
+        .enableMergeAnnotations()
+        .addKeepMainRule(Main.class)
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(EXPECTED);
+  }
+
+  @FunctionalInterface
+  @NeverMerge
+  public interface I {
+    void foo();
+  }
+
+  public interface J {
+    default void bar() {
+      System.out.println("J.bar");
+    }
+  }
+
+  public interface K {
+    default void baz() {
+      System.out.println("K.baz");
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      callI((I & J & K) () -> System.out.println("Lambda.foo"));
+    }
+
+    private static void callI(I i) {
+      i.foo();
+      ((J) i).bar();
+      ((K) i).baz();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/IntersectionWithInheritanceLambdaTest.java b/src/test/java/com/android/tools/r8/naming/IntersectionWithInheritanceLambdaTest.java
new file mode 100644
index 0000000..f784a8f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/IntersectionWithInheritanceLambdaTest.java
@@ -0,0 +1,78 @@
+// 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.naming;
+
+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;
+
+@RunWith(Parameterized.class)
+public class IntersectionWithInheritanceLambdaTest extends TestBase {
+
+  private static final String[] EXPECTED = new String[] {"Lambda.foo", "J.bar", "K.baz"};
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public IntersectionWithInheritanceLambdaTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testRuntime() throws IOException, CompilationFailedException, ExecutionException {
+    testForRuntime(parameters)
+        .addInnerClasses(IntersectionWithInheritanceLambdaTest.class)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(EXPECTED);
+  }
+
+  @Test
+  public void testR8() throws IOException, CompilationFailedException, ExecutionException {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(IntersectionWithInheritanceLambdaTest.class)
+        .addKeepMainRule(Main.class)
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(EXPECTED);
+  }
+
+  public interface J {
+    default void bar() {
+      System.out.println("J.bar");
+    }
+  }
+
+  public interface K extends J {
+    void foo();
+
+    default void baz() {
+      System.out.println("K.baz");
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      callFooBarBaz(() -> System.out.println("Lambda.foo"));
+    }
+
+    private static void callFooBarBaz(K k) {
+      k.foo();
+      k.bar();
+      k.baz();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/InvalidObfuscationEntryTest.java b/src/test/java/com/android/tools/r8/naming/InvalidObfuscationEntryTest.java
index 982267f..57bd145 100644
--- a/src/test/java/com/android/tools/r8/naming/InvalidObfuscationEntryTest.java
+++ b/src/test/java/com/android/tools/r8/naming/InvalidObfuscationEntryTest.java
@@ -48,7 +48,7 @@
 
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimes().build();
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
   }
 
   public InvalidObfuscationEntryTest(TestParameters parameters) {
@@ -65,13 +65,10 @@
         .addKeepRules("-obfuscationdictionary " + dictionary.toString())
         .addKeepAllClassesRuleWithAllowObfuscation()
         .addKeepMainRule(Main.class)
-        .setMinApi(parameters.getRuntime())
+        .allowDiagnosticInfoMessages()
+        .setMinApi(parameters.getApiLevel())
         .compile()
-        .inspectDiagnosticMessages(
-            testDiagnosticMessages -> {
-              testDiagnosticMessages.assertInfoMessageThatMatches(
-                  containsString("Invalid character"));
-            })
+        .assertInfoMessageThatMatches(containsString("Invalid character"))
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("Hello from a", "Hello from b")
         .inspect(
diff --git a/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java b/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
index 7828143..daa21a4 100644
--- a/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
+++ b/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
@@ -4,6 +4,7 @@
 package com.android.tools.r8.naming;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
@@ -67,12 +68,16 @@
   public void test_example3() throws Exception {
     TestKotlinClass ex3 = new TestKotlinClass("intrinsics_identifiers.Example3Kt");
     String mainClassName = ex3.getClassName();
-    TestCompileResult result = testForR8(Backend.DEX)
-        .addProgramFiles(getKotlinJarFile(FOLDER))
-        .addProgramFiles(getJavaJarFile(FOLDER))
-        .addKeepMainRule(mainClassName)
-        .minification(minification)
-        .compile();
+    TestCompileResult result =
+        testForR8(Backend.DEX)
+            .addProgramFiles(getKotlinJarFile(FOLDER))
+            .addProgramFiles(getJavaJarFile(FOLDER))
+            .addKeepMainRule(mainClassName)
+            .allowDiagnosticWarningMessages()
+            .minification(minification)
+            .compile()
+            .assertAllWarningMessagesMatch(
+                equalTo("Resource 'META-INF/MANIFEST.MF' already exists."));
     CodeInspector codeInspector = result.inspector();
     MethodSubject main = codeInspector.clazz(ex3.getClassName()).mainMethod();
     assertThat(main, isPresent());
@@ -116,18 +121,23 @@
       String targetFieldName,
       String targetMethodName) throws Exception {
     String mainClassName = testMain.getClassName();
-    TestRunResult result = testForR8(Backend.DEX)
-        .addProgramFiles(getKotlinJarFile(FOLDER))
-        .addProgramFiles(getJavaJarFile(FOLDER))
-        .enableProguardTestOptions()
-        .addKeepMainRule(mainClassName)
-        .addKeepRules(StringUtils.lines(
-            "-neverclassinline class **." + targetClassName,
-            "-nevermerge class **." + targetClassName,
-            "-neverinline class **." + targetClassName + " { <methods>; }"
-        ))
-        .minification(minification)
-        .run(mainClassName);
+    TestRunResult result =
+        testForR8(Backend.DEX)
+            .addProgramFiles(getKotlinJarFile(FOLDER))
+            .addProgramFiles(getJavaJarFile(FOLDER))
+            .enableProguardTestOptions()
+            .addKeepMainRule(mainClassName)
+            .addKeepRules(
+                StringUtils.lines(
+                    "-neverclassinline class **." + targetClassName,
+                    "-nevermerge class **." + targetClassName,
+                    "-neverinline class **." + targetClassName + " { <methods>; }"))
+            .allowDiagnosticWarningMessages()
+            .minification(minification)
+            .compile()
+            .assertAllWarningMessagesMatch(
+                equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
+            .run(mainClassName);
     CodeInspector codeInspector = result.inspector();
 
     MethodSubject main = codeInspector.clazz(testMain.getClassName()).mainMethod();
diff --git a/src/test/java/com/android/tools/r8/proguard/configuration/UnusedKeepRuleTest.java b/src/test/java/com/android/tools/r8/proguard/configuration/UnusedKeepRuleTest.java
index 44e95ec..a391a21 100644
--- a/src/test/java/com/android/tools/r8/proguard/configuration/UnusedKeepRuleTest.java
+++ b/src/test/java/com/android/tools/r8/proguard/configuration/UnusedKeepRuleTest.java
@@ -4,13 +4,7 @@
 
 package com.android.tools.r8.proguard.configuration;
 
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
-
-import com.android.tools.r8.Diagnostic;
 import com.android.tools.r8.TestBase;
-import java.util.List;
 import org.junit.Test;
 
 public class UnusedKeepRuleTest extends TestBase {
@@ -19,20 +13,8 @@
   public void test() throws Exception {
     testForR8(Backend.DEX)
         .addKeepRules("-keep class NotPresent")
-        .addOptionsModification(
-            options -> options.testing.reportUnusedProguardConfigurationRules = true)
         .allowUnusedProguardConfigurationRules()
         .compile()
-        .inspectDiagnosticMessages(
-            messages -> {
-              messages.assertOnlyInfos();
-              List<Diagnostic> infos = messages.getInfos();
-              assertEquals(1, infos.size());
-
-              Diagnostic info = infos.get(0);
-              assertThat(
-                  info.getDiagnosticMessage(),
-                  containsString("Proguard configuration rule does not match anything"));
-            });
+        .assertInfosCount(1);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/proguard/rules/InnerClassNameSeparatorTest.java b/src/test/java/com/android/tools/r8/proguard/rules/InnerClassNameSeparatorTest.java
index 6da44a5..bb37f6f 100644
--- a/src/test/java/com/android/tools/r8/proguard/rules/InnerClassNameSeparatorTest.java
+++ b/src/test/java/com/android/tools/r8/proguard/rules/InnerClassNameSeparatorTest.java
@@ -7,6 +7,7 @@
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.junit.Assume.assumeTrue;
 
+import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestRunResult;
@@ -27,7 +28,7 @@
   @Parameterized.Parameters(name = "{0}, separator: {1}")
   public static List<Object[]> data() {
     return buildParameters(
-        getTestParameters().withAllRuntimes().build(), ImmutableList.of("$", "."));
+        getTestParameters().withAllRuntimesAndApiLevels().build(), ImmutableList.of("$", "."));
   }
 
   public InnerClassNameSeparatorTest(TestParameters parameters, String separator) {
@@ -37,17 +38,23 @@
 
   @Test
   public void testR8() throws Exception {
-    TestRunResult<?> result =
-        runTest(
-            testForR8(parameters.getBackend())
-                .addOptionsModification(InternalOptions::disableNameReflectionOptimization)
-                .addOptionsModification(
-                    options -> {
-                      if (separator.equals(".")) {
-                        // R8 currently does not recognize the '.' as an inner class name separator.
-                        options.testing.allowUnusedProguardConfigurationRules = true;
-                      }
-                    }));
+    R8TestRunResult result =
+        testForR8(parameters.getBackend())
+            .addOptionsModification(InternalOptions::disableNameReflectionOptimization)
+            .allowUnusedProguardConfigurationRules(separator.equals("."))
+            .addProgramClassesAndInnerClasses(InnerClassNameSeparatorTestClass.class)
+            .addKeepMainRule(InnerClassNameSeparatorTestClass.class)
+            .addKeepRules(
+                "-keep,allowobfuscation class "
+                    + InnerClassNameSeparatorTestClass.class.getTypeName()
+                    + separator
+                    + InnerClassNameSeparatorTestClass.Inner.class.getSimpleName()
+                    + " {",
+                "  <init>(...);",
+                "}")
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .run(parameters.getRuntime(), InnerClassNameSeparatorTestClass.class);
     if (separator.equals("$")) {
       result.assertSuccessWithOutputLines("Hello world!");
     } else {
@@ -73,7 +80,7 @@
                 + " {",
             "  <init>(...);",
             "}")
-        .setMinApi(parameters.getRuntime())
+        .setMinApi(parameters.getApiLevel())
         .compile()
         .run(parameters.getRuntime(), InnerClassNameSeparatorTestClass.class);
   }
diff --git a/src/test/java/com/android/tools/r8/resolution/LibraryExtendsProgramRefinedReceiverIsLibraryClass.java b/src/test/java/com/android/tools/r8/resolution/LibraryExtendsProgramRefinedReceiverIsLibraryClass.java
index db1864c..2bd5e75 100644
--- a/src/test/java/com/android/tools/r8/resolution/LibraryExtendsProgramRefinedReceiverIsLibraryClass.java
+++ b/src/test/java/com/android/tools/r8/resolution/LibraryExtendsProgramRefinedReceiverIsLibraryClass.java
@@ -4,6 +4,8 @@
 
 package com.android.tools.r8.resolution;
 
+import static org.hamcrest.CoreMatchers.containsString;
+
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
@@ -47,9 +49,11 @@
         .enableInliningAnnotations()
         .addKeepClassRules(ProgramClass.class)
         .addKeepMainRule(ProgramTestRunnerWithoutPhi.class)
+        .allowDiagnosticWarningMessages()
         .setMinApi(parameters.getApiLevel())
         .debug()
         .compile()
+        .assertAllWarningMessagesMatch(containsString("extends program class"))
         .addRunClasspathClasses(LibraryClass.class)
         .run(parameters.getRuntime(), ProgramTestRunnerWithoutPhi.class)
         .assertSuccessWithOutput(StringUtils.lines("SUCCESS"));
@@ -64,8 +68,10 @@
         .enableInliningAnnotations()
         .addKeepClassRules(ProgramClass.class)
         .addKeepMainRule(ProgramTestRunnerWithPhi.class)
+        .allowDiagnosticWarningMessages()
         .setMinApi(parameters.getApiLevel())
         .compile()
+        .assertAllWarningMessagesMatch(containsString("extends program class"))
         .addRunClasspathClasses(LibraryClass.class)
         .run(parameters.getRuntime(), ProgramTestRunnerWithPhi.class)
         .assertSuccessWithOutput(StringUtils.lines("SUCCESS"));
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodAsOverrideWithLambdaTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodAsOverrideWithLambdaTest.java
index d2a1ee6..609b506 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodAsOverrideWithLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodAsOverrideWithLambdaTest.java
@@ -4,7 +4,7 @@
 
 package com.android.tools.r8.resolution.interfacetargets;
 
-import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assume.assumeTrue;
 
 import com.android.tools.r8.CompilationFailedException;
@@ -49,7 +49,8 @@
   public void testResolution() throws Exception {
     assumeTrue(parameters.useRuntimeAsNoneRuntime());
     AppInfoWithLiveness appInfo =
-        computeAppViewWithLiveness(buildClasses(I.class, A.class, Main.class).build(), Main.class)
+        computeAppViewWithLiveness(
+                buildClasses(I.class, J.class, A.class, Main.class).build(), Main.class)
             .appInfo();
     DexMethod method = buildNullaryVoidMethod(I.class, "bar", appInfo.dexItemFactory());
     ResolutionResult resolutionResult = appInfo.resolveMethodOnInterface(method.holder, method);
@@ -59,8 +60,7 @@
             .collect(Collectors.toSet());
     ImmutableSet<String> expected =
         ImmutableSet.of(A.class.getTypeName() + ".bar", J.class.getTypeName() + ".bar");
-    // TODO(b/148168065): Correct incorrect target lookup.
-    // assertEquals(expected, targets);
+    assertEquals(expected, targets);
   }
 
   @Test
@@ -81,9 +81,7 @@
         .addKeepMainRule(Main.class)
         .setMinApi(parameters.getApiLevel())
         .run(parameters.getRuntime(), Main.class)
-        .assertFailureWithErrorThatMatches(containsString("AbstractMethodError"));
-    // TODO(b/148168065): Correct incorrect target lookup.
-    //    .assertSuccessWithOutputLines(EXPECTED);
+        .assertSuccessWithOutputLines(EXPECTED);
   }
 
   @FunctionalInterface
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceClInitTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceClInitTest.java
new file mode 100644
index 0000000..65448a0
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceClInitTest.java
@@ -0,0 +1,155 @@
+// 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.resolution.interfacetargets;
+
+import static org.hamcrest.core.StringContains.containsString;
+import static org.junit.Assume.assumeTrue;
+
+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 com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.TestRuntime.DexRuntime;
+import com.android.tools.r8.ToolHelper.DexVm;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.transformers.ClassTransformer;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.Matcher;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.objectweb.asm.MethodVisitor;
+
+@RunWith(Parameterized.class)
+public class InvokeInterfaceClInitTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  static {
+  }
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public InvokeInterfaceClInitTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testResolution() throws Exception {
+    assumeTrue(parameters.useRuntimeAsNoneRuntime());
+    AppInfoWithLiveness appInfo =
+        computeAppViewWithLiveness(
+                buildClasses(A.class, B.class)
+                    .addClassProgramData(transformI(), transformMain())
+                    .build(),
+                Main.class)
+            .appInfo();
+    DexMethod method = buildNullaryVoidMethod(I.class, "<clinit>", appInfo.dexItemFactory());
+    Assert.assertThrows(
+        AssertionError.class,
+        () -> {
+          appInfo.resolveMethod(method.holder, method).lookupInterfaceTargets(appInfo);
+        });
+  }
+
+  private Matcher<String> getExpected() {
+    if (parameters.getRuntime().isCf()) {
+      Matcher<String> expected = containsString("java.lang.VerifyError");
+      // JDK 9 and 11 output VerifyError or ClassFormatError non-deterministically.
+      if (parameters.getRuntime().asCf().isNewerThanOrEqual(CfVm.JDK9)) {
+        expected = CoreMatchers.anyOf(expected, containsString("java.lang.ClassFormatError"));
+      }
+      return expected;
+    }
+    assert parameters.getRuntime().isDex();
+    DexRuntime dexRuntime = parameters.getRuntime().asDex();
+    if (dexRuntime.getVm().isOlderThanOrEqual(DexVm.ART_4_4_4_TARGET)) {
+      return containsString("NoSuchMethodError");
+    }
+    if (parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N)) {
+      return containsString("java.lang.ClassNotFoundException");
+    }
+    return containsString("java.lang.VerifyError");
+  }
+
+  @Test
+  public void testRuntimeClInit()
+      throws IOException, CompilationFailedException, ExecutionException {
+    testForRuntime(parameters)
+        .addProgramClasses(A.class, B.class)
+        .addProgramClassFileData(transformMain(), transformI())
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatMatches(getExpected());
+  }
+
+  @Test
+  public void testR8ClInit() throws IOException, CompilationFailedException, ExecutionException {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(A.class, B.class)
+        .addProgramClassFileData(transformMain(), transformI())
+        .addKeepMainRule(Main.class)
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatMatches(getExpected());
+  }
+
+  private byte[] transformI() throws IOException {
+    return transformer(I.class)
+        .addClassTransformer(
+            new ClassTransformer() {
+              @Override
+              public MethodVisitor visitMethod(
+                  int access,
+                  String name,
+                  String descriptor,
+                  String signature,
+                  String[] exceptions) {
+                return super.visitMethod(access, "<clinit>", descriptor, signature, exceptions);
+              }
+            })
+        .transform();
+  }
+
+  private byte[] transformMain() throws IOException {
+    return transformer(Main.class)
+        .transformMethodInsnInMethod(
+            "callClInit",
+            (opcode, owner, name, descriptor, isInterface, continuation) ->
+                continuation.apply(opcode, owner, "<clinit>", descriptor, isInterface))
+        .transform();
+  }
+
+  public interface I {
+
+    default void foo() { // <-- will be rewritten to <clinit>
+      System.out.println("I.foo");
+    }
+  }
+
+  public static class A implements I {}
+
+  public static class B implements I {}
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      callClInit(args.length == 0 ? new A() : new B());
+    }
+
+    private static void callClInit(I i) {
+      i.foo(); // <-- will be i.<clinit>()
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceWithStaticTargetTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceWithStaticTargetTest.java
new file mode 100644
index 0000000..ede5785
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceWithStaticTargetTest.java
@@ -0,0 +1,131 @@
+// 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.resolution.interfacetargets;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assume.assumeTrue;
+import static org.objectweb.asm.Opcodes.INVOKEINTERFACE;
+
+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 com.android.tools.r8.TestRuntime;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.DescriptorUtils;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class InvokeInterfaceWithStaticTargetTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public InvokeInterfaceWithStaticTargetTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testResolution() throws Exception {
+    assumeTrue(parameters.getRuntime().equals(TestRuntime.getDefaultJavaRuntime()));
+    AppInfoWithLiveness appInfo =
+        computeAppViewWithLiveness(
+                buildClasses(A.class, I.class).addClassProgramData(transformMain()).build(),
+                Main.class)
+            .appInfo();
+    DexMethod method = buildNullaryVoidMethod(I.class, "bar", appInfo.dexItemFactory());
+    Assert.assertThrows(
+        AssertionError.class,
+        () -> appInfo.resolveMethod(method.holder, method).lookupInterfaceTargets(appInfo));
+  }
+
+  @Test
+  public void testRuntimeClInit()
+      throws IOException, CompilationFailedException, ExecutionException {
+    testForRuntime(parameters)
+        .addProgramClasses(A.class, I.class)
+        .addProgramClassFileData(transformMain())
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatMatches(containsString(getExpected()));
+  }
+
+  @Test
+  public void testR8ClInit() throws IOException, CompilationFailedException, ExecutionException {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(A.class, I.class)
+        .addProgramClassFileData(transformMain())
+        .addKeepMainRule(Main.class)
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatMatches(containsString(getExpected()));
+  }
+
+  private String getExpected() {
+    return parameters.isCfRuntime()
+            || parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N)
+        ? "IncompatibleClassChangeError"
+        : "NoSuchMethodError";
+  }
+
+  private byte[] transformMain() throws IOException {
+    return transformer(Main.class)
+        .transformMethodInsnInMethod(
+            "callFooBar",
+            (opcode, owner, name, descriptor, isInterface, continuation) -> {
+              if (name.equals("notify")) {
+                continuation.apply(
+                    INVOKEINTERFACE,
+                    DescriptorUtils.getBinaryNameFromJavaType(I.class.getTypeName()),
+                    "bar",
+                    descriptor,
+                    true);
+              } else {
+                continuation.apply(opcode, owner, name, descriptor, isInterface);
+              }
+            })
+        .transform();
+  }
+
+  public interface I {
+
+    void foo();
+
+    static void bar() {
+      System.out.println("I.bar");
+    }
+  }
+
+  public static class A implements I {
+
+    @Override
+    public void foo() {
+      System.out.println("A.foo");
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      callFooBar(args.length == 0 ? () -> System.out.println("Lambda.foo") : new A());
+    }
+
+    public static void callFooBar(I i) {
+      i.foo();
+      i.notify(); // <-- will be i.bar()
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
index 5d2a2d8..13190d9 100644
--- a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
@@ -10,6 +10,7 @@
 import static com.android.tools.r8.utils.codeinspector.Matchers.isInlineFrame;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isInlineStack;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.StringContains.containsString;
 
@@ -86,8 +87,11 @@
         .addKeepAttributes("SourceFile", "LineNumberTable")
         .setMode(CompilationMode.RELEASE)
         .addKeepMainRule(MAIN)
+        .allowDiagnosticWarningMessages()
         .noMinification()
         .setMinApi(parameters.getApiLevel())
+        .compile()
+        .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
         .run(parameters.getRuntime(), MAIN)
         .assertFailureWithErrorThatMatches(containsString("main"))
         .inspectStackTrace(
diff --git a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
index e2fe820..2d9f47b 100644
--- a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
@@ -11,6 +11,7 @@
 import static com.android.tools.r8.utils.codeinspector.Matchers.isInlineFrame;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isInlineStack;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.StringContains.containsString;
 
@@ -81,9 +82,12 @@
         .addProgramFiles(compilationResults.apply(parameters.getRuntime()))
         .addProgramFiles(ToolHelper.getKotlinStdlibJar())
         .addKeepAttributes("SourceFile", "LineNumberTable")
+        .allowDiagnosticWarningMessages()
         .setMode(CompilationMode.RELEASE)
         .addKeepMainRule(main)
         .setMinApi(parameters.getApiLevel())
+        .compile()
+        .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
         .run(parameters.getRuntime(), main)
         .assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
         .inspectStackTrace(
@@ -106,9 +110,12 @@
         .addProgramFiles(compilationResults.apply(parameters.getRuntime()))
         .addProgramFiles(ToolHelper.getKotlinStdlibJar())
         .addKeepAttributes("SourceFile", "LineNumberTable")
+        .allowDiagnosticWarningMessages()
         .setMode(CompilationMode.RELEASE)
         .addKeepMainRule(main)
         .setMinApi(parameters.getApiLevel())
+        .compile()
+        .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
         .run(parameters.getRuntime(), main)
         .assertFailureWithErrorThatMatches(containsString("inlineExceptionInstance"))
         .inspectStackTrace(
@@ -131,9 +138,12 @@
         .addProgramFiles(compilationResults.apply(parameters.getRuntime()))
         .addProgramFiles(ToolHelper.getKotlinStdlibJar())
         .addKeepAttributes("SourceFile", "LineNumberTable")
+        .allowDiagnosticWarningMessages()
         .setMode(CompilationMode.RELEASE)
         .addKeepMainRule(main)
         .setMinApi(parameters.getApiLevel())
+        .compile()
+        .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
         .run(parameters.getRuntime(), main)
         .assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
         .inspectStackTrace(
@@ -158,9 +168,12 @@
         .addProgramFiles(compilationResults.apply(parameters.getRuntime()))
         .addProgramFiles(ToolHelper.getKotlinStdlibJar())
         .addKeepAttributes("SourceFile", "LineNumberTable")
+        .allowDiagnosticWarningMessages()
         .setMode(CompilationMode.RELEASE)
         .addKeepMainRule(main)
         .setMinApi(parameters.getApiLevel())
+        .compile()
+        .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
         .run(parameters.getRuntime(), main)
         .assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
         .inspectStackTrace(
diff --git a/src/test/java/com/android/tools/r8/rewrite/JavaScriptScriptEngineTest.java b/src/test/java/com/android/tools/r8/rewrite/JavaScriptScriptEngineTest.java
index 5143949..b299b76 100644
--- a/src/test/java/com/android/tools/r8/rewrite/JavaScriptScriptEngineTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/JavaScriptScriptEngineTest.java
@@ -4,6 +4,9 @@
 
 package com.android.tools.r8.rewrite;
 
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assume.assumeTrue;
 
 import com.android.tools.r8.CompilationFailedException;
@@ -26,7 +29,7 @@
 
   @Parameterized.Parameters(name = "{0}")
   public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimes().build();
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
   }
 
   public JavaScriptScriptEngineTest(TestParameters parameters) {
@@ -41,7 +44,7 @@
     assumeTrue("Only run D8 for dex backend", parameters.isDexRuntime());
     testForD8()
         .addInnerClasses(JavaScriptScriptEngineTest.class)
-        .setMinApi(parameters.getRuntime())
+        .setMinApi(parameters.getApiLevel())
         .apply(this::addRhinoForAndroid)
         .compile()
         .run(parameters.getRuntime(), TestClassWithExplicitRhinoScriptEngineRegistration.class)
@@ -53,15 +56,21 @@
     testForR8(parameters.getBackend())
         .addInnerClasses(JavaScriptScriptEngineTest.class)
         .addKeepMainRule(TestClass.class)
-        .setMinApi(parameters.getRuntime())
+        .setMinApi(parameters.getApiLevel())
         .apply(
             b -> {
               if (parameters.isDexRuntime()) {
                 addRhinoForAndroid(b);
                 addKeepRulesForAndroidRhino(b);
+                b.allowDiagnosticWarningMessages();
               }
             })
         .compile()
+        .assertAllWarningMessagesMatch(
+            anyOf(
+                containsString("Missing class:"),
+                containsString("required for default or static interface methods desugaring"),
+                equalTo("Resource 'META-INF/MANIFEST.MF' already exists.")))
         .run(parameters.getRuntime(), TestClass.class)
         .assertSuccessWithOutput(
             parameters.isCfRuntime() ? EXPECTED_NASHORN_OUTPUT : EXPECTED_RHINO_OUTPUT);
diff --git a/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTest.java b/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTest.java
index 4e451ee..c7037ca 100644
--- a/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTest.java
@@ -4,12 +4,14 @@
 
 package com.android.tools.r8.rewrite;
 
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.DataEntryResource;
-import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.origin.Origin;
@@ -41,7 +43,7 @@
 
   @Parameterized.Parameters(name = "{0}")
   public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimes().build();
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
   }
 
   public ScriptEngineTest(TestParameters parameters) {
@@ -51,33 +53,37 @@
   @Test
   public void test() throws IOException, CompilationFailedException, ExecutionException {
     Path path = temp.newFile("out.zip").toPath();
-    R8FullTestBuilder builder =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(ScriptEngineTest.class)
-            .addKeepMainRule(TestClass.class)
-            .setMinApi(parameters.getRuntime())
-            .addDataEntryResources(
-                DataEntryResource.fromBytes(
-                    StringUtils.lines(MyScriptEngine1FactoryImpl.class.getTypeName()).getBytes(),
-                    "META-INF/services/" + ScriptEngineFactory.class.getTypeName(),
-                    Origin.unknown()))
-            .addDataEntryResources(
-                DataEntryResource.fromBytes(
-                    StringUtils.lines(MyScriptEngine2FactoryImpl.class.getTypeName()).getBytes(),
-                    "META-INF/services/" + ScriptEngineFactory.class.getTypeName(),
-                    Origin.unknown()))
-            .apply(
-                b -> {
-                  if (parameters.isDexRuntime()) {
-                    addRhinoForAndroid(b);
-                  }
-                })
-            // TODO(b/136633154): This should work both with and without -dontobfuscate.
-            .noMinification()
-            // TODO(b/136633154): This should work both with and without -dontshrink.
-            .noTreeShaking();
-    builder
+    testForR8(parameters.getBackend())
+        .addInnerClasses(ScriptEngineTest.class)
+        .addKeepMainRule(TestClass.class)
+        .setMinApi(parameters.getApiLevel())
+        .addDataEntryResources(
+            DataEntryResource.fromBytes(
+                StringUtils.lines(MyScriptEngine1FactoryImpl.class.getTypeName()).getBytes(),
+                "META-INF/services/" + ScriptEngineFactory.class.getTypeName(),
+                Origin.unknown()))
+        .addDataEntryResources(
+            DataEntryResource.fromBytes(
+                StringUtils.lines(MyScriptEngine2FactoryImpl.class.getTypeName()).getBytes(),
+                "META-INF/services/" + ScriptEngineFactory.class.getTypeName(),
+                Origin.unknown()))
+        .apply(
+            b -> {
+              if (parameters.isDexRuntime()) {
+                addRhinoForAndroid(b);
+                b.allowDiagnosticWarningMessages();
+              }
+            })
+        // TODO(b/136633154): This should work both with and without -dontobfuscate.
+        .noMinification()
+        // TODO(b/136633154): This should work both with and without -dontshrink.
+        .noTreeShaking()
         .compile()
+        .assertAllWarningMessagesMatch(
+            anyOf(
+                containsString("Missing class:"),
+                containsString("it is required for default or static interface methods desugaring"),
+                equalTo("Resource 'META-INF/MANIFEST.MF' already exists.")))
         .writeToZip(path)
         .run(parameters.getRuntime(), TestClass.class)
         // TODO(b/136633154): This should provide 2 script engines on both runtimes. The use of
diff --git a/src/test/java/com/android/tools/r8/shaking/EffectivelyFinalStaticFieldsTest.java b/src/test/java/com/android/tools/r8/shaking/EffectivelyFinalStaticFieldsTest.java
index 6f18cdc..302cb28 100644
--- a/src/test/java/com/android/tools/r8/shaking/EffectivelyFinalStaticFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/EffectivelyFinalStaticFieldsTest.java
@@ -68,8 +68,7 @@
                   mainMethod
                       .streamInstructions()
                       .noneMatch(i -> i.isConstString("Dead code: 1", JumboStringMode.ALLOW)));
-              // TODO(b/138913138): effectively final, and default value is set.
-              assertFalse(
+              assertTrue(
                   mainMethod
                       .streamInstructions()
                       .noneMatch(i -> i.isConstString("Dead code: 2", JumboStringMode.ALLOW)));
@@ -97,8 +96,7 @@
                   mainMethod
                       .streamInstructions()
                       .noneMatch(i -> i.isConstString("Dead code: 7", JumboStringMode.ALLOW)));
-              // TODO(b/138913138): effectively final, and default value is set.
-              assertFalse(
+              assertTrue(
                   mainMethod
                       .streamInstructions()
                       .noneMatch(i -> i.isConstString("Dead code: 8", JumboStringMode.ALLOW)));
diff --git a/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java b/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java
index b42be41..5b119ce 100644
--- a/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java
@@ -7,6 +7,7 @@
 import static org.hamcrest.CoreMatchers.allOf;
 import static org.hamcrest.CoreMatchers.anyOf;
 import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.core.IsNot.not;
 
 import com.android.tools.r8.D8TestRunResult;
@@ -79,7 +80,9 @@
   @Parameters(name = "{0}, mode: {1}, use interface: {2}")
   public static Collection<Object[]> parameters() {
     return buildParameters(
-        getTestParameters().withAllRuntimes().build(), Mode.values(), BooleanUtils.values());
+        getTestParameters().withAllRuntimesAndApiLevels().build(),
+        Mode.values(),
+        BooleanUtils.values());
   }
 
   @Test
@@ -171,7 +174,8 @@
     jasminBuilder.writeJar(inputJar);
 
     if (parameters.isCfRuntime()) {
-      TestRunResult<?> jvmResult = testForJvm().addClasspath(inputJar).run(mainClass.name);
+      TestRunResult<?> jvmResult =
+          testForJvm().addClasspath(inputJar).run(parameters.getRuntime(), mainClass.name);
       checkTestRunResult(jvmResult, Compiler.JAVAC);
 
       ProguardTestRunResult proguardResult =
@@ -184,10 +188,12 @@
     } else {
       assert parameters.isDexRuntime();
 
-      DXTestRunResult dxResult = testForDX().addProgramFiles(inputJar).run(mainClass.name);
+      DXTestRunResult dxResult =
+          testForDX().addProgramFiles(inputJar).run(parameters.getRuntime(), mainClass.name);
       checkTestRunResult(dxResult, Compiler.DX);
 
-      D8TestRunResult d8Result = testForD8().addProgramFiles(inputJar).run(mainClass.name);
+      D8TestRunResult d8Result =
+          testForD8().addProgramFiles(inputJar).run(parameters.getRuntime(), mainClass.name);
       checkTestRunResult(d8Result, Compiler.D8);
     }
 
@@ -205,7 +211,14 @@
                     options.testing.allowTypeErrors = true;
                   }
                 })
-            .setMinApi(parameters.getRuntime())
+            .allowDiagnosticWarningMessages(
+                mode == Mode.INVOKE_UNVERIFIABLE_METHOD && !useInterface)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .assertAllWarningMessagesMatch(
+                equalTo(
+                    "The method `void UnverifiableClass.unverifiableMethod()` does not type check"
+                        + " and will be assumed to be unreachable."))
             .run(parameters.getRuntime(), mainClass.name);
     checkTestRunResult(r8Result, Compiler.R8);
 
@@ -224,7 +237,14 @@
                   }
                   options.enableUninstantiatedTypeOptimizationForInterfaces = true;
                 })
-            .setMinApi(parameters.getRuntime())
+            .allowDiagnosticWarningMessages(
+                mode == Mode.INVOKE_UNVERIFIABLE_METHOD && !useInterface)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .assertAllWarningMessagesMatch(
+                equalTo(
+                    "The method `void UnverifiableClass.unverifiableMethod()` does not type check"
+                        + " and will be assumed to be unreachable."))
             .run(parameters.getRuntime(), mainClass.name);
     checkTestRunResult(
         r8ResultWithUninstantiatedTypeOptimizationForInterfaces,
diff --git a/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java b/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java
index 28e04fd..cd153f2 100644
--- a/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/PreserveDesugaredLambdaTest.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
 import java.io.IOException;
 import java.util.concurrent.ExecutionException;
 import org.junit.Test;
@@ -44,7 +45,7 @@
 
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
-    return getTestParameters().withDexRuntimes().build();
+    return getTestParameters().withDexRuntimes().withAllApiLevels().build();
   }
 
   public PreserveDesugaredLambdaTest(TestParameters parameters) {
@@ -58,16 +59,18 @@
         testForR8(parameters.getBackend())
             .addProgramClasses(Interface.class, A.class)
             .addKeepAllClassesRule()
-            .setMinApi(parameters.getRuntime())
+            .setMinApi(parameters.getApiLevel())
             .compile();
     // A is not passed in to ensure the Enqueuer is not tracing through classpath to see the use of
-    // computeFoo().s
+    // computeFoo().
     testForR8(parameters.getBackend())
         .addProgramClasses(Main.class)
         .addClasspathClasses(Interface.class)
         .addLibraryFiles(TestBase.runtimeJar(parameters.getBackend()))
         .addKeepAllClassesRule()
-        .setMinApi(parameters.getRuntime())
+        .allowDiagnosticWarningMessages(
+            parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.N))
+        .setMinApi(parameters.getApiLevel())
         .compile()
         .addRunClasspathFiles(libraryCompileResult.writeToZip())
         .inspect(
diff --git a/src/test/java/com/android/tools/r8/shaking/UsageInformationConsumerTest.java b/src/test/java/com/android/tools/r8/shaking/UsageInformationConsumerTest.java
index 4c9b057..3355fab 100644
--- a/src/test/java/com/android/tools/r8/shaking/UsageInformationConsumerTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/UsageInformationConsumerTest.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.shaking;
 
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertEquals;
 
 import com.android.tools.r8.TestBase;
@@ -11,8 +12,6 @@
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.utils.Box;
 import com.android.tools.r8.utils.StringUtils;
-import java.io.ByteArrayOutputStream;
-import java.io.PrintStream;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -49,16 +48,16 @@
 
   @Test
   public void testRule() throws Exception {
-    ByteArrayOutputStream out = new ByteArrayOutputStream();
     testForR8(parameters.getBackend())
-        .redirectStdOut(new PrintStream(out))
+        .collectStdout()
         .addProgramClasses(TestClass.class, UnusedClass.class)
         .addKeepClassAndMembersRules(TestClass.class)
         .addKeepRules("-printusage")
         .setMinApi(parameters.getApiLevel())
+        .compile()
+        .assertStdoutThatMatches(equalTo(StringUtils.lines(UnusedClass.class.getTypeName())))
         .run(parameters.getRuntime(), TestClass.class)
         .assertSuccessWithOutput(EXPECTED);
-    assertEquals(StringUtils.lines(UnusedClass.class.getTypeName()), out.toString());
   }
 
   static class UnusedClass {
diff --git a/src/test/java/com/android/tools/r8/shaking/VerticalClassMergerInvokeSpecialInConstructorTest.java b/src/test/java/com/android/tools/r8/shaking/VerticalClassMergerInvokeSpecialInConstructorTest.java
new file mode 100644
index 0000000..4f2943f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/VerticalClassMergerInvokeSpecialInConstructorTest.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.shaking;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.NeverClassInline;
+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;
+
+/** This is a reproduction of b/148313389, where we rewrite the super-call in B.<init>. */
+@RunWith(Parameterized.class)
+public class VerticalClassMergerInvokeSpecialInConstructorTest extends TestBase {
+
+  public static final String[] EXPECTED =
+      new String[] {"A.<init>", "B.<init>", "A.foo", "C.<init>", "B.foo"};
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public VerticalClassMergerInvokeSpecialInConstructorTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testRuntime() throws IOException, CompilationFailedException, ExecutionException {
+    testForRuntime(parameters)
+        .addInnerClasses(VerticalClassMergerInvokeSpecialInConstructorTest.class)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(EXPECTED);
+  }
+
+  @Test
+  public void testR8() throws IOException, CompilationFailedException, ExecutionException {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(VerticalClassMergerInvokeSpecialInConstructorTest.class)
+        .addKeepMainRule(Main.class)
+        .addKeepClassRules(A.class)
+        .enableNeverClassInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(EXPECTED);
+  }
+
+  public abstract static class A {
+
+    public A() {
+      System.out.println("A.<init>");
+    }
+
+    public void foo() {
+      System.out.println("A.foo");
+    }
+  }
+
+  public static class B extends A {
+
+    public B() {
+      System.out.println("B.<init>");
+      super.foo(); // <-- In b/148313389, this was rewritten to invoke-direct B.foo.
+    }
+
+    @Override
+    public void foo() {
+      System.out.println("B.foo");
+    }
+  }
+
+  @NeverClassInline
+  public static class C extends B {
+
+    public C() {
+      System.out.println("C.<init>");
+      super.foo();
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      new C();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
index 5c6a305..84ceffa 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
@@ -6,6 +6,7 @@
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
 import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
@@ -62,7 +63,7 @@
   @Parameterized.Parameters(name = "{0} target: {1} minify: {2}")
   public static Collection<Object[]> data() {
     return buildParameters(
-        getTestParameters().withAllRuntimes().build(),
+        getTestParameters().withAllRuntimesAndApiLevels().build(),
         KotlinTargetVersion.values(),
         BooleanUtils.values());
   }
@@ -87,20 +88,22 @@
 
   @Test
   public void b120951621_keepAll() throws Exception {
-    CodeInspector inspector = testForR8(parameters.getBackend())
-        .addProgramFiles(getKotlinJarFile(FOLDER))
-        .addProgramFiles(getJavaJarFile(FOLDER))
-        .addKeepMainRule(MAIN_CLASS_NAME)
-        .addKeepRules(KEEP_ANNOTATIONS)
-        .addKeepRules(
-            "-keep @interface " + ANNOTATION_NAME + " {",
-            "  *;",
-            "}"
-        )
-        .minification(minify)
-        .setMinApi(parameters.getRuntime())
-        .run(parameters.getRuntime(), MAIN_CLASS_NAME)
-        .assertSuccessWithOutput(JAVA_OUTPUT).inspector();
+    CodeInspector inspector =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(getKotlinJarFile(FOLDER))
+            .addProgramFiles(getJavaJarFile(FOLDER))
+            .addKeepMainRule(MAIN_CLASS_NAME)
+            .addKeepRules(KEEP_ANNOTATIONS)
+            .addKeepRules("-keep @interface " + ANNOTATION_NAME + " {", "  *;", "}")
+            .allowDiagnosticWarningMessages()
+            .minification(minify)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .assertAllWarningMessagesMatch(
+                equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
+            .run(parameters.getRuntime(), MAIN_CLASS_NAME)
+            .assertSuccessWithOutput(JAVA_OUTPUT)
+            .inspector();
     ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
     assertThat(clazz, isPresent());
     assertThat(clazz, not(isRenamed()));
@@ -126,20 +129,25 @@
 
   @Test
   public void b120951621_partiallyKeep() throws Exception {
-    CodeInspector inspector = testForR8(parameters.getBackend())
-        .addProgramFiles(getKotlinJarFile(FOLDER))
-        .addProgramFiles(getJavaJarFile(FOLDER))
-        .addKeepMainRule(MAIN_CLASS_NAME)
-        .addKeepRules(KEEP_ANNOTATIONS)
-        .addKeepRules(
-            "-keep,allowobfuscation @interface " + ANNOTATION_NAME + " {",
-            "  java.lang.String *f2();",
-            "}"
-        )
-        .minification(minify)
-        .setMinApi(parameters.getRuntime())
-        .run(parameters.getRuntime(), MAIN_CLASS_NAME)
-        .assertSuccessWithOutput(JAVA_OUTPUT).inspector();
+    CodeInspector inspector =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(getKotlinJarFile(FOLDER))
+            .addProgramFiles(getJavaJarFile(FOLDER))
+            .addKeepMainRule(MAIN_CLASS_NAME)
+            .addKeepRules(KEEP_ANNOTATIONS)
+            .addKeepRules(
+                "-keep,allowobfuscation @interface " + ANNOTATION_NAME + " {",
+                "  java.lang.String *f2();",
+                "}")
+            .allowDiagnosticWarningMessages()
+            .minification(minify)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .assertAllWarningMessagesMatch(
+                equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
+            .run(parameters.getRuntime(), MAIN_CLASS_NAME)
+            .assertSuccessWithOutput(JAVA_OUTPUT)
+            .inspector();
     ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
     assertThat(clazz, isPresent());
     assertEquals(minify, clazz.isRenamed());
@@ -163,15 +171,21 @@
 
   @Test
   public void b120951621_keepAnnotation() throws Exception {
-    CodeInspector inspector = testForR8(parameters.getBackend())
-        .addProgramFiles(getKotlinJarFile(FOLDER))
-        .addProgramFiles(getJavaJarFile(FOLDER))
-        .addKeepMainRule(MAIN_CLASS_NAME)
-        .addKeepRules(KEEP_ANNOTATIONS)
-        .minification(minify)
-        .setMinApi(parameters.getRuntime())
-        .run(parameters.getRuntime(), MAIN_CLASS_NAME)
-        .assertSuccessWithOutput(JAVA_OUTPUT).inspector();
+    CodeInspector inspector =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(getKotlinJarFile(FOLDER))
+            .addProgramFiles(getJavaJarFile(FOLDER))
+            .addKeepMainRule(MAIN_CLASS_NAME)
+            .addKeepRules(KEEP_ANNOTATIONS)
+            .allowDiagnosticWarningMessages()
+            .minification(minify)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .assertAllWarningMessagesMatch(
+                equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
+            .run(parameters.getRuntime(), MAIN_CLASS_NAME)
+            .assertSuccessWithOutput(JAVA_OUTPUT)
+            .inspector();
     ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
     assertThat(clazz, isPresent());
     assertEquals(minify, clazz.isRenamed());
@@ -195,14 +209,20 @@
 
   @Test
   public void b120951621_noKeep() throws Exception {
-    CodeInspector inspector = testForR8(parameters.getBackend())
-        .addProgramFiles(getKotlinJarFile(FOLDER))
-        .addProgramFiles(getJavaJarFile(FOLDER))
-        .addKeepMainRule(MAIN_CLASS_NAME)
-        .minification(minify)
-        .setMinApi(parameters.getRuntime())
-        .run(parameters.getRuntime(), MAIN_CLASS_NAME)
-        .assertSuccessWithOutput(OUTPUT_WITHOUT_ANNOTATION).inspector();
+    CodeInspector inspector =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(getKotlinJarFile(FOLDER))
+            .addProgramFiles(getJavaJarFile(FOLDER))
+            .addKeepMainRule(MAIN_CLASS_NAME)
+            .allowDiagnosticWarningMessages()
+            .minification(minify)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .assertAllWarningMessagesMatch(
+                equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
+            .run(parameters.getRuntime(), MAIN_CLASS_NAME)
+            .assertSuccessWithOutput(OUTPUT_WITHOUT_ANNOTATION)
+            .inspector();
     ClassSubject clazz = inspector.clazz(ANNOTATION_NAME);
     assertThat(clazz, isPresent());
     assertEquals(minify, clazz.isRenamed());
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/b137392797/B137392797.java b/src/test/java/com/android/tools/r8/shaking/annotations/b137392797/B137392797.java
index 9e92530..acb1e86 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/b137392797/B137392797.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/b137392797/B137392797.java
@@ -5,11 +5,13 @@
 package com.android.tools.r8.shaking.annotations.b137392797;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -70,8 +72,12 @@
             "com.squareup.wire.WireField", "com.squareup.demo.myapplication.Test")
         .addKeepMainRule(TestClass.class)
         .addKeepAttributes("*Annotation*")
-        .setMinApi(parameters.getRuntime())
+        .allowDiagnosticWarningMessages(
+            parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.N))
+        .setMinApi(parameters.getApiLevel())
         .compile()
+        .assertAllWarningMessagesMatch(
+            containsString("required for default or static interface methods desugaring"))
         .inspect(this::checkEnumUses)
         .run(parameters.getRuntime(), TestClass.class, "com.squareup.demo.myapplication.Test")
         .assertSuccessWithOutputLines(
diff --git a/src/test/java/com/android/tools/r8/shaking/assumevalues/SynthesizedRulesFromApiLevelTest.java b/src/test/java/com/android/tools/r8/shaking/assumevalues/SynthesizedRulesFromApiLevelTest.java
index fd2696f..0d9fa5e 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumevalues/SynthesizedRulesFromApiLevelTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumevalues/SynthesizedRulesFromApiLevelTest.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.D8Command;
 import com.android.tools.r8.OutputMode;
 import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.R8TestBuilder;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.ThrowableConsumer;
 import com.android.tools.r8.ToolHelper;
@@ -274,11 +275,10 @@
         AndroidApiLevel.O_MR1,
         AndroidApiLevel.O_MR1,
         expectedResultForNative(AndroidApiLevel.O_MR1),
-        builder ->
-            builder.addOptionsModification(
-                options ->
-                    // android.os.Build$VERSION only exists in the Android runtime.
-                    options.testing.allowUnusedProguardConfigurationRules = backend == Backend.CF),
+        builder -> {
+          // android.os.Build$VERSION only exists in the Android runtime.
+          builder.allowUnusedProguardConfigurationRules(backend == Backend.CF);
+        },
         this::compatCodeNotPresent,
         ImmutableList.of(
             "-assumevalues class android.os.Build$VERSION { public static final int SDK_INT return "
@@ -307,9 +307,7 @@
           AndroidApiLevel.O_MR1,
           AndroidApiLevel.O_MR1,
           expectedResultForNative(AndroidApiLevel.O_MR1),
-          builder ->
-              builder.addOptionsModification(
-                  options -> options.testing.allowUnusedProguardConfigurationRules = true),
+          builder -> builder.allowUnusedProguardConfigurationRules(backend == Backend.CF),
           this::compatCodePresent,
           ImmutableList.of(rule),
           SynthesizedRule.NOT_PRESENT);
@@ -332,9 +330,7 @@
           AndroidApiLevel.O_MR1,
           AndroidApiLevel.O_MR1,
           expectedResultForNative(AndroidApiLevel.O_MR1),
-          builder ->
-              builder.addOptionsModification(
-                  options -> options.testing.allowUnusedProguardConfigurationRules = true),
+          R8TestBuilder::allowUnusedProguardConfigurationRules,
           this::compatCodeNotPresent,
           ImmutableList.of(rule),
           SynthesizedRule.PRESENT);
diff --git a/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisherTest.java b/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisherTest.java
index 6d0d767..4ce41ce 100644
--- a/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisherTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisherTest.java
@@ -4,6 +4,8 @@
 
 package com.android.tools.r8.shaking.b134858535;
 
+import static org.hamcrest.CoreMatchers.containsString;
+
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.utils.AndroidApiLevel;
@@ -25,7 +27,9 @@
         .addProgramClassFileData(EventPublisher$bDump.dump())
         .addKeepClassRules(Interface.class)
         .addKeepMainRule(Main.class)
+        .allowDiagnosticInfoMessages()
         .setMinApi(AndroidApiLevel.L)
-        .compile();
+        .compile()
+        .assertAllWarningMessagesMatch(containsString("Unrecognized Kotlin lambda"));
   }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/desugar/KeepRuleWarningTest.java b/src/test/java/com/android/tools/r8/shaking/desugar/KeepRuleWarningTest.java
index ab37cb0..27bb092 100644
--- a/src/test/java/com/android/tools/r8/shaking/desugar/KeepRuleWarningTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/desugar/KeepRuleWarningTest.java
@@ -8,9 +8,14 @@
 import com.android.tools.r8.NeverMerge;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
 
 @NeverMerge
 interface I {
@@ -34,68 +39,82 @@
   }
 }
 
+@RunWith(Parameterized.class)
 public class KeepRuleWarningTest extends TestBase {
+
   private static final Class<?> MAIN = KeepRuleWarningTestRunner.class;
   private static final String EXPECTED_OUTPUT = StringUtils.lines("static::foo", "default::bar");
 
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDexRuntimes().withApiLevel(AndroidApiLevel.L).build();
+  }
+
+  public KeepRuleWarningTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
   @Test
   public void test_allMethods() throws Exception {
-    testForR8(Backend.DEX)
+    testForR8(parameters.getBackend())
         .addProgramClasses(I.class, C.class, MAIN)
-        .setMinApi(AndroidApiLevel.L)
+        .setMinApi(parameters.getApiLevel())
         .enableMergeAnnotations()
         .addKeepMainRule(MAIN)
         .addKeepRules("-keep interface **.I { <methods>; }")
         .compile()
         .inspectDiagnosticMessages(TestDiagnosticMessages::assertNoMessages)
-        .run(MAIN)
+        .run(parameters.getRuntime(), MAIN)
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
   }
 
   @Test
   public void test_asterisk() throws Exception {
-    testForR8(Backend.DEX)
+    testForR8(parameters.getBackend())
         .addProgramClasses(I.class, C.class, MAIN)
-        .setMinApi(AndroidApiLevel.L)
+        .setMinApi(parameters.getApiLevel())
         .enableMergeAnnotations()
         .addKeepMainRule(MAIN)
         .addKeepRules("-keep interface **.I { *(); }")
         .compile()
         .inspectDiagnosticMessages(TestDiagnosticMessages::assertNoMessages)
-        .run(MAIN)
+        .run(parameters.getRuntime(), MAIN)
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
   }
 
   @Test
   public void test_stillNotSpecific() throws Exception {
-    testForR8(Backend.DEX)
+    testForR8(parameters.getBackend())
         .addProgramClasses(I.class, C.class, MAIN)
-        .setMinApi(AndroidApiLevel.L)
+        .setMinApi(parameters.getApiLevel())
         .enableMergeAnnotations()
         .addKeepMainRule(MAIN)
         .addKeepRules("-keep interface **.I { *** f*(); }")
         .compile()
         .inspectDiagnosticMessages(TestDiagnosticMessages::assertNoMessages)
-        .run(MAIN)
+        .run(parameters.getRuntime(), MAIN)
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
   }
 
   @Test
   public void test_specific() throws Exception {
-    testForR8(Backend.DEX)
+    testForR8(parameters.getBackend())
         .addProgramClasses(I.class, C.class, MAIN)
-        .setMinApi(AndroidApiLevel.L)
+        .setMinApi(parameters.getApiLevel())
         .enableMergeAnnotations()
         .addKeepMainRule(MAIN)
         .addKeepRules("-keep interface **.I { static void foo(); }")
+        .allowDiagnosticWarningMessages()
         .compile()
-        .inspectDiagnosticMessages(m -> {
-          m.assertWarningsCount(1)
-              .assertWarningMessageThatMatches(containsString("static void foo()"))
-              .assertWarningMessageThatMatches(containsString("is ignored"))
-              .assertWarningMessageThatMatches(containsString("will be desugared"));
-        })
-        .run(MAIN)
+        .inspectDiagnosticMessages(
+            m ->
+                m.assertWarningsCount(1)
+                    .assertWarningMessageThatMatches(containsString("static void foo()"))
+                    .assertWarningMessageThatMatches(containsString("is ignored"))
+                    .assertWarningMessageThatMatches(containsString("will be desugared")))
+        .run(parameters.getRuntime(), MAIN)
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
   }
 
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAccessModifierTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAccessModifierTest.java
index 8cb1cf0..445e24b 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAccessModifierTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAccessModifierTest.java
@@ -47,6 +47,10 @@
   }
 
   private TestShrinkerBuilder<?, ?, ?, ?, ?> getTestBuilder() {
+    return getTestBuilder(false);
+  }
+
+  private TestShrinkerBuilder<?, ?, ?, ?, ?> getTestBuilder(boolean allowDiagnosticInfoMessages) {
     switch (shrinker) {
       case PROGUARD6:
         assertTrue(parameters.isCfRuntime());
@@ -54,7 +58,7 @@
       case R8:
         return testForR8(parameters.getBackend())
             .addTestingAnnotationsAsProgramClasses()
-            .allowUnusedProguardConfigurationRules()
+            .allowUnusedProguardConfigurationRules(allowDiagnosticInfoMessages)
             .enableNeverClassInliningAnnotations()
             .enableInliningAnnotations();
       default:
@@ -66,7 +70,7 @@
   public void ifOnPublic_noPublicClassForIfRule() throws Exception {
     assumeFalse(shrinker.isProguard() && parameters.isDexRuntime());
 
-    getTestBuilder()
+    getTestBuilder(shrinker.isR8())
         .addProgramClasses(CLASSES)
         .addKeepRules(
             "-repackageclasses 'top'",
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java
index 54fcadf..b79d90e 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/interfacemethoddesugaring/IfRuleWithInterfaceMethodDesugaringTest.java
@@ -9,6 +9,7 @@
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPublic;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isStatic;
 import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
@@ -17,15 +18,32 @@
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.NeverMerge;
 import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
 
+@RunWith(Parameterized.class)
 public class IfRuleWithInterfaceMethodDesugaringTest extends TestBase {
 
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDexRuntimes().withApiLevel(AndroidApiLevel.M).build();
+  }
+
+  public IfRuleWithInterfaceMethodDesugaringTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
   @Test
   public void test() throws Exception {
     String expectedOutput =
@@ -34,7 +52,7 @@
     testForJvm().addTestClasspath().run(TestClass.class).assertSuccessWithOutput(expectedOutput);
 
     CodeInspector inspector =
-        testForR8(Backend.DEX)
+        testForR8(parameters.getBackend())
             .addInnerClasses(IfRuleWithInterfaceMethodDesugaringTest.class)
             .addKeepMainRule(TestClass.class)
             .addKeepRules(
@@ -50,8 +68,9 @@
             .enableInliningAnnotations()
             .enableNeverClassInliningAnnotations()
             .enableMergeAnnotations()
-            .setMinApi(AndroidApiLevel.M)
-            .run(TestClass.class)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .run(parameters.getRuntime(), TestClass.class)
             .assertSuccessWithOutput(expectedOutput)
             .inspector();
 
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/RemovedClassTestRunner.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/RemovedClassTestRunner.java
index 37ba854..9edc64d 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/RemovedClassTestRunner.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/RemovedClassTestRunner.java
@@ -5,20 +5,19 @@
 
 import static com.android.tools.r8.references.Reference.classFromClass;
 import static com.android.tools.r8.references.Reference.methodFromMethod;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertEquals;
 
 import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.TestBase;
-import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.graphinspector.GraphInspector;
 import com.android.tools.r8.utils.graphinspector.GraphInspector.QueryNode;
 import com.google.common.collect.ImmutableList;
-import java.io.ByteArrayOutputStream;
-import java.io.PrintStream;
-import java.nio.charset.StandardCharsets;
 import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -34,15 +33,15 @@
 
   private static final String EXPECTED = StringUtils.lines("called bar");
 
-  private final Backend backend;
+  private final TestParameters parameters;
 
   @Parameters(name = "{0}")
-  public static Backend[] data() {
-    return ToolHelper.getBackends();
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
   }
 
-  public RemovedClassTestRunner(Backend backend) {
-    this.backend = backend;
+  public RemovedClassTestRunner(TestParameters parameters) {
+    this.parameters = parameters;
   }
 
   @Test
@@ -51,22 +50,24 @@
     MethodReference barMethod = methodFromMethod(CLASS.getDeclaredMethod("bar"));
     MethodReference bazMethod = methodFromMethod(CLASS.getDeclaredMethod("baz"));
 
-    ByteArrayOutputStream baos = new ByteArrayOutputStream();
     R8TestCompileResult compileResult =
-        testForR8(backend)
+        testForR8(parameters.getBackend())
             .enableGraphInspector()
             .enableInliningAnnotations()
             .addProgramClasses(CLASSES)
             .addKeepMethodRules(mainMethod)
             .addKeepRules("-whyareyoukeeping class " + REMOVED_CLASS.getTypeName())
-            .redirectStdOut(new PrintStream(baos))
-            .compile();
-    String expectedOutput = StringUtils.lines("Nothing is keeping " + REMOVED_CLASS.getTypeName());
-    String compileOutput = new String(baos.toByteArray(), StandardCharsets.UTF_8);
-    assertEquals(expectedOutput, compileOutput);
+            .setMinApi(parameters.getApiLevel())
+            .collectStdout()
+            .compile()
+            .assertStdoutThatMatches(
+                equalTo(StringUtils.lines("Nothing is keeping " + REMOVED_CLASS.getTypeName())));
 
     GraphInspector inspector =
-        compileResult.run(CLASS).assertSuccessWithOutput(EXPECTED).graphInspector();
+        compileResult
+            .run(parameters.getRuntime(), CLASS)
+            .assertSuccessWithOutput(EXPECTED)
+            .graphInspector();
 
     // The only root should be the keep main-method rule.
     assertEquals(1, inspector.getRoots().size());
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/WhyAreYouKeepingAllTest.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/WhyAreYouKeepingAllTest.java
index f4ed50c..2387e7c 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/WhyAreYouKeepingAllTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/WhyAreYouKeepingAllTest.java
@@ -5,7 +5,6 @@
 
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
@@ -13,7 +12,6 @@
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.utils.StringUtils;
 import java.io.ByteArrayOutputStream;
-import java.io.PrintStream;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import org.junit.Test;
@@ -40,7 +38,7 @@
     return getTestParameters().withNoneRuntime().build();
   }
 
-  final TestParameters parameters;
+  private final TestParameters parameters;
 
   public WhyAreYouKeepingAllTest(TestParameters parameters) {
     this.parameters = parameters;
@@ -53,13 +51,13 @@
         .addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR)
         .addKeepRuleFiles(MAIN_KEEP)
         .addKeepRules(WHY_ARE_YOU_KEEPING_ALL)
-        .redirectStdOut(new PrintStream(baos))
-        .compile();
-    assertThat(baos.toString(), containsString("referenced in keep rule"));
-
-    // TODO(b/124655065): We should always know the reason for keeping.
-    // It is OK if this starts failing while the kept-graph API is incomplete, in which case replace
-    // the 'not(containsString(' by just 'containsString('.
-    assertThat(baos.toString(), not(containsString("kept for unknown reasons")));
+        .collectStdout()
+        .compile()
+        .assertStdoutThatMatches(containsString("referenced in keep rule"))
+        // TODO(b/124655065): We should always know the reason for keeping.
+        // It is OK if this starts failing while the kept-graph API is incomplete, in which case
+        // replace
+        // the 'not(containsString(' by just 'containsString('.
+        .assertStdoutThatMatches(not(containsString("kept for unknown reasons")));
   }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java b/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java
index 82234e7..a084679 100644
--- a/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java
@@ -5,12 +5,14 @@
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 
-import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -30,31 +32,38 @@
   private static final Path MOCKITO_INTERFACE_JAR =
       Paths.get(ToolHelper.EXAMPLES_BUILD_DIR, M_I_PKG + FileUtils.JAR_EXTENSION);
 
-  private final Backend backend;
+  private final TestParameters parameters;
   private final boolean minify;
 
-  @Parameterized.Parameters(name = "Backend: {0} minify: {1}")
+  @Parameterized.Parameters(name = "{0}, minify: {1}")
   public static Collection<Object[]> data() {
-    return buildParameters(ToolHelper.getBackends(), BooleanUtils.values());
+    return buildParameters(
+        getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.values());
   }
 
-  public MockitoTest(Backend backend, boolean minify) {
-    this.backend = backend;
+  public MockitoTest(TestParameters parameters, boolean minify) {
+    this.parameters = parameters;
     this.minify = minify;
   }
 
   @Test
   public void b120675359_devirtualized() throws Exception {
     Path flagToKeepTestRunner = Paths.get(ToolHelper.EXAMPLES_DIR, M_I_PKG, "keep-rules.txt");
-    R8FullTestBuilder builder =
-        testForR8(backend)
+    CodeInspector inspector =
+        testForR8(parameters.getBackend())
             .addProgramFiles(MOCKITO_INTERFACE_JAR)
             .addKeepRuleFiles(flagToKeepTestRunner)
-            .minification(minify);
-    CodeInspector inspector = builder.compile().inspector();
+            .allowDiagnosticWarningMessages(
+                parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.N))
+            .minification(minify)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .assertAllWarningMessagesMatch(
+                containsString("required for default or static interface methods desugaring"))
+            .inspector();
     ClassSubject itf = inspector.clazz(M_I);
     assertThat(itf, isPresent());
-    MethodSubject mtd = itf.method("void", "onEnterForeground");
+    MethodSubject mtd = itf.uniqueMethodWithName("onEnterForeground");
     assertThat(mtd, not(isPresent()));
   }
 
@@ -62,15 +71,21 @@
   public void b120675359_conditional_keep() throws Exception {
     Path flagToKeepInterfaceConditionally =
         Paths.get(ToolHelper.EXAMPLES_DIR, M_I_PKG, "keep-rules-conditional-on-mock.txt");
-    R8FullTestBuilder builder =
-        testForR8(backend)
+    CodeInspector inspector =
+        testForR8(parameters.getBackend())
             .addProgramFiles(MOCKITO_INTERFACE_JAR)
             .addKeepRuleFiles(flagToKeepInterfaceConditionally)
-            .minification(minify);
-    CodeInspector inspector = builder.compile().inspector();
+            .allowDiagnosticWarningMessages(
+                parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.N))
+            .minification(minify)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .assertAllWarningMessagesMatch(
+                containsString("required for default or static interface methods desugaring"))
+            .inspector();
     ClassSubject itf = inspector.clazz(M_I);
     assertThat(itf, isPresent());
-    MethodSubject mtd = itf.method("void", "onEnterForeground");
+    MethodSubject mtd = itf.uniqueMethodWithName("onEnterForeground");
     assertThat(mtd, isPresent());
     assertThat(mtd, not(isRenamed()));
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingOverriddenMethodTest.java b/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingOverriddenMethodTest.java
index 2914c4e..39d3aaf 100644
--- a/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingOverriddenMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingOverriddenMethodTest.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.shaking.WhyAreYouKeepingConsumer;
+import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.BooleanUtils;
 import java.io.ByteArrayOutputStream;
 import java.io.PrintStream;
@@ -45,7 +46,6 @@
 
   private void testViaConfig(Class<?> main, Class<?> targetClass, Class<?> subClass)
       throws Exception {
-    ByteArrayOutputStream baos = new ByteArrayOutputStream();
     testForR8(Backend.DEX)
         .addInnerClasses(WhyAreYouKeepingOverriddenMethodTest.class)
         .addKeepMainRule(main)
@@ -55,13 +55,12 @@
         .enableInliningAnnotations()
         .enableMergeAnnotations()
         .minification(minification)
-        .setMinApi(parameters.getRuntime())
+        .setMinApi(AndroidApiLevel.B)
         // Redirect the compilers stdout to intercept the '-whyareyoukeeping' output
-        .redirectStdOut(new PrintStream(baos))
-        .compile();
-    String output = new String(baos.toByteArray(), StandardCharsets.UTF_8);
-    assertThat(output, containsString(expectedMessage(targetClass)));
-    assertThat(output, not(containsString(expectedNotContainingMessage(subClass))));
+        .collectStdout()
+        .compile()
+        .assertStdoutThatMatches(containsString(expectedMessage(targetClass)))
+        .assertStdoutThatMatches(not(containsString(expectedNotContainingMessage(subClass))));
   }
 
   private void testViaConsumer(
@@ -74,7 +73,7 @@
         .enableInliningAnnotations()
         .enableMergeAnnotations()
         .minification(minification)
-        .setMinApi(parameters.getRuntime())
+        .setMinApi(AndroidApiLevel.B)
         .setKeptGraphConsumer(graphConsumer)
         .compile();
 
diff --git a/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingTest.java b/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingTest.java
index c230c00..eeb280b 100644
--- a/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingTest.java
@@ -4,8 +4,9 @@
 
 package com.android.tools.r8.shaking.whyareyoukeeping;
 
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.not;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
 
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.NeverInline;
@@ -77,10 +78,9 @@
         .addKeepMethodRules(Reference.methodFromMethod(A.class.getMethod("foo")))
         .addKeepRules("-whyareyoukeeping class " + A.class.getTypeName())
         // Redirect the compilers stdout to intercept the '-whyareyoukeeping' output
-        .redirectStdOut(new PrintStream(baos))
-        .compile();
-    String output = new String(baos.toByteArray(), StandardCharsets.UTF_8);
-    assertEquals(expected, output);
+        .collectStdout()
+        .compile()
+        .assertStdoutThatMatches(equalTo(expected));
   }
 
   @Test
@@ -108,10 +108,9 @@
         .addKeepRules("-whyareyoukeeping class " + A.class.getTypeName() + " { baz(); }")
         .addKeepMethodRules(Reference.methodFromMethod(A.class.getMethod("foo")))
         // Redirect the compilers stdout to intercept the '-whyareyoukeeping' output
-        .redirectStdOut(new PrintStream(baos))
-        .compile();
-    String output = new String(baos.toByteArray(), StandardCharsets.UTF_8);
-    assertEquals(expected + expectedPathToBaz, output);
+        .collectStdout()
+        .compile()
+        .assertStdoutThatMatches(equalTo(expected + expectedPathToBaz));
   }
 
   @Test
@@ -133,18 +132,15 @@
 
   @Test
   public void testNonExistentClassWhyAreYouKeepingViaProguardConfig() throws Exception {
-    ByteArrayOutputStream baos = new ByteArrayOutputStream();
     testForR8(backend)
         .addProgramClasses(A.class)
         .addKeepMethodRules(Reference.methodFromMethod(A.class.getMethod("foo")))
         .addKeepRules("-whyareyoukeeping class NonExistentClass")
         .allowUnusedProguardConfigurationRules()
         // Redirect the compilers stdout to intercept the '-whyareyoukeeping' output
-        .redirectStdOut(new PrintStream(baos))
-        .compile();
-    String output = new String(baos.toByteArray(), StandardCharsets.UTF_8);
-    // Expected outcome is empty.
-    assertEquals("", output);
+        .collectStdout()
+        .compile()
+        .assertNoStdout();
   }
 
   @Test
@@ -156,10 +152,8 @@
         .addKeepMethodRules(Reference.methodFromMethod(A.class.getMethod("foo")))
         .addKeepRules("-whyareyoukeeping class " + aName + " { nonExistentMethod(); }")
         // Redirect the compilers stdout to intercept the '-whyareyoukeeping' output
-        .redirectStdOut(new PrintStream(baos))
-        .compile();
-    String output = new String(baos.toByteArray(), StandardCharsets.UTF_8);
-    // Expected outcome is empty.
-    assertFalse("b/122820741", output.isEmpty());
+        .collectStdout()
+        .compile()
+        .assertStdoutThatMatches(not(equalTo("")));
   }
 }
diff --git a/src/test/java/com/android/tools/r8/utils/ForwardingOutputStream.java b/src/test/java/com/android/tools/r8/utils/ForwardingOutputStream.java
new file mode 100644
index 0000000..082c947
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/utils/ForwardingOutputStream.java
@@ -0,0 +1,54 @@
+// 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.utils;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Arrays;
+import java.util.List;
+
+public class ForwardingOutputStream extends OutputStream {
+
+  private final List<OutputStream> listeners;
+
+  public ForwardingOutputStream(OutputStream... listeners) {
+    this.listeners = Arrays.asList(listeners);
+  }
+
+  @Override
+  public void write(int b) throws IOException {
+    for (OutputStream out : listeners) {
+      out.write(b);
+    }
+  }
+
+  @Override
+  public void write(byte[] b) throws IOException {
+    for (OutputStream out : listeners) {
+      out.write(b);
+    }
+  }
+
+  @Override
+  public void write(byte[] b, int off, int len) throws IOException {
+    for (OutputStream out : listeners) {
+      out.write(b, off, len);
+    }
+  }
+
+  @Override
+  public void flush() throws IOException {
+    for (OutputStream out : listeners) {
+      out.flush();
+    }
+  }
+
+  @Override
+  public void close() throws IOException {
+    for (OutputStream out : listeners) {
+      out.close();
+    }
+  }
+}
diff --git a/tools/apk_utils.py b/tools/apk_utils.py
index 69a9db9..9155657 100644
--- a/tools/apk_utils.py
+++ b/tools/apk_utils.py
@@ -10,7 +10,7 @@
 def sign(unsigned_apk, signed_apk, keystore, quiet=False, logging=True):
   utils.Print('Signing (ignore the warnings)', quiet=quiet)
   cmd = ['zip', '-d', unsigned_apk, 'META-INF/*']
-  utils.RunCmd(cmd, quiet=quiet, logging=logging)
+  utils.RunCmd(cmd, quiet=quiet, logging=logging, fail=False)
   cmd = [
     'jarsigner',
     '-sigalg', 'SHA1withRSA',
diff --git a/tools/build_sample_apk.py b/tools/build_sample_apk.py
index 29f7459..c035520 100755
--- a/tools/build_sample_apk.py
+++ b/tools/build_sample_apk.py
@@ -42,7 +42,8 @@
   result.add_option('--api',
                     help='Android api level',
                     default=21,
-                    choices=[14, 15, 19, 21, 22, 23, 24, 25, 26])
+                    choices=['14', '15', '19', '21', '22', '23', '24', '25',
+                             '26'])
   result.add_option('--keystore',
                     help='Keystore used for signing',
                     default=DEFAULT_KEYSTORE)
@@ -156,7 +157,8 @@
              '--classpath', utils.get_android_jar(api),
              '--min-api', str(api)]
   command.extend(files)
-  command.append(get_guava_jar())
+  if app != 'simple':
+    command.append(get_guava_jar())
 
   utils.PrintCmd(command)
   subprocess.check_call(command)
diff --git a/tools/run_on_app.py b/tools/run_on_app.py
index c31bfea..ab01595 100755
--- a/tools/run_on_app.py
+++ b/tools/run_on_app.py
@@ -163,6 +163,10 @@
                     help='Setting the increment',
                     type='int',
                     default=32)
+  result.add_option('--print-times',
+                    help='Include timing',
+                    default=False,
+                    action='store_true')
 
   return result.parse_args(argv)
 
@@ -431,6 +435,9 @@
   if not options.ignore_java_version:
     utils.check_java_version()
 
+  if options.print_times:
+    extra_args.append('-Dcom.android.tools.r8.printtimes=1')
+
   outdir = options.out
   (version_id, data) = get_version_and_data(options)