diff --git a/src/main/java/com/android/tools/r8/AssertionsConfiguration.java b/src/main/java/com/android/tools/r8/AssertionsConfiguration.java
index 15acd6f..7199b77 100644
--- a/src/main/java/com/android/tools/r8/AssertionsConfiguration.java
+++ b/src/main/java/com/android/tools/r8/AssertionsConfiguration.java
@@ -4,8 +4,7 @@
 
 package com.android.tools.r8;
 
-import java.util.ArrayList;
-import java.util.List;
+import com.android.tools.r8.utils.Reporter;
 
 @Keep
 public class AssertionsConfiguration {
@@ -24,55 +23,37 @@
     PASSTHROUGH
   }
 
-  public enum ConfigurationType {
+  public enum AssertionTransformationScope {
     ALL,
     PACKAGE,
     CLASS
   }
 
-  public static class ConfigurationEntry {
-    private final AssertionTransformation transformation;
-    private final ConfigurationType type;
-    private final String value;
+  private final AssertionTransformation transformation;
+  private final AssertionTransformationScope scope;
+  private final String value;
 
-    private ConfigurationEntry(
-        AssertionTransformation transformation, ConfigurationType type, String value) {
-      assert value != null || type == ConfigurationType.ALL;
-      this.transformation = transformation;
-      this.type = type;
-      this.value = value;
-    }
-
-    public AssertionTransformation getTransformation() {
-      return transformation;
-    }
-
-    public ConfigurationType getType() {
-      return type;
-    }
-
-    public String getValue() {
-      return value;
-    }
+  AssertionsConfiguration(
+      AssertionTransformation transformation, AssertionTransformationScope scope, String value) {
+    this.transformation = transformation;
+    this.scope = scope;
+    this.value = value;
   }
 
-  // Methods which need to be public.
-  public static class InternalAssertionConfiguration {
-
-    public static List<ConfigurationEntry> getConfiguration(AssertionsConfiguration configuration) {
-      return configuration.entries;
-    }
+  public AssertionTransformation getTransformation() {
+    return transformation;
   }
 
-  private final List<ConfigurationEntry> entries;
-
-  private AssertionsConfiguration(List<ConfigurationEntry> entries) {
-    this.entries = entries;
+  public AssertionTransformationScope getScope() {
+    return scope;
   }
 
-  static AssertionsConfiguration.Builder builder(AssertionsConfiguration previous) {
-    return new AssertionsConfiguration.Builder(
-        previous != null ? previous.entries : new ArrayList<>());
+  public String getValue() {
+    return value;
+  }
+
+  static AssertionsConfiguration.Builder builder(Reporter reporter) {
+    return new AssertionsConfiguration.Builder(reporter);
   }
 
   /**
@@ -83,33 +64,19 @@
    */
   @Keep
   public static class Builder {
-    private final List<ConfigurationEntry> entries;
+    Reporter reporter;
+    private AssertionTransformation transformation;
+    private AssertionTransformationScope scope;
+    private String value;
 
-    private Builder(List<ConfigurationEntry> previousEntries) {
-      assert previousEntries != null;
-      this.entries = previousEntries;
-    }
-
-    private void addEntry(
-        AssertionTransformation transformation, ConfigurationType type, String value) {
-      entries.add(new ConfigurationEntry(transformation, type, value));
+    private Builder(Reporter reporter) {
+      this.reporter = reporter;
     }
 
     /** Set how to handle javac generated assertion code. */
     public AssertionsConfiguration.Builder setTransformation(
         AssertionTransformation transformation) {
-      addEntry(transformation, ConfigurationType.ALL, null);
-      return this;
-    }
-
-    AssertionsConfiguration.Builder setDefault(AssertionTransformation transformation) {
-      // Add the default by inserting a transform all entry at the beginning of the list, if there
-      // isn't already one.
-      ConfigurationEntry defaultEntry =
-          new ConfigurationEntry(transformation, ConfigurationType.ALL, null);
-      if (entries.size() == 0 || entries.get(0).type != ConfigurationType.ALL) {
-        entries.listIterator().add(defaultEntry);
-      }
+      this.transformation = transformation;
       return this;
     }
 
@@ -117,7 +84,7 @@
      * Unconditionally enable javac generated assertion code in all packages and classes. This
      * corresponds to passing <code>-enableassertions</code> or <code>-ea</code> to the java CLI.
      */
-    public AssertionsConfiguration.Builder enable() {
+    public AssertionsConfiguration.Builder setEnable() {
       setTransformation(AssertionTransformation.ENABLE);
       return this;
     }
@@ -126,86 +93,145 @@
      * Disable the javac generated assertion code in all packages and classes. This corresponds to
      * passing <code>-disableassertions</code> or <code>-da</code> to the java CLI.
      */
-    public AssertionsConfiguration.Builder disable() {
+    public AssertionsConfiguration.Builder setDisable() {
       setTransformation(AssertionTransformation.DISABLE);
       return this;
     }
 
     /** Passthrough of the javac generated assertion code in all packages and classes. */
-    public AssertionsConfiguration.Builder passthrough() {
+    public AssertionsConfiguration.Builder setPassthrough() {
       setTransformation(AssertionTransformation.PASSTHROUGH);
       return this;
     }
 
-    /** Set how to handle javac generated assertion code in package and all subpackages. */
-    public AssertionsConfiguration.Builder setTransformationForPackage(
-        String packageName, AssertionTransformation transformation) {
-      addEntry(transformation, ConfigurationType.PACKAGE, packageName);
+    public AssertionsConfiguration.Builder setScopeAll() {
+      this.scope = AssertionTransformationScope.ALL;
+      this.value = null;
       return this;
     }
 
     /**
-     * Unconditionally enable javac generated assertion code in package <code>packageName</code> and
-     * all subpackages. This corresponds to passing <code>-enableassertions:packageName...</code> or
-     * <code>-ea:packageName...</code> to the java CLI.
+     * Apply the specified transformation in package <code>packageName</code> and all subpackages.
+     * If <code>packageName</code> is the empty string, this specifies that the transformation is
+     * applied ion the unnamed package.
      *
-     * <p>If <code>packageName</code> is the empty string, assertions are enabled in the unnamed
-     * package, which corresponds to passing <code>-enableassertions:...</code> or <code>-ea:...
-     * </code> to the java CLI.
-     */
-    public AssertionsConfiguration.Builder enableForPackage(String packageName) {
-      return setTransformationForPackage(packageName, AssertionTransformation.ENABLE);
-    }
-
-    /**
-     * Disable the javac generated assertion code in package <code>packageName</code> and all
-     * subpackages. This corresponds to passing <code>-disableassertions:packageName...</code> or
-     * <code>-da:packageName...</code> to the java CLI.
+     * <p>If the transformation is 'enable' this corresponds to passing <code>
+     * -enableassertions:packageName...</code> or <code>-ea:packageName...</code> to the java CLI.
      *
-     * <p>If <code>packageName</code> is the empty string assertions are disabled in the unnamed
-     * package, which corresponds to passing <code>-disableassertions:...</code> or <code>-da:...
-     * </code> to the java CLI.
+     * <p>If the transformation is 'disable' this corresponds to passing <code>
+     * -disableassertions:packageName...</code> or <code>-da:packageName...</code> to the java CLI.
      */
-    public AssertionsConfiguration.Builder disableForPackage(String packageName) {
-      return setTransformationForPackage(packageName, AssertionTransformation.DISABLE);
-    }
-
-    public AssertionsConfiguration.Builder passthroughForPackage(String packageName) {
-      return setTransformationForPackage(packageName, AssertionTransformation.PASSTHROUGH);
-    }
-
-    /** Set how to handle javac generated assertion code in class. */
-    public AssertionsConfiguration.Builder setTransformationForClass(
-        String className, AssertionTransformation transformation) {
-      addEntry(transformation, ConfigurationType.CLASS, className);
+    public AssertionsConfiguration.Builder setScopePackage(String packageName) {
+      this.scope = AssertionTransformationScope.PACKAGE;
+      this.value = packageName;
       return this;
     }
 
     /**
-     * Unconditionally enable javac generated assertion in class <code>className</code>. This
-     * corresponds to passing <code> -enableassertions:className</code> or <code>-ea:className
-     * </code> to the java CLI.
+     * Apply the specified transformation in class <code>className</code>.
+     *
+     * <p>If the transformation is 'enable' this corresponds to passing <code>
+     * -enableassertions:className</code> or <code>-ea:className...</code> to the java CLI.
+     *
+     * <p>If the transformation is 'disable' this corresponds to passing <code>
+     * -disableassertions:className</code> or <code>-da:className</code> to the java CLI.
      */
-    public AssertionsConfiguration.Builder enableForClass(String className) {
-      return setTransformationForClass(className, AssertionTransformation.ENABLE);
-    }
-
-    /**
-     * Disable the javac generated assertion code in class <code>className</code>. This corresponds
-     * to passing <code> -disableassertions:className</code> or <code>-da:className</code> to the
-     * java CLI.
-     */
-    public AssertionsConfiguration.Builder disableForClass(String className) {
-      return setTransformationForClass(className, AssertionTransformation.DISABLE);
-    }
-
-    public AssertionsConfiguration.Builder passthroughForClass(String className) {
-      return setTransformationForClass(className, AssertionTransformation.PASSTHROUGH);
+    public AssertionsConfiguration.Builder setScopeClass(String className) {
+      this.scope = AssertionTransformationScope.CLASS;
+      this.value = className;
+      return this;
     }
 
     /** Build and return the {@link AssertionsConfiguration}. */
     public AssertionsConfiguration build() {
-      return new AssertionsConfiguration(entries);
+      if (transformation == null) {
+        reporter.error("No transformation specified for building AccertionConfiguration");
+      }
+      if (scope == null) {
+        reporter.error("No scope specified for building AccertionConfiguration");
+      }
+      if (scope == AssertionTransformationScope.PACKAGE && value == null) {
+        reporter.error("No package name specified for building AccertionConfiguration");
+      }
+      if (scope == AssertionTransformationScope.CLASS && value == null) {
+        reporter.error("No class name specified for building AccertionConfiguration");
+      }
+      return new AssertionsConfiguration(transformation, scope, value);
+    }
+
+    /**
+     * Static helper to build an <code>AssertionConfiguration</code> which unconditionally enables
+     * javac generated assertion code in all packages and classes. To be used like this:
+     *
+     * <pre>
+     *   D8Command command = D8Command.builder()
+     *     .addAssertionsConfiguration(AssertionsConfiguration.Builder::enableAllAssertions)
+     *     ...
+     *     .build();
+     * </pre>
+     *
+     * which is a shorthand for:
+     *
+     * <pre>
+     *   D8Command command = D8Command.builder()
+     *     .addAssertionsConfiguration(builder -> builder.setEnabled().setScopeAll().build())
+     *     ...
+     *     .build();
+     * </pre>
+     */
+    public static AssertionsConfiguration enableAllAssertions(
+        AssertionsConfiguration.Builder builder) {
+      return builder.setEnable().setScopeAll().build();
+    }
+
+    /**
+     * Static helper to build an <code>AssertionConfiguration</code> which unconditionally disables
+     * javac generated assertion code in all packages and classes. To be used like this:
+     *
+     * <pre>
+     *   D8Command command = D8Command.builder()
+     *     .addAssertionsConfiguration(AssertionsConfiguration.Builder::disableAllAssertions)
+     *     ...
+     *     .build();
+     * </pre>
+     *
+     * which is a shorthand for:
+     *
+     * <pre>
+     *   D8Command command = D8Command.builder()
+     *     .addAssertionsConfiguration(builder -> builder.setDisabled().setScopeAll().build())
+     *     ...
+     *     .build();
+     * </pre>
+     */
+    public static AssertionsConfiguration disableAllAssertions(
+        AssertionsConfiguration.Builder builder) {
+      return builder.setDisable().setScopeAll().build();
+    }
+
+    /**
+     * Static helper to build an <code>AssertionConfiguration</code> which will passthrough javac
+     * generated assertion code in all packages and classes. To be used like this:
+     *
+     * <pre>
+     *   D8Command command = D8Command.builder()
+     *     .addAssertionsConfiguration(AssertionsConfiguration.Builder::passthroughAllAssertions)
+     *     ...
+     *     .build();
+     * </pre>
+     *
+     * which is a shorthand for:
+     *
+     * <pre>
+     *   D8Command command = D8Command.builder()
+     *     .addAssertionsConfiguration(builder -> builder.setPassthrough().setScopeAll().build())
+     *     ...
+     *     .build();
+     * </pre>
+     */
+    public static AssertionsConfiguration passthroughAllAssertions(
+        AssertionsConfiguration.Builder builder) {
+      return builder.setPassthrough().setScopeAll().build();
     }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/BaseCompilerCommand.java b/src/main/java/com/android/tools/r8/BaseCompilerCommand.java
index 2b94a54..fd2ecb3 100644
--- a/src/main/java/com/android/tools/r8/BaseCompilerCommand.java
+++ b/src/main/java/com/android/tools/r8/BaseCompilerCommand.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8;
 
-import com.android.tools.r8.AssertionsConfiguration.AssertionTransformation;
 import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.DexItemFactory;
@@ -40,7 +39,7 @@
   private final boolean includeClassesChecksum;
   private final boolean optimizeMultidexForLinearAlloc;
   private final BiPredicate<String, Long> dexClassChecksumFilter;
-  private final AssertionsConfiguration assertionsConfiguration;
+  private final List<AssertionsConfiguration> assertionsConfiguration;
 
   BaseCompilerCommand(boolean printHelp, boolean printVersion) {
     super(printHelp, printVersion);
@@ -53,7 +52,7 @@
     includeClassesChecksum = false;
     optimizeMultidexForLinearAlloc = false;
     dexClassChecksumFilter = (name, checksum) -> true;
-    assertionsConfiguration = null;
+    assertionsConfiguration = new ArrayList<>();
   }
 
   BaseCompilerCommand(
@@ -67,7 +66,7 @@
       boolean optimizeMultidexForLinearAlloc,
       boolean includeClassesChecksum,
       BiPredicate<String, Long> dexClassChecksumFilter,
-      AssertionsConfiguration assertionsConfiguration) {
+      List<AssertionsConfiguration> assertionsConfiguration) {
     super(app);
     assert minApiLevel > 0;
     assert mode != null;
@@ -135,11 +134,8 @@
     return optimizeMultidexForLinearAlloc;
   }
 
-  AssertionsConfiguration getAssertionsConfiguration(
-      AssertionTransformation defaultTransformation) {
-    return AssertionsConfiguration.builder(assertionsConfiguration)
-        .setDefault(defaultTransformation)
-        .build();
+  public List<AssertionsConfiguration> getAssertionsConfiguration() {
+    return assertionsConfiguration;
   }
 
   Reporter getReporter() {
@@ -171,7 +167,7 @@
     private boolean lookupLibraryBeforeProgram = true;
     private boolean optimizeMultidexForLinearAlloc = false;
     private BiPredicate<String, Long> dexClassChecksumFilter = (name, checksum) -> true;
-    private AssertionsConfiguration assertionsConfiguration;
+    private List<AssertionsConfiguration> assertionsConfiguration = new ArrayList<>();
 
     abstract CompilationMode defaultCompilationMode();
 
@@ -490,20 +486,19 @@
       return includeClassesChecksum;
     }
 
+    List<AssertionsConfiguration> getAssertionsConfiguration() {
+      return assertionsConfiguration;
+    }
+
     /** Configure compile time assertion enabling through a {@link AssertionsConfiguration}. */
     public B addAssertionsConfiguration(
         Function<AssertionsConfiguration.Builder, AssertionsConfiguration>
             assertionsConfigurationGenerator) {
-      assertionsConfiguration =
-          assertionsConfigurationGenerator.apply(
-              AssertionsConfiguration.builder(assertionsConfiguration));
+      assertionsConfiguration.add(
+          assertionsConfigurationGenerator.apply(AssertionsConfiguration.builder(getReporter())));
       return self();
     }
 
-    public AssertionsConfiguration getAssertionsConfiguration() {
-      return assertionsConfiguration;
-    }
-
     @Override
     void validate() {
       Reporter reporter = getReporter();
diff --git a/src/main/java/com/android/tools/r8/D8.java b/src/main/java/com/android/tools/r8/D8.java
index d3ec378..cf5e6c8 100644
--- a/src/main/java/com/android/tools/r8/D8.java
+++ b/src/main/java/com/android/tools/r8/D8.java
@@ -159,7 +159,7 @@
 
       final CfgPrinter printer = options.printCfg ? new CfgPrinter() : null;
 
-      if (!AssertionsRewriter.isPassthroughAll(options.assertionsConfiguration)) {
+      if (AssertionsRewriter.isEnabled(options)) {
         // Run analysis to mark all <clinit> methods having the javac generated assertion
         // enabling code.
         ClassInitializerAssertionEnablingAnalysis analysis =
diff --git a/src/main/java/com/android/tools/r8/D8Command.java b/src/main/java/com/android/tools/r8/D8Command.java
index 2401aa5..b76e6a7 100644
--- a/src/main/java/com/android/tools/r8/D8Command.java
+++ b/src/main/java/com/android/tools/r8/D8Command.java
@@ -10,11 +10,13 @@
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.AssertionConfigurationWithDefault;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.Reporter;
 import com.android.tools.r8.utils.StringDiagnostic;
 import java.nio.file.Path;
 import java.util.Collection;
+import java.util.List;
 import java.util.function.BiPredicate;
 
 /**
@@ -287,7 +289,7 @@
       DesugarGraphConsumer desugarGraphConsumer,
       StringConsumer desugaredLibraryKeepRuleConsumer,
       DesugaredLibraryConfiguration libraryConfiguration,
-      AssertionsConfiguration assertionsConfiguration,
+      List<AssertionsConfiguration> assertionsConfiguration,
       DexItemFactory factory) {
     super(
         inputApp,
@@ -361,10 +363,11 @@
     internal.desugaredLibraryConfiguration = libraryConfiguration;
     internal.desugaredLibraryKeepRuleConsumer = desugaredLibraryKeepRuleConsumer;
 
+    // Default is to remove all javac generated assertion code when generating dex.
     assert internal.assertionsConfiguration == null;
-    // Default, when no configuration is provided, is to remove all javac generated assertion
-    // code when generating dex.
-    internal.assertionsConfiguration = getAssertionsConfiguration(AssertionTransformation.DISABLE);
+    internal.assertionsConfiguration =
+        new AssertionConfigurationWithDefault(
+            AssertionTransformation.DISABLE, getAssertionsConfiguration());
 
     return internal;
   }
diff --git a/src/main/java/com/android/tools/r8/D8CommandParser.java b/src/main/java/com/android/tools/r8/D8CommandParser.java
index 792f8b9..1099cf9 100644
--- a/src/main/java/com/android/tools/r8/D8CommandParser.java
+++ b/src/main/java/com/android/tools/r8/D8CommandParser.java
@@ -30,7 +30,8 @@
           "--classpath",
           "--min-api",
           "--main-dex-list",
-          "--main-dex-list-output");
+          "--main-dex-list-output",
+          "--desugared-lib");
 
   private static final String APK_EXTENSION = ".apk";
   private static final String JAR_EXTENSION = ".jar";
@@ -124,6 +125,8 @@
               "                          # merging.",
               "  --file-per-class        # Produce a separate dex file per input class",
               "  --no-desugaring         # Force disable desugaring.",
+              "  --desugared-lib <file>  # Specify desugared library configuration.",
+              "                          # <file> is a desugared library configuration (json).",
               "  --main-dex-list <file>  # List of classes to place in the primary dex file.",
               "  --main-dex-list-output <file>",
               "                          # Output resulting main dex list in <file>.",
@@ -245,6 +248,8 @@
         builder.setIntermediate(true);
       } else if (arg.equals("--no-desugaring")) {
         builder.setDisableDesugaring(true);
+      } else if (arg.equals("--desugared-lib")) {
+        builder.addDesugaredLibraryConfiguration(StringResource.fromFile(Paths.get(nextArg)));
       } else {
         if (arg.startsWith("--")) {
           builder.error(new StringDiagnostic("Unknown option: " + arg, origin));
diff --git a/src/main/java/com/android/tools/r8/DesugarGraphConsumer.java b/src/main/java/com/android/tools/r8/DesugarGraphConsumer.java
index d75b2b0..2210490 100644
--- a/src/main/java/com/android/tools/r8/DesugarGraphConsumer.java
+++ b/src/main/java/com/android/tools/r8/DesugarGraphConsumer.java
@@ -21,4 +21,11 @@
    * @param dependency Origin of code that is a dependency to compile {@code dependent}.
    */
   void accept(Origin dependent, Origin dependency);
+
+  /**
+   * Callback indicating no more dependency edges for the active compilation unit.
+   *
+   * <p>Note: this callback places no other guarantees on number of calls or on which threads.
+   */
+  void finished();
 }
diff --git a/src/main/java/com/android/tools/r8/L8.java b/src/main/java/com/android/tools/r8/L8.java
index 50ea501..a692e1d 100644
--- a/src/main/java/com/android/tools/r8/L8.java
+++ b/src/main/java/com/android/tools/r8/L8.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8;
 
+import static com.android.tools.r8.L8Command.USAGE_MESSAGE;
 import static com.android.tools.r8.utils.ExceptionUtils.unwrapExecutionException;
 
 import com.android.tools.r8.dex.ApplicationReader;
@@ -15,11 +16,13 @@
 import com.android.tools.r8.ir.desugar.PrefixRewritingMapper;
 import com.android.tools.r8.jar.CfApplicationWriter;
 import com.android.tools.r8.naming.PrefixRewritingNamingLens;
+import com.android.tools.r8.origin.CommandLineOrigin;
 import com.android.tools.r8.shaking.AnnotationRemover;
 import com.android.tools.r8.shaking.L8TreePruner;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.ExceptionUtils;
 import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.SelfRetraceTest;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
 import java.io.IOException;
@@ -144,4 +147,31 @@
       }
     }
   }
+
+  private static void run(String[] args) throws CompilationFailedException {
+    L8Command command = L8Command.parse(args, CommandLineOrigin.INSTANCE).build();
+    if (command.isPrintHelp()) {
+      SelfRetraceTest.test();
+      System.out.println(USAGE_MESSAGE);
+      return;
+    }
+    if (command.isPrintVersion()) {
+      System.out.println("L8 " + Version.getVersionString());
+      return;
+    }
+    run(command);
+  }
+
+  /**
+   * Command-line entry to L8.
+   *
+   * <p>See {@link L8Command#USAGE_MESSAGE} or run {@code l8 --help} for usage information.
+   */
+  public static void main(String[] args) {
+    if (args.length == 0) {
+      System.err.println(USAGE_MESSAGE);
+      System.exit(ExceptionUtils.STATUS_ERROR);
+    }
+    ExceptionUtils.withMainProgramHandler(() -> run(args));
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/L8Command.java b/src/main/java/com/android/tools/r8/L8Command.java
index 1346623..1ddd338 100644
--- a/src/main/java/com/android/tools/r8/L8Command.java
+++ b/src/main/java/com/android/tools/r8/L8Command.java
@@ -10,10 +10,12 @@
 import com.android.tools.r8.ir.desugar.DesugaredLibraryConfiguration;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.AssertionConfigurationWithDefault;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.Pair;
 import com.android.tools.r8.utils.Reporter;
 import com.android.tools.r8.utils.StringDiagnostic;
+import com.google.common.collect.ImmutableList;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -24,9 +26,11 @@
 @Keep
 public final class L8Command extends BaseCompilerCommand {
 
+  static final String USAGE_MESSAGE = R8CommandParser.USAGE_MESSAGE;
+
   private final D8Command d8Command;
   private final R8Command r8Command;
-  private final com.android.tools.r8.ir.desugar.DesugaredLibraryConfiguration libraryConfiguration;
+  private final DesugaredLibraryConfiguration libraryConfiguration;
   private final DexItemFactory factory;
 
   boolean isShrinking() {
@@ -41,6 +45,33 @@
     return r8Command;
   }
 
+  /**
+   * Parse the L8 command-line.
+   *
+   * <p>Parsing will set the supplied options or their default value if they have any.
+   *
+   * @param args Command-line arguments array.
+   * @param origin Origin description of the command-line arguments.
+   * @return L8 command builder with state set up according to parsed command line.
+   */
+  public static Builder parse(String[] args, Origin origin) {
+    return L8CommandParser.parse(args, origin);
+  }
+
+  /**
+   * Parse the L8 command-line.
+   *
+   * <p>Parsing will set the supplied options or their default value if they have any.
+   *
+   * @param args Command-line arguments array.
+   * @param origin Origin description of the command-line arguments.
+   * @param handler Custom defined diagnostics handler.
+   * @return L8 command builder with state set up according to parsed command line.
+   */
+  public static Builder parse(String[] args, Origin origin, DiagnosticsHandler handler) {
+    return L8CommandParser.parse(args, origin, handler);
+  }
+
   private L8Command(
       R8Command r8Command,
       D8Command d8Command,
@@ -63,7 +94,7 @@
         false,
         false,
         (name, checksum) -> true,
-        AssertionsConfiguration.builder(null).build());
+        ImmutableList.of());
     this.d8Command = d8Command;
     this.r8Command = r8Command;
     this.libraryConfiguration = libraryConfiguration;
@@ -142,10 +173,11 @@
     // TODO(134732760): This is still work in progress.
     internal.desugaredLibraryConfiguration = libraryConfiguration;
 
+    // Default is to remove all javac generated assertion code when generating dex.
     assert internal.assertionsConfiguration == null;
-    // Default, when no configuration is provided, is to remove all javac generated assertion
-    // code when generating dex.
-    internal.assertionsConfiguration = getAssertionsConfiguration(AssertionTransformation.DISABLE);
+    internal.assertionsConfiguration =
+        new AssertionConfigurationWithDefault(
+            AssertionTransformation.DISABLE, getAssertionsConfiguration());
 
     return internal;
   }
diff --git a/src/main/java/com/android/tools/r8/L8CommandParser.java b/src/main/java/com/android/tools/r8/L8CommandParser.java
new file mode 100644
index 0000000..1dc83c1
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/L8CommandParser.java
@@ -0,0 +1,164 @@
+// 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;
+
+import com.android.tools.r8.D8CommandParser.OrderedClassFileResourceProvider;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.FlagFile;
+import com.android.tools.r8.utils.StringDiagnostic;
+import com.google.common.collect.ImmutableSet;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Set;
+
+public class L8CommandParser extends BaseCompilerCommandParser {
+
+  private static final Set<String> OPTIONS_WITH_PARAMETER =
+      ImmutableSet.of("--output", "--lib", "--min-api", "--desugared-lib");
+
+  public static void main(String[] args) throws CompilationFailedException {
+    L8Command command = parse(args, Origin.root()).build();
+    if (command.isPrintHelp()) {
+      System.out.println(USAGE_MESSAGE);
+      System.exit(1);
+    }
+    L8.run(command);
+  }
+
+  static final String USAGE_MESSAGE =
+      String.join(
+          "\n",
+          Arrays.asList(
+              "Usage: l8 [options] <input-files>",
+              " where <input-files> are any combination of dex, class, zip, jar, or apk files",
+              " and options are:",
+              "  --debug                 # Compile with debugging information (default).",
+              "  --release               # Compile without debugging information.",
+              "  --output <file>         # Output result in <outfile>.",
+              "                          # <file> must be an existing directory or a zip file.",
+              "  --lib <file|jdk-home>   # Add <file|jdk-home> as a library resource.",
+              "  --min-api <number>      # Minimum Android API level compatibility, default: "
+                  + AndroidApiLevel.getDefault().getLevel()
+                  + ".",
+              "  --pg-conf <file>        # Proguard configuration <file>.",
+              "  --desugared-lib <file>  # Specify desugared library configuration.",
+              "                          # <file> is a desugared library configuration (json).",
+              "  --version               # Print the version of l8.",
+              "  --help                  # Print this message."));
+
+  /**
+   * Parse the D8 command-line.
+   *
+   * <p>Parsing will set the supplied options or their default value if they have any.
+   *
+   * @param args Command-line arguments array.
+   * @param origin Origin description of the command-line arguments.
+   * @return D8 command builder with state set up according to parsed command line.
+   */
+  public static L8Command.Builder parse(String[] args, Origin origin) {
+    return parse(args, origin, L8Command.builder());
+  }
+
+  /**
+   * Parse the D8 command-line.
+   *
+   * <p>Parsing will set the supplied options or their default value if they have any.
+   *
+   * @param args Command-line arguments array.
+   * @param origin Origin description of the command-line arguments.
+   * @param handler Custom defined diagnostics handler.
+   * @return D8 command builder with state set up according to parsed command line.
+   */
+  public static L8Command.Builder parse(String[] args, Origin origin, DiagnosticsHandler handler) {
+    return parse(args, origin, L8Command.builder(handler));
+  }
+
+  private static L8Command.Builder parse(String[] args, Origin origin, L8Command.Builder builder) {
+    CompilationMode compilationMode = null;
+    Path outputPath = null;
+    OutputMode outputMode = null;
+    boolean hasDefinedApiLevel = false;
+    OrderedClassFileResourceProvider.Builder classpathBuilder =
+        OrderedClassFileResourceProvider.builder();
+    String[] expandedArgs = FlagFile.expandFlagFiles(args, builder);
+    for (int i = 0; i < expandedArgs.length; i++) {
+      String arg = expandedArgs[i].trim();
+      String nextArg = null;
+      if (OPTIONS_WITH_PARAMETER.contains(arg)) {
+        if (++i < expandedArgs.length) {
+          nextArg = expandedArgs[i];
+        } else {
+          builder.error(
+              new StringDiagnostic("Missing parameter for " + expandedArgs[i - 1] + ".", origin));
+          break;
+        }
+      }
+      if (arg.length() == 0) {
+        continue;
+      } else if (arg.equals("--help")) {
+        builder.setPrintHelp(true);
+      } else if (arg.equals("--version")) {
+        builder.setPrintVersion(true);
+      } else if (arg.equals("--debug")) {
+        if (compilationMode == CompilationMode.RELEASE) {
+          builder.error(
+              new StringDiagnostic("Cannot compile in both --debug and --release mode.", origin));
+          continue;
+        }
+        compilationMode = CompilationMode.DEBUG;
+      } else if (arg.equals("--release")) {
+        if (compilationMode == CompilationMode.DEBUG) {
+          builder.error(
+              new StringDiagnostic("Cannot compile in both --debug and --release mode.", origin));
+          continue;
+        }
+        compilationMode = CompilationMode.RELEASE;
+      } else if (arg.equals("--output")) {
+        if (outputPath != null) {
+          builder.error(
+              new StringDiagnostic(
+                  "Cannot output both to '" + outputPath.toString() + "' and '" + nextArg + "'",
+                  origin));
+          continue;
+        }
+        outputPath = Paths.get(nextArg);
+      } else if (arg.equals("--min-api")) {
+        if (hasDefinedApiLevel) {
+          builder.error(new StringDiagnostic("Cannot set multiple --min-api options", origin));
+        } else {
+          parseMinApi(builder, nextArg, origin);
+          hasDefinedApiLevel = true;
+        }
+      } else if (arg.equals("--lib")) {
+        addLibraryArgument(builder, origin, nextArg);
+      } else if (arg.equals("--pg-conf")) {
+        builder.addProguardConfigurationFiles(Paths.get(nextArg));
+      } else if (arg.equals("--desugared-lib")) {
+        builder.addDesugaredLibraryConfiguration(StringResource.fromFile(Paths.get(nextArg)));
+      } else {
+        if (arg.startsWith("--")) {
+          builder.error(new StringDiagnostic("Unknown option: " + arg, origin));
+          continue;
+        }
+        builder.addProgramFiles(Paths.get(arg));
+      }
+    }
+    if (!classpathBuilder.isEmpty()) {
+      builder.addClasspathResourceProvider(classpathBuilder.build());
+    }
+    if (compilationMode != null) {
+      builder.setMode(compilationMode);
+    }
+    if (outputMode == null) {
+      outputMode = OutputMode.DexIndexed;
+    }
+    if (outputPath == null) {
+      outputPath = Paths.get(".");
+    }
+    return builder.setOutput(outputPath, outputMode);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 8c26650..dbe1572 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -807,7 +807,7 @@
     if (appView.options().enableInitializedClassesInInstanceMethodsAnalysis) {
       enqueuer.registerAnalysis(new InitializedClassesInInstanceMethodsAnalysis(appView));
     }
-    if (!AssertionsRewriter.isPassthroughAll(appView.options().assertionsConfiguration)) {
+    if (AssertionsRewriter.isEnabled(appView.options())) {
       enqueuer.registerAnalysis(
           new ClassInitializerAssertionEnablingAnalysis(
               appView.dexItemFactory(), OptimizationFeedbackSimple.getInstance()));
diff --git a/src/main/java/com/android/tools/r8/R8Command.java b/src/main/java/com/android/tools/r8/R8Command.java
index 265fa38..187e095 100644
--- a/src/main/java/com/android/tools/r8/R8Command.java
+++ b/src/main/java/com/android/tools/r8/R8Command.java
@@ -21,6 +21,7 @@
 import com.android.tools.r8.shaking.ProguardConfigurationSourceStrings;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.AssertionConfigurationWithDefault;
 import com.android.tools.r8.utils.ExceptionDiagnostic;
 import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.InternalOptions;
@@ -720,7 +721,7 @@
       StringConsumer desugaredLibraryKeepRuleConsumer,
       DesugaredLibraryConfiguration libraryConfiguration,
       FeatureSplitConfiguration featureSplitConfiguration,
-      AssertionsConfiguration assertionsConfiguration) {
+      List<AssertionsConfiguration> assertionsConfiguration) {
     super(
         inputApp,
         mode,
@@ -870,14 +871,14 @@
 
     internal.syntheticProguardRulesConsumer = syntheticProguardRulesConsumer;
 
+    // Default is to remove all javac generated assertion code when generating dex.
     assert internal.assertionsConfiguration == null;
-    // Default, when no configuration is provided, is to remove all javac generated assertion
-    // code when generating dex and leave it when generating class files.
     internal.assertionsConfiguration =
-        getAssertionsConfiguration(
-            internal.isGeneratingClassFiles()
+        new AssertionConfigurationWithDefault(
+            getProgramConsumer() instanceof ClassFileConsumer
                 ? AssertionTransformation.PASSTHROUGH
-                : AssertionTransformation.DISABLE);
+                : AssertionTransformation.DISABLE,
+            getAssertionsConfiguration());
 
     // When generating class files the build is "intermediate" and we cannot pollute the namespace
     // with the a hard-coded outline class. Doing so would prohibit subsequent merging of two
diff --git a/src/main/java/com/android/tools/r8/R8CommandParser.java b/src/main/java/com/android/tools/r8/R8CommandParser.java
index b0acdb6..dd9ab8e 100644
--- a/src/main/java/com/android/tools/r8/R8CommandParser.java
+++ b/src/main/java/com/android/tools/r8/R8CommandParser.java
@@ -25,7 +25,8 @@
           "--main-dex-list",
           "--main-dex-list-output",
           "--pg-conf",
-          "--pg-map-output");
+          "--pg-map-output",
+          "--desugared-lib");
 
   public static void main(String[] args) throws CompilationFailedException {
     R8Command command = parse(args, Origin.root()).build();
@@ -65,6 +66,8 @@
                   + ".",
               "  --pg-conf <file>         # Proguard configuration <file>.",
               "  --pg-map-output <file>   # Output the resulting name and line mapping to <file>.",
+              "  --desugared-lib <file>   # Specify desugared library configuration.",
+              "                           # <file> is a desugared library configuration (json).",
               "  --no-tree-shaking        # Force disable tree shaking of unreachable classes.",
               "  --no-minification        # Force disable minification of names.",
               "  --no-data-resources      # Ignore all data resources.",
@@ -206,6 +209,8 @@
         builder.addProguardConfigurationFiles(Paths.get(nextArg));
       } else if (arg.equals("--pg-map-output")) {
         builder.setProguardMapOutputPath(Paths.get(nextArg));
+      } else if (arg.equals("--desugared-lib")) {
+        builder.addDesugaredLibraryConfiguration(StringResource.fromFile(Paths.get(nextArg)));
       } else if (arg.equals("--no-data-resources")) {
         state.includeDataResources = false;
       } else {
diff --git a/src/main/java/com/android/tools/r8/SwissArmyKnife.java b/src/main/java/com/android/tools/r8/SwissArmyKnife.java
index f54233b..d13081c 100644
--- a/src/main/java/com/android/tools/r8/SwissArmyKnife.java
+++ b/src/main/java/com/android/tools/r8/SwissArmyKnife.java
@@ -76,6 +76,9 @@
       case "r8":
         R8.main(shift(args));
         break;
+      case "l8":
+        L8.main(shift(args));
+        break;
       default:
         runDefault(args);
         break;
diff --git a/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java b/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java
index afdc15b..4656408 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java
@@ -212,7 +212,7 @@
       // default interface methods, it is expected they are targeted with invoke-direct.
       return this.itf && desugaringEnabled ? Type.DIRECT : Type.SUPER;
     }
-    if (!encodedMethod.isVirtualMethod()) {
+    if (!encodedMethod.isNonPrivateVirtualMethod()) {
       return Type.DIRECT;
     }
     if (encodedMethod.accessFlags.isFinal()) {
diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java b/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
index 7ba04b5..993363c 100644
--- a/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
@@ -49,8 +49,8 @@
 import com.android.tools.r8.utils.ThreadUtils;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ObjectArrays;
-import it.unimi.dsi.fastutil.objects.Object2LongMap;
-import it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap;
+import it.unimi.dsi.fastutil.objects.Reference2LongMap;
+import it.unimi.dsi.fastutil.objects.Reference2LongOpenHashMap;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -204,14 +204,15 @@
    */
   private void encodeChecksums(Iterable<VirtualFile> files) {
     List<DexProgramClass> classes = application.classes();
-    Object2LongMap<String> inputChecksums = new Object2LongOpenHashMap<>(classes.size());
+    Reference2LongMap<DexString> inputChecksums = new Reference2LongOpenHashMap<>(classes.size());
     for (DexProgramClass clazz : classes) {
-      inputChecksums.put(clazz.getType().descriptor.toASCIIString(), clazz.getChecksum());
+      inputChecksums.put(clazz.getType().descriptor, clazz.getChecksum());
     }
     for (VirtualFile file : files) {
       ClassesChecksum toWrite = new ClassesChecksum();
-      for (String desc : file.getClassDescriptors()) {
-        toWrite.addChecksum(desc, inputChecksums.getLong(desc));
+      for (DexProgramClass clazz : file.classes()) {
+        DexString desc = clazz.type.descriptor;
+        toWrite.addChecksum(desc.toString(), inputChecksums.getLong(desc));
       }
       file.injectString(application.dexItemFactory.createString(toWrite.toJsonString()));
     }
diff --git a/src/main/java/com/android/tools/r8/dex/DexParser.java b/src/main/java/com/android/tools/r8/dex/DexParser.java
index d5e338e..c69d8e0 100644
--- a/src/main/java/com/android/tools/r8/dex/DexParser.java
+++ b/src/main/java/com/android/tools/r8/dex/DexParser.java
@@ -716,7 +716,7 @@
 
       Long checksum = null;
       if (checksums != null && !checksums.isEmpty()) {
-        String desc = type.descriptor.toASCIIString();
+        String desc = type.toDescriptorString();
         checksum = checksums.getOrDefault(desc, null);
         if (!options.dexClassChecksumFilter.test(desc, checksum)) {
           continue;
diff --git a/src/main/java/com/android/tools/r8/graph/AppInfo.java b/src/main/java/com/android/tools/r8/graph/AppInfo.java
index 86b2cb8..ad19ed4 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfo.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfo.java
@@ -256,16 +256,17 @@
 
   /**
    * Lookup virtual method starting in type and following the super chain.
-   * <p>
-   * This method will resolve the method on the holder of {@code method} and only return a
-   * non-null value if the result of resolution was a non-static, non-private method.
+   *
+   * <p>This method will resolve the method on the holder of {@code method} and only return a
+   * non-null value if the result of resolution was a virtual target.
+   *
+   * <p>TODO(b/140204899): Delete this method as it does resolution and not a "lookup of targets".
    */
   public DexEncodedMethod lookupVirtualTarget(DexType type, DexMethod method) {
     assert checkIfObsolete();
     assert type.isClassType() || type.isArrayType();
     ResolutionResult resolutionResult = resolveMethod(type, method);
-    DexEncodedMethod target = resolutionResult.getSingleTarget();
-    return target == null || target.isVirtualMethod() ? target : null;
+    return resolutionResult.isVirtualTarget() ? resolutionResult.getSingleTarget() : null;
   }
 
   /**
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
index dbd455b..a928529 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -221,11 +221,11 @@
   }
 
   public OptionalBool isLibraryMethodOverride() {
-    return isVirtualMethod() ? isLibraryMethodOverride : OptionalBool.FALSE;
+    return isNonPrivateVirtualMethod() ? isLibraryMethodOverride : OptionalBool.FALSE;
   }
 
   public void setLibraryMethodOverride(OptionalBool isLibraryMethodOverride) {
-    assert isVirtualMethod();
+    assert isNonPrivateVirtualMethod();
     assert !isLibraryMethodOverride.isUnknown();
     assert isLibraryMethodOverride.isPossiblyFalse()
             || this.isLibraryMethodOverride.isPossiblyTrue()
@@ -287,12 +287,19 @@
   }
 
   /**
-   * Returns true if this method can be invoked via invoke-virtual, invoke-super or
-   * invoke-interface.
+   * Returns true if this method can be invoked via invoke-virtual/interface.
+   *
+   * <p>Note that also private methods can be the target of a virtual invoke. In such cases, the
+   * validity of the invoke depends on the access granted to the call site.
    */
   public boolean isVirtualMethod() {
     checkIfObsolete();
-    return !accessFlags.isStatic() && !accessFlags.isPrivate() && !accessFlags.isConstructor();
+    return !accessFlags.isStatic() && !accessFlags.isConstructor();
+  }
+
+  public boolean isNonPrivateVirtualMethod() {
+    checkIfObsolete();
+    return !isPrivateMethod() && isVirtualMethod();
   }
 
   /**
diff --git a/src/main/java/com/android/tools/r8/graph/DexType.java b/src/main/java/com/android/tools/r8/graph/DexType.java
index bbed9bc..9a8a73c 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -82,7 +82,14 @@
   public boolean isAlwaysNull(AppView<AppInfoWithLiveness> appView) {
     if (isClassType()) {
       DexProgramClass clazz = asProgramClassOrNull(appView.definitionFor(this));
-      return clazz != null && !appView.appInfo().isInstantiatedDirectlyOrIndirectly(clazz);
+      if (clazz == null) {
+        return false;
+      }
+      if (appView.options().enableUninstantiatedTypeOptimizationForInterfaces) {
+        return !appView.appInfo().isInstantiatedDirectlyOrIndirectly(clazz);
+      } else {
+        return !clazz.isInterface() && !appView.appInfo().isInstantiatedDirectlyOrIndirectly(clazz);
+      }
     }
     return false;
   }
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 3080960..4854741 100644
--- a/src/main/java/com/android/tools/r8/graph/ResolutionResult.java
+++ b/src/main/java/com/android/tools/r8/graph/ResolutionResult.java
@@ -3,10 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.graph;
 
-import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
-
 import com.android.tools.r8.errors.CompilationError;
-import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.SetUtils;
 import com.google.common.collect.Sets;
 import java.util.Collection;
@@ -57,9 +54,9 @@
   public abstract boolean isAccessibleForVirtualDispatchFrom(
       DexProgramClass context, AppInfoWithSubtyping appInfo);
 
-  public abstract boolean isValidVirtualTarget(InternalOptions options);
-
-  public abstract boolean isValidVirtualTargetForDynamicDispatch();
+  // TODO(b/145187573): Remove this and use proper access checks.
+  @Deprecated
+  public abstract boolean isVirtualTarget();
 
   /** Lookup the single target of an invoke-special on this resolution result if possible. */
   public abstract DexEncodedMethod lookupInvokeSpecialTarget(
@@ -87,12 +84,6 @@
     private final DexClass resolvedHolder;
     private final DexEncodedMethod resolvedMethod;
 
-    public static boolean isValidVirtualTarget(InternalOptions options, DexEncodedMethod target) {
-      return options.canUseNestBasedAccess()
-          ? (!target.accessFlags.isStatic() && !target.accessFlags.isConstructor())
-          : target.isVirtualMethod();
-    }
-
     public SingleResolutionResult(
         DexClass initialResolutionHolder,
         DexClass resolvedHolder,
@@ -133,20 +124,11 @@
     @Override
     public boolean isAccessibleForVirtualDispatchFrom(
         DexProgramClass context, AppInfoWithSubtyping appInfo) {
-      // If a private method is accessible (which implies it is via its nest), then it is a valid
-      // virtual dispatch target if non-static.
-      return isAccessibleFrom(context, appInfo)
-          && (resolvedMethod.isVirtualMethod()
-              || (resolvedMethod.isPrivateMethod() && !resolvedMethod.isStatic()));
+      return resolvedMethod.isVirtualMethod() && isAccessibleFrom(context, appInfo);
     }
 
     @Override
-    public boolean isValidVirtualTarget(InternalOptions options) {
-      return isValidVirtualTarget(options, resolvedMethod);
-    }
-
-    @Override
-    public boolean isValidVirtualTargetForDynamicDispatch() {
+    public boolean isVirtualTarget() {
       return resolvedMethod.isVirtualMethod();
     }
 
@@ -301,12 +283,16 @@
     @Override
     // TODO(b/140204899): Leverage refined receiver type if available.
     public Set<DexEncodedMethod> lookupVirtualTargets(AppInfoWithSubtyping appInfo) {
-      assert isValidVirtualTarget(appInfo.app().options);
+      if (resolvedMethod.isPrivateMethod()) {
+        // If the resolved reference is private there is no dispatch.
+        // This is assuming that the method is accessible, which implies self/nest access.
+        return Collections.singleton(resolvedMethod);
+      }
+      assert resolvedMethod.isNonPrivateVirtualMethod();
       // First add the target for receiver type method.type.
-      DexEncodedMethod encodedMethod = getSingleTarget();
-      Set<DexEncodedMethod> result = SetUtils.newIdentityHashSet(encodedMethod);
+      Set<DexEncodedMethod> result = SetUtils.newIdentityHashSet(resolvedMethod);
       // Add all matching targets from the subclass hierarchy.
-      DexMethod method = encodedMethod.method;
+      DexMethod method = resolvedMethod.method;
       // TODO(b/140204899): Instead of subtypes of holder, we could iterate subtypes of refined
       //   receiver type if available.
       for (DexType type : appInfo.subtypes(method.holder)) {
@@ -314,7 +300,7 @@
         if (!clazz.isInterface()) {
           ResolutionResult methods = appInfo.resolveMethodOnClass(clazz, method);
           DexEncodedMethod target = methods.getSingleTarget();
-          if (target != null && target.isVirtualMethod()) {
+          if (target != null && target.isNonPrivateVirtualMethod()) {
             result.add(target);
           }
         }
@@ -325,43 +311,44 @@
     @Override
     // TODO(b/140204899): Leverage refined receiver type if available.
     public Set<DexEncodedMethod> lookupInterfaceTargets(AppInfoWithSubtyping appInfo) {
-      assert isValidVirtualTarget(appInfo.app().options);
+      if (resolvedMethod.isPrivateMethod()) {
+        // If the resolved reference is private there is no dispatch.
+        // This is assuming that the method is accessible, which implies self/nest access.
+        assert resolvedMethod.hasCode();
+        return Collections.singleton(resolvedMethod);
+      }
+      assert resolvedMethod.isNonPrivateVirtualMethod();
       Set<DexEncodedMethod> result = Sets.newIdentityHashSet();
-      if (isSingleResolution()) {
-        // Add default interface methods to the list of targets.
-        //
-        // This helps to make sure we take into account synthesized lambda classes
-        // that we are not aware of. Like in the following example, we know that all
-        // classes, XX in this case, override B::bar(), but there are also synthesized
-        // classes for lambda which don't, so we still need default method to be live.
-        //
-        //   public static void main(String[] args) {
-        //     X x = () -> {};
-        //     x.bar();
-        //   }
-        //
-        //   interface X {
-        //     void foo();
-        //     default void bar() { }
-        //   }
-        //
-        //   class XX implements X {
-        //     public void foo() { }
-        //     public void bar() { }
-        //   }
-        //
-        DexEncodedMethod singleTarget = getSingleTarget();
-        if (singleTarget.hasCode()) {
-          DexProgramClass holder =
-              asProgramClassOrNull(appInfo.definitionFor(singleTarget.method.holder));
-          if (appInfo.hasAnyInstantiatedLambdas(holder)) {
-            result.add(singleTarget);
-          }
+      // Add default interface methods to the list of targets.
+      //
+      // This helps to make sure we take into account synthesized lambda classes
+      // that we are not aware of. Like in the following example, we know that all
+      // classes, XX in this case, override B::bar(), but there are also synthesized
+      // classes for lambda which don't, so we still need default method to be live.
+      //
+      //   public static void main(String[] args) {
+      //     X x = () -> {};
+      //     x.bar();
+      //   }
+      //
+      //   interface X {
+      //     void foo();
+      //     default void bar() { }
+      //   }
+      //
+      //   class XX implements X {
+      //     public void foo() { }
+      //     public void bar() { }
+      //   }
+      //
+      if (resolvedMethod.hasCode()) {
+        DexProgramClass holder = resolvedHolder.asProgramClass();
+        if (appInfo.hasAnyInstantiatedLambdas(holder)) {
+          result.add(resolvedMethod);
         }
       }
 
-      DexEncodedMethod encodedMethod = getSingleTarget();
-      DexMethod method = encodedMethod.method;
+      DexMethod method = resolvedMethod.method;
       Consumer<DexEncodedMethod> addIfNotAbstract =
           m -> {
             if (!m.accessFlags.isAbstract()) {
@@ -451,12 +438,7 @@
     }
 
     @Override
-    public boolean isValidVirtualTarget(InternalOptions options) {
-      return true;
-    }
-
-    @Override
-    public boolean isValidVirtualTargetForDynamicDispatch() {
+    public boolean isVirtualTarget() {
       return true;
     }
   }
@@ -490,12 +472,7 @@
     }
 
     @Override
-    public boolean isValidVirtualTarget(InternalOptions options) {
-      return false;
-    }
-
-    @Override
-    public boolean isValidVirtualTargetForDynamicDispatch() {
+    public boolean isVirtualTarget() {
       return false;
     }
   }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/proto/ProtoEnqueuerUseRegistry.java b/src/main/java/com/android/tools/r8/ir/analysis/proto/ProtoEnqueuerUseRegistry.java
index d1c82d4..71750f1 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/proto/ProtoEnqueuerUseRegistry.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/proto/ProtoEnqueuerUseRegistry.java
@@ -42,7 +42,7 @@
    */
   @Override
   public boolean registerConstClass(DexType type) {
-    if (references.isDynamicMethod(currentMethod)) {
+    if (references.isDynamicMethod(getContextMethod())) {
       return false;
     }
     return super.registerConstClass(type);
@@ -57,7 +57,7 @@
    */
   @Override
   public boolean registerStaticFieldRead(DexField field) {
-    if (references.isDynamicMethod(currentMethod)) {
+    if (references.isDynamicMethod(getContextMethod())) {
       return false;
     }
     return super.registerStaticFieldRead(field);
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/CallGraphBuilderBase.java b/src/main/java/com/android/tools/r8/ir/conversion/CallGraphBuilderBase.java
index c7939b5..ade31ca 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/CallGraphBuilderBase.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/CallGraphBuilderBase.java
@@ -180,7 +180,7 @@
               method -> {
                 ResolutionResult resolution =
                     appView.appInfo().resolveMethod(method.holder, method, isInterface);
-                if (resolution.isValidVirtualTarget(appView.options())) {
+                if (resolution.isVirtualTarget()) {
                   return resolution.lookupVirtualDispatchTargets(isInterface, appView.appInfo());
                 }
                 return null;
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/CodeOptimization.java b/src/main/java/com/android/tools/r8/ir/conversion/CodeOptimization.java
index 5d73cd5..8a40db4 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/CodeOptimization.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/CodeOptimization.java
@@ -6,9 +6,14 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedback;
+import com.google.common.collect.ImmutableList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.function.Consumer;
 
 /**
- * An abstraction of {@link IRCode}-level optimization.
+ * An abstraction of {@link IRCode}-level optimization, which may retrieve info from
+ * {@link AppView}; update {@link OptimizationFeedback}; or utilize {@link MethodProcessor}.
  */
 public interface CodeOptimization {
 
@@ -17,9 +22,61 @@
   //  rewriting every affected optimization.
   // Note that a code optimization can be a collection of other code optimizations.
   // In that way, IRConverter will serve as the default full processing of all optimizations.
-  void optimize(
-      AppView<?> appView,
-      IRCode code,
-      OptimizationFeedback feedback,
-      MethodProcessor methodProcessor);
+  void optimize(IRCode code, OptimizationFeedback feedback, MethodProcessor methodProcessor);
+
+  static CodeOptimization from(Consumer<IRCode> consumer) {
+    return (code, feedback, methodProcessor) -> {
+      consumer.accept(code);
+    };
+  }
+
+  static CodeOptimization sequence(CodeOptimization... codeOptimizations) {
+    return sequence(Arrays.asList(codeOptimizations));
+  }
+
+  static CodeOptimization sequence(Collection<CodeOptimization> codeOptimizations) {
+    return (code, feedback, methodProcessor) -> {
+      for (CodeOptimization codeOptimization : codeOptimizations) {
+        codeOptimization.optimize(code, feedback, methodProcessor);
+      }
+    };
+  }
+
+  /**
+   * Builder for {@link CodeOptimization}.
+   *
+   * Users can append either {@link CodeOptimization}, or simply {@link IRCode} consumer.
+   *
+   * Note that the order of everything that is appended through the builder matters.
+   */
+  public static class Builder {
+    private ImmutableList.Builder<CodeOptimization> processingQueue;
+
+    private Builder() {
+      processingQueue = ImmutableList.builder();
+    }
+
+    public static Builder builder() {
+      return new Builder();
+    }
+
+    public Builder addIRCodeConsumer(Consumer<IRCode> consumer) {
+      processingQueue.add(from(consumer));
+      return this;
+    }
+
+    public Builder addCodeOptimization(CodeOptimization optimization) {
+      processingQueue.add(optimization);
+      return this;
+    }
+
+    public CodeOptimization build() {
+      return (code, feedback, methodProcessor) -> {
+        processingQueue
+            .build()
+            .forEach(codeOptimization ->
+                codeOptimization.optimize(code, feedback, methodProcessor));
+      };
+    }
+  }
 }
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 00d2f79..b3a6d66 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
@@ -1092,12 +1092,11 @@
       feedback.markProcessed(method, ConstraintWithTarget.NEVER);
       return;
     }
-    optimize(appView, code, feedback, methodProcessor);
+    optimize(code, feedback, methodProcessor);
   }
 
   // TODO(b/140766440): Convert all sub steps an implementer of CodeOptimization
   private void optimize(
-      AppView<?> appView,
       IRCode code,
       OptimizationFeedback feedback,
       MethodProcessor methodProcessor) {
@@ -1218,7 +1217,7 @@
       stringOptimizer.computeTrivialOperationsOnConstString(code);
       stringOptimizer.removeTrivialConversions(code);
       if (libraryMethodOptimizer != null) {
-        libraryMethodOptimizer.optimize(appView, code, feedback, methodProcessor);
+        libraryMethodOptimizer.optimize(code, feedback, methodProcessor);
       }
       assert code.isConsistentSSA();
     }
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 bf556c8..dc425e4 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
@@ -643,7 +643,8 @@
   }
 
   private boolean canInvokeTargetWithInvokeVirtual(DexEncodedMethod target) {
-    return target.isVirtualMethod() && appView.isInterface(target.method.holder).isFalse();
+    return target.isNonPrivateVirtualMethod()
+        && appView.isInterface(target.method.holder).isFalse();
   }
 
   private boolean hasAccessToInvokeTargetFromContext(DexEncodedMethod target, DexType context) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java
index 9ecc62d..7e0c9d5 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java
@@ -153,7 +153,7 @@
     }
     // TODO(b/140768815): Reprocessing may trigger more methods to revisit. Update waves on-the-fly.
     for (CodeOptimization codeOptimization : codeOptimizations) {
-      codeOptimization.optimize(appView, code, feedback, this);
+      codeOptimization.optimize(code, feedback, this);
     }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java b/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java
index a4fc2e9..565af2f 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java
@@ -333,7 +333,7 @@
   private boolean isRetargetMethod(DexLibraryClass holder, DexEncodedMethod method) {
     assert needsLibraryInfo();
     assert holder.type == method.method.holder;
-    assert method.isVirtualMethod();
+    assert method.isNonPrivateVirtualMethod();
     if (method.isFinal()) {
       return false;
     }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
index 7f4c043..328d8e2 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
@@ -26,7 +26,6 @@
 import com.android.tools.r8.graph.DexTypeList;
 import com.android.tools.r8.graph.DexValue;
 import com.android.tools.r8.graph.GraphLense.NestedGraphLense;
-import com.android.tools.r8.graph.ResolutionResult;
 import com.android.tools.r8.ir.code.BasicBlock;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Instruction;
@@ -397,15 +396,17 @@
     if (appView.rewritePrefix.hasRewrittenType(dexClass.type)) {
       return null;
     }
-    ResolutionResult resolutionResult =
-        appView.appInfo().resolveMaximallySpecificMethods(dexClass, invokedMethod);
-    if (!resolutionResult.isSingleResolution()) {
+    DexEncodedMethod singleTarget =
+        appView
+            .appInfo()
+            .resolveMaximallySpecificMethods(dexClass, invokedMethod)
+            .getSingleTarget();
+    if (singleTarget == null) {
       // At this point we are in a library class. Failures can happen with NoSuchMethod if a
       // library class implement a method with same signature but not related to emulated
       // interfaces.
       return null;
     }
-    DexEncodedMethod singleTarget = resolutionResult.getSingleTarget();
     if (!singleTarget.isAbstract() && isEmulatedInterface(singleTarget.method.holder)) {
       return singleTarget.method.holder;
     }
@@ -1143,10 +1144,16 @@
     assert !dependency.isLibraryClass();
     DesugarGraphConsumer consumer = options.desugarGraphConsumer;
     if (consumer != null) {
-      Origin dependentOrigin = dependent.getOrigin();
       Origin dependencyOrigin = dependency.getOrigin();
-      if (dependentOrigin != dependencyOrigin) {
-        consumer.accept(dependentOrigin, dependencyOrigin);
+      java.util.Collection<DexProgramClass> dependents = dependent.getSynthesizedFrom();
+      if (dependents == null || dependents.isEmpty()) {
+        dependents = Collections.singletonList(dependent);
+      }
+      for (DexProgramClass clazz : dependents) {
+        Origin dependentOrigin = clazz.getOrigin();
+        if (dependentOrigin != dependencyOrigin) {
+          consumer.accept(dependentOrigin, dependencyOrigin);
+        }
       }
     }
   }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/NestBasedAccessDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/NestBasedAccessDesugaring.java
index 30edf6a..cf66050 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/NestBasedAccessDesugaring.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/NestBasedAccessDesugaring.java
@@ -25,6 +25,7 @@
 import com.android.tools.r8.ir.code.Invoke;
 import com.android.tools.r8.origin.SynthesizedOrigin;
 import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.Pair;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -90,7 +91,7 @@
   }
 
   // Extract the list of types in the programClass' nest, of host hostClass
-  private List<DexType> extractNest(DexClass clazz) {
+  private Pair<DexClass, List<DexType>> extractNest(DexClass clazz) {
     assert clazz != null;
     DexClass hostClass = clazz.isNestHost() ? clazz : definitionFor(clazz.getNestHost());
     if (hostClass == null) {
@@ -105,22 +106,22 @@
       classesInNest.add(nestmate.getNestMember());
     }
     classesInNest.add(hostClass.type);
-    return classesInNest;
+    return new Pair<>(hostClass, classesInNest);
   }
 
   Future<?> asyncProcessNest(DexClass clazz, ExecutorService executorService) {
     return executorService.submit(
         () -> {
-          List<DexType> nest = extractNest(clazz);
+          Pair<DexClass, List<DexType>> nest = extractNest(clazz);
           // Nest is null when nest host is missing, we do nothing in this case.
           if (nest != null) {
-            processNest(nest);
+            processNest(nest.getFirst(), nest.getSecond());
           }
           return null; // we want a Callable not a Runnable to be able to throw
         });
   }
 
-  private void processNest(List<DexType> nest) {
+  private void processNest(DexClass host, List<DexType> nest) {
     boolean reported = false;
     for (DexType type : nest) {
       DexClass clazz = definitionFor(type);
@@ -130,6 +131,7 @@
           reported = true;
         }
       } else {
+        reportDesugarDependencies(host, clazz);
         if (shouldProcessClassInNest(clazz, nest)) {
           NestBasedAccessDesugaringUseRegistry registry =
               new NestBasedAccessDesugaringUseRegistry(clazz);
@@ -142,6 +144,18 @@
     }
   }
 
+  private void reportDesugarDependencies(DexClass host, DexClass clazz) {
+    if (host == clazz) {
+      return;
+    }
+    if (host.isProgramClass()) {
+      InterfaceMethodRewriter.reportDependencyEdge(host.asProgramClass(), clazz, appView.options());
+    }
+    if (clazz.isProgramClass()) {
+      InterfaceMethodRewriter.reportDependencyEdge(clazz.asProgramClass(), host, appView.options());
+    }
+  }
+
   protected abstract boolean shouldProcessClassInNest(DexClass clazz, List<DexType> nest);
 
   private DexProgramClass createNestAccessConstructor() {
@@ -272,9 +286,9 @@
       return true;
     }
     assert holder.isLibraryClass();
-    List<DexType> nest = extractNest(holder);
+    Pair<DexClass, List<DexType>> nest = extractNest(holder);
     assert nest != null : "Should be a compilation error if missing nest host on library class.";
-    reportIncompleteNest(nest);
+    reportIncompleteNest(nest.getSecond());
     throw new Unreachable(
         "Incomplete nest due to missing library class should raise a compilation error.");
   }
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 babdbae..9fca058 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
@@ -41,9 +41,9 @@
     assert methodMap instanceof IdentityHashMap;
     assert getFieldMap instanceof IdentityHashMap;
     assert putFieldMap instanceof IdentityHashMap;
+    this.nestConstructorType = nestConstructorType;
     this.getFieldMap = getFieldMap;
     this.putFieldMap = putFieldMap;
-    this.nestConstructorType = nestConstructorType;
   }
 
   private DexMethod lookupFieldForMethod(
@@ -111,11 +111,8 @@
   @Override
   public GraphLenseLookupResult lookupMethod(
       DexMethod method, DexMethod context, Invoke.Type type) {
-    DexMethod previousContext =
-        originalMethodSignatures != null
-            ? originalMethodSignatures.getOrDefault(context, context)
-            : context;
-    GraphLenseLookupResult previous = previousLense.lookupMethod(method, previousContext, type);
+    assert originalMethodSignatures == null;
+    GraphLenseLookupResult previous = previousLense.lookupMethod(method, context, type);
     DexMethod bridge = methodMap.get(previous.getMethod());
     if (bridge == null) {
       return previous;
@@ -130,4 +127,31 @@
     return new GraphLenseLookupResult(bridge, Invoke.Type.STATIC);
   }
 
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static class Builder extends NestedGraphLense.Builder {
+
+    private Map<DexField, DexMethod> getFieldMap = new IdentityHashMap<>();
+    private Map<DexField, DexMethod> putFieldMap = new IdentityHashMap<>();
+
+    public void mapGetField(DexField from, DexMethod to) {
+      getFieldMap.put(from, to);
+    }
+
+    public void mapPutField(DexField from, DexMethod to) {
+      putFieldMap.put(from, to);
+    }
+
+    public GraphLense build(AppView<?> appView, DexType nestConstructorType) {
+      assert typeMap.isEmpty();
+      assert fieldMap.isEmpty();
+      if (getFieldMap.isEmpty() && methodMap.isEmpty() && putFieldMap.isEmpty()) {
+        return appView.graphLense();
+      }
+      return new NestedPrivateMethodLense(
+          appView, nestConstructorType, methodMap, getFieldMap, putFieldMap, appView.graphLense());
+    }
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/R8NestBasedAccessDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/R8NestBasedAccessDesugaring.java
index a4642cd..1a6c365 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/R8NestBasedAccessDesugaring.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/R8NestBasedAccessDesugaring.java
@@ -8,7 +8,6 @@
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
@@ -16,13 +15,13 @@
 import com.android.tools.r8.utils.ThreadUtils;
 import com.google.common.collect.Sets;
 import java.util.ArrayList;
-import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
+import java.util.function.BiConsumer;
 
 // Summary:
 // - Computes all the live nests reachable from Program Classes (Sequential), each time a
@@ -31,10 +30,6 @@
 // for the lens (Sequential)
 public class R8NestBasedAccessDesugaring extends NestBasedAccessDesugaring {
 
-  private final Map<DexMethod, DexMethod> lensBridges = new IdentityHashMap<>();
-  private final Map<DexField, DexMethod> lensGetFieldBridges = new IdentityHashMap<>();
-  private final Map<DexField, DexMethod> lensPutFieldBridges = new IdentityHashMap<>();
-
   public R8NestBasedAccessDesugaring(AppView<?> appView) {
     super(appView);
   }
@@ -44,43 +39,27 @@
     assert !appView.options().canUseNestBasedAccess()
         || appView.options().testing.enableForceNestBasedAccessDesugaringForTest;
     computeAndProcessNestsConcurrently(executorService);
-    addDeferredBridgesAndMapMethods();
+    NestedPrivateMethodLense.Builder lensBuilder = NestedPrivateMethodLense.builder();
+    addDeferredBridgesAndMapMethods(lensBuilder);
     clearNestAttributes();
-    if (nothingToMap()) {
-      return appView.graphLense();
-    }
     synthesizeNestConstructor(appBuilder);
-    return new NestedPrivateMethodLense(
-        appView,
-        getNestConstructorType(),
-        lensBridges,
-        lensGetFieldBridges,
-        lensPutFieldBridges,
-        appView.graphLense());
+    return lensBuilder.build(appView, getNestConstructorType());
   }
 
-  private boolean nothingToMap() {
-    return lensBridges.isEmpty() && lensGetFieldBridges.isEmpty() && lensPutFieldBridges.isEmpty();
-  }
-
-  private void addDeferredBridgesAndMapMethods() {
+  private void addDeferredBridgesAndMapMethods(NestedPrivateMethodLense.Builder lensBuilder) {
     // Here we add the bridges and we fill the lens map.
-    // The lens map are different than the original map since
-    // they refer DexMethod and not DexEncodedMethod (so they can be long lived without issues),
-    // and since they do not require synchronization (they are only read in the lens).
-    // We cannot easily do this concurrently since methods are added to classes.
-    addDeferredBridgesAndMapMethods(bridges, lensBridges);
-    addDeferredBridgesAndMapMethods(getFieldBridges, lensGetFieldBridges);
-    addDeferredBridgesAndMapMethods(putFieldBridges, lensPutFieldBridges);
+    addDeferredBridgesAndMapMethods(bridges, lensBuilder::map);
+    addDeferredBridgesAndMapMethods(getFieldBridges, lensBuilder::mapGetField);
+    addDeferredBridgesAndMapMethods(putFieldBridges, lensBuilder::mapPutField);
   }
 
   private <E> void addDeferredBridgesAndMapMethods(
-      Map<E, DexEncodedMethod> bridges, Map<E, DexMethod> map) {
+      Map<E, DexEncodedMethod> bridges, BiConsumer<E, DexMethod> lensInserter) {
     for (Map.Entry<E, DexEncodedMethod> entry : bridges.entrySet()) {
       DexClass holder = definitionFor(entry.getValue().method.holder);
       assert holder != null && holder.isProgramClass();
       holder.asProgramClass().addMethod(entry.getValue());
-      map.put(entry.getKey(), entry.getValue().method);
+      lensInserter.accept(entry.getKey(), entry.getValue().method);
     }
     bridges.clear();
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/AssertionsRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/AssertionsRewriter.java
index 2292b0a..a344095 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/AssertionsRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/AssertionsRewriter.java
@@ -6,9 +6,6 @@
 
 import com.android.tools.r8.AssertionsConfiguration;
 import com.android.tools.r8.AssertionsConfiguration.AssertionTransformation;
-import com.android.tools.r8.AssertionsConfiguration.ConfigurationEntry;
-import com.android.tools.r8.AssertionsConfiguration.ConfigurationType;
-import com.android.tools.r8.AssertionsConfiguration.InternalAssertionConfiguration;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClass;
@@ -21,7 +18,9 @@
 import com.android.tools.r8.ir.code.InvokeMethod;
 import com.android.tools.r8.ir.code.StaticGet;
 import com.android.tools.r8.ir.code.StaticPut;
+import com.android.tools.r8.utils.AssertionConfigurationWithDefault;
 import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.ThrowingCharIterator;
 import java.io.UTFDataFormatException;
 import java.util.List;
@@ -31,21 +30,21 @@
 
   private static class ConfigurationEntryWithDexString {
 
-    private ConfigurationEntry entry;
+    private AssertionsConfiguration entry;
     private final DexString value;
 
     private ConfigurationEntryWithDexString(
-        ConfigurationEntry entry, DexItemFactory dexItemFactory) {
-      this.entry = entry;
-      switch (entry.getType()) {
+        AssertionsConfiguration configuration, DexItemFactory dexItemFactory) {
+      this.entry = configuration;
+      switch (configuration.getScope()) {
         case PACKAGE:
-          if (entry.getValue().length() == 0) {
+          if (configuration.getValue().length() == 0) {
             value = dexItemFactory.createString("");
           } else {
             value =
                 dexItemFactory.createString(
                     "L"
-                        + entry
+                        + configuration
                             .getValue()
                             .replace(
                                 DescriptorUtils.JAVA_PACKAGE_SEPARATOR,
@@ -57,7 +56,7 @@
           value =
               dexItemFactory.createString(
                   "L"
-                      + entry
+                      + configuration
                           .getValue()
                           .replace(
                               DescriptorUtils.JAVA_PACKAGE_SEPARATOR,
@@ -75,39 +74,38 @@
 
   private final AppView<?> appView;
   private final DexItemFactory dexItemFactory;
+  private final AssertionTransformation defaultTransformation;
   private final List<ConfigurationEntryWithDexString> configuration;
   private final boolean enabled;
 
   public AssertionsRewriter(AppView<?> appView) {
     this.appView = appView;
     this.dexItemFactory = appView.dexItemFactory();
-    if (appView.options().assertionsConfiguration == null) {
-      this.configuration = null;
-      this.enabled = false;
-    } else {
-      List<ConfigurationEntry> configuration =
-          InternalAssertionConfiguration
-              .getConfiguration(appView.options().assertionsConfiguration);
-      this.configuration =
-          configuration.stream()
-              .map(entry -> new ConfigurationEntryWithDexString(entry, appView.dexItemFactory()))
-              .collect(Collectors.toList());
-      this.enabled = !isPassthroughAll(appView.options().assertionsConfiguration);
+    this.enabled = isEnabled(appView.options());
+    if (!enabled) {
+      defaultTransformation = null;
+      configuration = null;
+      return;
     }
+    // Convert the assertion transformation to the representation used for this rewriter.
+    this.defaultTransformation = appView.options().assertionsConfiguration.defautlTransformation;
+    this.configuration =
+        appView.options().assertionsConfiguration.assertionsConfigurations.stream()
+            .map(entry -> new ConfigurationEntryWithDexString(entry, appView.dexItemFactory()))
+            .collect(Collectors.toList());
   }
 
-  public static boolean isPassthroughAll(AssertionsConfiguration assertionsConfiguration) {
-    List<ConfigurationEntry> configuration =
-        InternalAssertionConfiguration.getConfiguration(assertionsConfiguration);
-    return configuration.size() == 1
-        && configuration.get(0).getTransformation() == AssertionTransformation.PASSTHROUGH
-        && configuration.get(0).getType() == ConfigurationType.ALL;
+  // Static method used by other analyses to see if additional analysis is required to support
+  // this rewriting.
+  public static boolean isEnabled(InternalOptions options) {
+    AssertionConfigurationWithDefault configuration = options.assertionsConfiguration;
+    return configuration != null && !configuration.isPassthroughAll();
   }
 
   private AssertionTransformation getTransformationForMethod(DexEncodedMethod method) {
-    AssertionTransformation transformation = null;
+    AssertionTransformation transformation = defaultTransformation;
     for (ConfigurationEntryWithDexString entry : configuration) {
-      switch (entry.entry.getType()) {
+      switch (entry.entry.getScope()) {
         case ALL:
           transformation = entry.entry.getTransformation();
           break;
@@ -132,7 +130,7 @@
           throw new Unreachable();
       }
     }
-    assert transformation != null; // Default transformation are always added.
+    assert transformation != null;
     return transformation;
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java b/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
index e83a17a..00c797d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
@@ -88,7 +88,7 @@
           ResolutionResult resolutionResult =
               appView.appInfo().resolveMethod(invokedMethod.holder, invokedMethod);
           // For virtual and interface calls, proceed on valid results only (since it's enforced).
-          if (!resolutionResult.isValidVirtualTarget(appView.options())) {
+          if (!resolutionResult.isVirtualTarget()) {
             continue;
           }
           // If the resolution ended up with a single target, check if it is a library override.
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java b/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
index 4977d4c..b95f69e 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
@@ -352,7 +352,7 @@
     // resolution result.
     ResolutionResult resolutionResult =
         appView.appInfo().resolveMethod(method.holder, method, isInterface);
-    if (!resolutionResult.isValidVirtualTarget(appView.options())) {
+    if (!resolutionResult.isVirtualTarget()) {
       return ConstraintWithTarget.NEVER;
     }
 
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 194b84a..aec5219 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
@@ -291,7 +291,7 @@
     if (method.getCode() == null || !method.getCode().isCfCode()) {
       return null;
     }
-    if (method.isVirtualMethod()) {
+    if (method.isNonPrivateVirtualMethod()) {
       // Abort if the method overrides another method, or if the method is overridden. In both cases
       // an unused argument cannot be removed unless it is unused in all of the related methods in
       // the hierarchy.
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
index c522ff3..d4d43f4 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
@@ -859,13 +859,14 @@
 
     // We should not inline a method if the invocation has type interface or virtual and the
     // signature of the invocation resolves to a private or static method.
+    // TODO(b/147212189): Why not inline private methods? If access is permitted it is valid.
     ResolutionResult resolutionResult = appView.appInfo().resolveMethod(callee.holder, callee);
     if (resolutionResult.isSingleResolution()
-        && !resolutionResult.getSingleTarget().isVirtualMethod()) {
+        && !resolutionResult.getSingleTarget().isNonPrivateVirtualMethod()) {
       return null;
     }
 
-    if (!singleTarget.isVirtualMethod()) {
+    if (!singleTarget.isNonPrivateVirtualMethod()) {
       return null;
     }
     if (method == singleTarget) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
index a11f309..8fee6c5 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
@@ -135,7 +135,7 @@
         return;
       }
 
-      assert method.isVirtualMethod();
+      assert method.isNonPrivateVirtualMethod();
       assert context == null;
 
       Map<InvokeVirtual, InliningInfo> invokesToInline = new IdentityHashMap<>();
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 0a92679..9c5a8d1 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
@@ -24,10 +24,13 @@
 
 public class LibraryMethodOptimizer implements CodeOptimization {
 
+  private final AppView<?> appView;
+
   private final Map<DexType, LibraryMethodModelCollection> libraryMethodModelCollections =
       new IdentityHashMap<>();
 
   public LibraryMethodOptimizer(AppView<? extends AppInfoWithSubtyping> appView) {
+    this.appView = appView;
     register(new BooleanMethodOptimizer(appView));
   }
 
@@ -39,7 +42,6 @@
 
   @Override
   public void optimize(
-      AppView<?> appView,
       IRCode code,
       OptimizationFeedback feedback,
       MethodProcessor methodProcessor) {
diff --git a/src/main/java/com/android/tools/r8/retrace/Retrace.java b/src/main/java/com/android/tools/r8/retrace/Retrace.java
index 79d9721..057875d 100644
--- a/src/main/java/com/android/tools/r8/retrace/Retrace.java
+++ b/src/main/java/com/android/tools/r8/retrace/Retrace.java
@@ -6,6 +6,7 @@
 
 import static com.android.tools.r8.utils.ExceptionUtils.STATUS_ERROR;
 
+import com.android.tools.r8.Diagnostic;
 import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.Keep;
 import com.android.tools.r8.naming.ClassNameMapper;
@@ -35,7 +36,7 @@
 
   public static final String USAGE_MESSAGE =
       StringUtils.lines(
-          "Usage: retrace <proguard-map> <stacktrace-file>",
+          "Usage: retrace <proguard-map> <stacktrace-file> [--regex <regexp>, --verbose, --info]",
           "  where <proguard-map> is an r8 generated mapping file.");
 
   private static Builder parseArguments(String[] args, DiagnosticsHandler diagnosticsHandler) {
@@ -48,16 +49,19 @@
       if (help != null) {
         return null;
       }
+      Boolean info = OptionsParsing.tryParseBoolean(context, "--info");
+      if (info != null) {
+        // This is already set in the diagnostics handler.
+        continue;
+      }
       Boolean verbose = OptionsParsing.tryParseBoolean(context, "--verbose");
       if (verbose != null) {
-        // TODO(b/132850880): Enable support for verbose.
-        diagnosticsHandler.error(new StringDiagnostic("Currently no support for --verbose"));
+        builder.setVerbose(true);
         continue;
       }
       String regex = OptionsParsing.tryParseSingle(context, "--regex", "r");
       if (regex != null && !regex.isEmpty()) {
-        // TODO(b/132850880): Enable support for regex.
-        diagnosticsHandler.error(new StringDiagnostic("Currently no support for --regex"));
+        builder.setRegularExpression(regex);
         continue;
       }
       if (!hasSetProguardMap) {
@@ -108,7 +112,7 @@
   }
 
   /**
-   * The main entry point for running the retrace.
+   * The main entry point for running retrace.
    *
    * @param command The command that describes the desired behavior of this retrace invocation.
    */
@@ -128,7 +132,8 @@
                 .retrace();
       } else {
         result =
-            new RetraceStackTrace(retraceBase, command.stackTrace, command.diagnosticsHandler)
+            new RetraceStackTrace(
+                    retraceBase, command.stackTrace, command.diagnosticsHandler, command.isVerbose)
                 .retrace();
       }
       command.retracedStackTraceConsumer.accept(result.getNodes());
@@ -139,9 +144,11 @@
     }
   }
 
-  static void run(String[] args) {
-    DiagnosticsHandler diagnosticsHandler = new DiagnosticsHandler() {};
-    Builder builder = parseArguments(args, diagnosticsHandler);
+  public static void run(String[] args) {
+    RetraceDiagnosticsHandler retraceDiagnosticsHandler =
+        new RetraceDiagnosticsHandler(
+            new DiagnosticsHandler() {}, Arrays.asList(args).contains("--info"));
+    Builder builder = parseArguments(args, retraceDiagnosticsHandler);
     if (builder == null) {
       // --help was an argument to list
       assert Arrays.asList(args).contains("--help");
@@ -152,6 +159,7 @@
         retraced -> System.out.print(StringUtils.lines(retraced)));
     run(builder.build());
   }
+
   /**
    * The main entry point for running a legacy compatible retrace from the command line.
    *
@@ -189,4 +197,33 @@
       System.exit(STATUS_ERROR);
     }
   }
+
+  private static class RetraceDiagnosticsHandler implements DiagnosticsHandler {
+
+    private final DiagnosticsHandler diagnosticsHandler;
+    private final boolean printInfo;
+
+    public RetraceDiagnosticsHandler(DiagnosticsHandler diagnosticsHandler, boolean printInfo) {
+      this.diagnosticsHandler = diagnosticsHandler;
+      this.printInfo = printInfo;
+      assert diagnosticsHandler != null;
+    }
+
+    @Override
+    public void error(Diagnostic error) {
+      diagnosticsHandler.error(error);
+    }
+
+    @Override
+    public void warning(Diagnostic warning) {
+      diagnosticsHandler.warning(warning);
+    }
+
+    @Override
+    public void info(Diagnostic info) {
+      if (printInfo) {
+        diagnosticsHandler.info(info);
+      }
+    }
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceCommand.java b/src/main/java/com/android/tools/r8/retrace/RetraceCommand.java
index b2692a2..93addc4 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceCommand.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceCommand.java
@@ -6,6 +6,7 @@
 
 import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.Keep;
+import com.android.tools.r8.utils.StringDiagnostic;
 import java.io.IOException;
 import java.util.List;
 import java.util.function.Consumer;
@@ -56,7 +57,7 @@
   public static class Builder {
 
     private boolean isVerbose;
-    private DiagnosticsHandler diagnosticsHandler;
+    private final DiagnosticsHandler diagnosticsHandler;
     private ProguardMapProducer proguardMapProducer;
     private String regularExpression;
     private List<String> stackTrace;
@@ -67,8 +68,8 @@
     }
 
     /** Set if the produced stack trace should have additional information. */
-    public Builder isVerbose() {
-      this.isVerbose = true;
+    public Builder setVerbose(boolean verbose) {
+      this.isVerbose = verbose;
       return this;
     }
 
@@ -127,6 +128,11 @@
       if (this.retracedStackTraceConsumer == null) {
         throw new RuntimeException("RetracedStackConsumer not specified");
       }
+      if (isVerbose && regularExpression != null) {
+        this.diagnosticsHandler.warning(
+            new StringDiagnostic(
+                "Retrace does not support verbose output when a regular expression is specified"));
+      }
       return new RetraceCommand(
           isVerbose,
           regularExpression,
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceStackTrace.java b/src/main/java/com/android/tools/r8/retrace/RetraceStackTrace.java
index 3a564d8..3b68d3d 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceStackTrace.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceStackTrace.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.retrace;
 
+import static com.android.tools.r8.retrace.RetraceUtils.methodDescriptionFromMethodReference;
 import static com.google.common.base.Predicates.not;
 
 import com.android.tools.r8.DiagnosticsHandler;
@@ -11,7 +12,7 @@
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.DescriptorUtils;
-import com.google.common.base.Strings;
+import com.android.tools.r8.utils.StringUtils;
 import com.google.common.collect.ImmutableList;
 import java.util.ArrayList;
 import java.util.List;
@@ -42,17 +43,21 @@
       if (lines.get(0).asAtLine().isAmbiguous) {
         lines.sort(new AtStackTraceLineComparator());
       }
-      String previousClazz = "";
+      boolean shouldPrintOr = false;
       for (StackTraceLine line : lines) {
         assert line.isAtLine();
         AtLine atLine = line.asAtLine();
-        if (atLine.isAmbiguous) {
+        if (atLine.isAmbiguous && shouldPrintOr) {
+          String atLineString = atLine.toString();
+          int firstNonWhitespaceCharacter = StringUtils.firstNonWhitespaceCharacter(atLineString);
           strings.add(
-              atLine.toString(previousClazz.isEmpty() ? atLine.at : "<OR> " + atLine.at, ""));
+              atLineString.substring(0, firstNonWhitespaceCharacter)
+                  + "<OR> "
+                  + atLineString.substring(firstNonWhitespaceCharacter));
         } else {
           strings.add(atLine.toString());
         }
-        previousClazz = atLine.clazz;
+        shouldPrintOr = true;
       }
     }
   }
@@ -84,12 +89,17 @@
   private final RetraceBase retraceBase;
   private final List<String> stackTrace;
   private final DiagnosticsHandler diagnosticsHandler;
+  private final boolean verbose;
 
   RetraceStackTrace(
-      RetraceBase retraceBase, List<String> stackTrace, DiagnosticsHandler diagnosticsHandler) {
+      RetraceBase retraceBase,
+      List<String> stackTrace,
+      DiagnosticsHandler diagnosticsHandler,
+      boolean verbose) {
     this.retraceBase = retraceBase;
     this.stackTrace = stackTrace;
     this.diagnosticsHandler = diagnosticsHandler;
+    this.verbose = verbose;
   }
 
   public RetraceCommandLineResult retrace() {
@@ -107,7 +117,7 @@
       return;
     }
     StackTraceLine stackTraceLine = parseLine(index + 1, stackTrace.get(index));
-    List<StackTraceLine> retraced = stackTraceLine.retrace(retraceBase);
+    List<StackTraceLine> retraced = stackTraceLine.retrace(retraceBase, verbose);
     StackTraceNode node = new StackTraceNode(retraced);
     result.add(node);
     retraceLine(stackTrace, index + 1, result);
@@ -115,7 +125,7 @@
 
   abstract static class StackTraceLine {
 
-    abstract List<StackTraceLine> retrace(RetraceBase retraceBase);
+    abstract List<StackTraceLine> retrace(RetraceBase retraceBase, boolean verbose);
 
     static int firstNonWhiteSpaceCharacterFromIndex(String line, int index) {
       return firstFromIndex(line, index, not(Character::isWhitespace));
@@ -215,7 +225,7 @@
     }
 
     @Override
-    List<StackTraceLine> retrace(RetraceBase retraceBase) {
+    List<StackTraceLine> retrace(RetraceBase retraceBase, boolean verbose) {
       List<StackTraceLine> exceptionLines = new ArrayList<>();
       retraceBase
           .retrace(Reference.classFromTypeName(exceptionClass))
@@ -267,6 +277,7 @@
     private final String at;
     private final String clazz;
     private final String method;
+    private final String methodAsString;
     private final String fileName;
     private final int linePosition;
     private final boolean isAmbiguous;
@@ -276,6 +287,7 @@
         String at,
         String clazz,
         String method,
+        String methodAsString,
         String fileName,
         int linePosition,
         boolean isAmbiguous) {
@@ -283,6 +295,7 @@
       this.at = at;
       this.clazz = clazz;
       this.method = method;
+      this.methodAsString = methodAsString;
       this.fileName = fileName;
       this.linePosition = linePosition;
       this.isAmbiguous = isAmbiguous;
@@ -335,11 +348,14 @@
       } else {
         fileName = line.substring(parensStart + 1, parensEnd);
       }
+      String className = line.substring(classStartIndex, methodSeparator);
+      String methodName = line.substring(methodSeparator + 1, parensStart);
       return new AtLine(
           line.substring(0, firstNonWhiteSpace),
           line.substring(firstNonWhiteSpace, classStartIndex),
-          line.substring(classStartIndex, methodSeparator),
-          line.substring(methodSeparator + 1, parensStart),
+          className,
+          methodName,
+          className + "." + methodName,
           fileName,
           position,
           false);
@@ -350,49 +366,38 @@
     }
 
     @Override
-    List<StackTraceLine> retrace(RetraceBase retraceBase) {
+    List<StackTraceLine> retrace(RetraceBase retraceBase, boolean verbose) {
       List<StackTraceLine> lines = new ArrayList<>();
       ClassReference classReference = Reference.classFromTypeName(clazz);
-      RetraceMethodResult retraceMethodResult =
-          retraceBase
-              .retrace(classReference)
-              .lookupMethod(method)
-              .narrowByLine(linePosition)
-              .forEach(
-                  methodElement -> {
-                    MethodReference methodReference = methodElement.getMethodReference();
-                    lines.add(
-                        new AtLine(
-                            startingWhitespace,
-                            at,
-                            methodReference.getHolderClass().getTypeName(),
-                            methodReference.getMethodName(),
-                            retraceBase.retraceSourceFile(
-                                classReference, fileName, methodReference.getHolderClass(), true),
-                            hasLinePosition()
-                                ? methodElement.getOriginalLineNumber(linePosition)
-                                : linePosition,
-                            methodElement.getRetraceMethodResult().isAmbiguous()));
-                  });
+      retraceBase
+          .retrace(classReference)
+          .lookupMethod(method)
+          .narrowByLine(linePosition)
+          .forEach(
+              methodElement -> {
+                MethodReference methodReference = methodElement.getMethodReference();
+                lines.add(
+                    new AtLine(
+                        startingWhitespace,
+                        at,
+                        methodReference.getHolderClass().getTypeName(),
+                        methodReference.getMethodName(),
+                        methodDescriptionFromMethodReference(methodReference, verbose),
+                        retraceBase.retraceSourceFile(
+                            classReference, fileName, methodReference.getHolderClass(), true),
+                        hasLinePosition()
+                            ? methodElement.getOriginalLineNumber(linePosition)
+                            : linePosition,
+                        methodElement.getRetraceMethodResult().isAmbiguous()));
+              });
       return lines;
     }
 
     @Override
     public String toString() {
-      return toString(at, "");
-    }
-
-    protected String toString(String at, String previousClass) {
       StringBuilder sb = new StringBuilder(startingWhitespace);
       sb.append(at);
-      String commonPrefix = Strings.commonPrefix(clazz, previousClass);
-      if (commonPrefix.length() == clazz.length()) {
-        sb.append(Strings.repeat(" ", clazz.length() + 1));
-      } else {
-        sb.append(Strings.padStart(clazz.substring(commonPrefix.length()), clazz.length(), ' '));
-        sb.append(".");
-      }
-      sb.append(method);
+      sb.append(methodAsString);
       sb.append("(");
       sb.append(fileName);
       if (linePosition != NO_POSITION) {
@@ -443,7 +448,7 @@
     }
 
     @Override
-    List<StackTraceLine> retrace(RetraceBase retraceBase) {
+    List<StackTraceLine> retrace(RetraceBase retraceBase, boolean verbose) {
       return ImmutableList.of(new MoreLine(line));
     }
 
@@ -461,7 +466,7 @@
     }
 
     @Override
-    List<StackTraceLine> retrace(RetraceBase retraceBase) {
+    List<StackTraceLine> retrace(RetraceBase retraceBase, boolean verbose) {
       return ImmutableList.of(new UnknownLine(line));
     }
 
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceUtils.java b/src/main/java/com/android/tools/r8/retrace/RetraceUtils.java
new file mode 100644
index 0000000..81c2272
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceUtils.java
@@ -0,0 +1,38 @@
+// 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.retrace;
+
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.TypeReference;
+
+public class RetraceUtils {
+
+  public static String methodDescriptionFromMethodReference(
+      MethodReference methodReference, boolean verbose) {
+    if (!verbose || methodReference.isUnknown()) {
+      return methodReference.getHolderClass().getTypeName() + "." + methodReference.getMethodName();
+    }
+    StringBuilder sb = new StringBuilder();
+    sb.append(
+        methodReference.getReturnType() == null
+            ? "void"
+            : methodReference.getReturnType().getTypeName());
+    sb.append(" ");
+    sb.append(methodReference.getHolderClass().getTypeName());
+    sb.append(".");
+    sb.append(methodReference.getMethodName());
+    sb.append("(");
+    boolean seenFirstIndex = false;
+    for (TypeReference formalType : methodReference.getFormalTypes()) {
+      if (seenFirstIndex) {
+        sb.append(",");
+      }
+      seenFirstIndex = true;
+      sb.append(formalType.getTypeName());
+    }
+    sb.append(")");
+    return sb.toString();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
index 25a7b15..9b5029f 100644
--- a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
+++ b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
@@ -26,7 +26,6 @@
 import com.android.tools.r8.graph.GraphLense;
 import com.android.tools.r8.graph.PresortedComparable;
 import com.android.tools.r8.graph.ResolutionResult;
-import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
 import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
 import com.android.tools.r8.ir.code.Invoke.Type;
 import com.android.tools.r8.utils.CollectionUtils;
@@ -979,7 +978,7 @@
 
   private DexEncodedMethod validateSingleVirtualTarget(
       DexEncodedMethod singleTarget, DexEncodedMethod resolutionResult) {
-    assert SingleResolutionResult.isValidVirtualTarget(options(), resolutionResult);
+    assert resolutionResult.isVirtualMethod();
 
     if (singleTarget == null || singleTarget == DexEncodedMethod.SENTINEL) {
       return null;
@@ -996,7 +995,7 @@
 
   private boolean isInvalidSingleVirtualTarget(
       DexEncodedMethod singleTarget, DexEncodedMethod resolutionResult) {
-    assert SingleResolutionResult.isValidVirtualTarget(options(), resolutionResult);
+    assert resolutionResult.isVirtualMethod();
     // Art978_virtual_interfaceTest correctly expects an IncompatibleClassChangeError exception
     // at runtime.
     return !singleTarget.accessFlags.isAtLeastAsVisibleAs(resolutionResult.accessFlags);
@@ -1039,11 +1038,10 @@
     // from the runtime type of the receiver.
     if (receiverLowerBoundType != null) {
       if (receiverLowerBoundType.getClassType() == refinedReceiverType) {
-        if (resolutionResult.isSingleResolution()
-            && resolutionResult.isValidVirtualTargetForDynamicDispatch()) {
+        if (resolutionResult.isSingleResolution() && resolutionResult.isVirtualTarget()) {
           ResolutionResult refinedResolutionResult = resolveMethod(refinedReceiverType, method);
           if (refinedResolutionResult.isSingleResolution()
-              && refinedResolutionResult.isValidVirtualTargetForDynamicDispatch()) {
+              && refinedResolutionResult.isVirtualTarget()) {
             return validateSingleVirtualTarget(
                 refinedResolutionResult.getSingleTarget(), resolutionResult.getSingleTarget());
           }
@@ -1081,7 +1079,7 @@
     // First get the target for the holder type.
     ResolutionResult topMethod = resolveMethodOnClass(holder, method);
     // We might hit none or multiple targets. Both make this fail at runtime.
-    if (!topMethod.isSingleResolution() || !topMethod.isValidVirtualTarget(options())) {
+    if (!topMethod.isSingleResolution() || !topMethod.isVirtualTarget()) {
       method.setSingleVirtualMethodCache(refinedReceiverType, null);
       return null;
     }
@@ -1223,11 +1221,10 @@
     if (receiverLowerBoundType != null) {
       if (receiverLowerBoundType.getClassType() == refinedReceiverType) {
         ResolutionResult resolutionResult = resolveMethod(method.holder, method, true);
-        if (resolutionResult.isSingleResolution()
-            && resolutionResult.isValidVirtualTargetForDynamicDispatch()) {
+        if (resolutionResult.isSingleResolution() && resolutionResult.isVirtualTarget()) {
           ResolutionResult refinedResolutionResult = resolveMethod(refinedReceiverType, method);
           if (refinedResolutionResult.isSingleResolution()
-              && refinedResolutionResult.isValidVirtualTargetForDynamicDispatch()) {
+              && refinedResolutionResult.isVirtualTarget()) {
             return validateSingleVirtualTarget(
                 refinedResolutionResult.getSingleTarget(), resolutionResult.getSingleTarget());
           }
diff --git a/src/main/java/com/android/tools/r8/shaking/DefaultEnqueuerUseRegistry.java b/src/main/java/com/android/tools/r8/shaking/DefaultEnqueuerUseRegistry.java
index 7c78ac5..f05d068 100644
--- a/src/main/java/com/android/tools/r8/shaking/DefaultEnqueuerUseRegistry.java
+++ b/src/main/java/com/android/tools/r8/shaking/DefaultEnqueuerUseRegistry.java
@@ -12,100 +12,107 @@
 import com.android.tools.r8.graph.DexMethodHandle;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.UseRegistry;
 
 public class DefaultEnqueuerUseRegistry extends UseRegistry {
 
-  private final DexProgramClass currentHolder;
-  protected final DexEncodedMethod currentMethod;
+  private final ProgramMethod context;
   private final Enqueuer enqueuer;
 
   public DefaultEnqueuerUseRegistry(
-      AppView<?> appView,
-      DexProgramClass currentHolder,
-      DexEncodedMethod currentMethod,
-      Enqueuer enqueuer) {
+      AppView<?> appView, DexProgramClass holder, DexEncodedMethod method, Enqueuer enqueuer) {
     super(appView.dexItemFactory());
-    assert currentHolder.type == currentMethod.method.holder;
-    this.currentHolder = currentHolder;
-    this.currentMethod = currentMethod;
+    this.context = new ProgramMethod(holder, method);
     this.enqueuer = enqueuer;
   }
 
+  public ProgramMethod getContext() {
+    return context;
+  }
+
+  public DexProgramClass getContextHolder() {
+    return context.holder;
+  }
+
+  public DexEncodedMethod getContextMethod() {
+    return context.method;
+  }
+
   @Override
   public boolean registerInvokeVirtual(DexMethod invokedMethod) {
-    return enqueuer.traceInvokeVirtual(invokedMethod, currentHolder, currentMethod);
+    return enqueuer.traceInvokeVirtual(invokedMethod, context);
   }
 
   @Override
   public boolean registerInvokeDirect(DexMethod invokedMethod) {
-    return enqueuer.traceInvokeDirect(invokedMethod, currentHolder, currentMethod);
+    return enqueuer.traceInvokeDirect(invokedMethod, context);
   }
 
   @Override
   public boolean registerInvokeStatic(DexMethod invokedMethod) {
-    return enqueuer.traceInvokeStatic(invokedMethod, currentHolder, currentMethod);
+    return enqueuer.traceInvokeStatic(invokedMethod, context);
   }
 
   @Override
   public boolean registerInvokeInterface(DexMethod invokedMethod) {
-    return enqueuer.traceInvokeInterface(invokedMethod, currentHolder, currentMethod);
+    return enqueuer.traceInvokeInterface(invokedMethod, context);
   }
 
   @Override
   public boolean registerInvokeSuper(DexMethod invokedMethod) {
-    return enqueuer.traceInvokeSuper(invokedMethod, currentHolder, currentMethod);
+    return enqueuer.traceInvokeSuper(invokedMethod, context);
   }
 
   @Override
   public boolean registerInstanceFieldWrite(DexField field) {
-    return enqueuer.traceInstanceFieldWrite(field, currentMethod);
+    return enqueuer.traceInstanceFieldWrite(field, context.method);
   }
 
   @Override
   public boolean registerInstanceFieldRead(DexField field) {
-    return enqueuer.traceInstanceFieldRead(field, currentMethod);
+    return enqueuer.traceInstanceFieldRead(field, context.method);
   }
 
   @Override
   public boolean registerNewInstance(DexType type) {
-    return enqueuer.traceNewInstance(type, currentMethod);
+    return enqueuer.traceNewInstance(type, context);
   }
 
   @Override
   public boolean registerStaticFieldRead(DexField field) {
-    return enqueuer.traceStaticFieldRead(field, currentMethod);
+    return enqueuer.traceStaticFieldRead(field, context.method);
   }
 
   @Override
   public boolean registerStaticFieldWrite(DexField field) {
-    return enqueuer.traceStaticFieldWrite(field, currentMethod);
+    return enqueuer.traceStaticFieldWrite(field, context.method);
   }
 
   @Override
   public boolean registerConstClass(DexType type) {
-    return enqueuer.traceConstClass(type, currentMethod);
+    return enqueuer.traceConstClass(type, context.method);
   }
 
   @Override
   public boolean registerCheckCast(DexType type) {
-    return enqueuer.traceCheckCast(type, currentMethod);
+    return enqueuer.traceCheckCast(type, context.method);
   }
 
   @Override
   public boolean registerTypeReference(DexType type) {
-    return enqueuer.traceTypeReference(type, currentMethod);
+    return enqueuer.traceTypeReference(type, context.method);
   }
 
   @Override
   public void registerMethodHandle(DexMethodHandle methodHandle, MethodHandleUse use) {
     super.registerMethodHandle(methodHandle, use);
-    enqueuer.traceMethodHandle(methodHandle, use, currentMethod);
+    enqueuer.traceMethodHandle(methodHandle, use, context.method);
   }
 
   @Override
   public void registerCallSite(DexCallSite callSite) {
     super.registerCallSite(callSite);
-    enqueuer.traceCallSite(callSite, currentMethod);
+    enqueuer.traceCallSite(callSite, context);
   }
 }
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 6bd3db2..ac1dea1 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.dex.IndexedItemCollection;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.experimental.graphinfo.GraphConsumer;
+import com.android.tools.r8.graph.AccessControl;
 import com.android.tools.r8.graph.AppInfoWithSubtyping;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.Descriptor;
@@ -37,6 +38,7 @@
 import com.android.tools.r8.graph.FieldAccessInfoImpl;
 import com.android.tools.r8.graph.KeyedDexItem;
 import com.android.tools.r8.graph.PresortedComparable;
+import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.ResolutionResult;
 import com.android.tools.r8.graph.ResolutionResult.FailedResolutionResult;
 import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
@@ -93,7 +95,6 @@
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.function.BiConsumer;
-import java.util.function.BiPredicate;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
@@ -586,21 +587,20 @@
     return isRead ? info.recordRead(field, context) : info.recordWrite(field, context);
   }
 
-  void traceCallSite(DexCallSite callSite, DexEncodedMethod currentMethod) {
+  void traceCallSite(DexCallSite callSite, ProgramMethod context) {
     callSites.add(callSite);
 
     List<DexType> directInterfaces = LambdaDescriptor.getInterfaces(callSite, appInfo);
     if (directInterfaces != null) {
       for (DexType lambdaInstantiatedInterface : directInterfaces) {
-        markLambdaInstantiated(lambdaInstantiatedInterface, currentMethod);
+        markLambdaInstantiated(lambdaInstantiatedInterface, context.method);
       }
     } else {
       if (!appInfo.isStringConcat(callSite.bootstrapMethod)) {
         if (options.reporter != null) {
           Diagnostic message =
               new StringDiagnostic(
-                  "Unknown bootstrap method " + callSite.bootstrapMethod,
-                  appInfo.originFor(currentMethod.method.holder));
+                  "Unknown bootstrap method " + callSite.bootstrapMethod, context.holder.origin);
           options.reporter.warning(message);
         }
       }
@@ -634,19 +634,19 @@
 
     switch (implHandle.type) {
       case INVOKE_STATIC:
-        traceInvokeStaticFromLambda(method, currentMethod);
+        traceInvokeStaticFromLambda(method, context);
         break;
       case INVOKE_INTERFACE:
-        traceInvokeInterfaceFromLambda(method, currentMethod);
+        traceInvokeInterfaceFromLambda(method, context);
         break;
       case INVOKE_INSTANCE:
-        traceInvokeVirtualFromLambda(method, currentMethod);
+        traceInvokeVirtualFromLambda(method, context);
         break;
       case INVOKE_DIRECT:
-        traceInvokeDirectFromLambda(method, currentMethod);
+        traceInvokeDirectFromLambda(method, context);
         break;
       case INVOKE_CONSTRUCTOR:
-        traceNewInstanceFromLambda(method.holder, currentMethod);
+        traceNewInstanceFromLambda(method.holder, context);
         break;
       default:
         throw new Unreachable();
@@ -726,7 +726,7 @@
       if (clazz != null) {
         KeepReason reason = KeepReason.methodHandleReferencedIn(currentMethod);
         if (clazz.isInterface() && !clazz.accessFlags.isAnnotation()) {
-          markInterfaceAsInstantiated(clazz, graphReporter.registerClass(clazz, reason));
+          markInterfaceAsInstantiated(clazz, graphReporter.registerInterface(clazz, reason));
         } else {
           markInstantiated(clazz, null, reason);
         }
@@ -739,8 +739,9 @@
     return true;
   }
 
-  boolean traceInvokeDirect(
-      DexMethod invokedMethod, DexProgramClass currentHolder, DexEncodedMethod currentMethod) {
+  boolean traceInvokeDirect(DexMethod invokedMethod, ProgramMethod context) {
+    DexProgramClass currentHolder = context.holder;
+    DexEncodedMethod currentMethod = context.method;
     boolean skipTracing =
         registerDeferredActionForDeadProtoBuilder(
             invokedMethod.holder,
@@ -753,7 +754,7 @@
     }
 
     return traceInvokeDirect(
-        invokedMethod, currentMethod, KeepReason.invokedFrom(currentHolder, currentMethod));
+        invokedMethod, context, KeepReason.invokedFrom(currentHolder, currentMethod));
   }
 
   /** Returns true if a deferred action was registered. */
@@ -770,13 +771,14 @@
     return false;
   }
 
-  boolean traceInvokeDirectFromLambda(DexMethod invokedMethod, DexEncodedMethod currentMethod) {
+  boolean traceInvokeDirectFromLambda(DexMethod invokedMethod, ProgramMethod context) {
     return traceInvokeDirect(
-        invokedMethod, currentMethod, KeepReason.invokedFromLambdaCreatedIn(currentMethod));
+        invokedMethod, context, KeepReason.invokedFromLambdaCreatedIn(context.method));
   }
 
   private boolean traceInvokeDirect(
-      DexMethod invokedMethod, DexEncodedMethod currentMethod, KeepReason reason) {
+      DexMethod invokedMethod, ProgramMethod context, KeepReason reason) {
+    DexEncodedMethod currentMethod = context.method;
     if (!registerMethodWithTargetAndContext(directInvokes, invokedMethod, currentMethod)) {
       return false;
     }
@@ -787,42 +789,42 @@
     return true;
   }
 
-  boolean traceInvokeInterface(
-      DexMethod invokedMethod, DexProgramClass currentHolder, DexEncodedMethod currentMethod) {
+  boolean traceInvokeInterface(DexMethod invokedMethod, ProgramMethod context) {
     return traceInvokeInterface(
-        invokedMethod, currentMethod, KeepReason.invokedFrom(currentHolder, currentMethod));
+        invokedMethod, context, KeepReason.invokedFrom(context.holder, context.method));
   }
 
-  boolean traceInvokeInterfaceFromLambda(DexMethod invokedMethod, DexEncodedMethod currentMethod) {
+  boolean traceInvokeInterfaceFromLambda(DexMethod invokedMethod, ProgramMethod context) {
     return traceInvokeInterface(
-        invokedMethod, currentMethod, KeepReason.invokedFromLambdaCreatedIn(currentMethod));
+        invokedMethod, context, KeepReason.invokedFromLambdaCreatedIn(context.method));
   }
 
   private boolean traceInvokeInterface(
-      DexMethod method, DexEncodedMethod currentMethod, KeepReason keepReason) {
+      DexMethod method, ProgramMethod context, KeepReason keepReason) {
+    DexEncodedMethod currentMethod = context.method;
     if (!registerMethodWithTargetAndContext(interfaceInvokes, method, currentMethod)) {
       return false;
     }
     if (Log.ENABLED) {
       Log.verbose(getClass(), "Register invokeInterface `%s`.", method);
     }
-    workList.enqueueMarkReachableInterfaceAction(method, keepReason);
+    markVirtualMethodAsReachable(method, true, context, keepReason);
     return true;
   }
 
-  boolean traceInvokeStatic(
-      DexMethod invokedMethod, DexProgramClass currentHolder, DexEncodedMethod currentMethod) {
+  boolean traceInvokeStatic(DexMethod invokedMethod, ProgramMethod context) {
     return traceInvokeStatic(
-        invokedMethod, currentMethod, KeepReason.invokedFrom(currentHolder, currentMethod));
+        invokedMethod, context, KeepReason.invokedFrom(context.holder, context.method));
   }
 
-  boolean traceInvokeStaticFromLambda(DexMethod invokedMethod, DexEncodedMethod currentMethod) {
+  boolean traceInvokeStaticFromLambda(DexMethod invokedMethod, ProgramMethod context) {
     return traceInvokeStatic(
-        invokedMethod, currentMethod, KeepReason.invokedFromLambdaCreatedIn(currentMethod));
+        invokedMethod, context, KeepReason.invokedFromLambdaCreatedIn(context.method));
   }
 
   private boolean traceInvokeStatic(
-      DexMethod invokedMethod, DexEncodedMethod currentMethod, KeepReason reason) {
+      DexMethod invokedMethod, ProgramMethod context, KeepReason reason) {
+    DexEncodedMethod currentMethod = context.method;
     DexItemFactory dexItemFactory = appView.dexItemFactory();
     if (dexItemFactory.classMethods.isReflectiveClassLookup(invokedMethod)
         || dexItemFactory.atomicFieldUpdaterMethods.isFieldUpdater(invokedMethod)) {
@@ -852,8 +854,9 @@
     return true;
   }
 
-  boolean traceInvokeSuper(
-      DexMethod invokedMethod, DexProgramClass currentHolder, DexEncodedMethod currentMethod) {
+  boolean traceInvokeSuper(DexMethod invokedMethod, ProgramMethod context) {
+    DexProgramClass currentHolder = context.holder;
+    DexEncodedMethod currentMethod = context.method;
     // We have to revisit super invokes based on the context they are found in. The same
     // method descriptor will hit different targets, depending on the context it is used in.
     DexMethod actualTarget = getInvokeSuperTarget(invokedMethod, currentMethod);
@@ -867,56 +870,55 @@
     return true;
   }
 
-  boolean traceInvokeVirtual(
-      DexMethod invokedMethod, DexProgramClass currentHolder, DexEncodedMethod currentMethod) {
+  boolean traceInvokeVirtual(DexMethod invokedMethod, ProgramMethod context) {
     return traceInvokeVirtual(
-        invokedMethod, currentMethod, KeepReason.invokedFrom(currentHolder, currentMethod));
+        invokedMethod, context, KeepReason.invokedFrom(context.holder, context.method));
   }
 
-  boolean traceInvokeVirtualFromLambda(DexMethod invokedMethod, DexEncodedMethod currentMethod) {
+  boolean traceInvokeVirtualFromLambda(DexMethod invokedMethod, ProgramMethod context) {
     return traceInvokeVirtual(
-        invokedMethod, currentMethod, KeepReason.invokedFromLambdaCreatedIn(currentMethod));
+        invokedMethod, context, KeepReason.invokedFromLambdaCreatedIn(context.method));
   }
 
   private boolean traceInvokeVirtual(
-      DexMethod invokedMethod, DexEncodedMethod currentMethod, KeepReason reason) {
+      DexMethod invokedMethod, ProgramMethod context, KeepReason reason) {
     if (invokedMethod == appView.dexItemFactory().classMethods.newInstance
         || invokedMethod == appView.dexItemFactory().constructorMethods.newInstance) {
-      pendingReflectiveUses.add(currentMethod);
+      pendingReflectiveUses.add(context.method);
     } else if (appView.dexItemFactory().classMethods.isReflectiveMemberLookup(invokedMethod)) {
       // Implicitly add -identifiernamestring rule for the Java reflection in use.
       identifierNameStrings.add(invokedMethod);
       // Revisit the current method to implicitly add -keep rule for items with reflective access.
-      pendingReflectiveUses.add(currentMethod);
+      pendingReflectiveUses.add(context.method);
     }
-    if (!registerMethodWithTargetAndContext(virtualInvokes, invokedMethod, currentMethod)) {
+    if (!registerMethodWithTargetAndContext(virtualInvokes, invokedMethod, context.method)) {
       return false;
     }
     if (Log.ENABLED) {
       Log.verbose(getClass(), "Register invokeVirtual `%s`.", invokedMethod);
     }
-    workList.enqueueMarkReachableVirtualAction(invokedMethod, reason);
+    markVirtualMethodAsReachable(invokedMethod, false, context, reason);
     return true;
   }
 
-  boolean traceNewInstance(DexType type, DexEncodedMethod currentMethod) {
+  boolean traceNewInstance(DexType type, ProgramMethod context) {
+    DexEncodedMethod currentMethod = context.method;
     boolean skipTracing =
         registerDeferredActionForDeadProtoBuilder(
-            type, currentMethod, () -> workList.enqueueTraceNewInstanceAction(type, currentMethod));
+            type, currentMethod, () -> workList.enqueueTraceNewInstanceAction(type, context));
     if (skipTracing) {
       return false;
     }
 
-    return traceNewInstance(type, currentMethod, KeepReason.instantiatedIn(currentMethod));
+    return traceNewInstance(type, context, KeepReason.instantiatedIn(currentMethod));
   }
 
-  boolean traceNewInstanceFromLambda(DexType type, DexEncodedMethod currentMethod) {
-    return traceNewInstance(
-        type, currentMethod, KeepReason.invokedFromLambdaCreatedIn(currentMethod));
+  boolean traceNewInstanceFromLambda(DexType type, ProgramMethod context) {
+    return traceNewInstance(type, context, KeepReason.invokedFromLambdaCreatedIn(context.method));
   }
 
-  private boolean traceNewInstance(
-      DexType type, DexEncodedMethod currentMethod, KeepReason keepReason) {
+  private boolean traceNewInstance(DexType type, ProgramMethod context, KeepReason keepReason) {
+    DexEncodedMethod currentMethod = context.method;
     DexProgramClass clazz = getProgramClassOrNull(type);
     if (clazz != null) {
       if (clazz.isInterface()) {
@@ -1416,7 +1418,7 @@
     // It is valid to have an invoke-direct instruction in a default interface method that
     // targets another default method in the same interface (see testInvokeSpecialToDefault-
     // Method). In a class, that would lead to a verification error.
-    if (encodedMethod.isVirtualMethod()
+    if (encodedMethod.isNonPrivateVirtualMethod()
         && virtualMethodsTargetedByInvokeDirect.add(encodedMethod.method)) {
       enqueueMarkMethodLiveAction(clazz, encodedMethod, reason);
     }
@@ -1658,7 +1660,7 @@
   }
 
   private void markResolutionAsLive(DexClass libraryClass, ResolutionResult resolution) {
-    if (resolution.isValidVirtualTarget(options)) {
+    if (resolution.isVirtualTarget()) {
       DexEncodedMethod target = resolution.getSingleTarget();
       DexProgramClass targetHolder = getProgramClassOrNull(target.method.holder);
       if (targetHolder != null
@@ -1960,16 +1962,8 @@
     }
   }
 
-  // Package protected due to entry point from worklist.
-  void markVirtualMethodAsReachable(DexMethod method, boolean interfaceInvoke, KeepReason reason) {
-    markVirtualMethodAsReachable(method, interfaceInvoke, reason, (x, y) -> true);
-  }
-
   private void markVirtualMethodAsReachable(
-      DexMethod method,
-      boolean interfaceInvoke,
-      KeepReason reason,
-      BiPredicate<DexProgramClass, DexEncodedMethod> possibleTargetsFilter) {
+      DexMethod method, boolean interfaceInvoke, ProgramMethod contextOrNull, KeepReason reason) {
     if (method.holder.isArrayType()) {
       // This is an array type, so the actual class will be generated at runtime. We treat this
       // like an invoke on a direct subtype of java.lang.Object that has no further subtypes.
@@ -2002,9 +1996,18 @@
 
     // Otherwise, the resolution target is marked and cached, and all possible targets identified.
     resolution = findAndMarkResolutionTarget(method, interfaceInvoke, reason);
+    if (contextOrNull != null
+        && !resolution.isUnresolved()
+        && !AccessControl.isMethodAccessible(
+            resolution.method, holder, contextOrNull.holder, appInfo)) {
+      // Not accessible from this context, so this call will cause a runtime exception.
+      // Note that the resolution is not cached, as another call context may be valid.
+      return;
+    }
+
+    // The resolution is unresolved or accessible, both are context independent, so cache it.
     virtualTargetsMarkedAsReachable.put(method, resolution);
-    if (resolution.isUnresolved()
-        || !SingleResolutionResult.isValidVirtualTarget(options, resolution.method)) {
+    if (resolution.isUnresolved() || !resolution.method.isVirtualMethod()) {
       // There is no valid resolution, so any call will lead to a runtime exception.
       return;
     }
@@ -2027,24 +2030,20 @@
       if (encodedPossibleTarget.isAbstract()) {
         continue;
       }
-      markPossibleTargetsAsReachable(resolution, possibleTargetsFilter, encodedPossibleTarget);
+      markPossibleTargetsAsReachable(resolution, encodedPossibleTarget);
     }
   }
 
   private void markPossibleTargetsAsReachable(
       MarkedResolutionTarget reason,
-      BiPredicate<DexProgramClass, DexEncodedMethod> possibleTargetsFilter,
       DexEncodedMethod encodedPossibleTarget) {
-    assert encodedPossibleTarget.isVirtualMethod() || options.canUseNestBasedAccess();
+    assert encodedPossibleTarget.isVirtualMethod();
     assert !encodedPossibleTarget.isAbstract();
     DexMethod possibleTarget = encodedPossibleTarget.method;
     DexProgramClass clazz = getProgramClassOrNull(possibleTarget.holder);
     if (clazz == null) {
       return;
     }
-    if (!possibleTargetsFilter.test(clazz, encodedPossibleTarget)) {
-      return;
-    }
     ReachableVirtualMethodsSet reachable =
         reachableVirtualMethods.computeIfAbsent(clazz, ignore -> new ReachableVirtualMethodsSet());
     if (!reachable.add(encodedPossibleTarget, reason)) {
@@ -2500,10 +2499,8 @@
       // A virtual method. Mark it as reachable so that subclasses, if instantiated, keep
       // their overrides. However, we don't mark it live, as a keep rule might not imply that
       // the corresponding class is live.
-      if (!holder.isInterface()) {
-        workList.enqueueMarkReachableVirtualAction(method, reason);
-      } else {
-        workList.enqueueMarkReachableInterfaceAction(method, reason);
+      markVirtualMethodAsReachable(method, holder.isInterface(), null, reason);
+      if (holder.isInterface()) {
         // Reachability for default methods is based on live subtypes in general. For keep rules,
         // we need special handling as we essentially might have live subtypes that are outside of
         // the current compilation unit. Keep either the default-method or its implementation
@@ -2543,7 +2540,7 @@
       DexProgramClass clazz, DexEncodedMethod method) {
     assert method.isVirtualMethod();
 
-    if (method.isAbstract()) {
+    if (method.isAbstract() || method.isPrivateMethod()) {
       return false;
     }
 
@@ -2719,7 +2716,9 @@
       if (clazz == null) {
         return;
       }
-      if (!clazz.isInterface()) {
+      if (clazz.isInterface()) {
+        markTypeAsLive(clazz.type, KeepReason.reflectiveUseIn(method));
+      } else {
         markInstantiated(clazz, null, KeepReason.reflectiveUseIn(method));
         if (clazz.hasDefaultInitializer()) {
           DexEncodedMethod initializer = clazz.getDefaultInitializer();
diff --git a/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java b/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java
index ff6ece0..d98d7c9 100644
--- a/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java
+++ b/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java
@@ -11,6 +11,7 @@
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.shaking.GraphReporter.KeepReasonWitness;
 import java.util.ArrayDeque;
 import java.util.Queue;
@@ -36,36 +37,6 @@
     }
   }
 
-  static class MarkReachableVirtualAction extends EnqueuerAction {
-    final DexMethod target;
-    final KeepReason reason;
-
-    MarkReachableVirtualAction(DexMethod target, KeepReason reason) {
-      this.target = target;
-      this.reason = reason;
-    }
-
-    @Override
-    public void run(Enqueuer enqueuer) {
-      enqueuer.markVirtualMethodAsReachable(target, false, reason);
-    }
-  }
-
-  static class MarkReachableInterfaceAction extends EnqueuerAction {
-    final DexMethod target;
-    final KeepReason reason;
-
-    public MarkReachableInterfaceAction(DexMethod target, KeepReason reason) {
-      this.target = target;
-      this.reason = reason;
-    }
-
-    @Override
-    public void run(Enqueuer enqueuer) {
-      enqueuer.markVirtualMethodAsReachable(target, true, reason);
-    }
-  }
-
   static class MarkReachableSuperAction extends EnqueuerAction {
     final DexMethod target;
     final DexEncodedMethod context;
@@ -194,22 +165,22 @@
 
     @Override
     public void run(Enqueuer enqueuer) {
-      enqueuer.traceInvokeDirect(invokedMethod, currentHolder, currentMethod);
+      enqueuer.traceInvokeDirect(invokedMethod, new ProgramMethod(currentHolder, currentMethod));
     }
   }
 
   static class TraceNewInstanceAction extends EnqueuerAction {
     final DexType type;
-    final DexEncodedMethod currentMethod;
+    final ProgramMethod context;
 
-    TraceNewInstanceAction(DexType type, DexEncodedMethod currentMethod) {
+    TraceNewInstanceAction(DexType type, ProgramMethod context) {
       this.type = type;
-      this.currentMethod = currentMethod;
+      this.context = context;
     }
 
     @Override
     public void run(Enqueuer enqueuer) {
-      enqueuer.traceNewInstance(type, currentMethod);
+      enqueuer.traceNewInstance(type, context);
     }
   }
 
@@ -251,14 +222,6 @@
     queue.add(new MarkReachableDirectAction(method, reason));
   }
 
-  void enqueueMarkReachableVirtualAction(DexMethod method, KeepReason reason) {
-    queue.add(new MarkReachableVirtualAction(method, reason));
-  }
-
-  void enqueueMarkReachableInterfaceAction(DexMethod method, KeepReason reason) {
-    queue.add(new MarkReachableInterfaceAction(method, reason));
-  }
-
   void enqueueMarkReachableSuperAction(DexMethod method, DexEncodedMethod from) {
     queue.add(new MarkReachableSuperAction(method, from));
   }
@@ -306,9 +269,8 @@
     queue.add(new TraceInvokeDirectAction(invokedMethod, currentHolder, currentMethod));
   }
 
-  public void enqueueTraceNewInstanceAction(DexType type, DexEncodedMethod currentMethod) {
-    assert currentMethod.isProgramMethod(appView);
-    queue.add(new TraceNewInstanceAction(type, currentMethod));
+  public void enqueueTraceNewInstanceAction(DexType type, ProgramMethod context) {
+    queue.add(new TraceNewInstanceAction(type, context));
   }
 
   public void enqueueTraceStaticFieldRead(DexField field, DexEncodedMethod currentMethod) {
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 b86857a..b842680 100644
--- a/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
+++ b/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
@@ -533,8 +533,7 @@
       }
       ResolutionResult resolutionResult =
           appView.appInfo().resolveMethod(originalClazz, method.method);
-      if (!resolutionResult.isValidVirtualTarget(appView.options())
-          || !resolutionResult.isSingleResolution()) {
+      if (!resolutionResult.isVirtualTarget() || !resolutionResult.isSingleResolution()) {
         return;
       }
       DexEncodedMethod methodToKeep = resolutionResult.getSingleTarget();
diff --git a/src/main/java/com/android/tools/r8/utils/AssertionConfigurationWithDefault.java b/src/main/java/com/android/tools/r8/utils/AssertionConfigurationWithDefault.java
new file mode 100644
index 0000000..7dc7b33
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/AssertionConfigurationWithDefault.java
@@ -0,0 +1,34 @@
+// 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 com.android.tools.r8.AssertionsConfiguration;
+import com.android.tools.r8.AssertionsConfiguration.AssertionTransformation;
+import com.android.tools.r8.AssertionsConfiguration.AssertionTransformationScope;
+import java.util.List;
+
+public class AssertionConfigurationWithDefault {
+
+  public final AssertionTransformation defautlTransformation;
+  public final List<AssertionsConfiguration> assertionsConfigurations;
+
+  public AssertionConfigurationWithDefault(
+      AssertionTransformation defautlTransformation,
+      List<AssertionsConfiguration> assertionsConfigurations) {
+    this.defautlTransformation = defautlTransformation;
+    assert assertionsConfigurations != null;
+    this.assertionsConfigurations = assertionsConfigurations;
+  }
+
+  public boolean isPassthroughAll() {
+    if (assertionsConfigurations.size() == 0) {
+      return defautlTransformation == AssertionTransformation.PASSTHROUGH;
+    }
+    return assertionsConfigurations.size() == 1
+        && assertionsConfigurations.get(0).getScope() == AssertionTransformationScope.ALL
+        && assertionsConfigurations.get(0).getTransformation()
+            == AssertionTransformation.PASSTHROUGH;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/DescriptorUtils.java b/src/main/java/com/android/tools/r8/utils/DescriptorUtils.java
index dccd176..fd51973 100644
--- a/src/main/java/com/android/tools/r8/utils/DescriptorUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/DescriptorUtils.java
@@ -329,6 +329,10 @@
     return className.replace(JAVA_PACKAGE_SEPARATOR, DESCRIPTOR_PACKAGE_SEPARATOR);
   }
 
+  public static String getJavaTypeFromBinaryName(String className) {
+    return className.replace(DESCRIPTOR_PACKAGE_SEPARATOR, JAVA_PACKAGE_SEPARATOR);
+  }
+
   public static String getBinaryNameFromDescriptor(String classDescriptor) {
     assert isClassDescriptor(classDescriptor);
     return classDescriptor.substring(1, classDescriptor.length() - 1);
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 9b47305..1425bc0 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -5,7 +5,6 @@
 
 import static com.google.common.base.Predicates.not;
 
-import com.android.tools.r8.AssertionsConfiguration;
 import com.android.tools.r8.ClassFileConsumer;
 import com.android.tools.r8.CompilationMode;
 import com.android.tools.r8.DataResourceConsumer;
@@ -243,6 +242,7 @@
   // TODO(b/125282093): Enable member value propagation for instance fields.
   public boolean enableValuePropagationForInstanceFields = false;
   public boolean enableUninstantiatedTypeOptimization = true;
+  public boolean enableUninstantiatedTypeOptimizationForInterfaces = true;
   // TODO(b/138917494): Disable until we have numbers on potential performance penalties.
   public boolean enableRedundantConstNumberOptimization = false;
 
@@ -366,6 +366,9 @@
         }
       }
     }
+    if (desugarGraphConsumer != null) {
+      desugarGraphConsumer.finished();
+    }
   }
 
   public boolean shouldDesugarNests() {
@@ -434,7 +437,7 @@
   public boolean ignoreMissingClasses = false;
   // EXPERIMENTAL flag to get behaviour as close to Proguard as possible.
   public boolean forceProguardCompatibility = false;
-  public AssertionsConfiguration assertionsConfiguration = null;
+  public AssertionConfigurationWithDefault assertionsConfiguration = null;
   public boolean configurationDebugging = false;
 
   // Don't convert Code objects to IRCode.
diff --git a/src/main/java/com/android/tools/r8/utils/SelfRetraceTest.java b/src/main/java/com/android/tools/r8/utils/SelfRetraceTest.java
index ab891e8..dc7ce2b 100644
--- a/src/main/java/com/android/tools/r8/utils/SelfRetraceTest.java
+++ b/src/main/java/com/android/tools/r8/utils/SelfRetraceTest.java
@@ -22,7 +22,7 @@
   }
 
   public static void test() {
-    if (System.getenv(SELFRETRACETEST_ENVIRONMENT_VAR) != null) {
+    if (System.getProperty(SELFRETRACETEST_ENVIRONMENT_VAR) != null) {
       new SelfRetraceTest().foo1();
     }
   }
diff --git a/src/test/apiUsageSample/com/android/tools/apiusagesample/D8ApiUsageSample.java b/src/test/apiUsageSample/com/android/tools/apiusagesample/D8ApiUsageSample.java
index 23dc7e0..41b328c 100644
--- a/src/test/apiUsageSample/com/android/tools/apiusagesample/D8ApiUsageSample.java
+++ b/src/test/apiUsageSample/com/android/tools/apiusagesample/D8ApiUsageSample.java
@@ -8,6 +8,7 @@
 import com.android.tools.r8.CompilationMode;
 import com.android.tools.r8.D8;
 import com.android.tools.r8.D8Command;
+import com.android.tools.r8.DesugarGraphConsumer;
 import com.android.tools.r8.DexFilePerClassFileConsumer;
 import com.android.tools.r8.DexIndexedConsumer;
 import com.android.tools.r8.DiagnosticsHandler;
@@ -335,6 +336,7 @@
               .addLibraryFiles(libraries)
               .addProgramFiles(inputs)
               .setDisableDesugaring(false)
+              .setDesugarGraphConsumer(new MyDesugarGraphConsumer())
               .build());
     } catch (CompilationFailedException e) {
       throw new RuntimeException("Unexpected compilation exceptions", e);
@@ -498,4 +500,15 @@
       }
     }
   }
+
+  private static class MyDesugarGraphConsumer implements DesugarGraphConsumer {
+
+    @Override
+    public void accept(Origin dependent, Origin dependency) {
+    }
+
+    public void finished() {
+
+    }
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/D8CommandTest.java b/src/test/java/com/android/tools/r8/D8CommandTest.java
index ae63272..db0baa3 100644
--- a/src/test/java/com/android/tools/r8/D8CommandTest.java
+++ b/src/test/java/com/android/tools/r8/D8CommandTest.java
@@ -525,6 +525,13 @@
         "Missing parameter", handler -> parse(handler, "--output"));
   }
 
+  @Test
+  public void desugaredLibrary() throws CompilationFailedException {
+    D8Command d8Command = parse("--desugared-lib", "src/library_desugar/desugar_jdk_libs.json");
+    assertFalse(
+        d8Command.getInternalOptions().desugaredLibraryConfiguration.getRewritePrefix().isEmpty());
+  }
+
   private D8Command parse(String... args) throws CompilationFailedException {
     return D8Command.parse(args, EmbeddedOrigin.INSTANCE).build();
   }
diff --git a/src/test/java/com/android/tools/r8/L8CommandTest.java b/src/test/java/com/android/tools/r8/L8CommandTest.java
index 0a55b8a..558ba0d 100644
--- a/src/test/java/com/android/tools/r8/L8CommandTest.java
+++ b/src/test/java/com/android/tools/r8/L8CommandTest.java
@@ -4,10 +4,12 @@
 package com.android.tools.r8;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.dex.Marker;
+import com.android.tools.r8.origin.EmbeddedOrigin;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import java.nio.charset.StandardCharsets;
@@ -68,6 +70,27 @@
     Marker marker = markers.iterator().next();
   }
 
+  @Test
+  public void testMarkerCommandLine() throws Throwable {
+    Path output = temp.newFolder().toPath().resolve("desugar_jdk_libs.zip");
+    L8Command l8Command =
+        parse(
+            ToolHelper.getDesugarJDKLibs().toString(),
+            "--lib",
+            ToolHelper.getAndroidJar(AndroidApiLevel.P).toString(),
+            "--min-api",
+            "20",
+            "--desugared-lib",
+            ToolHelper.DESUGAR_LIB_JSON_FOR_TESTING.toString(),
+            "--output",
+            output.toString());
+    L8.run(l8Command);
+    Collection<Marker> markers = ExtractMarker.extractMarkerFromDexFile(output);
+    // TODO(b/134732760): Shouldn't we remove the D8/R8 marker?
+    assertEquals(2, markers.size());
+    Marker marker = markers.iterator().next();
+  }
+
   private L8Command.Builder prepareBuilder(DiagnosticsHandler handler) {
     return L8Command.builder(handler)
         .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P))
@@ -156,4 +179,15 @@
     assertTrue(builder2.isShrinking());
     assertNotNull(builder2.build().getR8Command());
   }
+
+  @Test
+  public void desugaredLibrary() throws CompilationFailedException {
+    L8Command l8Command = parse("--desugared-lib", "src/library_desugar/desugar_jdk_libs.json");
+    assertFalse(
+        l8Command.getInternalOptions().desugaredLibraryConfiguration.getRewritePrefix().isEmpty());
+  }
+
+  private L8Command parse(String... args) throws CompilationFailedException {
+    return L8Command.parse(args, EmbeddedOrigin.INSTANCE).build();
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/R8CommandTest.java b/src/test/java/com/android/tools/r8/R8CommandTest.java
index 57d278e..165b510 100644
--- a/src/test/java/com/android/tools/r8/R8CommandTest.java
+++ b/src/test/java/com/android/tools/r8/R8CommandTest.java
@@ -206,7 +206,8 @@
     Path mainDexRules1 = temp.newFile("main-dex-1.rules").toPath();
     Path mainDexRules2 = temp.newFile("main-dex-2.rules").toPath();
     parse("--main-dex-rules", mainDexRules1.toString());
-    parse("--main-dex-rules", mainDexRules1.toString(), "--main-dex-rules", mainDexRules2.toString());
+    parse(
+        "--main-dex-rules", mainDexRules1.toString(), "--main-dex-rules", mainDexRules2.toString());
   }
 
   @Test(expected = CompilationFailedException.class)
@@ -637,6 +638,13 @@
         "Missing parameter", handler -> parse(handler, "--output"));
   }
 
+  @Test
+  public void desugaredLibrary() throws CompilationFailedException {
+    R8Command r8Command = parse("--desugared-lib", "src/library_desugar/desugar_jdk_libs.json");
+    assertFalse(
+        r8Command.getInternalOptions().desugaredLibraryConfiguration.getRewritePrefix().isEmpty());
+  }
+
   private R8Command parse(String... args) throws CompilationFailedException {
     return R8Command.parse(args, EmbeddedOrigin.INSTANCE).build();
   }
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 a19cfec..0ba8510 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,8 +5,12 @@
 
 import static com.android.tools.r8.utils.FileUtils.JAR_EXTENSION;
 import static com.google.common.io.ByteStreams.toByteArray;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 
 import com.android.tools.r8.ArchiveClassFileProvider;
 import com.android.tools.r8.CompilationFailedException;
@@ -18,8 +22,12 @@
 import com.android.tools.r8.TestRuntime;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.retrace.Retrace;
+import com.android.tools.r8.retrace.RetraceCommand;
 import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.Pair;
+import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.Lists;
 import java.io.BufferedInputStream;
 import java.io.FileInputStream;
 import java.io.IOException;
@@ -104,14 +112,59 @@
 
   @Test
   public void testRetrace() throws IOException {
-    ProcessResult result =
+    ProcessResult processResult =
         ToolHelper.runProcess(
-            new ProcessBuilder(
-                "python",
-                Paths.get(ToolHelper.TOOLS_DIR, "test_self_retrace.py").toString(),
-                r8R8Release.getFirst().toString(),
-                r8R8Release.getSecond().toString()));
-    assertEquals(result.toString(), 0, result.exitCode);
+            new ProcessBuilder()
+                .command(
+                    parameters.getRuntime().asCf().getJavaExecutable().toString(),
+                    "-DR8_THROW_EXCEPTION_FOR_TESTING_RETRACE=1",
+                    "-cp",
+                    r8R8Release.getFirst().toString(),
+                    "com.android.tools.r8.R8",
+                    "--help"));
+    assertNotEquals(0, processResult.exitCode);
+    assertThat(processResult.stderr, not(containsString("SelfRetraceTest")));
+
+    List<String> expectedStackTrace =
+        Lists.newArrayList(
+            "Intentional exception for testing retrace.",
+            "com.android.tools.r8.utils.SelfRetraceTest.foo3(SelfRetraceTest.java:13)",
+            "com.android.tools.r8.utils.SelfRetraceTest.foo2(SelfRetraceTest.java:17)",
+            "com.android.tools.r8.utils.SelfRetraceTest.foo1(SelfRetraceTest.java:21)",
+            "com.android.tools.r8.utils.SelfRetraceTest.test(SelfRetraceTest.java:26)",
+            "com.android.tools.r8.R8.run(R8.java:");
+
+    RetraceCommand retraceCommand =
+        RetraceCommand.builder()
+            .setStackTrace(StringUtils.splitLines(processResult.stderr))
+            .setProguardMapProducer(
+                () -> {
+                  Path mappingFile = r8R8Release.getSecond();
+                  try {
+                    return new String(Files.readAllBytes(mappingFile));
+                  } catch (IOException e) {
+                    e.printStackTrace();
+                    throw new RuntimeException(
+                        "Could not read mapping file " + mappingFile.toString());
+                  }
+                })
+            .setRetracedStackTraceConsumer(
+                retraced -> {
+                  int expectedIndex = -1;
+                  for (String line : retraced) {
+                    if (expectedIndex >= expectedStackTrace.size()) {
+                      break;
+                    } else if (expectedIndex == -1 && line.contains("java.lang.RuntimeException")) {
+                      expectedIndex = 0;
+                    }
+                    if (expectedIndex > -1) {
+                      assertThat(line, containsString(expectedStackTrace.get(expectedIndex++)));
+                    }
+                  }
+                  assertEquals(expectedStackTrace.size(), expectedIndex);
+                })
+            .build();
+    Retrace.run(retraceCommand);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java
index cd3e666..2330854 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java
@@ -90,11 +90,6 @@
             .addInnerClasses(CustomCollectionTest.class)
             .setMinApi(parameters.getApiLevel())
             .addKeepClassAndMembersRules(Executor.class)
-            .addOptionsModification(
-                options -> {
-                  // TODO(b/140233505): Allow devirtualization once fixed.
-                  options.enableDevirtualization = false;
-                })
             .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
             .compile()
             .inspect(
@@ -145,22 +140,28 @@
                 instr ->
                     instr.toString().contains("$-EL")
                         || instr.toString().contains("Comparator$-CC")));
-    inherited.streamInstructions().forEach(CustomCollectionTest::assertEmulatedInterfaceDispatch);
+    inherited.streamInstructions().forEach(x -> assertInheritedDispatchCorrect(x, r8));
   }
 
-  private static void assertEmulatedInterfaceDispatch(InstructionSubject instructionSubject) {
+  private void assertInheritedDispatchCorrect(InstructionSubject instructionSubject, boolean r8) {
     if (!instructionSubject.isConstString(JumboStringMode.ALLOW)) {
       for (String s : new String[] {"stream", "parallelStream", "spliterator", "sort"}) {
         if (instructionSubject.toString().contains(s)) {
-          assertTrue(instructionSubject.isInvokeStatic());
-          assertTrue(
-              instructionSubject.toString().contains("$-EL")
-                  || instructionSubject.toString().contains("Comparator$-CC"));
+          if (!r8 || instructionSubject.isInvokeStatic()) {
+            assertTrue(instructionSubject.isInvokeStatic());
+            assertTrue(
+                instructionSubject.toString().contains("$-EL")
+                    || instructionSubject.toString().contains("Comparator$-CC"));
+          } else {
+            // Has been devirtualized.
+            assertTrue(instructionSubject.isInvokeVirtual());
+          }
         }
       }
     }
   }
 
+
   static class Executor {
 
     // In directTypes() the collections use directly their type which implements a j$ interface
diff --git a/src/test/java/com/android/tools/r8/desugar/graph/DesugarGraphTestConsumer.java b/src/test/java/com/android/tools/r8/desugar/graph/DesugarGraphTestConsumer.java
index 2111b7d..186b01b 100644
--- a/src/test/java/com/android/tools/r8/desugar/graph/DesugarGraphTestConsumer.java
+++ b/src/test/java/com/android/tools/r8/desugar/graph/DesugarGraphTestConsumer.java
@@ -3,6 +3,9 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.desugar.graph;
 
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
 import com.android.tools.r8.DesugarGraphConsumer;
 import com.android.tools.r8.origin.Origin;
 import java.util.Collections;
@@ -13,13 +16,16 @@
 
 public class DesugarGraphTestConsumer implements DesugarGraphConsumer {
 
+  private boolean finished = false;
   private Map<Origin, Set<Origin>> edges = new HashMap<>();
 
   public boolean contains(Origin dependency, Origin dependent) {
+    assertTrue(finished);
     return edges.getOrDefault(dependency, Collections.emptySet()).contains(dependent);
   }
 
   public int totalEdgeCount() {
+    assertTrue(finished);
     int count = 0;
     for (Set<Origin> dependents : edges.values()) {
       count += dependents.size();
@@ -29,6 +35,13 @@
 
   @Override
   public synchronized void accept(Origin dependent, Origin dependency) {
+    assertFalse(finished);
     edges.computeIfAbsent(dependency, s -> new HashSet<>()).add(dependent);
   }
+
+  @Override
+  public void finished() {
+    assertFalse(finished);
+    finished = true;
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/desugar/graph/DesugarGraphUtils.java b/src/test/java/com/android/tools/r8/desugar/graph/DesugarGraphUtils.java
index af3c6a0..937540e 100644
--- a/src/test/java/com/android/tools/r8/desugar/graph/DesugarGraphUtils.java
+++ b/src/test/java/com/android/tools/r8/desugar/graph/DesugarGraphUtils.java
@@ -12,8 +12,12 @@
 
   public static Origin addClassWithOrigin(Class<?> clazz, D8TestBuilder builder)
       throws IOException {
-    Origin origin = makeOrigin(clazz.getTypeName());
-    builder.getBuilder().addClassProgramData(ToolHelper.getClassAsBytes(clazz), origin);
+    return addClassWithOrigin(clazz.getTypeName(), ToolHelper.getClassAsBytes(clazz), builder);
+  }
+
+  public static Origin addClassWithOrigin(String name, byte[] bytes, D8TestBuilder builder) {
+    Origin origin = makeOrigin(name);
+    builder.getBuilder().addClassProgramData(bytes, origin);
     return origin;
   }
 
diff --git a/src/test/java/com/android/tools/r8/desugar/graph/InterfaceToImplementingClassDependencyTest.java b/src/test/java/com/android/tools/r8/desugar/graph/InterfaceToImplementingClassDependencyTest.java
index 7f76cad..705410a 100644
--- a/src/test/java/com/android/tools/r8/desugar/graph/InterfaceToImplementingClassDependencyTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/graph/InterfaceToImplementingClassDependencyTest.java
@@ -36,7 +36,7 @@
     // Emtpy.
   }
 
-  public class A implements I {
+  public static class A implements I {
     // Empty.
   }
 
@@ -80,8 +80,8 @@
           .assertSuccessWithOutputLines("Hello World!");
       // If API level indicates desugaring is needed check the edges are reported.
       if (parameters.getApiLevel().getLevel() < AndroidApiLevel.N.getLevel()) {
-        assertEquals(1, consumer.totalEdgeCount());
         assertTrue(consumer.contains(originI, originA));
+        assertEquals(1, consumer.totalEdgeCount());
       } else {
         assertEquals(0, consumer.totalEdgeCount());
       }
diff --git a/src/test/java/com/android/tools/r8/desugar/graph/LambdaDependencyTest.java b/src/test/java/com/android/tools/r8/desugar/graph/LambdaDependencyTest.java
new file mode 100644
index 0000000..d7f39e5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/graph/LambdaDependencyTest.java
@@ -0,0 +1,81 @@
+// 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.desugar.graph;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.D8TestBuilder;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.AndroidApiLevel;
+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 LambdaDependencyTest extends TestBase {
+
+  public interface I {
+    void foo();
+  }
+
+  public static class A {
+    void bar(I i) {
+      i.foo();
+    }
+  }
+
+  public static class TestClass {
+
+    public static void main(String[] args) {
+      new A().bar(() -> System.out.println("lambda!"));
+    }
+  }
+
+  // Test runner follows.
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().withAllApiLevels().build();
+  }
+
+  private final TestParameters parameters;
+
+  public LambdaDependencyTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    if (parameters.isCfRuntime()) {
+      testForJvm()
+          .addProgramClasses(I.class, A.class, TestClass.class)
+          .run(parameters.getRuntime(), TestClass.class)
+          .assertSuccessWithOutputLines("lambda!");
+    } else {
+      D8TestBuilder builder = testForD8();
+      DesugarGraphTestConsumer consumer = new DesugarGraphTestConsumer();
+      builder.getBuilder().setDesugarGraphConsumer(consumer);
+      Origin originI = DesugarGraphUtils.addClassWithOrigin(I.class, builder);
+      Origin originA = DesugarGraphUtils.addClassWithOrigin(A.class, builder);
+      Origin originMain = DesugarGraphUtils.addClassWithOrigin(TestClass.class, builder);
+      builder
+          .setMinApi(parameters.getApiLevel())
+          .run(parameters.getRuntime(), TestClass.class)
+          .assertSuccessWithOutputLines("lambda!");
+      // If API level indicates desugaring is needed check the edges are reported.
+      if (parameters.getApiLevel().getLevel() < AndroidApiLevel.N.getLevel()) {
+        // Generated lambda class in TestClass.main depends on potential default methods in I.
+        assertTrue(consumer.contains(originI, originMain));
+        assertEquals(1, consumer.totalEdgeCount());
+      } else {
+        assertEquals(0, consumer.totalEdgeCount());
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/graph/NestDependencyTest.java b/src/test/java/com/android/tools/r8/desugar/graph/NestDependencyTest.java
new file mode 100644
index 0000000..c67f497
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/graph/NestDependencyTest.java
@@ -0,0 +1,87 @@
+// 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.desugar.graph;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.D8TestBuilder;
+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.origin.Origin;
+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 NestDependencyTest extends TestBase {
+
+  public static class Host {}
+
+  public static class Member1 {}
+
+  public static class Member2 {}
+
+  public static class TestClass {
+
+    public static void main(String[] args) {
+      System.out.println("Hello World!");
+    }
+  }
+
+  // Test runner follows.
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters()
+        .withCfRuntimesStartingFromIncluding(CfVm.JDK11)
+        .withDexRuntimes()
+        .withAllApiLevels()
+        .build();
+  }
+
+  private final TestParameters parameters;
+
+  public NestDependencyTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  private byte[] inNest(Class<?> clazz) throws Exception {
+    return transformer(clazz).setNest(Host.class, Member1.class, Member2.class).transform();
+  }
+
+  @Test
+  public void test() throws Exception {
+    if (parameters.isCfRuntime()) {
+      testForJvm()
+          .addProgramClassFileData(inNest(Host.class), inNest(Member1.class), inNest(Member2.class))
+          .addProgramClasses(TestClass.class)
+          .run(parameters.getRuntime(), TestClass.class)
+          .assertSuccessWithOutputLines("Hello World!");
+    } else {
+      D8TestBuilder builder = testForD8();
+      DesugarGraphTestConsumer consumer = new DesugarGraphTestConsumer();
+      builder.getBuilder().setDesugarGraphConsumer(consumer);
+      Origin originHost = DesugarGraphUtils.addClassWithOrigin("Host", inNest(Host.class), builder);
+      Origin originMember1 =
+          DesugarGraphUtils.addClassWithOrigin("Member1", inNest(Member1.class), builder);
+      Origin originMember2 =
+          DesugarGraphUtils.addClassWithOrigin("Member2", inNest(Member2.class), builder);
+      builder
+          .addProgramClasses(TestClass.class)
+          .setMinApi(parameters.getApiLevel())
+          .run(parameters.getRuntime(), TestClass.class)
+          .assertSuccessWithOutputLines("Hello World!");
+      // Currently there is no level at which nest desugaring is not needed.
+      assertTrue(consumer.contains(originHost, originMember1));
+      assertTrue(consumer.contains(originHost, originMember2));
+      assertTrue(consumer.contains(originMember1, originHost));
+      assertTrue(consumer.contains(originMember2, originHost));
+      assertEquals(4, consumer.totalEdgeCount());
+    }
+  }
+}
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 aa52d82..dbdc654 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
@@ -10,7 +10,7 @@
 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.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -30,7 +30,11 @@
 
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
-    return getTestParameters().withDexRuntimesStartingFromIncluding(Version.V5_1_1).build();
+    return getTestParameters()
+        // Use of APIs, such as java.util.functions.* are only available from 24+
+        .withApiLevelsStartingAtIncluding(AndroidApiLevel.N)
+        .withDexRuntimes()
+        .build();
   }
 
   private static final Path MAIN_KEEP = Paths.get("src/main/keep.txt");
@@ -42,6 +46,7 @@
   @Test
   public void testR8CompiledWithR8() throws Exception {
     testForR8(parameters.getBackend())
+        .setMinApi(parameters.getApiLevel())
         .addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR_11)
         .addKeepRuleFiles(MAIN_KEEP)
         .addOptionsModification(opt -> opt.ignoreMissingClasses = true)
diff --git a/src/test/java/com/android/tools/r8/dexfilemerger/NonAsciiClassNameChecksumTest.java b/src/test/java/com/android/tools/r8/dexfilemerger/NonAsciiClassNameChecksumTest.java
new file mode 100644
index 0000000..8e4700b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/dexfilemerger/NonAsciiClassNameChecksumTest.java
@@ -0,0 +1,100 @@
+// 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.dexfilemerger;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.OutputMode;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.io.IOException;
+import java.nio.file.Path;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class NonAsciiClassNameChecksumTest extends TestBase {
+
+  static final String EXPECTED = StringUtils.lines("Hello æ");
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+  }
+
+  public NonAsciiClassNameChecksumTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  private String getTransformedName(Class<?> clazz) {
+    return getTransformedName(clazz.getTypeName());
+  }
+
+  private String getTransformedName(String typeName) {
+    return NonAsciiClassNameChecksumTest.class.getTypeName()
+        + "$"
+        + (typeName.equals(TestClaass.class.getTypeName()) ? "TestClåss" : "TæstClass");
+  }
+
+  private byte[] getTransform(Class<?> clazz) throws IOException {
+    return transformer(clazz)
+        .setClassDescriptor(DescriptorUtils.javaTypeToDescriptor(getTransformedName(clazz)))
+        .transform();
+  }
+
+  @Test
+  public void test() throws Exception {
+    Path intermediate1 = compileIntermediate(TaestClass.class);
+    Path intermediate2 = compileIntermediate(TestClaass.class);
+    testForD8()
+        .addProgramFiles(intermediate1, intermediate2)
+        .setMinApi(parameters.getApiLevel())
+        .setIncludeClassesChecksum(true)
+        .run(parameters.getRuntime(), getTransformedName(TaestClass.class))
+        .assertSuccessWithOutput(EXPECTED)
+        .inspect(inspector -> {
+          checkIncludesChecksum(inspector, TaestClass.class);
+          checkIncludesChecksum(inspector, TestClaass.class);
+        });
+  }
+
+  private Path compileIntermediate(Class<?> clazz) throws Exception {
+    return testForD8()
+        .setOutputMode(OutputMode.DexFilePerClassFile)
+        .addProgramClassFileData(getTransform(clazz))
+        .setMinApi(parameters.getApiLevel())
+        .setIncludeClassesChecksum(true)
+        .compile()
+        .inspect(inspector -> checkIncludesChecksum(inspector, clazz))
+        .writeToZip();
+  }
+
+  private void checkIncludesChecksum(CodeInspector inspector, Class<?> clazz) {
+    ClassSubject classSubject = inspector.clazz(getTransformedName(clazz));
+    assertThat(classSubject, isPresent());
+    assertTrue(classSubject.getDexClass().asProgramClass().getChecksum() > 0);
+  }
+
+  static class TaestClass {
+    public static void main(String[] args) {
+      System.out.println("Hello æ");
+    }
+  }
+
+  static class TestClaass {
+    public static void main(String[] args) {
+      System.out.println("Hello å");
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/reflection/ForNameInterfaceTest.java b/src/test/java/com/android/tools/r8/ir/optimize/reflection/ForNameInterfaceTest.java
new file mode 100644
index 0000000..31f8463
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/reflection/ForNameInterfaceTest.java
@@ -0,0 +1,60 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.reflection;
+
+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 ForNameInterfaceTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public ForNameInterfaceTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  public interface I {}
+
+  public @interface J {}
+
+  public static class Main {
+
+    public static void main(String[] args) throws ClassNotFoundException {
+      Class<?> aClass =
+          Class.forName("com.android.tools.r8.ir.optimize.reflection.ForNameInterfaceTest$I");
+      System.out.println(aClass.getName());
+      aClass = Class.forName("com.android.tools.r8.ir.optimize.reflection.ForNameInterfaceTest$J");
+      System.out.println(aClass.getName());
+    }
+  }
+
+  @Test
+  public void testForNameOnInterface()
+      throws ExecutionException, CompilationFailedException, IOException {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(ForNameInterfaceTest.class)
+        .addKeepMainRule(Main.class)
+        .minification(false)
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(
+            "com.android.tools.r8.ir.optimize.reflection.ForNameInterfaceTest$I",
+            "com.android.tools.r8.ir.optimize.reflection.ForNameInterfaceTest$J");
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/B146957343.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/B146957343.java
new file mode 100644
index 0000000..289e095
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/B146957343.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.uninstantiatedtypes;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.io.IOException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.objectweb.asm.Opcodes;
+
+@RunWith(Parameterized.class)
+public class B146957343 extends TestBase implements Opcodes {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().withAllApiLevels().build();
+  }
+
+  public B146957343(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  private byte[] getAimplementsI() throws IOException {
+    return transformer(A.class).setImplements(I.class).transform();
+  }
+
+  @Test
+  public void testWithoutR8() throws Exception {
+    testForRuntime(parameters)
+        .addProgramClasses(I.class, J.class, Main.class)
+        .addProgramClassFileData(getAimplementsI())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("In A.f()");
+  }
+
+  @Test
+  public void testWithUninstantiatedTypeOptimizationForInterfaces() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(I.class, J.class, Main.class)
+        .addProgramClassFileData(getAimplementsI())
+        .addKeepMainRule(Main.class)
+        .addKeepRules("-keep class **A { createA(); }")
+        .setMinApi(parameters.getApiLevel())
+        .addOptionsModification(
+            options -> options.enableUninstantiatedTypeOptimizationForInterfaces = true)
+        .compile()
+        .disassemble()
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatThrows(NullPointerException.class);
+  }
+
+  @Test
+  public void testWithoutUninstantiatedTypeOptimizationForInterfaces() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(I.class, J.class, Main.class)
+        .addProgramClassFileData(getAimplementsI())
+        .addKeepMainRule(Main.class)
+        .addKeepRules("-keep class **A { createA(); }")
+        .setMinApi(parameters.getApiLevel())
+        .addOptionsModification(
+            options -> options.enableUninstantiatedTypeOptimizationForInterfaces = false)
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("In A.f()");
+  }
+
+  public interface I {}
+
+  public interface J extends I {}
+
+  public static class A implements J {
+    public static J createA() {
+      return new A();
+    }
+
+    public void f() {
+      System.out.println("In A.f()");
+    }
+  }
+
+  public static class Main {
+    public static void main(String[] args) {
+      ((A) A.createA()).f();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/resolution/PrivateInvokeVirtualTest.java b/src/test/java/com/android/tools/r8/resolution/PrivateInvokeVirtualTest.java
new file mode 100644
index 0000000..543ecad
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/resolution/PrivateInvokeVirtualTest.java
@@ -0,0 +1,95 @@
+// 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.resolution;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.objectweb.asm.Opcodes;
+
+@RunWith(Parameterized.class)
+public class PrivateInvokeVirtualTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public PrivateInvokeVirtualTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  public static class UInt implements Comparable<UInt> {
+
+    private final int val;
+
+    public UInt(int val) {
+      this.val = val;
+    }
+
+    private int compareToHelper(int i) {
+      return Integer.compare(val, i);
+    }
+
+    @Override
+    public int compareTo(UInt o) {
+      return compareToHelper(o.val);
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      System.out.println(new UInt(3).compareTo(new UInt(args.length)));
+    }
+  }
+
+  @Test
+  public void testRuntime() throws IOException, CompilationFailedException, ExecutionException {
+    testForRuntime(parameters)
+        .addProgramClassFileData(getUIntWithTransformedInvoke())
+        .addProgramClasses(Main.class)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("1");
+  }
+
+  @Test
+  public void testPrivateInvokeVirtual()
+      throws IOException, CompilationFailedException, ExecutionException {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(Main.class)
+        .addProgramClassFileData(getUIntWithTransformedInvoke())
+        .addKeepMainRule(Main.class)
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("1");
+  }
+
+  private byte[] getUIntWithTransformedInvoke() throws IOException {
+    return transformer(UInt.class)
+        .transformMethodInsnInMethod(
+            "compareTo",
+            (opcode, owner, name, descriptor, isInterface, continuation) -> {
+              if (name.contains("compareToHelper")) {
+                assertEquals(Opcodes.INVOKESPECIAL, opcode);
+                continuation.apply(Opcodes.INVOKEVIRTUAL, owner, name, descriptor, isInterface);
+              } else {
+                continuation.apply(opcode, owner, name, descriptor, isInterface);
+              }
+            })
+        .transform();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java b/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java
index b1bcb52..e290d51 100644
--- a/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java
@@ -228,7 +228,7 @@
     Assert.assertNotNull(
         appInfo.resolveMethod(toType(invokeReceiver, appInfo), method).getSingleTarget());
     ResolutionResult resolutionResult = appInfo.resolveMethod(method.holder, method);
-    if (resolutionResult.isValidVirtualTarget(appInfo.app().options)) {
+    if (resolutionResult.isVirtualTarget()) {
       Set<DexEncodedMethod> targets = resolutionResult.lookupVirtualTargets(appInfo);
       Set<DexType> targetHolders =
           targets.stream().map(m -> m.method.holder).collect(Collectors.toSet());
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java
index 63aa76f..c90b6e4 100644
--- a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java
@@ -122,7 +122,7 @@
         appInfo.resolveMethodOnInterface(methodOnB.holder, methodOnB);
     DexEncodedMethod resolved = resolutionResult.getSingleTarget();
     assertEquals(methodOnB, resolved.method);
-    assertFalse(resolutionResult.isValidVirtualTarget(appInfo.app().options));
+    assertFalse(resolutionResult.isVirtualTarget());
     DexEncodedMethod singleVirtualTarget =
         appInfo.lookupSingleInterfaceTarget(methodOnB, methodOnB.holder);
     Assert.assertNull(singleVirtualTarget);
@@ -133,7 +133,7 @@
     ResolutionResult resolutionResult = appInfo.resolveMethodOnInterface(methodOnB.holder, methodOnB);
     DexEncodedMethod resolved = resolutionResult.getSingleTarget();
     assertEquals(methodOnB, resolved.method);
-    assertFalse(resolutionResult.isValidVirtualTarget(appInfo.app().options));
+    assertFalse(resolutionResult.isVirtualTarget());
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java
index 22a12f2..f41a60f 100644
--- a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java
@@ -168,7 +168,7 @@
     ResolutionResult resolutionResult = appInfo.resolveMethodOnClass(methodOnB.holder, methodOnB);
     DexEncodedMethod resolved = resolutionResult.getSingleTarget();
     assertEquals(methodOnA, resolved.method);
-    assertFalse(resolutionResult.isValidVirtualTarget(appInfo.app().options));
+    assertFalse(resolutionResult.isVirtualTarget());
     DexEncodedMethod singleVirtualTarget =
         appInfo.lookupSingleVirtualTarget(methodOnB, methodOnB.holder);
     Assert.assertNull(singleVirtualTarget);
@@ -179,7 +179,7 @@
     ResolutionResult resolutionResult = appInfo.resolveMethodOnClass(methodOnB.holder, methodOnB);
     DexEncodedMethod resolved = resolutionResult.getSingleTarget();
     assertEquals(methodOnA, resolved.method);
-    assertFalse(resolutionResult.isValidVirtualTarget(appInfo.app().options));
+    assertFalse(resolutionResult.isVirtualTarget());
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessTest.java
index 69cdad5..f1c5fa1 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessTest.java
@@ -92,16 +92,7 @@
         .setMinApi(parameters.getApiLevel())
         .addKeepMainRule(Main.class)
         .run(parameters.getRuntime(), Main.class)
-        .apply(
-            result -> {
-              if (parameters.isDexRuntime() && inSameNest) {
-                // TODO(b/145187969): R8 incorrectly compiles the nest based access away.
-                result.assertFailureWithErrorThatMatches(
-                    containsString(NullPointerException.class.getName()));
-              } else {
-                checkExpectedResult(result);
-              }
-            });
+        .apply(this::checkExpectedResult);
   }
 
   private void checkExpectedResult(TestRunResult<?> result) {
diff --git a/src/test/java/com/android/tools/r8/resolution/access/SelfVirtualMethodAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/SelfVirtualMethodAccessTest.java
index a997622..f2f3309 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/SelfVirtualMethodAccessTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/SelfVirtualMethodAccessTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.resolution.access;
 
-import static org.hamcrest.CoreMatchers.containsString;
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.TestBase;
@@ -77,16 +76,7 @@
         .setMinApi(parameters.getApiLevel())
         .addKeepMainRule(Main.class)
         .run(parameters.getRuntime(), Main.class)
-        .apply(
-            result -> {
-              if (parameters.isCfRuntime()) {
-                result.assertSuccessWithOutput(EXPECTED);
-              } else {
-                // TODO(b/145187969): R8 compiles an incorrect program.
-                result.assertFailureWithErrorThatMatches(
-                    containsString(NullPointerException.class.getName()));
-              }
-            });
+        .assertSuccessWithOutput(EXPECTED);
   }
 
   static class A {
diff --git a/src/test/java/com/android/tools/r8/retrace/stacktraces/InlineWithoutNullCheck.java b/src/test/java/com/android/tools/r8/retrace/InlineWithoutNullCheckTest.java
similarity index 94%
rename from src/test/java/com/android/tools/r8/retrace/stacktraces/InlineWithoutNullCheck.java
rename to src/test/java/com/android/tools/r8/retrace/InlineWithoutNullCheckTest.java
index 6126c4b..c46d3ce 100644
--- a/src/test/java/com/android/tools/r8/retrace/stacktraces/InlineWithoutNullCheck.java
+++ b/src/test/java/com/android/tools/r8/retrace/InlineWithoutNullCheckTest.java
@@ -2,7 +2,7 @@
 // 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.retrace.stacktraces;
+package com.android.tools.r8.retrace;
 
 import static com.android.tools.r8.naming.retrace.StackTrace.isSame;
 import static com.android.tools.r8.naming.retrace.StackTrace.isSameExceptForFileNameAndLineNumber;
@@ -25,7 +25,7 @@
 import org.junit.runners.Parameterized;
 
 @RunWith(Parameterized.class)
-public class InlineWithoutNullCheck extends TestBase {
+public class InlineWithoutNullCheckTest extends TestBase {
 
   private final TestParameters parameters;
 
@@ -34,7 +34,7 @@
     return getTestParameters().withAllRuntimes().withAllApiLevels().build();
   }
 
-  public InlineWithoutNullCheck(TestParameters parameters) {
+  public InlineWithoutNullCheckTest(TestParameters parameters) {
     this.parameters = parameters;
   }
 
@@ -47,21 +47,21 @@
     // Get the expected stack traces by running on the runtime to test.
     expectedStackTraceForInlineMethod =
         testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
-            .addInnerClasses(InlineWithoutNullCheck.class)
+            .addInnerClasses(InlineWithoutNullCheckTest.class)
             .run(parameters.getRuntime(), TestClassForInlineMethod.class)
             .writeProcessResult(System.out)
             .assertFailure()
             .getStackTrace();
     expectedStackTraceForInlineField =
         testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
-            .addInnerClasses(InlineWithoutNullCheck.class)
+            .addInnerClasses(InlineWithoutNullCheckTest.class)
             .run(parameters.getRuntime(), TestClassForInlineField.class)
             .writeProcessResult(System.out)
             .assertFailure()
             .getStackTrace();
     expectedStackTraceForInlineStaticField =
         testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
-            .addInnerClasses(InlineWithoutNullCheck.class)
+            .addInnerClasses(InlineWithoutNullCheckTest.class)
             .run(parameters.getRuntime(), TestClassForInlineStaticField.class)
             .writeProcessResult(System.out)
             .assertFailure()
@@ -104,7 +104,7 @@
   @Test
   public void testInlineMethodWhichChecksNullReceiverBeforeAnySideEffectMethod() throws Exception {
     testForR8(parameters.getBackend())
-        .addInnerClasses(InlineWithoutNullCheck.class)
+        .addInnerClasses(InlineWithoutNullCheckTest.class)
         .addKeepMainRule(TestClassForInlineMethod.class)
         .enableInliningAnnotations()
         .setMinApi(parameters.getApiLevel())
@@ -132,7 +132,7 @@
   @Test
   public void testInlineMethodWhichChecksNullReceiverBeforeAnySideEffectField() throws Exception {
     testForR8(parameters.getBackend())
-        .addInnerClasses(InlineWithoutNullCheck.class)
+        .addInnerClasses(InlineWithoutNullCheckTest.class)
         .addKeepMainRule(TestClassForInlineField.class)
         .enableInliningAnnotations()
         .setMinApi(parameters.getApiLevel())
@@ -161,7 +161,7 @@
   public void testInlineMethodWhichChecksNullReceiverBeforeAnySideEffectStaticField()
       throws Exception {
     testForR8(parameters.getBackend())
-        .addInnerClasses(InlineWithoutNullCheck.class)
+        .addInnerClasses(InlineWithoutNullCheckTest.class)
         .addKeepMainRule(TestClassForInlineStaticField.class)
         .enableInliningAnnotations()
         .setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceCommandLineTests.java b/src/test/java/com/android/tools/r8/retrace/RetraceCommandLineTests.java
index 258d869..102f7f0 100644
--- a/src/test/java/com/android/tools/r8/retrace/RetraceCommandLineTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceCommandLineTests.java
@@ -4,13 +4,16 @@
 
 package com.android.tools.r8.retrace;
 
-import static com.android.tools.r8.ToolHelper.LINE_SEPARATOR;
+import static com.android.tools.r8.retrace.RetraceTests.DEFAULT_REGULAR_EXPRESSION;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.StringContains.containsString;
 import static org.junit.Assert.assertEquals;
 
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.retrace.stacktraces.ActualRetraceBotStackTrace;
+import com.android.tools.r8.retrace.stacktraces.ActualRetraceBotStackTraceWithInfo;
+import com.android.tools.r8.retrace.stacktraces.FoundMethodVerboseStackTrace;
 import com.android.tools.r8.utils.StringUtils;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
@@ -22,6 +25,7 @@
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import org.hamcrest.Matcher;
 import org.junit.Rule;
@@ -30,7 +34,7 @@
 
 public class RetraceCommandLineTests {
 
-  private static final boolean testExternal = true;
+  private static final boolean testExternal = false;
 
   @Rule public TemporaryFolder folder = new TemporaryFolder();
 
@@ -56,7 +60,36 @@
 
   @Test
   public void testVerbose() throws IOException {
-    runAbortTest(containsString("Currently no support for --verbose"), "--verbose");
+    FoundMethodVerboseStackTrace stackTrace = new FoundMethodVerboseStackTrace();
+    runTest(
+        stackTrace.mapping(),
+        StringUtils.joinLines(stackTrace.obfuscatedStackTrace()),
+        false,
+        StringUtils.joinLines(stackTrace.retracedStackTrace()) + StringUtils.LINE_SEPARATOR,
+        "--verbose");
+  }
+
+  @Test
+  public void testRegularExpression() throws IOException {
+    ActualRetraceBotStackTrace stackTrace = new ActualRetraceBotStackTrace();
+    runTest(
+        stackTrace.mapping(),
+        StringUtils.joinLines(stackTrace.obfuscatedStackTrace()),
+        false,
+        StringUtils.joinLines(stackTrace.retracedStackTrace()) + StringUtils.LINE_SEPARATOR,
+        "--regex=" + DEFAULT_REGULAR_EXPRESSION);
+  }
+
+  @Test
+  public void testRegularExpressionWithInfo() throws IOException {
+    ActualRetraceBotStackTraceWithInfo stackTrace = new ActualRetraceBotStackTraceWithInfo();
+    runTest(
+        stackTrace.mapping(),
+        StringUtils.joinLines(stackTrace.obfuscatedStackTrace()),
+        false,
+        StringUtils.joinLines(stackTrace.retracedStackTrace()) + StringUtils.LINE_SEPARATOR,
+        "--regex=" + DEFAULT_REGULAR_EXPRESSION,
+        "--info");
   }
 
   @Test
@@ -66,7 +99,7 @@
 
   @Test
   public void testHelp() throws IOException {
-    ProcessResult processResult = runRetraceCommandLine(null, "--help");
+    ProcessResult processResult = runRetraceCommandLine(null, Arrays.asList("--help"));
     assertEquals(0, processResult.exitCode);
     assertEquals(Retrace.USAGE_MESSAGE, processResult.stdout);
   }
@@ -82,34 +115,39 @@
           "    at r8.retrace(App:184)",
           "    ... 7 more");
 
-  private void runTest(String mapping, String stackTrace, boolean stacktraceStdIn, String expected)
+  private void runTest(
+      String mapping, String stackTrace, boolean stacktraceStdIn, String expected, String... args)
       throws IOException {
-    ProcessResult result = runRetrace(mapping, stackTrace, stacktraceStdIn);
+    ProcessResult result = runRetrace(mapping, stackTrace, stacktraceStdIn, args);
     assertEquals(0, result.exitCode);
     assertEquals(expected, result.stdout);
   }
 
   private void runAbortTest(Matcher<String> errorMatch, String... args) throws IOException {
-    ProcessResult result = runRetraceCommandLine(null, args);
+    ProcessResult result = runRetraceCommandLine(null, Arrays.asList(args));
     assertEquals(1, result.exitCode);
     assertThat(result.stderr, errorMatch);
   }
 
-  private ProcessResult runRetrace(String mapping, String stackTrace, boolean stacktraceStdIn)
+  private ProcessResult runRetrace(
+      String mapping, String stackTrace, boolean stacktraceStdIn, String... additionalArgs)
       throws IOException {
     Path mappingFile = folder.newFile("mapping.txt").toPath();
     Files.write(mappingFile, mapping.getBytes());
     File stackTraceFile = folder.newFile("stacktrace.txt");
     Files.write(stackTraceFile.toPath(), stackTrace.getBytes());
-    if (stacktraceStdIn) {
-      return runRetraceCommandLine(stackTraceFile, mappingFile.toString());
-    } else {
-      return runRetraceCommandLine(
-          null, mappingFile.toString(), stackTraceFile.toPath().toString());
+
+    Collection<String> args = new ArrayList<>();
+    args.add(mappingFile.toString());
+    if (!stacktraceStdIn) {
+      args.add(stackTraceFile.toPath().toString());
     }
+    args.addAll(Arrays.asList(additionalArgs));
+    return runRetraceCommandLine(stacktraceStdIn ? stackTraceFile : null, args);
   }
 
-  private ProcessResult runRetraceCommandLine(File stdInput, String... args) throws IOException {
+  private ProcessResult runRetraceCommandLine(File stdInput, Collection<String> args)
+      throws IOException {
     if (testExternal) {
       List<String> command = new ArrayList<>();
       command.add(ToolHelper.getSystemJavaExecutable());
@@ -117,7 +155,7 @@
       command.add("-cp");
       command.add(ToolHelper.R8_JAR.toString());
       command.add("com.android.tools.r8.retrace.Retrace");
-      command.addAll(Arrays.asList(args));
+      command.addAll(args);
       ProcessBuilder builder = new ProcessBuilder(command);
       if (stdInput != null) {
         builder.redirectInput(stdInput);
@@ -136,7 +174,9 @@
       System.setErr(new PrintStream(errorByteStream));
       int exitCode = 0;
       try {
-        Retrace.run(args);
+        String[] strArgs = new String[0];
+        strArgs = args.toArray(strArgs);
+        Retrace.run(strArgs);
       } catch (Throwable t) {
         exitCode = 1;
       }
@@ -149,7 +189,7 @@
           exitCode,
           outputByteStream.toString(),
           errorByteStream.toString(),
-          StringUtils.join(LINE_SEPARATOR, args));
+          StringUtils.joinLines(args));
     }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceTests.java b/src/test/java/com/android/tools/r8/retrace/RetraceTests.java
index 59a67ad..e29c928 100644
--- a/src/test/java/com/android/tools/r8/retrace/RetraceTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceTests.java
@@ -43,7 +43,7 @@
   // This is a slight modification of the default regular expression shown for proguard retrace
   // that allow for retracing classes in the form <class>: lorem ipsum...
   // Seems like Proguard retrace is expecting the form "Caused by: <class>".
-  private static final String DEFAULT_REGULAR_EXPRESSION =
+  public static final String DEFAULT_REGULAR_EXPRESSION =
       "(?:.*?\\bat\\s+%c\\.%m\\s*\\(%s(?::%l)?\\)\\s*(?:~\\[.*\\])?)|(?:(?:(?:%c|.*)?[:\"]\\s+)?%c(?::.*)?)";
 
   @Parameters(name = "{0}, use regular expression: {1}")
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceVerboseTests.java b/src/test/java/com/android/tools/r8/retrace/RetraceVerboseTests.java
new file mode 100644
index 0000000..277d190
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceVerboseTests.java
@@ -0,0 +1,54 @@
+// 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.retrace;
+
+import static junit.framework.TestCase.assertEquals;
+
+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.retrace.stacktraces.FoundMethodVerboseStackTrace;
+import com.android.tools.r8.retrace.stacktraces.StackTraceForTest;
+import com.android.tools.r8.retrace.stacktraces.UnknownMethodVerboseStackTrace;
+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 RetraceVerboseTests extends TestBase {
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withNoneRuntime().build();
+  }
+
+  public RetraceVerboseTests(TestParameters parameters) {}
+
+  @Test
+  public void testFoundMethod() {
+    runRetraceTest(new FoundMethodVerboseStackTrace());
+  }
+
+  @Test
+  public void testUnknownMethod() {
+    runRetraceTest(new UnknownMethodVerboseStackTrace());
+  }
+
+  private TestDiagnosticMessagesImpl runRetraceTest(StackTraceForTest stackTraceForTest) {
+    TestDiagnosticMessagesImpl diagnosticsHandler = new TestDiagnosticMessagesImpl();
+    RetraceCommand retraceCommand =
+        RetraceCommand.builder(diagnosticsHandler)
+            .setProguardMapProducer(stackTraceForTest::mapping)
+            .setStackTrace(stackTraceForTest.obfuscatedStackTrace())
+            .setVerbose(true)
+            .setRetracedStackTraceConsumer(
+                retraced -> assertEquals(stackTraceForTest.retracedStackTrace(), retraced))
+            .build();
+    Retrace.run(retraceCommand);
+    return diagnosticsHandler;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/stacktraces/ActualRetraceBotStackTraceWithInfo.java b/src/test/java/com/android/tools/r8/retrace/stacktraces/ActualRetraceBotStackTraceWithInfo.java
new file mode 100644
index 0000000..53aa7c6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/stacktraces/ActualRetraceBotStackTraceWithInfo.java
@@ -0,0 +1,128 @@
+// 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.retrace.stacktraces;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class ActualRetraceBotStackTraceWithInfo extends ActualBotStackTraceBase {
+
+  @Override
+  public List<String> obfuscatedStackTrace() {
+    return Arrays.asList(
+        "com.android.tools.r8.CompilationFailedException: Compilation failed to complete",
+        "\tat com.android.tools.r8.BaseCommand$Builder.build(:6)",
+        "\tat com.android.tools.r8.R8TestBuilder.internalCompile(R8TestBuilder.java:104)",
+        "\tat com.android.tools.r8.R8TestBuilder.internalCompile(R8TestBuilder.java:29)",
+        "\tat com.android.tools.r8.TestCompilerBuilder.compile(TestCompilerBuilder.java:89)",
+        "\tat com.android.tools.r8.TestCompilerBuilder.run(TestCompilerBuilder.java:113)",
+        "\tat com.android.tools.r8.TestBuilder.run(TestBuilder.java:49)",
+        "\tat com.android.tools.r8.ir.optimize.classinliner.ClassInlinerTest.testCodeSample(ClassInlinerTest.java:289)",
+        "",
+        "Caused by:",
+        "com.android.tools.r8.utils.b: Error: offset: 158, line: 2, column: 33, Unexpected"
+            + " attribute at <no file>:2:33",
+        "-keepattributes -keepattributes LineNumberTable",
+        "                                ^",
+        "\tat com.android.tools.r8.utils.t0.a(:21)",
+        "\tat com.android.tools.r8.shaking.ProguardConfigurationParser.parse(:19)",
+        "\tat com.android.tools.r8.R8Command$Builder.i(:16)",
+        "\tat com.android.tools.r8.R8Command$Builder.b(:11)",
+        "\tat com.android.tools.r8.R8Command$Builder.b(:1)",
+        "\tat com.android.tools.r8.BaseCommand$Builder.build(:2)",
+        "\t... 6 more");
+  }
+
+  @Override
+  public String mapping() {
+    return r8MappingFromGitSha("dab96bbe5948133f0ae6e0a88fc133464421cf47");
+  }
+
+  // The Pruning lines is debug info printed by the command line interface if one passes --info and
+  // --regex=<DEFAULT_REGULAR_EXPRESSION> as options.
+  @Override
+  public List<String> retracedStackTrace() {
+    return Arrays.asList(
+        "Pruning \tat com.android.tools.r8.utils.Reporter.error(Reporter.java:21) from result"
+            + " because method is not defined on line number 21",
+        "Pruning \tat com.android.tools.r8.utils.Reporter.error(Reporter.java:21) from result"
+            + " because method is not defined on line number 21",
+        "Pruning \tat com.android.tools.r8.utils.Reporter.fatalError(Reporter.java:21) from result"
+            + " because method is not defined on line number 21",
+        "Pruning \tat"
+            + " com.android.tools.r8.utils.Reporter.addSuppressedExceptions(Reporter.java:21) from"
+            + " result because method is not defined on line number 21",
+        "Pruning \tat"
+            + " com.android.tools.r8.shaking.ProguardConfigurationParser.parse(ProguardConfigurationParser.java:19)"
+            + " from result because method is not defined on line number 19",
+        "Pruning \tat"
+            + " com.android.tools.r8.shaking.ProguardConfigurationParser.parse(ProguardConfigurationParser.java:19)"
+            + " from result because method is not defined on line number 19",
+        "Pruning \tat"
+            + " com.android.tools.r8.shaking.ProguardConfigurationParser.parse(ProguardConfigurationParser.java:19)"
+            + " from result because method is not in range on line number 19",
+        "Pruning \tat"
+            + " com.android.tools.r8.shaking.ProguardConfigurationParser.parse(ProguardConfigurationParser.java:19)"
+            + " from result because method is not in range on line number 19",
+        "Pruning \tat com.android.tools.r8.R8Command$Builder.makeCommand(R8Command.java:11) from"
+            + " result because method is not defined on line number 11",
+        "Pruning \tat"
+            + " com.android.tools.r8.R8Command$Builder.setDisableVerticalClassMerging(R8Command.java:11)"
+            + " from result because method is not defined on line number 11",
+        "Pruning \tat"
+            + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfigurationFiles$4(R8Command.java:11)"
+            + " from result because method is not defined on line number 11",
+        "Pruning \tat"
+            + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfiguration$6(R8Command.java:11)"
+            + " from result because method is not defined on line number 11",
+        "Pruning \tat"
+            + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfiguration$6(R8Command.java:11)"
+            + " from result because method is not defined on line number 11",
+        "Pruning \tat com.android.tools.r8.R8Command$Builder.makeCommand(R8Command.java:11) from"
+            + " result because method is not in range on line number 11",
+        "Pruning \tat"
+            + " com.android.tools.r8.R8Command$Builder.setDisableVerticalClassMerging(R8Command.java:1)"
+            + " from result because method is not defined on line number 1",
+        "Pruning \tat"
+            + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfigurationFiles$4(R8Command.java:1)"
+            + " from result because method is not defined on line number 1",
+        "Pruning \tat"
+            + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfiguration$6(R8Command.java:1)"
+            + " from result because method is not defined on line number 1",
+        "Pruning \tat"
+            + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfiguration$6(R8Command.java:1)"
+            + " from result because method is not defined on line number 1",
+        "Pruning \tat com.android.tools.r8.R8Command$Builder.makeCommand(R8Command.java:1) from"
+            + " result because method is not defined on line number 1",
+        "Pruning \tat com.android.tools.r8.R8Command$Builder.makeCommand(R8Command.java:1) from"
+            + " result because method is not defined on line number 1",
+        "com.android.tools.r8.CompilationFailedException: Compilation failed to complete",
+        "\tat com.android.tools.r8.BaseCommand$Builder.build(BaseCommand.java:143)",
+        "\tat com.android.tools.r8.R8TestBuilder.internalCompile(R8TestBuilder.java:104)",
+        "\tat com.android.tools.r8.R8TestBuilder.internalCompile(R8TestBuilder.java:29)",
+        "\tat com.android.tools.r8.TestCompilerBuilder.compile(TestCompilerBuilder.java:89)",
+        "\tat com.android.tools.r8.TestCompilerBuilder.run(TestCompilerBuilder.java:113)",
+        "\tat com.android.tools.r8.TestBuilder.run(TestBuilder.java:49)",
+        "\tat com.android.tools.r8.ir.optimize.classinliner.ClassInlinerTest.testCodeSample(ClassInlinerTest.java:289)",
+        "",
+        "Caused by:",
+        "com.android.tools.r8.utils.AbortException: Error: offset: 158, line: 2, column: 33,"
+            + " Unexpected attribute at <no file>:2:33",
+        "-keepattributes -keepattributes LineNumberTable",
+        "                                ^",
+        "\tat com.android.tools.r8.utils.Reporter.failIfPendingErrors(Reporter.java:101)",
+        "\tat com.android.tools.r8.shaking.ProguardConfigurationParser.parse(ProguardConfigurationParser.java:187)",
+        "\tat com.android.tools.r8.R8Command$Builder.makeR8Command(R8Command.java:432)",
+        "\tat com.android.tools.r8.R8Command$Builder.makeCommand(R8Command.java:413)",
+        "\tat com.android.tools.r8.R8Command$Builder.makeCommand(R8Command.java:61)",
+        "\tat com.android.tools.r8.BaseCommand$Builder.build(BaseCommand.java:139)",
+        "\t... 6 more");
+  }
+
+  @Override
+  public int expectedWarnings() {
+    return 1;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/stacktraces/FoundMethodVerboseStackTrace.java b/src/test/java/com/android/tools/r8/retrace/stacktraces/FoundMethodVerboseStackTrace.java
new file mode 100644
index 0000000..4d9418c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/stacktraces/FoundMethodVerboseStackTrace.java
@@ -0,0 +1,38 @@
+// 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.retrace.stacktraces;
+
+import com.android.tools.r8.utils.StringUtils;
+import java.util.Arrays;
+import java.util.List;
+
+public class FoundMethodVerboseStackTrace implements StackTraceForTest {
+
+  @Override
+  public List<String> obfuscatedStackTrace() {
+    return Arrays.asList(
+        "Exception in thread \"main\" java.lang.NullPointerException", "\tat a.a.a(Foo.java:7)");
+  }
+
+  @Override
+  public String mapping() {
+    return StringUtils.lines(
+        "com.android.tools.r8.naming.retrace.Main -> a.a:",
+        "    7:7:com.android.Foo main(java.lang.String[],com.android.Bar):102 -> a");
+  }
+
+  @Override
+  public List<String> retracedStackTrace() {
+    return Arrays.asList(
+        "Exception in thread \"main\" java.lang.NullPointerException",
+        "\tat com.android.Foo com.android.tools.r8.naming.retrace.Main.main(java.lang.String[],"
+            + "com.android.Bar)(Main.java:102)");
+  }
+
+  @Override
+  public int expectedWarnings() {
+    return 0;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/stacktraces/UnknownMethodVerboseStackTrace.java b/src/test/java/com/android/tools/r8/retrace/stacktraces/UnknownMethodVerboseStackTrace.java
new file mode 100644
index 0000000..3eb9710
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/stacktraces/UnknownMethodVerboseStackTrace.java
@@ -0,0 +1,48 @@
+// 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.retrace.stacktraces;
+
+import com.android.tools.r8.utils.StringUtils;
+import java.util.Arrays;
+import java.util.List;
+
+public class UnknownMethodVerboseStackTrace implements StackTraceForTest {
+
+  @Override
+  public List<String> obfuscatedStackTrace() {
+    return Arrays.asList(
+        "Exception in thread \"main\" java.lang.NullPointerException",
+        "\tat a.a.c(Foo.java)",
+        "\tat a.a.b(Bar.java)",
+        "\tat a.a.a(Baz.java)");
+  }
+
+  @Override
+  public String mapping() {
+    return StringUtils.lines(
+        "com.android.tools.r8.naming.retrace.Main -> a.a:",
+        "    com.android.Foo main(java.lang.String[],com.android.Bar) -> a",
+        "    com.android.Foo main(java.lang.String[]) -> b",
+        "    com.android.Bar main(com.android.Bar) -> b");
+  }
+
+  @Override
+  public List<String> retracedStackTrace() {
+    return Arrays.asList(
+        "Exception in thread \"main\" java.lang.NullPointerException",
+        "\tat com.android.tools.r8.naming.retrace.Main.c(Main.java)",
+        "\tat com.android.Foo com.android.tools.r8.naming.retrace.Main.main("
+            + "java.lang.String[])(Main.java)",
+        "\t<OR> at com.android.Bar com.android.tools.r8.naming.retrace.Main.main("
+            + "com.android.Bar)(Main.java)",
+        "\tat com.android.Foo com.android.tools.r8.naming.retrace.Main.main("
+            + "java.lang.String[],com.android.Bar)(Main.java)");
+  }
+
+  @Override
+  public int expectedWarnings() {
+    return 0;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsConfigurationTest.java b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsConfigurationTest.java
index ce9f1c5..2d79d48 100644
--- a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsConfigurationTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionsConfigurationTest.java
@@ -10,9 +10,12 @@
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.AssertionsConfiguration;
+import com.android.tools.r8.D8TestBuilder;
+import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ThrowableConsumer;
 import com.android.tools.r8.rewrite.assertions.testclasses.TestClassForInnerClass;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.ThrowingConsumer;
@@ -21,7 +24,6 @@
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
 import com.google.common.collect.ImmutableList;
 import java.util.List;
-import java.util.function.Function;
 import org.junit.Assume;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -65,15 +67,14 @@
   }
 
   private void runD8Test(
-      Function<AssertionsConfiguration.Builder, AssertionsConfiguration>
-          assertionsConfigurationBuilder,
+      ThrowableConsumer<D8TestBuilder> builderConsumer,
       ThrowingConsumer<CodeInspector, RuntimeException> inspector,
       List<String> outputLines)
       throws Exception {
     testForD8()
         .addProgramClasses(testClasses)
         .setMinApi(parameters.getApiLevel())
-        .addAssertionsConfiguration(assertionsConfigurationBuilder)
+        .apply(builderConsumer)
         .compile()
         .inspect(inspector)
         .run(parameters.getRuntime(), TestClass.class)
@@ -81,17 +82,15 @@
   }
 
   public void runR8Test(
-      Function<AssertionsConfiguration.Builder, AssertionsConfiguration>
-          assertionsConfigurationBuilder,
+      ThrowableConsumer<R8FullTestBuilder> builderConsumer,
       ThrowingConsumer<CodeInspector, RuntimeException> inspector,
       List<String> outputLines)
       throws Exception {
-    runR8Test(assertionsConfigurationBuilder, inspector, outputLines, false);
+    runR8Test(builderConsumer, inspector, outputLines, false);
   }
 
   public void runR8Test(
-      Function<AssertionsConfiguration.Builder, AssertionsConfiguration>
-          assertionsConfigurationBuilder,
+      ThrowableConsumer<R8FullTestBuilder> builderConsumer,
       ThrowingConsumer<CodeInspector, RuntimeException> inspector,
       List<String> outputLines,
       boolean enableJvmAssertions)
@@ -102,7 +101,7 @@
         .addKeepMainRule(TestClass.class)
         .addKeepClassAndMembersRules(class1, class2, subpackageClass1, subpackageClass2)
         .setMinApi(parameters.getApiLevel())
-        .addAssertionsConfiguration(assertionsConfigurationBuilder)
+        .apply(builderConsumer)
         .compile()
         .inspect(inspector)
         .enableRuntimeAssertions(enableJvmAssertions)
@@ -110,18 +109,6 @@
         .assertSuccessWithOutput(StringUtils.lines(outputLines));
   }
 
-  private AssertionsConfiguration enableAllAssertions(AssertionsConfiguration.Builder builder) {
-    return builder.enable().build();
-  }
-
-  private AssertionsConfiguration disableAllAssertions(AssertionsConfiguration.Builder builder) {
-    return builder.disable().build();
-  }
-
-  private AssertionsConfiguration leaveAllAssertions(AssertionsConfiguration.Builder builder) {
-    return builder.passthrough().build();
-  }
-
   private List<String> allAssertionsExpectedLines() {
     return ImmutableList.of(
         "AssertionError in testclasses.Class1",
@@ -218,29 +205,53 @@
     Assume.assumeTrue(parameters.isDexRuntime());
     // Leaving assertions in or disabling them on Dalvik/Art means no assertions.
     runD8Test(
-        this::leaveAllAssertions, this::checkAssertionCodeLeft, noAllAssertionsExpectedLines());
+        builder ->
+            builder.addAssertionsConfiguration(
+                AssertionsConfiguration.Builder::passthroughAllAssertions),
+        this::checkAssertionCodeLeft,
+        noAllAssertionsExpectedLines());
     runR8Test(
-        this::leaveAllAssertions, this::checkAssertionCodeLeft, noAllAssertionsExpectedLines());
+        builder ->
+            builder.addAssertionsConfiguration(
+                AssertionsConfiguration.Builder::passthroughAllAssertions),
+        this::checkAssertionCodeLeft,
+        noAllAssertionsExpectedLines());
     runD8Test(
-        this::disableAllAssertions,
+        builder ->
+            builder.addAssertionsConfiguration(
+                AssertionsConfiguration.Builder::disableAllAssertions),
         this::checkAssertionCodeRemoved,
         noAllAssertionsExpectedLines());
     runR8Test(
-        this::disableAllAssertions,
+        builder ->
+            builder.addAssertionsConfiguration(
+                AssertionsConfiguration.Builder::disableAllAssertions),
         this::checkAssertionCodeRemoved,
         noAllAssertionsExpectedLines());
     // Compile time enabling assertions gives assertions on Dalvik/Art.
     runD8Test(
-        this::enableAllAssertions, this::checkAssertionCodeEnabled, allAssertionsExpectedLines());
-    runR8Test(
-        this::enableAllAssertions, this::checkAssertionCodeEnabled, allAssertionsExpectedLines());
-    // Enabling for the package should enable all.
-    runD8Test(
-        builder -> builder.enableForPackage(packageName).build(),
+        builder ->
+            builder.addAssertionsConfiguration(
+                AssertionsConfiguration.Builder::enableAllAssertions),
         this::checkAssertionCodeEnabled,
         allAssertionsExpectedLines());
     runR8Test(
-        builder -> builder.enableForPackage(packageName).build(),
+        builder ->
+            builder.addAssertionsConfiguration(
+                AssertionsConfiguration.Builder::enableAllAssertions),
+        this::checkAssertionCodeEnabled,
+        allAssertionsExpectedLines());
+    // Enabling for the package should enable all.
+    runD8Test(
+        builder ->
+            builder.addAssertionsConfiguration(
+                b -> b.setEnable().setScopePackage(packageName).build()),
+        this::checkAssertionCodeEnabled,
+        allAssertionsExpectedLines());
+    runR8Test(
+        builder ->
+            builder.addAssertionsConfiguration(
+                b -> b.setEnable().setScopePackage(packageName).build()),
         this::checkAssertionCodeEnabled,
         allAssertionsExpectedLines());
   }
@@ -250,23 +261,42 @@
     Assume.assumeTrue(parameters.isCfRuntime());
     // Leaving assertion code means assertions are controlled by the -ea flag.
     runR8Test(
-        this::leaveAllAssertions, this::checkAssertionCodeLeft, noAllAssertionsExpectedLines());
+        builder ->
+            builder.addAssertionsConfiguration(
+                AssertionsConfiguration.Builder::passthroughAllAssertions),
+        this::checkAssertionCodeLeft,
+        noAllAssertionsExpectedLines());
     runR8Test(
-        this::leaveAllAssertions, this::checkAssertionCodeLeft, allAssertionsExpectedLines(), true);
+        builder ->
+            builder.addAssertionsConfiguration(
+                AssertionsConfiguration.Builder::passthroughAllAssertions),
+        this::checkAssertionCodeLeft,
+        allAssertionsExpectedLines(),
+        true);
     // Compile time enabling or disabling assertions means the -ea flag has no effect.
     runR8Test(
-        this::enableAllAssertions, this::checkAssertionCodeEnabled, allAssertionsExpectedLines());
+        builder ->
+            builder.addAssertionsConfiguration(
+                AssertionsConfiguration.Builder::enableAllAssertions),
+        this::checkAssertionCodeEnabled,
+        allAssertionsExpectedLines());
     runR8Test(
-        this::enableAllAssertions,
+        builder ->
+            builder.addAssertionsConfiguration(
+                AssertionsConfiguration.Builder::enableAllAssertions),
         this::checkAssertionCodeEnabled,
         allAssertionsExpectedLines(),
         true);
     runR8Test(
-        this::disableAllAssertions,
+        builder ->
+            builder.addAssertionsConfiguration(
+                AssertionsConfiguration.Builder::disableAllAssertions),
         this::checkAssertionCodeRemoved,
         noAllAssertionsExpectedLines());
     runR8Test(
-        this::disableAllAssertions,
+        builder ->
+            builder.addAssertionsConfiguration(
+                AssertionsConfiguration.Builder::disableAllAssertions),
         this::checkAssertionCodeRemoved,
         noAllAssertionsExpectedLines(),
         true);
@@ -276,7 +306,9 @@
   public void testEnableForPackageForDex() throws Exception {
     Assume.assumeTrue(parameters.isDexRuntime());
     runD8Test(
-        builder -> builder.enableForPackage(subPackageName).build(),
+        builder ->
+            builder.addAssertionsConfiguration(
+                b -> b.setEnable().setScopePackage(subPackageName).build()),
         inspector -> {
           checkAssertionCodeEnabled(inspector, subpackageClass1);
           checkAssertionCodeEnabled(inspector, subpackageClass2);
@@ -286,7 +318,9 @@
             "AssertionError in testclasses.subpackage.Class2",
             "DONE"));
     runR8Test(
-        builder -> builder.enableForPackage(subPackageName).build(),
+        builder ->
+            builder.addAssertionsConfiguration(
+                b -> b.setEnable().setScopePackage(subPackageName).build()),
         inspector -> {
           checkAssertionCodeEnabled(inspector, subpackageClass1);
           checkAssertionCodeEnabled(inspector, subpackageClass2);
@@ -303,12 +337,13 @@
     runD8Test(
         builder ->
             builder
-                .enableForClass(class1.getCanonicalName())
-                .enableForClass(subpackageClass2.getCanonicalName())
-                .build(),
+                .addAssertionsConfiguration(
+                    b -> b.setEnable().setScopeClass(class1.getCanonicalName()).build())
+                .addAssertionsConfiguration(
+                    b -> b.setEnable().setScopeClass(subpackageClass2.getCanonicalName()).build()),
         inspector -> {
-          // checkAssertionCodeEnabled(inspector, class1);
-          // checkAssertionCodeEnabled(inspector, subpackageClass2);
+          checkAssertionCodeEnabled(inspector, class1);
+          checkAssertionCodeEnabled(inspector, subpackageClass2);
         },
         ImmutableList.of(
             "AssertionError in testclasses.Class1",
@@ -317,9 +352,10 @@
     runR8Test(
         builder ->
             builder
-                .enableForClass(class1.getCanonicalName())
-                .enableForClass(subpackageClass2.getCanonicalName())
-                .build(),
+                .addAssertionsConfiguration(
+                    b -> b.setEnable().setScopeClass(class1.getCanonicalName()).build())
+                .addAssertionsConfiguration(
+                    b -> b.setEnable().setScopeClass(subpackageClass2.getCanonicalName()).build()),
         inspector -> {
           checkAssertionCodeEnabled(inspector, class1);
           checkAssertionCodeEnabled(inspector, subpackageClass2);
@@ -336,10 +372,11 @@
     runD8Test(
         builder ->
             builder
-                .enableForPackage(packageName)
-                .disableForClass(class2.getCanonicalName())
-                .disableForClass(subpackageClass1.getCanonicalName())
-                .build(),
+                .addAssertionsConfiguration(b -> b.setEnable().setScopePackage(packageName).build())
+                .addAssertionsConfiguration(
+                    b -> b.setDisable().setScopeClass(class2.getCanonicalName()).build())
+                .addAssertionsConfiguration(
+                    b -> b.setDisable().setScopeClass(subpackageClass1.getCanonicalName()).build()),
         inspector -> {
           checkAssertionCodeEnabled(inspector, class1);
           checkAssertionCodeRemoved(inspector, class2);
@@ -353,10 +390,11 @@
     runR8Test(
         builder ->
             builder
-                .enableForPackage(packageName)
-                .disableForClass(class2.getCanonicalName())
-                .disableForClass(subpackageClass1.getCanonicalName())
-                .build(),
+                .addAssertionsConfiguration(b -> b.setEnable().setScopePackage(packageName).build())
+                .addAssertionsConfiguration(
+                    b -> b.setDisable().setScopeClass(class2.getCanonicalName()).build())
+                .addAssertionsConfiguration(
+                    b -> b.setDisable().setScopeClass(subpackageClass1.getCanonicalName()).build()),
         inspector -> {
           checkAssertionCodeEnabled(inspector, class1);
           checkAssertionCodeRemoved(inspector, class2);
@@ -379,7 +417,7 @@
             classInUnnamedPackage("Class1"),
             classInUnnamedPackage("Class2"))
         .setMinApi(parameters.getApiLevel())
-        .addAssertionsConfiguration(builder -> builder.enableForPackage("").build())
+        .addAssertionsConfiguration(builder -> builder.setEnable().setScopePackage("").build())
         .compile()
         .inspect(
             inspector -> {
@@ -427,7 +465,10 @@
         .setMinApi(parameters.getApiLevel())
         .addAssertionsConfiguration(
             builder ->
-                builder.enableForClass(TestClassForInnerClass.class.getCanonicalName()).build())
+                builder
+                    .setEnable()
+                    .setScopeClass(TestClassForInnerClass.class.getCanonicalName())
+                    .build())
         .compile()
         .inspect(
             inspector -> {
diff --git a/src/test/java/com/android/tools/r8/rewrite/assertions/RemoveAssertionsTest.java b/src/test/java/com/android/tools/r8/rewrite/assertions/RemoveAssertionsTest.java
index 27e53ba..bbcc8e2 100644
--- a/src/test/java/com/android/tools/r8/rewrite/assertions/RemoveAssertionsTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/assertions/RemoveAssertionsTest.java
@@ -199,7 +199,8 @@
         .debug()
         .noTreeShaking()
         .noMinification()
-        .addAssertionsConfiguration(builder -> builder.setTransformation(transformation).build())
+        .addAssertionsConfiguration(
+            builder -> builder.setTransformation(transformation).setScopeAll().build())
         .compile();
   }
 
@@ -337,7 +338,8 @@
         .addProgramClasses(ClassWithAssertions.class)
         .debug()
         .setMinApi(AndroidApiLevel.B)
-        .addAssertionsConfiguration(builder -> builder.setTransformation(transformation).build())
+        .addAssertionsConfiguration(
+            builder -> builder.setTransformation(transformation).setScopeAll().build())
         .compile();
   }
 
@@ -357,7 +359,8 @@
         .addProgramFiles(program)
         .debug()
         .setMinApi(AndroidApiLevel.B)
-        .addAssertionsConfiguration(builder -> builder.setTransformation(transformation).build())
+        .addAssertionsConfiguration(
+            builder -> builder.setTransformation(transformation).setScopeAll().build())
         .compile();
   }
 
diff --git a/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java b/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
index 3d653d0..598f6f1 100644
--- a/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
+++ b/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
@@ -166,6 +166,31 @@
         });
   }
 
+  /** Unconditionally replace the descriptor (ie, qualified name) of a class. */
+  public ClassFileTransformer setClassDescriptor(String descriptor) {
+    assert DescriptorUtils.isClassDescriptor(descriptor);
+    return addClassTransformer(
+        new ClassTransformer() {
+          @Override
+          public void visit(
+              int version,
+              int access,
+              String ignoredName,
+              String signature,
+              String superName,
+              String[] interfaces) {
+            super.visit(
+                version,
+                access,
+                DescriptorUtils.getBinaryNameFromDescriptor(descriptor),
+                signature,
+                superName,
+                interfaces);
+          }
+        });
+  }
+
+
   public ClassFileTransformer setMinVersion(CfVm jdk) {
     return setMinVersion(jdk.getClassfileVersion());
   }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java
index 071fb4f..1051e28 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java
@@ -134,7 +134,7 @@
 
   @Override
   public boolean isVirtual() {
-    return dexMethod.isVirtualMethod();
+    return dexMethod.isNonPrivateVirtualMethod();
   }
 
   @Override
diff --git a/tests/d8_api_usage_sample.jar b/tests/d8_api_usage_sample.jar
index 30b00cb..e47a3ad 100644
--- a/tests/d8_api_usage_sample.jar
+++ b/tests/d8_api_usage_sample.jar
Binary files differ
diff --git a/tests/r8_api_usage_sample.jar b/tests/r8_api_usage_sample.jar
index 4c4801c..4970fe1 100644
--- a/tests/r8_api_usage_sample.jar
+++ b/tests/r8_api_usage_sample.jar
Binary files differ
diff --git a/tools/retrace.py b/tools/retrace.py
index 6f3593f..e8fdf89 100755
--- a/tools/retrace.py
+++ b/tools/retrace.py
@@ -71,8 +71,13 @@
       return 1
 
   retrace_args = [
-    jdk.GetJavaExecutable(), '-jar', utils.RETRACE_JAR, r8lib_map_path
+    jdk.GetJavaExecutable(),
+    '-cp',
+    utils.R8LIB_JAR,
+    'com.android.tools.r8.retrace.Retrace',
+    r8lib_map_path
   ]
+
   if args.stacktrace:
     retrace_args.append(args.stacktrace)
 
diff --git a/tools/test_self_retrace.py b/tools/test_self_retrace.py
deleted file mode 100755
index d7ab9aa..0000000
--- a/tools/test_self_retrace.py
+++ /dev/null
@@ -1,77 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-# for details. All rights reserved. Use of this source code is governed by a
-# BSD-style license that can be found in the LICENSE file.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import gradle
-import jdk
-import os
-import subprocess
-import sys
-
-import utils
-
-EXCEPTION_LINE = 'Intentional exception for testing retrace.'
-EXPECTED_LINES = [
-  'com.android.tools.r8.utils.SelfRetraceTest.foo3(SelfRetraceTest.java:13)',
-  'com.android.tools.r8.utils.SelfRetraceTest.foo2(SelfRetraceTest.java:17)',
-  'com.android.tools.r8.utils.SelfRetraceTest.foo1(SelfRetraceTest.java:21)',
-  'com.android.tools.r8.utils.SelfRetraceTest.test(SelfRetraceTest.java:26)',
-  'com.android.tools.r8.R8.run(R8.java:',
-]
-
-def main():
-  args = sys.argv[1:]
-  if len(args) == 0:
-    gradle.RunGradle(['r8lib'])
-    r8lib = utils.R8LIB_JAR
-    r8map = utils.R8LIB + '.map'
-  elif len(args) == 2:
-    r8lib = args[0]
-    r8map = args[1]
-  elif len(args) == 1 and args[0] == '--help':
-    print('Usage: test_self_retrace.py [<path-to-r8lib-jar> <path-to-r8lib-map]')
-    print('If the path is missing the script builds and uses ' + utils.R8LIB_JAR)
-    return
-  else:
-    raise Exception("Only two argument allowed, see '--help'.")
-
-  # Run 'r8 --help' which throws an exception.
-  cmd = [
-    jdk.GetJavaExecutable(),'-cp', r8lib, 'com.android.tools.r8.R8', '--help'
-  ]
-  os.environ["R8_THROW_EXCEPTION_FOR_TESTING_RETRACE"] = "1"
-  utils.PrintCmd(cmd)
-  p = subprocess.Popen(cmd, stderr=subprocess.PIPE)
-  _, stacktrace = p.communicate()
-  assert(p.returncode != 0)
-  assert(EXCEPTION_LINE in stacktrace)
-  # r8lib must be minified, original class names must not be present.
-  assert('SelfRetraceTest' not in stacktrace)
-
-  # Run the retrace tool.
-  cmd = [jdk.GetJavaExecutable(), '-jar', utils.RETRACE_JAR, r8map]
-  utils.PrintCmd(cmd)
-  p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
-  retrace_stdout, _ = p.communicate(stacktrace)
-  assert p.returncode == 0
-  retrace_lines = retrace_stdout.splitlines()
-  line_index = -1
-  for line in retrace_lines:
-    if line_index < 0:
-      if 'java.lang.RuntimeException' in line:
-        assert(EXCEPTION_LINE in line)
-        line_index = 0;
-    else:
-      assert EXPECTED_LINES[line_index] in line
-      line_index += 1
-      if line_index >= len(EXPECTED_LINES):
-         break
-  assert(line_index >= 0)
-
-if __name__ == '__main__':
-  sys.exit(main())
diff --git a/tools/utils.py b/tools/utils.py
index 51c5a12..6690ba2 100644
--- a/tools/utils.py
+++ b/tools/utils.py
@@ -60,12 +60,6 @@
 GENERATED_LICENSE = os.path.join(GENERATED_LICENSE_DIR, 'LICENSE')
 RT_JAR = os.path.join(REPO_ROOT, 'third_party/openjdk/openjdk-rt-1.8/rt.jar')
 R8LIB_KEEP_RULES = os.path.join(REPO_ROOT, 'src/main/keep.txt')
-RETRACE_JAR = os.path.join(
-    THIRD_PARTY,
-    'proguard',
-    'proguard6.0.1',
-    'lib',
-    'retrace.jar')
 PROGUARD_JAR = os.path.join(
     THIRD_PARTY,
     'proguard',