diff --git a/src/main/java/com/android/tools/r8/ClassFileConsumer.java b/src/main/java/com/android/tools/r8/ClassFileConsumer.java
index 18f68ba..8c52405 100644
--- a/src/main/java/com/android/tools/r8/ClassFileConsumer.java
+++ b/src/main/java/com/android/tools/r8/ClassFileConsumer.java
@@ -9,6 +9,7 @@
 import com.android.tools.r8.utils.OutputBuilder;
 import com.android.tools.r8.utils.ZipUtils;
 import com.google.common.io.Closer;
+import java.io.BufferedOutputStream;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.OpenOption;
@@ -148,7 +149,9 @@
       OpenOption[] options =
           new OpenOption[] {StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING};
       try (Closer closer = Closer.create()) {
-        try (ZipOutputStream out = new ZipOutputStream(Files.newOutputStream(archive, options))) {
+        try (ZipOutputStream out =
+            new ZipOutputStream(
+                new BufferedOutputStream(Files.newOutputStream(archive, options)))) {
           ZipUtils.writeResourcesToZip(resources, dataResources, closer, out);
         }
       }
diff --git a/src/main/java/com/android/tools/r8/D8.java b/src/main/java/com/android/tools/r8/D8.java
index 8def7ae..2e73927 100644
--- a/src/main/java/com/android/tools/r8/D8.java
+++ b/src/main/java/com/android/tools/r8/D8.java
@@ -17,6 +17,7 @@
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.GraphLens;
 import com.android.tools.r8.graph.InitClassLens;
+import com.android.tools.r8.graph.LazyLoadedDexApplication;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.analysis.ClassInitializerAssertionEnablingAnalysis;
 import com.android.tools.r8.inspector.internal.InspectorImpl;
@@ -35,6 +36,7 @@
 import com.android.tools.r8.utils.CfgPrinter;
 import com.android.tools.r8.utils.ExceptionUtils;
 import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.InternalOptions.DesugarState;
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
@@ -158,6 +160,16 @@
         });
   }
 
+  private static AppView<AppInfo> readApp(
+      AndroidApp inputApp, InternalOptions options, ExecutorService executor, Timing timing)
+      throws IOException {
+    PrefixRewritingMapper rewritePrefix =
+        options.desugaredLibraryConfiguration.createPrefixRewritingMapper(options);
+    LazyLoadedDexApplication app = new ApplicationReader(inputApp, options, timing).read(executor);
+    AppInfo appInfo = AppInfo.createInitialAppInfo(app);
+    return AppView.createForD8(appInfo, rewritePrefix);
+  }
+
   private static void run(AndroidApp inputApp, InternalOptions options, ExecutorService executor)
       throws IOException {
     Timing timing = Timing.create("D8", options);
@@ -165,10 +177,7 @@
       // Disable global optimizations.
       options.disableGlobalOptimizations();
 
-      DexApplication app = new ApplicationReader(inputApp, options, timing).read(executor);
-      PrefixRewritingMapper rewritePrefix =
-          options.desugaredLibraryConfiguration.createPrefixRewritingMapper(options);
-      AppInfo appInfo = AppInfo.createInitialAppInfo(app);
+      AppView<AppInfo> appView = readApp(inputApp, options, executor, timing);
 
       final CfgPrinter printer = options.printCfg ? new CfgPrinter() : null;
 
@@ -177,9 +186,9 @@
         // enabling code.
         ClassInitializerAssertionEnablingAnalysis analysis =
             new ClassInitializerAssertionEnablingAnalysis(
-                appInfo.dexItemFactory(), OptimizationFeedbackSimple.getInstance());
+                appView.dexItemFactory(), OptimizationFeedbackSimple.getInstance());
         ThreadUtils.processItems(
-            appInfo.classes(),
+            appView.appInfo().classes(),
             clazz -> {
               ProgramMethod classInitializer = clazz.getProgramClassInitializer();
               if (classInitializer != null) {
@@ -189,14 +198,11 @@
             executor);
       }
 
-      AppView<?> appView = AppView.createForD8(appInfo, rewritePrefix);
-
       if (options.testing.enableD8ResourcesPassThrough) {
         appView.setAppServices(AppServices.builder(appView).build());
       }
 
-      IRConverter converter = new IRConverter(appView, timing, printer);
-      app = converter.convert(app, executor);
+      new IRConverter(appView, timing, printer).convert(appView, executor);
 
       if (options.printCfg) {
         if (options.printCfgFile == null || options.printCfgFile.isEmpty()) {
@@ -223,7 +229,7 @@
       // if there were class file inputs.
       boolean hasClassResources = false;
       boolean hasDexResources = false;
-      for (DexProgramClass dexProgramClass : app.classes()) {
+      for (DexProgramClass dexProgramClass : appView.appInfo().classes()) {
         if (dexProgramClass.originatesFromClassResource()) {
           hasClassResources = true;
           if (hasDexResources) {
@@ -237,26 +243,26 @@
         }
       }
       Marker marker = options.getMarker(Tool.D8);
-      Set<Marker> markers = new HashSet<>(app.dexItemFactory.extractMarkers());
-      if (marker != null && hasClassResources) {
+      Set<Marker> markers = new HashSet<>(appView.dexItemFactory().extractMarkers());
+      // TODO(b/166617364): Don't add an additional marker when desugaring is turned off.
+      if (hasClassResources && (options.desugarState != DesugarState.OFF || markers.isEmpty())) {
         markers.add(marker);
       }
       Marker.checkCompatibleDesugaredLibrary(markers, options.reporter);
 
-      InspectorImpl.runInspections(options.outputInspections, app);
+      InspectorImpl.runInspections(options.outputInspections, appView.appInfo().classes());
       if (options.isGeneratingClassFiles()) {
         new CfApplicationWriter(
-                app,
                 appView,
-                options,
                 marker,
                 GraphLens.getIdentityLens(),
-                NamingLens.getIdentityLens(),
+                appView.rewritePrefix.isRewriting()
+                    ? PrefixRewritingNamingLens.createPrefixRewritingNamingLens(appView)
+                    : NamingLens.getIdentityLens(),
                 null)
             .write(options.getClassFileConsumer());
       } else {
         NamingLens namingLens;
-        DexApplication finalApp = app;
         if (!hasDexResources || !hasClassResources || !appView.rewritePrefix.isRewriting()) {
           // All inputs are either dex or cf, or there is nothing to rewrite.
           namingLens =
@@ -271,11 +277,14 @@
           // desugared library only on cf inputs. We cannot easily rewrite part of the program
           // without iterating again the IR. We fall-back to writing one app with rewriting and
           // merging it with the other app in rewriteNonDexInputs.
-          finalApp = rewriteNonDexInputs(appView, inputApp, options, executor, timing, app);
+          DexApplication app =
+              rewriteNonDexInputs(
+                  appView, inputApp, options, executor, timing, appView.appInfo().app());
+          appView.setAppInfo(new AppInfo(app, appView.appInfo().getSyntheticItems().commit(app)));
           namingLens = NamingLens.getIdentityLens();
         }
         new ApplicationWriter(
-                finalApp,
+                appView.appInfo().app(),
                 appView,
                 options,
                 marker == null ? null : ImmutableList.copyOf(markers),
@@ -353,17 +362,12 @@
     return finalDexApp.build();
   }
 
-  static DexApplication optimize(
-      DexApplication application,
-      AppInfo appInfo,
-      InternalOptions options,
-      Timing timing,
-      ExecutorService executor)
+  static void optimize(
+      AppView<AppInfo> appView, InternalOptions options, Timing timing, ExecutorService executor)
       throws IOException, ExecutionException {
     final CfgPrinter printer = options.printCfg ? new CfgPrinter() : null;
 
-    IRConverter converter = new IRConverter(appInfo, timing, printer);
-    application = converter.convert(application, executor);
+    new IRConverter(appView, timing, printer).convert(appView, executor);
 
     if (options.printCfg) {
       if (options.printCfgFile == null || options.printCfgFile.isEmpty()) {
@@ -376,7 +380,6 @@
         }
       }
     }
-    return application;
   }
 
   static class ConvertedCfFiles implements DexIndexedConsumer, ProgramResourceProvider {
diff --git a/src/main/java/com/android/tools/r8/D8Command.java b/src/main/java/com/android/tools/r8/D8Command.java
index d8fc991..cb00bb7 100644
--- a/src/main/java/com/android/tools/r8/D8Command.java
+++ b/src/main/java/com/android/tools/r8/D8Command.java
@@ -200,6 +200,9 @@
 
     @Override
     void validate() {
+      if (isPrintHelp()) {
+        return;
+      }
       Reporter reporter = getReporter();
       if (getProgramConsumer() instanceof ClassFileConsumer) {
         reporter.warning("Compiling to Java class files with D8 is not officially supported");
diff --git a/src/main/java/com/android/tools/r8/DexFileMergerHelper.java b/src/main/java/com/android/tools/r8/DexFileMergerHelper.java
index 8e6c389..49ab77b 100644
--- a/src/main/java/com/android/tools/r8/DexFileMergerHelper.java
+++ b/src/main/java/com/android/tools/r8/DexFileMergerHelper.java
@@ -10,6 +10,7 @@
 import com.android.tools.r8.dex.ApplicationWriter;
 import com.android.tools.r8.dex.Marker;
 import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.GraphLens;
@@ -90,15 +91,15 @@
                     null,
                     executor,
                     new DexFileMergerHelper(inputOrdering)::keepFirstProgramClassConflictResolver);
-        AppInfo appInfo = AppInfo.createInitialAppInfo(app);
-        app = D8.optimize(app, appInfo, options, timing, executor);
+        AppView<AppInfo> appView = AppView.createForD8(AppInfo.createInitialAppInfo(app));
+        D8.optimize(appView, options, timing, executor);
 
-        List<Marker> markers = app.dexItemFactory.extractMarkers();
+        List<Marker> markers = appView.dexItemFactory().extractMarkers();
 
         assert !options.hasMethodsFilter();
         ApplicationWriter writer =
             new ApplicationWriter(
-                app,
+                appView.appInfo().app(),
                 null,
                 options,
                 markers,
diff --git a/src/main/java/com/android/tools/r8/DexFilePerClassFileConsumer.java b/src/main/java/com/android/tools/r8/DexFilePerClassFileConsumer.java
index 2409847..364f2bf 100644
--- a/src/main/java/com/android/tools/r8/DexFilePerClassFileConsumer.java
+++ b/src/main/java/com/android/tools/r8/DexFilePerClassFileConsumer.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.utils.ZipUtils;
 import com.google.common.io.ByteStreams;
 import com.google.common.io.Closer;
+import java.io.BufferedOutputStream;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.OpenOption;
@@ -215,7 +216,9 @@
       OpenOption[] options =
           new OpenOption[] {StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING};
       try (Closer closer = Closer.create()) {
-        try (ZipOutputStream out = new ZipOutputStream(Files.newOutputStream(archive, options))) {
+        try (ZipOutputStream out =
+            new ZipOutputStream(
+                new BufferedOutputStream(Files.newOutputStream(archive, options)))) {
           for (ProgramResource resource : resources) {
             String primaryClassDescriptor = primaryClassDescriptors.get(resource);
             String entryName = getDexFileName(primaryClassDescriptor);
diff --git a/src/main/java/com/android/tools/r8/DexIndexedConsumer.java b/src/main/java/com/android/tools/r8/DexIndexedConsumer.java
index 300588f..ec1f516 100644
--- a/src/main/java/com/android/tools/r8/DexIndexedConsumer.java
+++ b/src/main/java/com/android/tools/r8/DexIndexedConsumer.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.utils.ZipUtils;
 import com.google.common.io.ByteStreams;
 import com.google.common.io.Closer;
+import java.io.BufferedOutputStream;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.OpenOption;
@@ -186,7 +187,9 @@
       OpenOption[] options =
           new OpenOption[] {StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING};
       try (Closer closer = Closer.create()) {
-        try (ZipOutputStream out = new ZipOutputStream(Files.newOutputStream(archive, options))) {
+        try (ZipOutputStream out =
+            new ZipOutputStream(
+                new BufferedOutputStream(Files.newOutputStream(archive, options)))) {
           for (int i = 0; i < resources.size(); i++) {
             ProgramResource resource = resources.get(i);
             String entryName = getDefaultDexFileName(i);
diff --git a/src/main/java/com/android/tools/r8/DexSplitterHelper.java b/src/main/java/com/android/tools/r8/DexSplitterHelper.java
index b7ece81..7203f8e 100644
--- a/src/main/java/com/android/tools/r8/DexSplitterHelper.java
+++ b/src/main/java/com/android/tools/r8/DexSplitterHelper.java
@@ -11,6 +11,7 @@
 import com.android.tools.r8.dex.ApplicationWriter;
 import com.android.tools.r8.dex.Marker;
 import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.GraphLens;
@@ -87,7 +88,8 @@
 
         // Run d8 optimize to ensure jumbo strings are handled.
         AppInfo appInfo = AppInfo.createInitialAppInfo(featureApp);
-        featureApp = D8.optimize(featureApp, appInfo, options, timing, executor);
+        AppView<AppInfo> appView = AppView.createForD8(appInfo);
+        D8.optimize(appView, options, timing, executor);
         // We create a specific consumer for each split.
         Path outputDir = Paths.get(output).resolve(entry.getKey());
         if (!Files.exists(outputDir)) {
@@ -97,7 +99,7 @@
 
         try {
           new ApplicationWriter(
-                  featureApp,
+                  appView.appInfo().app(),
                   null,
                   options,
                   markers,
diff --git a/src/main/java/com/android/tools/r8/DiagnosticsHandler.java b/src/main/java/com/android/tools/r8/DiagnosticsHandler.java
index 666e358..de3f800 100644
--- a/src/main/java/com/android/tools/r8/DiagnosticsHandler.java
+++ b/src/main/java/com/android/tools/r8/DiagnosticsHandler.java
@@ -57,4 +57,19 @@
     }
     System.out.println(info.getDiagnosticMessage());
   }
+
+  /**
+   * Modify the level of a diagnostic.
+   *
+   * <p>This modification is allowed only for non-fatal compiler diagnostics.
+   *
+   * <p>Changing a non-error into an error will cause the compiler to exit with a <code>
+   * CompilationFailedException</code> at its next error check point.
+   *
+   * <p>Changing an error into a non-error will allow the compiler to continue compilation. Note
+   * that doing so could very well lead to an internal compiler error due to a broken invariant.
+   */
+  default DiagnosticsLevel modifyDiagnosticsLevel(DiagnosticsLevel level, Diagnostic diagnostic) {
+    return level;
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/DiagnosticsLevel.java b/src/main/java/com/android/tools/r8/DiagnosticsLevel.java
new file mode 100644
index 0000000..9f9d26a
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/DiagnosticsLevel.java
@@ -0,0 +1,12 @@
+// Copyright (c) 2017, 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;
+
+/** Levels of diagnostics messages reported by the compiler. */
+@Keep
+public enum DiagnosticsLevel {
+  ERROR,
+  WARNING,
+  INFO
+}
diff --git a/src/main/java/com/android/tools/r8/GenerateLintFiles.java b/src/main/java/com/android/tools/r8/GenerateLintFiles.java
index 2bfba83..8144903 100644
--- a/src/main/java/com/android/tools/r8/GenerateLintFiles.java
+++ b/src/main/java/com/android/tools/r8/GenerateLintFiles.java
@@ -303,7 +303,6 @@
 
           addMethodsToHeaderJar(builder, clazz, methods);
         });
-    DexApplication app = builder.build();
 
     // Write a plain text file with the desugared APIs.
     desugaredApisSignatures.sort(Comparator.naturalOrder());
@@ -311,13 +310,11 @@
         lintFile(compilationApiLevel, minApiLevel, ".txt"), desugaredApisSignatures);
 
     // Write a header jar with the desugared APIs.
-    AppInfo appInfo = AppInfo.createInitialAppInfo(app);
+    AppInfo appInfo = AppInfo.createInitialAppInfo(builder.build());
     AppView<?> appView = AppView.createForD8(appInfo);
     CfApplicationWriter writer =
         new CfApplicationWriter(
-            builder.build(),
             appView,
-            options,
             options.getMarker(Tool.L8),
             GraphLens.getIdentityLens(),
             NamingLens.getIdentityLens(),
diff --git a/src/main/java/com/android/tools/r8/L8.java b/src/main/java/com/android/tools/r8/L8.java
index 99a87d3..aae1486 100644
--- a/src/main/java/com/android/tools/r8/L8.java
+++ b/src/main/java/com/android/tools/r8/L8.java
@@ -119,31 +119,19 @@
       // on it.
       options.enableLoadStoreOptimization = false;
 
-      LazyLoadedDexApplication lazyApp =
-          new ApplicationReader(inputApp, options, timing).read(executor);
-
-      PrefixRewritingMapper rewritePrefix =
-          options.desugaredLibraryConfiguration.createPrefixRewritingMapper(options);
-
-      DexApplication app = new L8TreePruner(options).prune(lazyApp, rewritePrefix);
-      AppInfo appInfo = AppInfo.createInitialAppInfo(app);
-
-      AppView<?> appView = AppView.createForL8(appInfo, rewritePrefix);
-      IRConverter converter = new IRConverter(appView, timing);
+      AppView<AppInfo> appView = readApp(inputApp, options, executor, timing);
 
       if (!options.testing.disableL8AnnotationRemoval) {
         AnnotationRemover.clearAnnotations(appView);
       }
-      app = converter.convert(app, executor);
-      assert appView.appInfo() == appInfo;
+
+      new IRConverter(appView, timing).convert(appView, executor);
 
       NamingLens namingLens = PrefixRewritingNamingLens.createPrefixRewritingNamingLens(appView);
-      new GenericSignatureRewriter(appView, namingLens).run(appInfo.classes(), executor);
+      new GenericSignatureRewriter(appView, namingLens).run(appView.appInfo().classes(), executor);
 
       new CfApplicationWriter(
-              app,
               appView,
-              options,
               options.getMarker(Tool.L8),
               GraphLens.getIdentityLens(),
               namingLens,
@@ -161,6 +149,19 @@
     }
   }
 
+  private static AppView<AppInfo> readApp(
+      AndroidApp inputApp, InternalOptions options, ExecutorService executor, Timing timing)
+      throws IOException {
+    LazyLoadedDexApplication lazyApp =
+        new ApplicationReader(inputApp, options, timing).read(executor);
+
+    PrefixRewritingMapper rewritePrefix =
+        options.desugaredLibraryConfiguration.createPrefixRewritingMapper(options);
+
+    DexApplication app = new L8TreePruner(options).prune(lazyApp, rewritePrefix);
+    return AppView.createForL8(AppInfo.createInitialAppInfo(app), rewritePrefix);
+  }
+
   private static void run(String[] args) throws CompilationFailedException {
     L8Command command = L8Command.parse(args, CommandLineOrigin.INSTANCE).build();
     if (command.isPrintHelp()) {
diff --git a/src/main/java/com/android/tools/r8/L8Command.java b/src/main/java/com/android/tools/r8/L8Command.java
index cae584b..a2cf589 100644
--- a/src/main/java/com/android/tools/r8/L8Command.java
+++ b/src/main/java/com/android/tools/r8/L8Command.java
@@ -32,7 +32,7 @@
 @Keep
 public final class L8Command extends BaseCompilerCommand {
 
-  static final String USAGE_MESSAGE = R8CommandParser.USAGE_MESSAGE;
+  static final String USAGE_MESSAGE = L8CommandParser.USAGE_MESSAGE;
 
   private final D8Command d8Command;
   private final R8Command r8Command;
@@ -253,6 +253,9 @@
 
     @Override
     void validate() {
+      if (isPrintHelp()) {
+        return;
+      }
       Reporter reporter = getReporter();
       if (!hasDesugaredLibraryConfiguration()) {
         reporter.error("L8 requires a desugared library configuration");
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 38e1556..9d6b199 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -40,6 +40,7 @@
 import com.android.tools.r8.graph.analysis.ClassInitializerAssertionEnablingAnalysis;
 import com.android.tools.r8.graph.analysis.InitializedClassesInInstanceMethodsAnalysis;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger;
+import com.android.tools.r8.horizontalclassmerging.HorizontalClassMergerGraphLens;
 import com.android.tools.r8.inspector.internal.InspectorImpl;
 import com.android.tools.r8.ir.conversion.IRConverter;
 import com.android.tools.r8.ir.desugar.BackportedMethodRewriter;
@@ -209,7 +210,6 @@
 
   static void writeApplication(
       ExecutorService executorService,
-      DexApplication application,
       AppView<?> appView,
       GraphLens graphLens,
       InitClassLens initClassLens,
@@ -217,7 +217,7 @@
       InternalOptions options,
       ProguardMapSupplier proguardMapSupplier)
       throws ExecutionException {
-    InspectorImpl.runInspections(options.outputInspections, application);
+    InspectorImpl.runInspections(options.outputInspections, appView.appInfo().classes());
     try {
       Marker marker = options.getMarker(Tool.R8);
       assert marker != null;
@@ -227,11 +227,15 @@
       markers.remove(marker);
       if (options.isGeneratingClassFiles()) {
         new CfApplicationWriter(
-                application, appView, options, marker, graphLens, namingLens, proguardMapSupplier)
+                appView,
+                marker,
+                graphLens,
+                namingLens,
+                proguardMapSupplier)
             .write(options.getClassFileConsumer());
       } else {
         new ApplicationWriter(
-                application,
+                appView.appInfo().app(),
                 appView,
                 options,
                 // Ensure that the marker for this compilation is the first in the list.
@@ -354,6 +358,7 @@
             }
           }
         }
+        options.reporter.failIfPendingErrors();
 
         // Add synthesized -assumenosideeffects from min api if relevant.
         if (options.isGeneratingDex()) {
@@ -547,7 +552,11 @@
           timing.begin("HorizontalClassMerger");
           HorizontalClassMerger merger =
               new HorizontalClassMerger(appViewWithLiveness, mainDexClasses);
-          merger.run();
+          HorizontalClassMergerGraphLens lens = merger.run();
+          if (lens != null) {
+            appView.setHorizontallyMergedClasses(lens.getHorizontallyMergedClasses());
+            appView.rewriteWithLens(lens);
+          }
           timing.end();
         }
 
@@ -905,7 +914,6 @@
       // Generate the resulting application resources.
       writeApplication(
           executorService,
-          appView.appInfo().app(),
           appView,
           appView.graphLens(),
           appView.initClassLens(),
diff --git a/src/main/java/com/android/tools/r8/R8Command.java b/src/main/java/com/android/tools/r8/R8Command.java
index f2d182d..6efe395 100644
--- a/src/main/java/com/android/tools/r8/R8Command.java
+++ b/src/main/java/com/android/tools/r8/R8Command.java
@@ -407,6 +407,9 @@
 
     @Override
     void validate() {
+      if (isPrintHelp()) {
+        return;
+      }
       Reporter reporter = getReporter();
       if (getProgramConsumer() instanceof DexFilePerClassFileConsumer) {
         reporter.error("R8 does not support compiling to a single DEX file per Java class file");
diff --git a/src/main/java/com/android/tools/r8/dex/FileWriter.java b/src/main/java/com/android/tools/r8/dex/FileWriter.java
index 8d1eac7..da90a09 100644
--- a/src/main/java/com/android/tools/r8/dex/FileWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/FileWriter.java
@@ -270,7 +270,8 @@
       return; // Class constructor is always OK.
     }
     if (method.accessFlags.isStatic()) {
-      if (!options.canUseDefaultAndStaticInterfaceMethods()) {
+      if (!options.canUseDefaultAndStaticInterfaceMethods()
+          && !options.testing.allowStaticInterfaceMethodsForPreNApiLevel) {
         throw options.reporter.fatalError(
             new StaticInterfaceMethodDiagnostic(new MethodPosition(method.method)));
       }
diff --git a/src/main/java/com/android/tools/r8/dex/Marker.java b/src/main/java/com/android/tools/r8/dex/Marker.java
index dd179c1..b4852a3 100644
--- a/src/main/java/com/android/tools/r8/dex/Marker.java
+++ b/src/main/java/com/android/tools/r8/dex/Marker.java
@@ -4,6 +4,7 @@
 package com.android.tools.r8.dex;
 
 import com.android.tools.r8.CompilationMode;
+import com.android.tools.r8.errors.DesugaredLibraryMismatchDiagnostic;
 import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.utils.Reporter;
 import com.android.tools.r8.utils.StringDiagnostic;
@@ -97,11 +98,7 @@
     }
 
     if (desugaredLibraryIdentifiers.size() > 1) {
-      reporter.error(
-          new StringDiagnostic(
-              "The compilation is merging inputs with different desugared library desugaring "
-                  + desugaredLibraryIdentifiers
-                  + ", which may lead to unexpected runtime errors."));
+      reporter.error(new DesugaredLibraryMismatchDiagnostic(desugaredLibraryIdentifiers));
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/errors/DesugaredLibraryMismatchDiagnostic.java b/src/main/java/com/android/tools/r8/errors/DesugaredLibraryMismatchDiagnostic.java
new file mode 100644
index 0000000..ba9af51
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/errors/DesugaredLibraryMismatchDiagnostic.java
@@ -0,0 +1,36 @@
+// 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.errors;
+
+import com.android.tools.r8.Diagnostic;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.position.Position;
+import java.util.Set;
+
+public class DesugaredLibraryMismatchDiagnostic implements Diagnostic {
+
+  private final Set<String> desugaredLibraryIdentifiers;
+
+  public DesugaredLibraryMismatchDiagnostic(Set<String> desugaredLibraryIdentifiers) {
+    this.desugaredLibraryIdentifiers = desugaredLibraryIdentifiers;
+  }
+
+  @Override
+  public Origin getOrigin() {
+    return Origin.unknown();
+  }
+
+  @Override
+  public Position getPosition() {
+    return Position.UNKNOWN;
+  }
+
+  @Override
+  public String getDiagnosticMessage() {
+    return "The compilation is merging inputs with different desugared library desugaring "
+        + desugaredLibraryIdentifiers
+        + ", which may lead to unexpected runtime errors.";
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/graph/AppView.java b/src/main/java/com/android/tools/r8/graph/AppView.java
index ccdfd2f..c6bc6b4 100644
--- a/src/main/java/com/android/tools/r8/graph/AppView.java
+++ b/src/main/java/com/android/tools/r8/graph/AppView.java
@@ -8,8 +8,10 @@
 import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
 import com.android.tools.r8.graph.analysis.InitializedClassesInInstanceMethodsAnalysis.InitializedClassesInInstanceMethods;
 import com.android.tools.r8.graph.classmerging.HorizontallyMergedLambdaClasses;
+import com.android.tools.r8.graph.classmerging.MergedClasses;
 import com.android.tools.r8.graph.classmerging.MergedClassesCollection;
 import com.android.tools.r8.graph.classmerging.VerticallyMergedClasses;
+import com.android.tools.r8.horizontalclassmerging.HorizontallyMergedClasses;
 import com.android.tools.r8.ir.analysis.proto.GeneratedExtensionRegistryShrinker;
 import com.android.tools.r8.ir.analysis.proto.GeneratedMessageLiteBuilderShrinker;
 import com.android.tools.r8.ir.analysis.proto.GeneratedMessageLiteShrinker;
@@ -70,6 +72,7 @@
   private Predicate<DexType> classesEscapingIntoLibrary = Predicates.alwaysTrue();
   private InitializedClassesInInstanceMethods initializedClassesInInstanceMethods;
   private HorizontallyMergedLambdaClasses horizontallyMergedLambdaClasses;
+  private HorizontallyMergedClasses horizontallyMergedClasses;
   private VerticallyMergedClasses verticallyMergedClasses;
   private EnumValueInfoMapCollection unboxedEnums = EnumValueInfoMapCollection.empty();
   private Set<DexMethod> cfByteCodePassThrough = ImmutableSet.of();
@@ -398,32 +401,48 @@
   }
 
   public boolean hasBeenMerged(DexProgramClass clazz) {
-    // TODO(b/165227525): Add support for the horizontal class merger here.
-    if (horizontallyMergedLambdaClasses != null
-        && horizontallyMergedLambdaClasses.hasBeenMerged(clazz)) {
-      return true;
-    }
-    return verticallyMergedClasses != null && verticallyMergedClasses.hasBeenMerged(clazz);
+    return MergedClasses.hasBeenMerged(horizontallyMergedClasses, clazz)
+        || MergedClasses.hasBeenMerged(horizontallyMergedLambdaClasses, clazz)
+        || MergedClasses.hasBeenMerged(verticallyMergedClasses, clazz);
   }
 
-  // Get the result of horizontal lambda class merging. Returns null if horizontal lambda class
-  // merging has not been run.
+  /**
+   * Get the result of horizontal lambda class merging. Returns null if horizontal lambda class
+   * merging has not been run.
+   */
   public HorizontallyMergedLambdaClasses horizontallyMergedLambdaClasses() {
     return horizontallyMergedLambdaClasses;
   }
 
   public void setHorizontallyMergedLambdaClasses(
       HorizontallyMergedLambdaClasses horizontallyMergedLambdaClasses) {
+    assert this.horizontallyMergedLambdaClasses == null;
     this.horizontallyMergedLambdaClasses = horizontallyMergedLambdaClasses;
   }
 
-  // Get the result of vertical class merging. Returns null if vertical class merging has not been
-  // run.
+  /**
+   * Get the result of horizontal class merging. Returns null if horizontal lambda class merging has
+   * not been run.
+   */
+  public HorizontallyMergedClasses horizontallyMergedClasses() {
+    return horizontallyMergedClasses;
+  }
+
+  public void setHorizontallyMergedClasses(HorizontallyMergedClasses horizontallyMergedClasses) {
+    assert this.horizontallyMergedClasses == null;
+    this.horizontallyMergedClasses = horizontallyMergedClasses;
+  }
+
+  /**
+   * Get the result of vertical class merging. Returns null if vertical class merging has not been
+   * run.
+   */
   public VerticallyMergedClasses verticallyMergedClasses() {
     return verticallyMergedClasses;
   }
 
   public void setVerticallyMergedClasses(VerticallyMergedClasses verticallyMergedClasses) {
+    assert this.verticallyMergedClasses == null;
     this.verticallyMergedClasses = verticallyMergedClasses;
   }
 
diff --git a/src/main/java/com/android/tools/r8/graph/AppliedGraphLens.java b/src/main/java/com/android/tools/r8/graph/AppliedGraphLens.java
index 90b940a..318b1bc 100644
--- a/src/main/java/com/android/tools/r8/graph/AppliedGraphLens.java
+++ b/src/main/java/com/android/tools/r8/graph/AppliedGraphLens.java
@@ -117,12 +117,12 @@
 
   @Override
   public GraphLensLookupResult lookupMethod(DexMethod method, DexMethod context, Invoke.Type type) {
-    return new GraphLensLookupResult(method, type);
+    return GraphLens.getIdentityLens().lookupMethod(method, context, type);
   }
 
   @Override
-  public RewrittenPrototypeDescription lookupPrototypeChanges(DexMethod method) {
-    return RewrittenPrototypeDescription.none();
+  public RewrittenPrototypeDescription lookupPrototypeChangesForMethodDefinition(DexMethod method) {
+    return GraphLens.getIdentityLens().lookupPrototypeChangesForMethodDefinition(method);
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
index 2cf3328..91a70a9 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -170,6 +170,7 @@
   public final DexString endsWithMethodName = createString("endsWith");
   public final DexString equalsMethodName = createString("equals");
   public final DexString hashCodeMethodName = createString("hashCode");
+  public final DexString identityHashCodeName = createString("identityHashCode");
   public final DexString equalsIgnoreCaseMethodName = createString("equalsIgnoreCase");
   public final DexString contentEqualsMethodName = createString("contentEquals");
   public final DexString indexOfMethodName = createString("indexOf");
@@ -225,6 +226,7 @@
   public final DexString fieldDescriptor = createString("Ljava/lang/reflect/Field;");
   public final DexString methodDescriptor = createString("Ljava/lang/reflect/Method;");
   public final DexString enumDescriptor = createString("Ljava/lang/Enum;");
+  public final DexString javaLangSystemDescriptor = createString("Ljava/lang/System;");
   public final DexString annotationDescriptor = createString("Ljava/lang/annotation/Annotation;");
   public final DexString objectsDescriptor = createString("Ljava/util/Objects;");
   public final DexString collectionsDescriptor = createString("Ljava/util/Collections;");
@@ -353,7 +355,7 @@
   public final DexType stringBuilderType = createStaticallyKnownType(stringBuilderDescriptor);
   public final DexType stringBufferType = createStaticallyKnownType(stringBufferDescriptor);
 
-  public final DexType javaLangSystemType = createStaticallyKnownType("Ljava/lang/System;");
+  public final DexType javaLangSystemType = createStaticallyKnownType(javaLangSystemDescriptor);
   public final DexType javaIoPrintStreamType = createStaticallyKnownType("Ljava/io/PrintStream;");
 
   public final DexType varHandleType = createStaticallyKnownType(varHandleDescriptor);
@@ -464,6 +466,7 @@
   public final ClassMethods classMethods = new ClassMethods();
   public final ConstructorMethods constructorMethods = new ConstructorMethods();
   public final EnumMembers enumMembers = new EnumMembers();
+  public final JavaLangSystemMethods javaLangSystemMethods = new JavaLangSystemMethods();
   public final NullPointerExceptionMethods npeMethods = new NullPointerExceptionMethods();
   public final IllegalArgumentExceptionMethods illegalArgumentExceptionMethods =
       new IllegalArgumentExceptionMethods();
@@ -1269,6 +1272,19 @@
     }
   }
 
+  public class JavaLangSystemMethods {
+    public final DexMethod identityHashCode;
+
+    private JavaLangSystemMethods() {
+      identityHashCode =
+          createMethod(
+              javaLangSystemDescriptor,
+              identityHashCodeName,
+              intDescriptor,
+              new DexString[] {objectDescriptor});
+    }
+  }
+
   public class EnumMembers {
 
     public final DexField nameField = createField(enumType, stringType, "name");
diff --git a/src/main/java/com/android/tools/r8/graph/DexMethod.java b/src/main/java/com/android/tools/r8/graph/DexMethod.java
index 8a50931..fce08d8 100644
--- a/src/main/java/com/android/tools/r8/graph/DexMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexMethod.java
@@ -31,6 +31,10 @@
     }
   }
 
+  public DexType getReturnType() {
+    return proto.returnType;
+  }
+
   @Override
   public <T> T apply(
       Function<DexType, T> classConsumer,
diff --git a/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java b/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java
index d803a42..fe85d28 100644
--- a/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java
+++ b/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java
@@ -8,6 +8,7 @@
 
 import com.android.tools.r8.DataResourceProvider;
 import com.android.tools.r8.graph.LazyLoadedDexApplication.AllClasses;
+import com.android.tools.r8.graph.classmerging.MergedClasses;
 import com.android.tools.r8.naming.ClassNameMapper;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.Timing;
@@ -137,7 +138,8 @@
         .allMatch(
             type ->
                 lens.lookupType(type) == type
-                    || appView.verticallyMergedClasses().hasBeenMergedIntoSubtype(type));
+                    || MergedClasses.hasBeenMerged(appView.verticallyMergedClasses(), type)
+                    || MergedClasses.hasBeenMerged(appView.horizontallyMergedClasses(), type));
     assert verifyCodeObjectsOwners();
     return true;
   }
diff --git a/src/main/java/com/android/tools/r8/graph/EnumValueInfoMapCollection.java b/src/main/java/com/android/tools/r8/graph/EnumValueInfoMapCollection.java
index 4ee6be1..362ff7c 100644
--- a/src/main/java/com/android/tools/r8/graph/EnumValueInfoMapCollection.java
+++ b/src/main/java/com/android/tools/r8/graph/EnumValueInfoMapCollection.java
@@ -84,6 +84,10 @@
       this.map = map;
     }
 
+    public Set<DexField> enumValues() {
+      return map.keySet();
+    }
+
     public int size() {
       return map.size();
     }
diff --git a/src/main/java/com/android/tools/r8/graph/GraphLens.java b/src/main/java/com/android/tools/r8/graph/GraphLens.java
index 07b3205..edce8d8 100644
--- a/src/main/java/com/android/tools/r8/graph/GraphLens.java
+++ b/src/main/java/com/android/tools/r8/graph/GraphLens.java
@@ -42,16 +42,21 @@
   /**
    * Result of a method lookup in a GraphLens.
    *
-   * <p>This provide the new target and the invoke type to use.
+   * <p>This provides the new target and invoke type to use, along with a description of the
+   * prototype changes that have been made to the target method and the corresponding required
+   * changes to the invoke arguments.
    */
   public static class GraphLensLookupResult {
 
     private final DexMethod method;
     private final Type type;
+    private final RewrittenPrototypeDescription prototypeChanges;
 
-    public GraphLensLookupResult(DexMethod method, Type type) {
+    public GraphLensLookupResult(
+        DexMethod method, Type type, RewrittenPrototypeDescription prototypeChanges) {
       this.method = method;
       this.type = type;
+      this.prototypeChanges = prototypeChanges;
     }
 
     public DexMethod getMethod() {
@@ -61,6 +66,10 @@
     public Type getType() {
       return type;
     }
+
+    public RewrittenPrototypeDescription getPrototypeChanges() {
+      return prototypeChanges;
+    }
   }
 
   public static class Builder {
@@ -189,7 +198,8 @@
   public abstract GraphLensLookupResult lookupMethod(
       DexMethod method, DexMethod context, Type type);
 
-  public abstract RewrittenPrototypeDescription lookupPrototypeChanges(DexMethod method);
+  public abstract RewrittenPrototypeDescription lookupPrototypeChangesForMethodDefinition(
+      DexMethod method);
 
   public abstract DexField lookupField(DexField field);
 
@@ -434,11 +444,12 @@
 
     @Override
     public GraphLensLookupResult lookupMethod(DexMethod method, DexMethod context, Type type) {
-      return new GraphLensLookupResult(method, type);
+      return new GraphLensLookupResult(method, type, RewrittenPrototypeDescription.none());
     }
 
     @Override
-    public RewrittenPrototypeDescription lookupPrototypeChanges(DexMethod method) {
+    public RewrittenPrototypeDescription lookupPrototypeChangesForMethodDefinition(
+        DexMethod method) {
       return RewrittenPrototypeDescription.none();
     }
 
@@ -628,24 +639,38 @@
 
     @Override
     public GraphLensLookupResult lookupMethod(DexMethod method, DexMethod context, Type type) {
-      DexMethod previousContext =
-          originalMethodSignatures != null
-              ? originalMethodSignatures.getOrDefault(context, context)
-              : context;
-      GraphLensLookupResult previous = previousLens.lookupMethod(method, previousContext, type);
-      DexMethod newMethod = methodMap.get(previous.getMethod());
+      DexMethod previousContext = internalGetPreviousMethodSignature(context);
+      GraphLensLookupResult lookup = previousLens.lookupMethod(method, previousContext, type);
+      DexMethod newMethod = methodMap.get(lookup.getMethod());
       if (newMethod == null) {
-        return previous;
+        return lookup;
       }
       // TODO(sgjesse): Should we always do interface to virtual mapping? Is it a performance win
-      // that only subclasses which are known to need it actually do it?
+      //  that only subclasses which are known to need it actually do it?
       return new GraphLensLookupResult(
-          newMethod, mapInvocationType(newMethod, method, previous.getType()));
+          newMethod,
+          mapInvocationType(newMethod, method, lookup.getType()),
+          internalDescribePrototypeChanges(lookup.getPrototypeChanges(), newMethod));
     }
 
     @Override
-    public RewrittenPrototypeDescription lookupPrototypeChanges(DexMethod method) {
-      return previousLens.lookupPrototypeChanges(method);
+    public RewrittenPrototypeDescription lookupPrototypeChangesForMethodDefinition(
+        DexMethod method) {
+      DexMethod previous = internalGetPreviousMethodSignature(method);
+      RewrittenPrototypeDescription lookup =
+          previousLens.lookupPrototypeChangesForMethodDefinition(previous);
+      return internalDescribePrototypeChanges(lookup, method);
+    }
+
+    protected RewrittenPrototypeDescription internalDescribePrototypeChanges(
+        RewrittenPrototypeDescription prototypeChanges, DexMethod method) {
+      return prototypeChanges;
+    }
+
+    protected DexMethod internalGetPreviousMethodSignature(DexMethod method) {
+      return originalMethodSignatures != null
+          ? originalMethodSignatures.getOrDefault(method, method)
+          : method;
     }
 
     @Override
diff --git a/src/main/java/com/android/tools/r8/graph/RewrittenPrototypeDescription.java b/src/main/java/com/android/tools/r8/graph/RewrittenPrototypeDescription.java
index 2828097..31ea06f 100644
--- a/src/main/java/com/android/tools/r8/graph/RewrittenPrototypeDescription.java
+++ b/src/main/java/com/android/tools/r8/graph/RewrittenPrototypeDescription.java
@@ -439,6 +439,9 @@
   }
 
   public RewrittenPrototypeDescription withRemovedArguments(ArgumentInfoCollection other) {
+    if (other.isEmpty()) {
+      return this;
+    }
     return new RewrittenPrototypeDescription(
         extraParameters, rewrittenReturnInfo, argumentInfoCollection.combine(other));
   }
diff --git a/src/main/java/com/android/tools/r8/graph/classmerging/HorizontallyMergedLambdaClasses.java b/src/main/java/com/android/tools/r8/graph/classmerging/HorizontallyMergedLambdaClasses.java
index fc8e49b..505dfd5 100644
--- a/src/main/java/com/android/tools/r8/graph/classmerging/HorizontallyMergedLambdaClasses.java
+++ b/src/main/java/com/android/tools/r8/graph/classmerging/HorizontallyMergedLambdaClasses.java
@@ -5,7 +5,6 @@
 package com.android.tools.r8.graph.classmerging;
 
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import java.util.Set;
@@ -30,7 +29,7 @@
   }
 
   @Override
-  public boolean hasBeenMerged(DexProgramClass clazz) {
-    return sources.contains(clazz.type);
+  public boolean hasBeenMerged(DexType type) {
+    return sources.contains(type);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/graph/classmerging/MergedClasses.java b/src/main/java/com/android/tools/r8/graph/classmerging/MergedClasses.java
index 66f9f6a..3f25895 100644
--- a/src/main/java/com/android/tools/r8/graph/classmerging/MergedClasses.java
+++ b/src/main/java/com/android/tools/r8/graph/classmerging/MergedClasses.java
@@ -6,11 +6,31 @@
 
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 
 public interface MergedClasses {
 
   boolean verifyAllSourcesPruned(AppView<AppInfoWithLiveness> appView);
 
-  boolean hasBeenMerged(DexProgramClass clazz);
+  boolean hasBeenMerged(DexType type);
+
+  /**
+   * Determine if the class has been merged by the merged classes object. If the merged classes is
+   * null then return false.
+   */
+  static boolean hasBeenMerged(MergedClasses mergedClasses, DexProgramClass clazz) {
+    return hasBeenMerged(mergedClasses, clazz.type);
+  }
+
+  /**
+   * Determine if the class has been merged by the merged classes object. If the merged classes is
+   * null then return false.
+   */
+  static boolean hasBeenMerged(MergedClasses mergedClasses, DexType type) {
+    if (mergedClasses != null) {
+      return mergedClasses.hasBeenMerged(type);
+    }
+    return false;
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/graph/classmerging/MergedClassesCollection.java b/src/main/java/com/android/tools/r8/graph/classmerging/MergedClassesCollection.java
index 1ced397..55c34b5 100644
--- a/src/main/java/com/android/tools/r8/graph/classmerging/MergedClassesCollection.java
+++ b/src/main/java/com/android/tools/r8/graph/classmerging/MergedClassesCollection.java
@@ -5,7 +5,7 @@
 package com.android.tools.r8.graph.classmerging;
 
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import java.util.ArrayList;
 import java.util.List;
@@ -27,9 +27,9 @@
   }
 
   @Override
-  public boolean hasBeenMerged(DexProgramClass clazz) {
+  public boolean hasBeenMerged(DexType type) {
     for (MergedClasses mergedClasses : collection) {
-      if (mergedClasses.hasBeenMerged(clazz)) {
+      if (mergedClasses.hasBeenMerged(type)) {
         return true;
       }
     }
diff --git a/src/main/java/com/android/tools/r8/graph/classmerging/VerticallyMergedClasses.java b/src/main/java/com/android/tools/r8/graph/classmerging/VerticallyMergedClasses.java
index d4c730a..f76f9e7 100644
--- a/src/main/java/com/android/tools/r8/graph/classmerging/VerticallyMergedClasses.java
+++ b/src/main/java/com/android/tools/r8/graph/classmerging/VerticallyMergedClasses.java
@@ -5,7 +5,6 @@
 package com.android.tools.r8.graph.classmerging;
 
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.google.common.collect.ImmutableList;
@@ -56,7 +55,7 @@
   }
 
   @Override
-  public boolean hasBeenMerged(DexProgramClass clazz) {
-    return hasBeenMergedIntoSubtype(clazz.type);
+  public boolean hasBeenMerged(DexType type) {
+    return hasBeenMergedIntoSubtype(type);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
new file mode 100644
index 0000000..e9aa061
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ClassMerger.java
@@ -0,0 +1,129 @@
+// 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.horizontalclassmerging;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexProto;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.utils.MethodSignatureEquivalence;
+import com.google.common.base.Equivalence.Wrapper;
+import java.util.Collection;
+import java.util.IdentityHashMap;
+import java.util.Map;
+
+/**
+ * The class merger is responsible for moving methods from {@link ClassMerger#toMergeGroup} into the
+ * class {@link ClassMerger#target}. While performing merging, this class tracks which methods have
+ * been moved, as well as which fields have been remapped in the {@link ClassMerger#lensBuilder}.
+ */
+class ClassMerger {
+  private final AppView<?> appView;
+  private final DexProgramClass target;
+  private final Collection<DexProgramClass> toMergeGroup;
+  private final DexItemFactory dexItemFactory;
+  private final HorizontalClassMergerGraphLens.Builder lensBuilder;
+
+  private final Map<DexProto, ConstructorMerger.Builder> constructorMergers;
+
+  ClassMerger(
+      AppView<?> appView,
+      HorizontalClassMergerGraphLens.Builder lensBuilder,
+      DexProgramClass target,
+      Collection<DexProgramClass> toMergeGroup) {
+    this.appView = appView;
+    this.lensBuilder = lensBuilder;
+    this.target = target;
+    this.toMergeGroup = toMergeGroup;
+    this.constructorMergers = new IdentityHashMap<>();
+
+    this.dexItemFactory = appView.dexItemFactory();
+  }
+
+  private Wrapper<DexMethod> bySignature(DexMethod method) {
+    return MethodSignatureEquivalence.get().wrap(method);
+  }
+
+  void addConstructor(DexEncodedMethod method) {
+    assert method.isInstanceInitializer();
+    constructorMergers
+        .computeIfAbsent(method.proto(), ignore -> new ConstructorMerger.Builder())
+        .add(method);
+  }
+
+  private void merge(DexProgramClass toMerge) {
+    toMerge.forEachProgramMethod(
+        programMethod -> {
+          DexEncodedMethod method = programMethod.getDefinition();
+          assert !method.isClassInitializer();
+
+          if (method.isInstanceInitializer()) {
+            addConstructor(method);
+          } else {
+            // TODO(b/166427795): Ensure that overriding relationships are not changed.
+            assert method.isVirtualMethod();
+
+            DexMethod newMethod = renameMethod(programMethod);
+            // TODO(b/165000217): Add all methods to `target` in one go using addVirtualMethods().;
+            target.addVirtualMethod(method.toTypeSubstitutedMethod(newMethod));
+            lensBuilder.moveMethod(method.method, newMethod);
+          }
+        });
+
+    // Clear the members of the class to be merged since they have now been moved to the target.
+    toMerge.setVirtualMethods(null);
+    toMerge.setDirectMethods(null);
+    toMerge.setInstanceFields(null);
+    toMerge.setStaticFields(null);
+  }
+
+  /**
+   * Find a new name for the method.
+   *
+   * @param method The class the method originally belonged to.
+   */
+  DexMethod renameMethod(ProgramMethod method) {
+    return dexItemFactory.createFreshMethodName(
+        method.getDefinition().method.name.toSourceString(),
+        method.getHolderType(),
+        method.getDefinition().proto(),
+        target.type,
+        tryMethod -> target.lookupMethod(tryMethod) == null);
+  }
+
+  void mergeConstructors() {
+    for (ConstructorMerger.Builder builder : constructorMergers.values()) {
+      ConstructorMerger constructorMerger = builder.build(appView, target);
+      constructorMerger.merge(lensBuilder);
+    }
+  }
+
+  /**
+   * To ensure constructor merging happens correctly, add all of the target constructors methods to
+   * constructor mergers.
+   */
+  void addTargetConstructors() {
+    target.forEachProgramDirectMethod(
+        programMethod -> {
+          DexEncodedMethod method = programMethod.getDefinition();
+          if (method.isInstanceInitializer()) {
+            addConstructor(method);
+          }
+        });
+  }
+
+  public void mergeGroup() {
+    addTargetConstructors();
+
+    for (DexProgramClass clazz : toMergeGroup) {
+      merge(clazz);
+    }
+
+    mergeConstructors();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorMerger.java
index d7e942d..aae7b0e 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorMerger.java
@@ -42,6 +42,23 @@
     this.dexItemFactory = appView.dexItemFactory();
   }
 
+  public static class Builder {
+    private final Collection<DexEncodedMethod> constructors;
+
+    public Builder() {
+      constructors = new ArrayList<>();
+    }
+
+    public Builder add(DexEncodedMethod constructor) {
+      constructors.add(constructor);
+      return this;
+    }
+
+    public ConstructorMerger build(AppView<?> appView, DexProgramClass target) {
+      return new ConstructorMerger(appView, target, constructors);
+    }
+  }
+
   private DexMethod moveConstructor(DexEncodedMethod constructor) {
     DexMethod method =
         dexItemFactory.createFreshMethodName(
@@ -75,7 +92,8 @@
     return MethodAccessFlags.fromSharedAccessFlags(Constants.ACC_PUBLIC, true);
   }
 
-  public void merge() {
+  /** Synthesize a new method which selects the constructor based on a parameter type. */
+  void mergeMany(HorizontalClassMergerGraphLens.Builder lensBuilder) {
     Map<DexType, DexMethod> typeConstructors = new IdentityHashMap<>();
 
     for (DexEncodedMethod constructor : constructors) {
@@ -99,6 +117,40 @@
             ParameterAnnotationsList.empty(),
             synthesizedCode);
 
+    // Map each old constructor to the newly synthesized constructor in the graph lens.
+    int constructorId = 0;
+    for (DexEncodedMethod constructor : constructors) {
+      lensBuilder.mapConstructor(constructor.method, newMethod.method, constructorId++);
+    }
+
     target.addDirectMethod(newMethod);
   }
+
+  /**
+   * The constructor does not conflict with any other constructors. Add the constructor (if any) to
+   * the target directly.
+   */
+  void mergeTrivial(HorizontalClassMergerGraphLens.Builder lensBuilder) {
+    assert constructors.size() <= 1;
+
+    if (!constructors.isEmpty()) {
+      DexEncodedMethod constructor = constructors.iterator().next();
+
+      // Only move the constructor if it is not already in the target type.
+      if (constructor.holder() != target.type) {
+        DexEncodedMethod newConstructor =
+            constructor.toRenamedHolderMethod(target.type, dexItemFactory);
+        target.addDirectMethod(constructor);
+        lensBuilder.moveConstructor(constructor.method, newConstructor.method);
+      }
+    }
+  }
+
+  public void merge(HorizontalClassMergerGraphLens.Builder lensBuilder) {
+    if (constructors.size() <= 1) {
+      mergeTrivial(lensBuilder);
+    } else {
+      mergeMany(lensBuilder);
+    }
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
index 56da905..60949e5 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
@@ -6,12 +6,22 @@
 
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.horizontalclassmerging.policies.NoFields;
+import com.android.tools.r8.horizontalclassmerging.policies.NoInterfaces;
+import com.android.tools.r8.horizontalclassmerging.policies.NoInternalUtilityClasses;
+import com.android.tools.r8.horizontalclassmerging.policies.NoOverlappingConstructors;
+import com.android.tools.r8.horizontalclassmerging.policies.NoStaticClassInitializer;
+import com.android.tools.r8.horizontalclassmerging.policies.NotEntryPoint;
+import com.android.tools.r8.horizontalclassmerging.policies.SameParentClass;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.shaking.MainDexClasses;
+import com.google.common.collect.ImmutableList;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.List;
 import java.util.Map;
 
 public class HorizontalClassMerger {
@@ -26,13 +36,22 @@
     this.appView = appView;
     this.mainDexClasses = mainDexClasses;
 
-    Policy[] policies = {
-      // TODO: add policies
-    };
-    this.policyExecutor = new SimplePolicyExecutor(Arrays.asList(policies));
+    List<Policy> policies =
+        ImmutableList.of(
+            new NoFields(),
+            new NoInterfaces(),
+            new NoStaticClassInitializer(),
+            new NotEntryPoint(appView.dexItemFactory()),
+            new NoInternalUtilityClasses(appView.dexItemFactory()),
+            new SameParentClass(),
+            new NoOverlappingConstructors()
+            // TODO: add policies
+            );
+
+    this.policyExecutor = new SimplePolicyExecutor(policies);
   }
 
-  public Collection<Collection<DexProgramClass>> run() {
+  public HorizontalClassMergerGraphLens run() {
     Map<FieldMultiset, Collection<DexProgramClass>> classes = new HashMap<>();
 
     // Group classes by same field signature using the hash map.
@@ -43,6 +62,38 @@
     // Run the policies on all collected classes to produce a final grouping.
     Collection<Collection<DexProgramClass>> groups = policyExecutor.run(classes.values());
 
-    return groups;
+    return createLens(groups);
+  }
+
+  // TODO(b/165577835): replace Collection<DexProgramClass> with MergeGroup
+  /**
+   * Merges all class groups using {@link ClassMerger}. Then fix all references to merged classes
+   * using the {@link TreeFixer}. Constructs a graph lens containing all changes while performing
+   * merging.
+   */
+  private HorizontalClassMergerGraphLens createLens(
+      Collection<Collection<DexProgramClass>> groups) {
+    Map<DexType, DexType> mergedClasses = new IdentityHashMap<>();
+    HorizontalClassMergerGraphLens.Builder lensBuilder =
+        new HorizontalClassMergerGraphLens.Builder();
+
+    // TODO(b/166577694): Replace Collection<DexProgramClass> with MergeGroup
+    for (Collection<DexProgramClass> group : groups) {
+      assert !group.isEmpty();
+
+      DexProgramClass target = group.stream().findFirst().get();
+      group.remove(target);
+
+      for (DexProgramClass clazz : group) {
+        mergedClasses.put(clazz.type, target.type);
+      }
+
+      ClassMerger merger = new ClassMerger(appView, lensBuilder, target, group);
+      merger.mergeGroup();
+    }
+
+    HorizontalClassMergerGraphLens lens =
+        new TreeFixer(appView, lensBuilder, mergedClasses).fixupTypeReferences();
+    return lens;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java
new file mode 100644
index 0000000..451e550
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerGraphLens.java
@@ -0,0 +1,129 @@
+// 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.horizontalclassmerging;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLens;
+import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class HorizontalClassMergerGraphLens extends NestedGraphLens {
+  private final AppView<?> appView;
+
+  private HorizontalClassMergerGraphLens(
+      AppView<?> appView,
+      Map<DexType, DexType> typeMap,
+      Map<DexField, DexField> fieldMap,
+      Map<DexMethod, DexMethod> methodMap,
+      BiMap<DexField, DexField> originalFieldSignatures,
+      BiMap<DexMethod, DexMethod> originalMethodSignatures,
+      GraphLens previousLens) {
+    super(
+        typeMap,
+        methodMap,
+        fieldMap,
+        originalFieldSignatures,
+        originalMethodSignatures,
+        previousLens,
+        appView.dexItemFactory());
+    this.appView = appView;
+  }
+
+  public HorizontallyMergedClasses getHorizontallyMergedClasses() {
+    return new HorizontallyMergedClasses(this.typeMap);
+  }
+
+  public static class Builder {
+    protected final BiMap<DexField, DexField> fieldMap = HashBiMap.create();
+    protected final Map<DexMethod, DexMethod> methodMap = new IdentityHashMap<>();
+    protected final Map<DexMethod, Set<DexMethod>> completeInverseMethodMap =
+        new IdentityHashMap<>();
+
+    private final BiMap<DexMethod, DexMethod> originalMethodSignatures = HashBiMap.create();
+
+    private final Map<DexMethod, Integer> constructorIds = new IdentityHashMap<>();
+
+    Builder() {}
+
+    public HorizontalClassMergerGraphLens build(
+        AppView<?> appView, Map<DexType, DexType> mergedClasses) {
+      if (mergedClasses.isEmpty()) {
+        return null;
+      } else {
+        BiMap<DexField, DexField> originalFieldSignatures = fieldMap.inverse();
+        return new HorizontalClassMergerGraphLens(
+            appView,
+            mergedClasses,
+            fieldMap,
+            methodMap,
+            originalFieldSignatures,
+            originalMethodSignatures,
+            appView.graphLens());
+      }
+    }
+
+    /** Bidirectional mapping from one method to another. */
+    public Builder moveMethod(DexMethod from, DexMethod to) {
+      mapMethod(from, to);
+      originalMethodSignatures.put(to, from);
+      return this;
+    }
+
+    /**
+     * Unidirectional mapping from one method to another. This seems to only be used by synthesized
+     * constructors so is private for now. See {@link Builder#moveConstructor(DexMethod,
+     * DexMethod)}.
+     */
+    private Builder mapMethod(DexMethod from, DexMethod to) {
+      for (DexMethod existingFrom :
+          completeInverseMethodMap.getOrDefault(from, Collections.emptySet())) {
+        methodMap.put(existingFrom, to);
+
+        // We currently assume that a single method can only be remapped twice.
+        assert completeInverseMethodMap
+            .getOrDefault(existingFrom, Collections.emptySet())
+            .isEmpty();
+      }
+      methodMap.put(from, to);
+      completeInverseMethodMap.computeIfAbsent(to, ignore -> new HashSet<>()).add(from);
+      return this;
+    }
+
+    public boolean hasOriginalSignatureMappingFor(DexMethod method) {
+      return originalMethodSignatures.containsKey(method);
+    }
+
+    /**
+     * One way mapping from one constructor to another. This is used for synthesized constructors,
+     * where many constructors are merged into a single constructor. The synthesized constructor
+     * therefore does not have a unique reverse constructor.
+     *
+     * @param constructorId The id that must be appended to the constructor call to ensure the
+     *     correct constructor is called.
+     */
+    public Builder mapConstructor(DexMethod from, DexMethod to, int constructorId) {
+      mapMethod(from, to);
+      constructorIds.put(from, constructorId);
+      return this;
+    }
+
+    /**
+     * Bidirectional mapping from one constructor to another. When a single constructor is simply
+     * moved from one class to another, we can uniquely map the new constructor back to the old one.
+     */
+    public Builder moveConstructor(DexMethod from, DexMethod to) {
+      return moveMethod(from, to);
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontallyMergedClasses.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontallyMergedClasses.java
new file mode 100644
index 0000000..00632e5
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontallyMergedClasses.java
@@ -0,0 +1,35 @@
+// 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.horizontalclassmerging;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.classmerging.MergedClasses;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import java.util.Map;
+
+public class HorizontallyMergedClasses implements MergedClasses {
+  private final Map<DexType, DexType> horizontallyMergedClasses;
+
+  public HorizontallyMergedClasses(Map<DexType, DexType> horizontallyMergedClasses) {
+    this.horizontallyMergedClasses = horizontallyMergedClasses;
+  }
+
+  @Override
+  public boolean verifyAllSourcesPruned(AppView<AppInfoWithLiveness> appView) {
+    for (DexType source : horizontallyMergedClasses.keySet()) {
+      assert appView.appInfo().wasPruned(source)
+          : "Expected horizontally merged lambda class `"
+              + source.toSourceString()
+              + "` to be absent";
+    }
+    return true;
+  }
+
+  @Override
+  public boolean hasBeenMerged(DexType type) {
+    return horizontallyMergedClasses.containsKey(type);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/TreeFixer.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/TreeFixer.java
new file mode 100644
index 0000000..cd2cabf
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/TreeFixer.java
@@ -0,0 +1,136 @@
+// 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.horizontalclassmerging;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClass.FieldSetter;
+import com.android.tools.r8.graph.DexEncodedField;
+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.DexProto;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.shaking.AnnotationFixer;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.OptionalBool;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * The tree fixer traverses all program classes and finds and fixes references to old classes which
+ * have been remapped to new classes by the class merger (stored in {@link
+ * TreeFixer#mergedClasses}). While doing so, all updated changes are tracked in {@link
+ * TreeFixer#lensBuilder}.
+ */
+class TreeFixer {
+  private final Map<DexType, DexType> mergedClasses;
+  private final Map<DexProto, DexProto> protoFixupCache = new IdentityHashMap<>();
+  private final HorizontalClassMergerGraphLens.Builder lensBuilder;
+  private final AppView<AppInfoWithLiveness> appView;
+
+  public TreeFixer(
+      AppView<AppInfoWithLiveness> appView,
+      HorizontalClassMergerGraphLens.Builder lensBuilder,
+      Map<DexType, DexType> mergedClasses) {
+    this.mergedClasses = mergedClasses;
+    this.lensBuilder = lensBuilder;
+    this.appView = appView;
+  }
+
+  HorizontalClassMergerGraphLens fixupTypeReferences() {
+    // Globally substitute merged class types in protos and holders.
+    for (DexProgramClass clazz : appView.appInfo().classes()) {
+      clazz.getMethodCollection().replaceMethods(this::fixupMethod);
+      fixupFields(clazz.staticFields(), clazz::setStaticField);
+      fixupFields(clazz.instanceFields(), clazz::setInstanceField);
+    }
+    HorizontalClassMergerGraphLens lens = lensBuilder.build(appView, mergedClasses);
+
+    if (lens != null) {
+      new AnnotationFixer(lens).run(appView.appInfo().classes());
+    }
+    return lens;
+  }
+
+  private DexEncodedMethod fixupMethod(DexEncodedMethod method) {
+    DexMethod methodReference = method.method;
+    DexMethod newMethodReference = fixupMethod(methodReference);
+    if (newMethodReference == methodReference) {
+      return method;
+    }
+
+    lensBuilder.moveMethod(methodReference, newMethodReference);
+    DexEncodedMethod newMethod = method.toTypeSubstitutedMethod(newMethodReference);
+    if (newMethod.isNonPrivateVirtualMethod()) {
+      // Since we changed the return type or one of the parameters, this method cannot be a
+      // classpath or library method override, since we only class merge program classes.
+      assert !method.isLibraryMethodOverride().isTrue();
+      newMethod.setLibraryMethodOverride(OptionalBool.FALSE);
+    }
+    return newMethod;
+  }
+
+  private void fixupFields(List<DexEncodedField> fields, FieldSetter setter) {
+    if (fields == null) {
+      return;
+    }
+    for (int i = 0; i < fields.size(); i++) {
+      DexEncodedField encodedField = fields.get(i);
+      DexField field = encodedField.field;
+      DexType newType = fixupType(field.type);
+      DexType newHolder = fixupType(field.holder);
+      DexField newField = appView.dexItemFactory().createField(newHolder, newType, field.name);
+      if (newField != encodedField.field) {
+        // TODO(b/165498187): track mapped fields
+        /* lensBuilder.map(field, newField); */
+        setter.setField(i, encodedField.toTypeSubstitutedField(newField));
+      }
+    }
+  }
+
+  private DexMethod fixupMethod(DexMethod method) {
+    return appView
+        .dexItemFactory()
+        .createMethod(fixupType(method.holder), fixupProto(method.proto), method.name);
+  }
+
+  private DexProto fixupProto(DexProto proto) {
+    DexProto result = protoFixupCache.get(proto);
+    if (result == null) {
+      DexType returnType = fixupType(proto.returnType);
+      DexType[] arguments = fixupTypes(proto.parameters.values);
+      result = appView.dexItemFactory().createProto(returnType, arguments);
+      protoFixupCache.put(proto, result);
+    }
+    return result;
+  }
+
+  private DexType fixupType(DexType type) {
+    if (type.isArrayType()) {
+      DexType base = type.toBaseType(appView.dexItemFactory());
+      DexType fixed = fixupType(base);
+      if (base == fixed) {
+        return type;
+      }
+      return type.replaceBaseType(fixed, appView.dexItemFactory());
+    }
+    if (type.isClassType()) {
+      while (mergedClasses.containsKey(type)) {
+        type = mergedClasses.get(type);
+      }
+    }
+    return type;
+  }
+
+  private DexType[] fixupTypes(DexType[] types) {
+    DexType[] result = new DexType[types.length];
+    for (int i = 0; i < result.length; i++) {
+      result[i] = fixupType(types[i]);
+    }
+    return result;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoFields.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoFields.java
new file mode 100644
index 0000000..9ba49a4
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoFields.java
@@ -0,0 +1,16 @@
+// 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.horizontalclassmerging.policies;
+
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.horizontalclassmerging.SingleClassPolicy;
+
+public class NoFields extends SingleClassPolicy {
+  @Override
+  public boolean canMerge(DexProgramClass program) {
+    // TODO(b/165498187): remove this policy
+    return !program.hasFields();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInterfaces.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInterfaces.java
new file mode 100644
index 0000000..7b194a2
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInterfaces.java
@@ -0,0 +1,16 @@
+// 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.horizontalclassmerging.policies;
+
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.horizontalclassmerging.SingleClassPolicy;
+
+public class NoInterfaces extends SingleClassPolicy {
+
+  @Override
+  public boolean canMerge(DexProgramClass program) {
+    return program.interfaces.isEmpty();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInternalUtilityClasses.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInternalUtilityClasses.java
new file mode 100644
index 0000000..2887849
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInternalUtilityClasses.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.horizontalclassmerging.policies;
+
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.horizontalclassmerging.SingleClassPolicy;
+import java.util.Collections;
+import java.util.Set;
+
+public class NoInternalUtilityClasses extends SingleClassPolicy {
+  private final Set<DexType> internalUtilityClasses;
+
+  public NoInternalUtilityClasses(DexItemFactory dexItemFactory) {
+    this.internalUtilityClasses = Collections.singleton(dexItemFactory.enumUnboxingUtilityType);
+  }
+
+  @Override
+  public boolean canMerge(DexProgramClass program) {
+    return !internalUtilityClasses.contains(program.type);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoOverlappingConstructors.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoOverlappingConstructors.java
new file mode 100644
index 0000000..112580c
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoOverlappingConstructors.java
@@ -0,0 +1,117 @@
+// 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.horizontalclassmerging.policies;
+
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexProto;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class NoOverlappingConstructors extends MultiClassPolicy {
+
+  public void removeNonConflicting(Map<DexProto, Set<DexProgramClass>> overlappingConstructors) {
+    Iterator<DexProto> i = overlappingConstructors.keySet().iterator();
+    while (i.hasNext()) {
+      DexProto proto = i.next();
+      if (overlappingConstructors.get(proto).size() == 1) {
+        i.remove();
+      }
+    }
+  }
+
+  private Set<DexProgramClass> sortedClassSet(Collection<DexProgramClass> classes) {
+    Set<DexProgramClass> set =
+        new TreeSet<DexProgramClass>(
+            Comparator.comparing(DexProgramClass::getType, DexType::slowCompareTo));
+    set.addAll(classes);
+    return set;
+  }
+
+  @Override
+  public Collection<Collection<DexProgramClass>> apply(Collection<DexProgramClass> group) {
+    Map<DexProto, Set<DexProgramClass>> overlappingConstructors = new IdentityHashMap<>();
+
+    for (DexProgramClass clazz : group) {
+      clazz.forEachProgramDirectMethod(
+          directMethod -> {
+            DexEncodedMethod method = directMethod.getDefinition();
+            if (method.isInstanceInitializer()) {
+              overlappingConstructors
+                  .computeIfAbsent(method.getProto(), ignore -> new HashSet<DexProgramClass>())
+                  .add(clazz);
+            }
+          });
+    }
+
+    removeNonConflicting(overlappingConstructors);
+
+    // This is probably related to the graph colouring problem so probably won't be efficient in
+    // worst cases. We assume there won't be that many overlapping constructors so this should be
+    // reasonable. Constructor merging should also make this obsolete.
+    Collection<Set<DexProgramClass>> groups = new LinkedList<>();
+    groups.add(sortedClassSet(group));
+
+    for (Set<DexProgramClass> overlappingClasses : overlappingConstructors.values()) {
+      Collection<Set<DexProgramClass>> newGroups = new LinkedList<>();
+
+      // For every set of classes that cannot be in the same group, generate a new group with the
+      // same constructor and with all remaining constructors.
+
+      for (Set<DexProgramClass> existingGroup : groups) {
+        Set<DexProgramClass> actuallyOverlapping = new HashSet<>(overlappingClasses);
+        actuallyOverlapping.retainAll(existingGroup);
+
+        if (actuallyOverlapping.size() <= 1) {
+          newGroups.add(existingGroup);
+        } else {
+          Set<DexProgramClass> notOverlapping = new HashSet<>(existingGroup);
+          notOverlapping.removeAll(overlappingClasses);
+          for (DexProgramClass overlappingClass : actuallyOverlapping) {
+            Set<DexProgramClass> newGroup = sortedClassSet(notOverlapping);
+            newGroup.add(overlappingClass);
+            newGroups.add(newGroup);
+          }
+        }
+      }
+
+      groups = newGroups;
+    }
+
+    // Ensure each class is only in a single group and remove singleton and empty groups.
+    Set<DexProgramClass> assignedClasses = new HashSet<>();
+
+    Iterator<Set<DexProgramClass>> i = groups.iterator();
+    while (i.hasNext()) {
+      Set<DexProgramClass> newGroup = i.next();
+      newGroup.removeAll(assignedClasses);
+      if (newGroup.size() <= 1) {
+        i.remove();
+      } else {
+        assignedClasses.addAll(newGroup);
+      }
+    }
+
+    // Map to collection
+    Collection<Collection<DexProgramClass>> newGroups = new ArrayList<>();
+    for (Set<DexProgramClass> newGroup : groups) {
+      List<DexProgramClass> newGroupList = new ArrayList<>(newGroup);
+      newGroups.add(new ArrayList<>(newGroup));
+    }
+
+    return newGroups;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoStaticClassInitializer.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoStaticClassInitializer.java
new file mode 100644
index 0000000..aeca6c0
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoStaticClassInitializer.java
@@ -0,0 +1,20 @@
+// 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.horizontalclassmerging.policies;
+
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.horizontalclassmerging.SingleClassPolicy;
+
+/**
+ * Prevent merging of classes with static initializers, as merging these causes side effects. It is
+ * okay for superclasses to have static initializers as all classes are expected to have the same
+ * super class.
+ */
+public class NoStaticClassInitializer extends SingleClassPolicy {
+  @Override
+  public boolean canMerge(DexProgramClass program) {
+    return !program.hasClassInitializer();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NotEntryPoint.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NotEntryPoint.java
new file mode 100644
index 0000000..4bc65e5
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NotEntryPoint.java
@@ -0,0 +1,30 @@
+// 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.horizontalclassmerging.policies;
+
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexString;
+import com.android.tools.r8.horizontalclassmerging.SingleClassPolicy;
+
+public class NotEntryPoint extends SingleClassPolicy {
+  private final DexString main;
+
+  public NotEntryPoint(DexItemFactory factory) {
+    main = factory.createString("main");
+  }
+
+  @Override
+  public boolean canMerge(DexProgramClass program) {
+    // TODO(b/165000217): Account for keep rules instead.
+    for (DexEncodedMethod method : program.directMethods()) {
+      if (method.method.name.equals(main)) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/SameParentClass.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/SameParentClass.java
new file mode 100644
index 0000000..4e1987e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/SameParentClass.java
@@ -0,0 +1,27 @@
+// 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.horizontalclassmerging.policies;
+
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.horizontalclassmerging.MultiClassPolicy;
+import java.util.Collection;
+import java.util.IdentityHashMap;
+import java.util.LinkedList;
+import java.util.Map;
+
+public class SameParentClass extends MultiClassPolicy {
+
+  @Override
+  public Collection<Collection<DexProgramClass>> apply(Collection<DexProgramClass> group) {
+    Map<DexType, Collection<DexProgramClass>> groups = new IdentityHashMap<>();
+    for (DexProgramClass clazz : group) {
+      groups
+          .computeIfAbsent(clazz.superType, ignore -> new LinkedList<DexProgramClass>())
+          .add(clazz);
+    }
+    return groups.values();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/internal/InspectorImpl.java b/src/main/java/com/android/tools/r8/inspector/internal/InspectorImpl.java
index c3d8a64..72e322f 100644
--- a/src/main/java/com/android/tools/r8/inspector/internal/InspectorImpl.java
+++ b/src/main/java/com/android/tools/r8/inspector/internal/InspectorImpl.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.inspector.internal;
 
-import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.inspector.ClassInspector;
 import com.android.tools.r8.inspector.Inspector;
@@ -29,25 +28,25 @@
   }
 
   public static void runInspections(
-      List<Consumer<InspectorImpl>> inspections, DexApplication application) {
+      List<Consumer<InspectorImpl>> inspections, Collection<DexProgramClass> classes) {
     if (inspections == null || inspections.isEmpty()) {
       return;
     }
-    InspectorImpl inspector = new InspectorImpl(application);
+    InspectorImpl inspector = new InspectorImpl(classes);
     for (Consumer<InspectorImpl> inspection : inspections) {
       inspection.accept(inspector);
     }
   }
 
-  private final DexApplication application;
+  private final Collection<DexProgramClass> classes;
 
-  public InspectorImpl(DexApplication application) {
-    this.application = application;
+  public InspectorImpl(Collection<DexProgramClass> classes) {
+    this.classes = classes;
   }
 
   @Override
   public void forEachClass(Consumer<ClassInspector> inspection) {
-    for (DexProgramClass clazz : application.classes()) {
+    for (DexProgramClass clazz : classes) {
       inspection.accept(new ClassInspectorImpl(clazz));
     }
   }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
index 3d8df1a..ebcdfff 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
@@ -18,6 +18,7 @@
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+import com.android.tools.r8.ir.analysis.value.EnumValuesObjectState;
 import com.android.tools.r8.ir.analysis.value.ObjectState;
 import com.android.tools.r8.ir.analysis.value.SingleFieldValue;
 import com.android.tools.r8.ir.code.ArrayPut;
@@ -25,6 +26,7 @@
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InvokeDirect;
+import com.android.tools.r8.ir.code.NewArrayEmpty;
 import com.android.tools.r8.ir.code.NewInstance;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.optimize.ClassInitializerDefaultsOptimization.ClassInitializerDefaultsResult;
@@ -141,9 +143,132 @@
    * array as long as the array is identified as being the {@code $VALUES} array.
    */
   private SingleFieldValue computeSingleEnumFieldValue(Value value) {
+    if (!context.getHolder().isEnum()) {
+      return null;
+    }
     assert !value.hasAliasedValue();
-    if (!context.getHolder().isEnum()
-        || !value.isDefinedByInstructionSatisfying(Instruction::isNewInstance)) {
+    if (isEnumValuesArray(value)) {
+      return computeSingleEnumFieldValueForValuesArray(value);
+    }
+    return computeSingleEnumFieldValueForInstance(value);
+  }
+
+  private SingleFieldValue computeSingleEnumFieldValueForValuesArray(Value value) {
+    if (!value.isDefinedByInstructionSatisfying(Instruction::isNewArrayEmpty)) {
+      return null;
+    }
+
+    NewArrayEmpty newArrayEmpty = value.definition.asNewArrayEmpty();
+    if (newArrayEmpty.type.toBaseType(appView.dexItemFactory()) != context.getHolder().type) {
+      return null;
+    }
+    if (value.hasDebugUsers() || value.hasPhiUsers()) {
+      return null;
+    }
+    if (!newArrayEmpty.size().isConstNumber()) {
+      return null;
+    }
+
+    int valuesSize = newArrayEmpty.size().getConstInstruction().asConstNumber().getIntValue();
+    if (valuesSize == 0) {
+      // No need to compute the state of an empty array.
+      return null;
+    }
+
+    ObjectState[] valuesState = new ObjectState[valuesSize];
+    DexEncodedField valuesField = null;
+    for (Instruction user : value.uniqueUsers()) {
+      switch (user.opcode()) {
+        case ARRAY_PUT:
+          ArrayPut arrayPut = user.asArrayPut();
+          if (arrayPut.array() != value) {
+            return null;
+          }
+          if (!arrayPut.index().isConstNumber()) {
+            return null;
+          }
+          int index = arrayPut.index().getConstInstruction().asConstNumber().getIntValue();
+          if (index < 0 || index >= valuesSize) {
+            return null;
+          }
+          ObjectState objectState = computeEnumInstanceObjectState(arrayPut.value());
+          if (objectState == null || objectState.isEmpty()) {
+            // We need the state of all fields for the analysis to be valuable.
+            return null;
+          }
+          assert verifyValuesArrayIndexMatchesOrdinal(index, objectState);
+          if (valuesState[index] != null) {
+            return null;
+          }
+          valuesState[index] = objectState;
+          break;
+
+        case STATIC_PUT:
+          DexEncodedField field =
+              context.getHolder().lookupStaticField(user.asStaticPut().getField());
+          if (field == null) {
+            return null;
+          }
+          if (valuesField != null) {
+            return null;
+          }
+          valuesField = field;
+          break;
+
+        default:
+          return null;
+      }
+    }
+
+    if (valuesField == null) {
+      return null;
+    }
+
+    for (ObjectState objectState : valuesState) {
+      if (objectState == null) {
+        return null;
+      }
+    }
+
+    return appView
+        .abstractValueFactory()
+        .createSingleFieldValue(valuesField.field, new EnumValuesObjectState(valuesState));
+  }
+
+  private ObjectState computeEnumInstanceObjectState(Value value) {
+    Value root = value.getAliasedValue();
+    if (root.isPhi()) {
+      return ObjectState.empty();
+    }
+    Instruction definition = root.getDefinition();
+    if (definition.isNewInstance()) {
+      return computeObjectState(definition.outValue());
+    }
+    if (definition.isStaticGet()) {
+      // TODO(b/166532388) : Enums with many instance rely on staticGets to set the $VALUES data
+      // instead of directly keeping the values in registers. We could consider analysing these
+      // and answer the analysed object state here.
+      return ObjectState.empty();
+    }
+    return ObjectState.empty();
+  }
+
+  private boolean verifyValuesArrayIndexMatchesOrdinal(int ordinal, ObjectState objectState) {
+    DexEncodedField ordinalField =
+        appView
+            .appInfo()
+            .resolveField(appView.dexItemFactory().enumMembers.ordinalField, context)
+            .getResolvedField();
+    assert ordinalField != null;
+    AbstractValue ordinalState = objectState.getAbstractFieldValue(ordinalField);
+    assert ordinalState != null;
+    assert ordinalState.isSingleNumberValue();
+    assert ordinalState.asSingleNumberValue().getIntValue() == ordinal;
+    return true;
+  }
+
+  private SingleFieldValue computeSingleEnumFieldValueForInstance(Value value) {
+    if (!value.isDefinedByInstructionSatisfying(Instruction::isNewInstance)) {
       return null;
     }
 
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/EnumValuesObjectState.java b/src/main/java/com/android/tools/r8/ir/analysis/value/EnumValuesObjectState.java
new file mode 100644
index 0000000..f1ec89c
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/EnumValuesObjectState.java
@@ -0,0 +1,82 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis.value;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.GraphLens;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import java.util.Arrays;
+import java.util.Objects;
+
+public class EnumValuesObjectState extends ObjectState {
+
+  private final ObjectState[] state;
+
+  public EnumValuesObjectState(ObjectState[] state) {
+    assert state.length > 0;
+    assert Arrays.stream(state).noneMatch(Objects::isNull);
+    this.state = state;
+  }
+
+  @Override
+  public AbstractValue getAbstractFieldValue(DexEncodedField field) {
+    return UnknownValue.getInstance();
+  }
+
+  public ObjectState getObjectStateForOrdinal(int ordinal) {
+    if (ordinal < 0 || ordinal >= state.length) {
+      return ObjectState.empty();
+    }
+    return state[ordinal];
+  }
+
+  @Override
+  public boolean isEnumValuesObjectState() {
+    return true;
+  }
+
+  @Override
+  public EnumValuesObjectState asEnumValuesObjectState() {
+    return this;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    // Non-empty by construction.
+    return false;
+  }
+
+  @Override
+  public ObjectState rewrittenWithLens(AppView<AppInfoWithLiveness> appView, GraphLens lens) {
+    ObjectState[] newState = new ObjectState[state.length];
+    for (int i = 0; i < state.length; i++) {
+      newState[i] = state[i].rewrittenWithLens(appView, lens);
+    }
+    return new EnumValuesObjectState(newState);
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (getClass() != o.getClass()) {
+      return false;
+    }
+    EnumValuesObjectState other = (EnumValuesObjectState) o;
+    if (state.length != other.state.length) {
+      return false;
+    }
+    for (int i = 0; i < state.length; i++) {
+      if (!state[i].equals(other.state[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    return Arrays.hashCode(state);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/ObjectState.java b/src/main/java/com/android/tools/r8/ir/analysis/value/ObjectState.java
index b724858..4e6d970 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/ObjectState.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/ObjectState.java
@@ -35,6 +35,14 @@
   @Override
   public abstract int hashCode();
 
+  public boolean isEnumValuesObjectState() {
+    return false;
+  }
+
+  public EnumValuesObjectState asEnumValuesObjectState() {
+    return null;
+  }
+
   public static class Builder {
 
     private final Map<DexField, AbstractValue> state = new IdentityHashMap<>();
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java b/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java
index 0cb75c3..98a7fa4 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java
@@ -50,6 +50,10 @@
     return value;
   }
 
+  public int getIntValue() {
+    return (int) value;
+  }
+
   @Override
   public boolean equals(Object o) {
     return this == o;
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
index 806917c..f2da1ac 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
@@ -457,7 +457,7 @@
   private static RewrittenPrototypeDescription lookupPrototypeChanges(
       AppView<?> appView, ProgramMethod method) {
     RewrittenPrototypeDescription prototypeChanges =
-        appView.graphLens().lookupPrototypeChanges(method.getReference());
+        appView.graphLens().lookupPrototypeChangesForMethodDefinition(method.getReference());
     if (Log.ENABLED && prototypeChanges.getArgumentInfoCollection().hasRemovedArguments()) {
       Log.info(
           IRBuilder.class,
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 61a2f18..4c10624 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
@@ -470,12 +470,12 @@
     }
   }
 
-  public DexApplication convert(DexApplication application, ExecutorService executor)
+  public void convert(AppView<AppInfo> appView, ExecutorService executor)
       throws ExecutionException {
     removeLambdaDeserializationMethods();
     workaroundAbstractMethodOnNonAbstractClassVerificationBug(
         executor, OptimizationFeedbackIgnore.getInstance());
-
+    DexApplication application = appView.appInfo().app();
     timing.begin("IR conversion");
     ThreadUtils.processItems(application.classes(), this::convertMethods, executor);
 
@@ -496,7 +496,8 @@
     handleSynthesizedClassMapping(builder);
     timing.end();
 
-    return builder.build();
+    DexApplication app = builder.build();
+    appView.setAppInfo(new AppInfo(app, appView.appInfo().getSyntheticItems().commit(app)));
   }
 
   private void handleSynthesizedClassMapping(Builder<?> builder) {
@@ -738,7 +739,6 @@
       postMethodProcessorBuilder.put(inliner);
     }
     if (enumUnboxer != null) {
-      enumUnboxer.finishAnalysis();
       enumUnboxer.unboxEnums(postMethodProcessorBuilder, executorService, feedback);
     }
     if (!options.debug) {
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 bd8ba8d..51905bf 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
@@ -227,8 +227,7 @@
               DexMethod actualTarget = lensLookup.getMethod();
               Invoke.Type actualInvokeType = lensLookup.getType();
               if (actualTarget != invokedMethod || invoke.getType() != actualInvokeType) {
-                RewrittenPrototypeDescription prototypeChanges =
-                    graphLens.lookupPrototypeChanges(actualTarget);
+                RewrittenPrototypeDescription prototypeChanges = lensLookup.getPrototypeChanges();
 
                 List<Value> newInValues;
                 ArgumentInfoCollection argumentInfoCollection =
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 88f6f04..2167964 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
@@ -265,9 +265,13 @@
                 // On pre-L devices static calls to interface methods result in verifier
                 // rejecting the whole class. We have to create special dispatch classes,
                 // so the user class is not rejected because it make this call directly.
+                // TODO(b/166247515): If this an incorrect invoke-static without the interface bit
+                //  we end up "fixing" the code and remove and ICCE error.
                 instructions.replaceCurrentInstruction(
-                    new InvokeStatic(staticAsMethodOfDispatchClass(method),
-                        invokeStatic.outValue(), invokeStatic.arguments()));
+                    new InvokeStatic(
+                        staticAsMethodOfDispatchClass(method),
+                        invokeStatic.outValue(),
+                        invokeStatic.arguments()));
                 requiredDispatchClasses
                     .computeIfAbsent(clazz.asLibraryClass(), k -> Sets.newConcurrentHashSet())
                     .add(appInfo.definitionFor(encodedMethod.holder()).asProgramClass());
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
index 5a50c02..f400369 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
@@ -259,10 +259,13 @@
       DexMethod newMethod = rewriter.staticAsMethodOfDispatchClass(origMethod);
       ForwardMethodSourceCode.Builder forwardSourceCodeBuilder =
           ForwardMethodSourceCode.builder(newMethod);
+      // Create a forwarding method to the library static interface method. The method is added
+      // to the dispatch class, however, the targeted method is still on the interface, so the
+      // interface bit should be set to true.
       forwardSourceCodeBuilder
           .setTarget(origMethod)
           .setInvokeType(Type.STATIC)
-          .setIsInterface(false); // We forward to the Companion class, not an interface.
+          .setIsInterface(true);
       DexEncodedMethod newEncodedMethod =
           new DexEncodedMethod(
               newMethod,
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
index 605397a..8deb4fc 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
@@ -10,7 +10,6 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.ClassAccessFlags;
 import com.android.tools.r8.graph.DexAnnotationSet;
-import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexField;
@@ -34,7 +33,6 @@
 import com.android.tools.r8.ir.synthetic.ForwardMethodSourceCode;
 import com.android.tools.r8.ir.synthetic.SynthesizedCode;
 import com.android.tools.r8.origin.SynthesizedOrigin;
-import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.OptionalBool;
 import com.google.common.base.Suppliers;
 import com.google.common.primitives.Longs;
@@ -541,18 +539,8 @@
       return accessibilityBridge;
     }
 
-    boolean holderIsInterface() {
-      InternalOptions options = appView.options();
-      DexMethod implMethod = descriptor.implHandle.asMethod();
-      DexClass implMethodHolder = appView.definitionFor(implMethod.holder);
-      if (implMethodHolder == null) {
-        assert options
-            .desugaredLibraryConfiguration
-            .getBackportCoreLibraryMember()
-            .containsKey(implMethod.holder);
-        return false;
-      }
-      return implMethodHolder.isInterface();
+    boolean isInterface() {
+      return descriptor.implHandle.isInterface;
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java
index 0d996d5..ac55e68 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java
@@ -243,7 +243,7 @@
                 methodToCall.proto,
                 argValueTypes,
                 argRegisters,
-                target.holderIsInterface()));
+                target.isInterface()));
 
     // Does the method have return value?
     if (enforcedReturnType.isVoidType()) {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/NestedPrivateMethodLens.java b/src/main/java/com/android/tools/r8/ir/desugar/NestedPrivateMethodLens.java
index e7c0b77..9e429a4 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/NestedPrivateMethodLens.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/NestedPrivateMethodLens.java
@@ -98,33 +98,36 @@
   }
 
   @Override
-  public RewrittenPrototypeDescription lookupPrototypeChanges(DexMethod method) {
+  protected RewrittenPrototypeDescription internalDescribePrototypeChanges(
+      RewrittenPrototypeDescription prototypeChanges, DexMethod method) {
     if (isConstructorBridge(method)) {
       // TODO (b/132767654): Try to write a test which breaks that assertion.
-      assert previousLens.lookupPrototypeChanges(method).isEmpty();
+      assert prototypeChanges.isEmpty();
       // TODO(b/164901008): Fix when the number of arguments overflows.
       return RewrittenPrototypeDescription.none().withExtraUnusedNullParameter();
-    } else {
-      return previousLens.lookupPrototypeChanges(method);
     }
+    return prototypeChanges;
   }
 
   @Override
   public GraphLensLookupResult lookupMethod(DexMethod method, DexMethod context, Invoke.Type type) {
     assert originalMethodSignatures == null;
-    GraphLensLookupResult previous = previousLens.lookupMethod(method, context, type);
-    DexMethod bridge = methodMap.get(previous.getMethod());
+    GraphLensLookupResult lookup = previousLens.lookupMethod(method, context, type);
+    DexMethod bridge = methodMap.get(lookup.getMethod());
     if (bridge == null) {
-      return previous;
+      return lookup;
     }
     assert context != null : "Guaranteed by isContextFreeForMethod";
     if (bridge.holder == context.holder) {
-      return previous;
+      return lookup;
     }
     if (isConstructorBridge(bridge)) {
-      return new GraphLensLookupResult(bridge, Invoke.Type.DIRECT);
+      return new GraphLensLookupResult(
+          bridge,
+          Invoke.Type.DIRECT,
+          internalDescribePrototypeChanges(lookup.getPrototypeChanges(), bridge));
     }
-    return new GraphLensLookupResult(bridge, Invoke.Type.STATIC);
+    return new GraphLensLookupResult(bridge, Invoke.Type.STATIC, lookup.getPrototypeChanges());
   }
 
   public static Builder builder() {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java b/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java
index 885a1d0..96e5e9c 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java
@@ -70,21 +70,18 @@
     }
 
     @Override
-    public RewrittenPrototypeDescription lookupPrototypeChanges(DexMethod method) {
-      DexMethod originalMethod = originalMethodSignatures.getOrDefault(method, method);
-      RewrittenPrototypeDescription result = previousLens.lookupPrototypeChanges(originalMethod);
-      if (originalMethod != method) {
-        if (method.proto.returnType.isVoidType() && !originalMethod.proto.returnType.isVoidType()) {
-          result = result.withConstantReturn(originalMethod.proto.returnType, appView);
-        }
-        ArgumentInfoCollection removedArgumentsInfo = removedArgumentsInfoPerMethod.get(method);
-        if (removedArgumentsInfo != null) {
-          result = result.withRemovedArguments(removedArgumentsInfo);
-        }
-      } else {
+    protected RewrittenPrototypeDescription internalDescribePrototypeChanges(
+        RewrittenPrototypeDescription prototypeChanges, DexMethod method) {
+      DexMethod previous = internalGetPreviousMethodSignature(method);
+      if (previous == method) {
         assert !removedArgumentsInfoPerMethod.containsKey(method);
+        return prototypeChanges;
       }
-      return result;
+      if (method.getReturnType().isVoidType() && !previous.getReturnType().isVoidType()) {
+        prototypeChanges = prototypeChanges.withConstantReturn(previous.getReturnType(), appView);
+      }
+      return prototypeChanges.withRemovedArguments(
+          removedArgumentsInfoPerMethod.getOrDefault(method, ArgumentInfoCollection.empty()));
     }
   }
 
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 e6bd21e..0dd84e7 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
@@ -76,14 +76,10 @@
     }
 
     @Override
-    public RewrittenPrototypeDescription lookupPrototypeChanges(DexMethod method) {
-      DexMethod originalMethod =
-          originalMethodSignatures != null
-              ? originalMethodSignatures.getOrDefault(method, method)
-              : method;
-      RewrittenPrototypeDescription result = previousLens.lookupPrototypeChanges(originalMethod);
-      ArgumentInfoCollection removedArguments = this.removedArguments.get(method);
-      return removedArguments != null ? result.withRemovedArguments(removedArguments) : result;
+    protected RewrittenPrototypeDescription internalDescribePrototypeChanges(
+        RewrittenPrototypeDescription prototypeChanges, DexMethod method) {
+      return prototypeChanges.withRemovedArguments(
+          removedArguments.getOrDefault(method, ArgumentInfoCollection.empty()));
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumInstanceFieldData.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumInstanceFieldData.java
new file mode 100644
index 0000000..4f4dea9
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumInstanceFieldData.java
@@ -0,0 +1,111 @@
+// 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.enums;
+
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import java.util.Map;
+
+/*
+ * My instances represent the values of an enum field for each of the enum instance.
+ * For example:
+ * <code> enum E {
+ *  A(10),B(20);
+ *  int f;
+ *  public E(int f) {
+ *     this.f = f;
+ *   }
+ * }</code>
+ * <p> The EnumFieldData for the field E#f is A -> 10, B -> 20.
+ * The EnumFieldData may be unknown, for example, if the enum fields are not set with constants.
+ */
+public abstract class EnumInstanceFieldData {
+
+  public abstract boolean isUnknown();
+
+  public boolean isKnown() {
+    return !isUnknown();
+  }
+
+  public EnumInstanceFieldKnownData asEnumFieldKnownData() {
+    return null;
+  }
+
+  public static class EnumInstanceFieldUnknownData extends EnumInstanceFieldData {
+
+    private static final EnumInstanceFieldUnknownData INSTANCE = new EnumInstanceFieldUnknownData();
+
+    public static EnumInstanceFieldUnknownData getInstance() {
+      return INSTANCE;
+    }
+
+    private EnumInstanceFieldUnknownData() {}
+
+    @Override
+    public boolean isUnknown() {
+      return true;
+    }
+  }
+
+  public abstract static class EnumInstanceFieldKnownData extends EnumInstanceFieldData {
+
+    @Override
+    public boolean isUnknown() {
+      return false;
+    }
+
+    public abstract boolean isOrdinal();
+
+    public abstract boolean isMapping();
+
+    @Override
+    public EnumInstanceFieldKnownData asEnumFieldKnownData() {
+      return this;
+    }
+
+    public EnumInstanceFieldMappingData asEnumFieldMappingData() {
+      return null;
+    }
+  }
+
+  public static class EnumInstanceFieldOrdinalData extends EnumInstanceFieldKnownData {
+    @Override
+    public boolean isOrdinal() {
+      return true;
+    }
+
+    @Override
+    public boolean isMapping() {
+      return false;
+    }
+  }
+
+  public static class EnumInstanceFieldMappingData extends EnumInstanceFieldKnownData {
+    private final Map<DexField, AbstractValue> mapping;
+
+    public EnumInstanceFieldMappingData(Map<DexField, AbstractValue> mapping) {
+      this.mapping = mapping;
+    }
+
+    @Override
+    public boolean isOrdinal() {
+      return false;
+    }
+
+    @Override
+    public boolean isMapping() {
+      return true;
+    }
+
+    @Override
+    public EnumInstanceFieldMappingData asEnumFieldMappingData() {
+      return this;
+    }
+
+    public AbstractValue getData(DexField field) {
+      return mapping.get(field);
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumInstanceFieldDataMap.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumInstanceFieldDataMap.java
new file mode 100644
index 0000000..f02e488
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumInstanceFieldDataMap.java
@@ -0,0 +1,27 @@
+// 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.enums;
+
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.optimize.enums.EnumInstanceFieldData.EnumInstanceFieldKnownData;
+import com.google.common.collect.ImmutableMap;
+
+public class EnumInstanceFieldDataMap {
+  private final ImmutableMap<DexType, ImmutableMap<DexField, EnumInstanceFieldKnownData>>
+      instanceFieldMap;
+
+  public EnumInstanceFieldDataMap(
+      ImmutableMap<DexType, ImmutableMap<DexField, EnumInstanceFieldKnownData>> instanceFieldMap) {
+    this.instanceFieldMap = instanceFieldMap;
+  }
+
+  public EnumInstanceFieldKnownData getInstanceFieldData(
+      DexType enumType, DexField enumInstanceField) {
+    assert instanceFieldMap.containsKey(enumType);
+    assert instanceFieldMap.get(enumType).containsKey(enumInstanceField);
+    return instanceFieldMap.get(enumType).get(enumInstanceField);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
index 3f910f5..12b42aa 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
@@ -30,6 +30,7 @@
 import com.android.tools.r8.graph.DexValue.DexValueInt;
 import com.android.tools.r8.graph.DexValue.DexValueNull;
 import com.android.tools.r8.graph.DirectMappedDexApplication;
+import com.android.tools.r8.graph.EnumValueInfoMapCollection;
 import com.android.tools.r8.graph.FieldResolutionResult;
 import com.android.tools.r8.graph.GraphLens;
 import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
@@ -42,6 +43,8 @@
 import com.android.tools.r8.ir.analysis.type.ArrayTypeElement;
 import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.analysis.value.ObjectState;
 import com.android.tools.r8.ir.code.ArrayPut;
 import com.android.tools.r8.ir.code.BasicBlock;
 import com.android.tools.r8.ir.code.CheckCast;
@@ -49,6 +52,7 @@
 import com.android.tools.r8.ir.code.FieldInstruction;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.If;
+import com.android.tools.r8.ir.code.InstanceGet;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.Invoke;
 import com.android.tools.r8.ir.code.InvokeMethod;
@@ -62,6 +66,10 @@
 import com.android.tools.r8.ir.conversion.PostMethodProcessor;
 import com.android.tools.r8.ir.conversion.PostOptimization;
 import com.android.tools.r8.ir.optimize.Inliner.Constraint;
+import com.android.tools.r8.ir.optimize.enums.EnumInstanceFieldData.EnumInstanceFieldKnownData;
+import com.android.tools.r8.ir.optimize.enums.EnumInstanceFieldData.EnumInstanceFieldMappingData;
+import com.android.tools.r8.ir.optimize.enums.EnumInstanceFieldData.EnumInstanceFieldOrdinalData;
+import com.android.tools.r8.ir.optimize.enums.EnumInstanceFieldData.EnumInstanceFieldUnknownData;
 import com.android.tools.r8.ir.optimize.info.FieldOptimizationInfo;
 import com.android.tools.r8.ir.optimize.info.MethodOptimizationInfo;
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedback.OptimizationInfoFixer;
@@ -69,6 +77,7 @@
 import com.android.tools.r8.origin.SynthesizedOrigin;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.OptionalBool;
 import com.android.tools.r8.utils.Reporter;
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.android.tools.r8.utils.collections.ProgramMethodSet;
@@ -97,6 +106,8 @@
   // Map the enum candidates with their dependencies, i.e., the methods to reprocess for the given
   // enum if the optimization eventually decides to unbox it.
   private final Map<DexType, ProgramMethodSet> enumsUnboxingCandidates;
+  private final Map<DexType, Set<DexField>> requiredEnumInstanceFieldData =
+      new ConcurrentHashMap<>();
   private final Set<DexType> enumsToUnboxWithPackageRequirement = Sets.newIdentityHashSet();
 
   private EnumUnboxingRewriter enumUnboxerRewriter;
@@ -118,6 +129,12 @@
     enumsUnboxingCandidates = new EnumUnboxingCandidateAnalysis(appView, this).findCandidates();
   }
 
+  private void requiredEnumInstanceFieldData(DexType enumType, DexField field) {
+    requiredEnumInstanceFieldData
+        .computeIfAbsent(enumType, ignored -> Sets.newConcurrentHashSet())
+        .add(field);
+  }
+
   private void markEnumAsUnboxable(Reason reason, DexProgramClass enumClass) {
     assert enumClass.isEnum();
     reportFailure(enumClass.type, reason);
@@ -268,27 +285,30 @@
     // We are using the ConstClass of an enum, which typically means the enum cannot be unboxed.
     // We however allow unboxing if the ConstClass is only used as an argument to Enum#valueOf, to
     // allow unboxing of: MyEnum a = Enum.valueOf(MyEnum.class, "A");.
-    if (!enumsUnboxingCandidates.containsKey(constClass.getValue())) {
+    DexType enumType = constClass.getValue();
+    if (!enumsUnboxingCandidates.containsKey(enumType)) {
       return;
     }
     if (constClass.outValue() == null) {
-      eligibleEnums.add(constClass.getValue());
+      eligibleEnums.add(enumType);
       return;
     }
+    DexProgramClass enumClass = appView.definitionFor(enumType).asProgramClass();
     if (constClass.outValue().hasPhiUsers()) {
-      markEnumAsUnboxable(
-          Reason.CONST_CLASS, appView.definitionForProgramType(constClass.getValue()));
+      markEnumAsUnboxable(Reason.CONST_CLASS, enumClass);
       return;
     }
     for (Instruction user : constClass.outValue().uniqueUsers()) {
       if (!(user.isInvokeStatic()
           && user.asInvokeStatic().getInvokedMethod() == factory.enumMembers.valueOf)) {
-        markEnumAsUnboxable(
-            Reason.CONST_CLASS, appView.definitionForProgramType(constClass.getValue()));
+        markEnumAsUnboxable(Reason.CONST_CLASS, enumClass);
         return;
       }
     }
-    eligibleEnums.add(constClass.getValue());
+    // The name data is required for the correct mapping from the enum name to the ordinal in the
+    // valueOf utility method.
+    requiredEnumInstanceFieldData(enumType, factory.enumMembers.nameField);
+    eligibleEnums.add(enumType);
   }
 
   private void addNullDependencies(IRCode code, Set<Instruction> uses, Set<DexType> eligibleEnums) {
@@ -345,6 +365,7 @@
       ExecutorService executorService,
       OptimizationFeedbackDelayed feedback)
       throws ExecutionException {
+    EnumInstanceFieldDataMap enumInstanceFieldDataMap = finishAnalysis();
     // At this point the enumsToUnbox are no longer candidates, they will all be unboxed.
     if (enumsUnboxingCandidates.isEmpty()) {
       return;
@@ -352,7 +373,7 @@
     ImmutableSet<DexType> enumsToUnbox = ImmutableSet.copyOf(this.enumsUnboxingCandidates.keySet());
     // Update keep info on any of the enum methods of the removed classes.
     updatePinnedItems(enumsToUnbox);
-    enumUnboxerRewriter = new EnumUnboxingRewriter(appView, enumsToUnbox);
+    enumUnboxerRewriter = new EnumUnboxingRewriter(appView, enumsToUnbox, enumInstanceFieldDataMap);
     DirectMappedDexApplication.Builder appBuilder = appView.appInfo().app().asDirect().builder();
     Map<DexType, DexType> newMethodLocation = synthesizeUnboxedEnumsMethodsLocations(appBuilder);
     NestedGraphLens enumUnboxingLens =
@@ -475,12 +496,38 @@
             });
   }
 
-  public void finishAnalysis() {
+  public EnumInstanceFieldDataMap finishAnalysis() {
     analyzeInitializers();
     analyzeAccessibility();
+    EnumInstanceFieldDataMap enumInstanceFieldDataMap = analyzeFields();
     if (debugLogEnabled) {
       reportEnumsAnalysis();
     }
+    return enumInstanceFieldDataMap;
+  }
+
+  private EnumInstanceFieldDataMap analyzeFields() {
+    ImmutableMap.Builder<DexType, ImmutableMap<DexField, EnumInstanceFieldKnownData>> builder =
+        ImmutableMap.builder();
+    requiredEnumInstanceFieldData.forEach(
+        (enumType, fields) -> {
+          ImmutableMap.Builder<DexField, EnumInstanceFieldKnownData> typeBuilder =
+              ImmutableMap.builder();
+          if (enumsUnboxingCandidates.containsKey(enumType)) {
+            DexProgramClass enumClass = appView.definitionFor(enumType).asProgramClass();
+            assert enumClass != null;
+            for (DexField field : fields) {
+              EnumInstanceFieldData enumInstanceFieldData = computeEnumFieldData(field, enumClass);
+              if (enumInstanceFieldData.isUnknown()) {
+                markEnumAsUnboxable(Reason.MISSING_INSTANCE_FIELD_DATA, enumClass);
+                return;
+              }
+              typeBuilder.put(field, enumInstanceFieldData.asEnumFieldKnownData());
+            }
+            builder.put(enumType, typeBuilder.build());
+          }
+        });
+    return new EnumInstanceFieldDataMap(builder.build());
   }
 
   private void analyzeAccessibility() {
@@ -721,20 +768,26 @@
       DexProgramClass enumClass = appView.definitionForProgramType(toUnbox);
       assert enumClass != null;
 
-      // Enum candidates have necessarily only one constructor matching enumMethods.constructor
-      // signature.
-      DexEncodedMethod initializer = enumClass.lookupDirectMethod(factory.enumMembers.constructor);
-      if (initializer == null) {
+      boolean hasInstanceInitializer = false;
+      for (DexEncodedMethod directMethod : enumClass.directMethods()) {
+        if (directMethod.isInstanceInitializer()) {
+          hasInstanceInitializer = true;
+          if (directMethod
+              .getOptimizationInfo()
+              .getInstanceInitializerInfo()
+              .mayHaveOtherSideEffectsThanInstanceFieldAssignments()) {
+            markEnumAsUnboxable(Reason.INVALID_INIT, enumClass);
+            break;
+          }
+        }
+      }
+      if (!hasInstanceInitializer) {
         // This case typically happens when a programmer uses EnumSet/EnumMap without using the
         // enum keep rules. The code is incorrect in this case (EnumSet/EnumMap won't work).
         // We bail out.
         markEnumAsUnboxable(Reason.NO_INIT, enumClass);
         continue;
       }
-      if (initializer.getOptimizationInfo().mayHaveSideEffects()) {
-        markEnumAsUnboxable(Reason.INVALID_INIT, enumClass);
-        continue;
-      }
 
       if (enumClass.classInitializationMayHaveSideEffects(appView)) {
         markEnumAsUnboxable(Reason.INVALID_CLINIT, enumClass);
@@ -798,6 +851,10 @@
       }
       assert dexClass.isLibraryClass();
       if (dexClass.type != factory.enumType) {
+        // System.identityHashCode(Object) is supported for proto enums.
+        if (singleTarget == factory.javaLangSystemMethods.identityHashCode) {
+          return Reason.ELIGIBLE;
+        }
         return Reason.UNSUPPORTED_LIBRARY_CALL;
       }
       // TODO(b/147860220): EnumSet and EnumMap may be interesting to model.
@@ -805,9 +862,10 @@
         return Reason.ELIGIBLE;
       } else if (singleTarget == factory.enumMembers.equals) {
         return Reason.ELIGIBLE;
-      } else if (singleTarget == factory.enumMembers.nameMethod) {
-        return Reason.ELIGIBLE;
-      } else if (singleTarget == factory.enumMembers.toString) {
+      } else if (singleTarget == factory.enumMembers.nameMethod
+          || singleTarget == factory.enumMembers.toString) {
+        assert invokeMethod.asInvokeMethodWithReceiver().getReceiver() == enumValue;
+        requiredEnumInstanceFieldData(enumClass.type, factory.enumMembers.nameField);
         return Reason.ELIGIBLE;
       } else if (singleTarget == factory.enumMembers.ordinalMethod) {
         return Reason.ELIGIBLE;
@@ -837,6 +895,10 @@
       if (dexClass == null) {
         return Reason.INVALID_FIELD_PUT;
       }
+      if (fieldInstruction.isInstancePut()
+          && fieldInstruction.asInstancePut().object() == enumValue) {
+        return Reason.ELIGIBLE;
+      }
       // The put value has to be of the field type.
       if (field.field.type.toBaseType(factory) != enumClass.type) {
         return Reason.TYPE_MISMATCH_FIELD_PUT;
@@ -844,6 +906,14 @@
       return Reason.ELIGIBLE;
     }
 
+    if (instruction.isInstanceGet()) {
+      InstanceGet instanceGet = instruction.asInstanceGet();
+      assert instanceGet.getField().holder == enumClass.type;
+      DexField field = instanceGet.getField();
+      requiredEnumInstanceFieldData(enumClass.type, field);
+      return Reason.ELIGIBLE;
+    }
+
     // An If using enum as inValue is valid if it matches e == null
     // or e == X with X of same enum type as e. Ex: if (e == MyEnum.A).
     if (instruction.isIf()) {
@@ -923,6 +993,89 @@
     return Reason.OTHER_UNSUPPORTED_INSTRUCTION;
   }
 
+  private EnumInstanceFieldData computeEnumFieldData(
+      DexField instanceField, DexProgramClass enumClass) {
+    DexEncodedField encodedInstanceField =
+        appView.appInfo().resolveFieldOn(enumClass, instanceField).getResolvedField();
+    assert encodedInstanceField != null;
+    boolean canBeOrdinal = instanceField.type.isIntType();
+    Map<DexField, AbstractValue> data = new IdentityHashMap<>();
+    EnumValueInfoMapCollection.EnumValueInfoMap enumValueInfoMap =
+        appView.appInfo().getEnumValueInfoMap(enumClass.type);
+    for (DexField staticField : enumValueInfoMap.enumValues()) {
+      ObjectState enumInstanceState =
+          computeEnumInstanceObjectState(enumClass, staticField, enumValueInfoMap);
+      if (enumInstanceState == null) {
+        // The enum instance is effectively unused. No need to generate anything for it, the path
+        // will never be taken.
+      } else {
+        AbstractValue fieldValue = enumInstanceState.getAbstractFieldValue(encodedInstanceField);
+        if (!(fieldValue.isSingleNumberValue() || fieldValue.isSingleStringValue())) {
+          return EnumInstanceFieldUnknownData.getInstance();
+        }
+        data.put(staticField, fieldValue);
+        if (canBeOrdinal) {
+          int ordinalValue = enumValueInfoMap.getEnumValueInfo(staticField).ordinal;
+          assert fieldValue.isSingleNumberValue();
+          int computedValue = fieldValue.asSingleNumberValue().getIntValue();
+          if (computedValue != ordinalValue) {
+            canBeOrdinal = false;
+          }
+        }
+      }
+    }
+    if (canBeOrdinal) {
+      return new EnumInstanceFieldOrdinalData();
+    }
+    return new EnumInstanceFieldMappingData(data);
+  }
+
+  // We need to access the enum instance object state to figure out if it contains known constant
+  // field values. The enum instance may be accessed in two ways, directly through the enum
+  // static field, or through the enum $VALUES field. If none of them are kept, the instance is
+  // effectively unused. The object state may be stored in the enum static field optimization
+  // info, if kept, or in the $VALUES optimization info, if kept.
+  // If the enum instance is unused, this method answers null.
+  private ObjectState computeEnumInstanceObjectState(
+      DexProgramClass enumClass,
+      DexField staticField,
+      EnumValueInfoMapCollection.EnumValueInfoMap enumValueInfoMap) {
+    // Attempt 1: Get object state from the instance field's optimization info.
+    DexEncodedField encodedStaticField = enumClass.lookupStaticField(staticField);
+    AbstractValue enumInstanceValue = encodedStaticField.getOptimizationInfo().getAbstractValue();
+    if (enumInstanceValue.isSingleFieldValue()) {
+      return enumInstanceValue.asSingleFieldValue().getState();
+    }
+    if (enumInstanceValue.isUnknown()) {
+      return ObjectState.empty();
+    }
+    assert enumInstanceValue.isZero();
+
+    // Attempt 2: Get object state from the values field's optimization info.
+    DexEncodedField valuesField =
+        enumClass.lookupStaticField(
+            factory.createField(
+                enumClass.type,
+                factory.createArrayType(1, enumClass.type),
+                factory.enumValuesFieldName));
+    AbstractValue valuesValue = valuesField.getOptimizationInfo().getAbstractValue();
+    if (valuesValue.isZero()) {
+      // Unused enum instance.
+      return null;
+    }
+    if (valuesValue.isUnknown()) {
+      return ObjectState.empty();
+    }
+    assert valuesValue.isSingleFieldValue();
+    ObjectState valuesState = valuesValue.asSingleFieldValue().getState();
+    if (valuesState.isEnumValuesObjectState()) {
+      return valuesState
+          .asEnumValuesObjectState()
+          .getObjectStateForOrdinal(enumValueInfoMap.getEnumValueInfo(staticField).ordinal);
+    }
+    return ObjectState.empty();
+  }
+
   private boolean isFirstInstructionAfterArguments(InvokeMethod invokeMethod, IRCode code) {
     BasicBlock basicBlock = code.entryBlock();
     for (Instruction instruction : basicBlock.getInstructions()) {
@@ -1000,7 +1153,7 @@
     DOWN_CAST,
     SUBTYPES,
     INTERFACE,
-    INSTANCE_FIELD,
+    MANY_INSTANCE_FIELDS,
     GENERIC_INVOKE,
     DEFAULT_METHOD_INVOKE,
     UNEXPECTED_STATIC_FIELD,
@@ -1018,6 +1171,8 @@
     COMPARE_TO_INVOKE,
     UNSUPPORTED_LIBRARY_CALL,
     MISSING_INFO_MAP,
+    MISSING_INSTANCE_FIELD_DATA,
+    INVALID_FIELD_READ,
     INVALID_FIELD_PUT,
     INVALID_ARRAY_PUT,
     FIELD_PUT_ON_ENUM,
@@ -1044,7 +1199,6 @@
       // Fix all methods and fields using enums to unbox.
       for (DexProgramClass clazz : appView.appInfo().classes()) {
         if (enumsToUnbox.contains(clazz.type)) {
-          assert clazz.instanceFields().size() == 0;
           // Clear the initializers and move the static methods to the new location.
           Set<DexEncodedMethod> methodsToRemove = Sets.newIdentityHashSet();
           clazz
@@ -1123,14 +1277,23 @@
         return encodedMethod;
       }
       assert !encodedMethod.isClassInitializer();
-      DexMethod newMethod =
-          factory.createMethod(encodedMethod.holder(), newProto, encodedMethod.getName());
+      // We add the $enumunboxing$ suffix to make sure we do not create a library override.
+      String newMethodName =
+          encodedMethod.getName().toString()
+              + (encodedMethod.isNonPrivateVirtualMethod() ? "$enumunboxing$" : "");
+      DexMethod newMethod = factory.createMethod(encodedMethod.holder(), newProto, newMethodName);
       newMethod = ensureUniqueMethod(encodedMethod, newMethod);
       int numberOfExtraNullParameters = newMethod.getArity() - encodedMethod.method.getArity();
       boolean isStatic = encodedMethod.isStatic();
       lensBuilder.move(
           encodedMethod.method, isStatic, newMethod, isStatic, numberOfExtraNullParameters);
-      return encodedMethod.toTypeSubstitutedMethod(newMethod);
+      DexEncodedMethod newEncodedMethod = encodedMethod.toTypeSubstitutedMethod(newMethod);
+      assert !encodedMethod.isLibraryMethodOverride().isTrue()
+          : "Enum unboxing is changing the signature of a library override in a non unboxed class.";
+      if (newEncodedMethod.isNonPrivateVirtualMethod()) {
+        newEncodedMethod.setLibraryMethodOverride(OptionalBool.FALSE);
+      }
+      return newEncodedMethod;
     }
 
     private DexMethod ensureUniqueMethod(DexEncodedMethod encodedMethod, DexMethod newMethod) {
@@ -1213,7 +1376,7 @@
 
   private static class EnumUnboxingLens extends NestedGraphLens {
 
-    private final Map<DexMethod, RewrittenPrototypeDescription> prototypeChanges;
+    private final Map<DexMethod, RewrittenPrototypeDescription> prototypeChangesPerMethod;
     private final Set<DexType> unboxedEnums;
 
     EnumUnboxingLens(
@@ -1224,7 +1387,7 @@
         BiMap<DexMethod, DexMethod> originalMethodSignatures,
         GraphLens previousLens,
         DexItemFactory dexItemFactory,
-        Map<DexMethod, RewrittenPrototypeDescription> prototypeChanges,
+        Map<DexMethod, RewrittenPrototypeDescription> prototypeChangesPerMethod,
         Set<DexType> unboxedEnums) {
       super(
           typeMap,
@@ -1234,17 +1397,18 @@
           originalMethodSignatures,
           previousLens,
           dexItemFactory);
-      this.prototypeChanges = prototypeChanges;
+      this.prototypeChangesPerMethod = prototypeChangesPerMethod;
       this.unboxedEnums = unboxedEnums;
     }
 
     @Override
-    public RewrittenPrototypeDescription lookupPrototypeChanges(DexMethod method) {
+    protected RewrittenPrototypeDescription internalDescribePrototypeChanges(
+        RewrittenPrototypeDescription prototypeChanges, DexMethod method) {
       // During the second IR processing enum unboxing is the only optimization rewriting
       // prototype description, if this does not hold, remove the assertion and merge
       // the two prototype changes.
-      assert previousLens.lookupPrototypeChanges(method).isEmpty();
-      return prototypeChanges.getOrDefault(method, RewrittenPrototypeDescription.none());
+      assert prototypeChanges.isEmpty();
+      return prototypeChangesPerMethod.getOrDefault(method, RewrittenPrototypeDescription.none());
     }
 
     @Override
@@ -1264,7 +1428,7 @@
 
     private static class Builder extends NestedGraphLens.Builder {
 
-      private Map<DexMethod, RewrittenPrototypeDescription> prototypeChanges =
+      private Map<DexMethod, RewrittenPrototypeDescription> prototypeChangesPerMethod =
           new IdentityHashMap<>();
 
       public void move(DexMethod from, boolean fromStatic, DexMethod to, boolean toStatic) {
@@ -1299,7 +1463,7 @@
             from.proto.returnType == to.proto.returnType
                 ? null
                 : new RewrittenTypeInfo(from.proto.returnType, to.proto.returnType);
-        prototypeChanges.put(
+        prototypeChangesPerMethod.put(
             to,
             RewrittenPrototypeDescription.createForRewrittenTypes(returnInfo, builder.build())
                 .withExtraUnusedNullParameters(numberOfExtraNullParameters));
@@ -1318,7 +1482,7 @@
             originalMethodSignatures,
             previousLens,
             dexItemFactory,
-            ImmutableMap.copyOf(prototypeChanges),
+            ImmutableMap.copyOf(prototypeChangesPerMethod),
             ImmutableSet.copyOf(unboxedEnums));
       }
     }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java
index c4a6bb4..b5a5b62 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java
@@ -22,6 +22,11 @@
 
 class EnumUnboxingCandidateAnalysis {
 
+  // Each time we unbox an enum with instance fields, we need to generate a method with a
+  // switch case to dispatch from the enum to the instance field value. We introduce this heuristic
+  // to avoid unboxing enums with too many instance fields.
+  private static final int MAX_INSTANCE_FIELDS_FOR_UNBOXING = 7;
+
   private final AppView<AppInfoWithLiveness> appView;
   private final EnumUnboxer enumUnboxer;
   private final DexItemFactory factory;
@@ -55,8 +60,8 @@
       enumUnboxer.reportFailure(clazz.type, Reason.SUBTYPES);
       return false;
     }
-    if (!clazz.instanceFields().isEmpty()) {
-      enumUnboxer.reportFailure(clazz.type, Reason.INSTANCE_FIELD);
+    if (clazz.instanceFields().size() > MAX_INSTANCE_FIELDS_FOR_UNBOXING) {
+      enumUnboxer.reportFailure(clazz.type, Reason.MANY_INSTANCE_FIELDS);
       return false;
     }
     if (!enumHasBasicStaticFields(clazz)) {
@@ -69,23 +74,9 @@
       enumUnboxer.reportFailure(clazz.type, Reason.MISSING_INFO_MAP);
       return false;
     }
-
-    // TODO(b/155036467): Fail lazily when an unsupported method is not only present but also used.
-    // Only Enums with default initializers and static methods can be unboxed at the moment.
-    for (DexEncodedMethod directMethod : clazz.directMethods()) {
-      if (directMethod.isInstanceInitializer() && !isStandardEnumInitializer(directMethod)) {
-        enumUnboxer.reportFailure(clazz.type, Reason.INVALID_INIT);
-        return false;
-      }
-    }
     return true;
   }
 
-  private boolean isStandardEnumInitializer(DexEncodedMethod method) {
-    return method.isInstanceInitializer()
-        && method.method.proto == factory.enumMembers.constructor.proto;
-  }
-
   // The enum should have the $VALUES static field and only fields directly referencing the enum
   // instances.
   private boolean enumHasBasicStaticFields(DexProgramClass clazz) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
index 087e808..54d9aaf 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
@@ -27,12 +27,15 @@
 import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.graph.ParameterAnnotationsList;
 import com.android.tools.r8.ir.analysis.type.ArrayTypeElement;
+import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.code.ArrayAccess;
 import com.android.tools.r8.ir.code.ConstNumber;
 import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.InstanceGet;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InstructionListIterator;
+import com.android.tools.r8.ir.code.InvokeMethod;
 import com.android.tools.r8.ir.code.InvokeMethodWithReceiver;
 import com.android.tools.r8.ir.code.InvokeStatic;
 import com.android.tools.r8.ir.code.MemberType;
@@ -40,6 +43,7 @@
 import com.android.tools.r8.ir.code.StaticGet;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.conversion.IRConverter;
+import com.android.tools.r8.ir.optimize.enums.EnumInstanceFieldData.EnumInstanceFieldKnownData;
 import com.android.tools.r8.ir.synthetic.EnumUnboxingCfCodeProvider;
 import com.android.tools.r8.origin.SynthesizedOrigin;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
@@ -65,6 +69,7 @@
   private final AppView<AppInfoWithLiveness> appView;
   private final DexItemFactory factory;
   private final EnumValueInfoMapCollection enumsToUnbox;
+  private final EnumInstanceFieldDataMap unboxedEnumsInstanceFieldData;
   private final Map<DexMethod, DexEncodedMethod> utilityMethods = new ConcurrentHashMap<>();
   private final Map<DexField, DexEncodedField> extraUtilityFields = new ConcurrentHashMap<>();
 
@@ -73,14 +78,19 @@
   private final DexMethod compareToUtilityMethod;
   private final DexMethod valuesUtilityMethod;
 
-  EnumUnboxingRewriter(AppView<AppInfoWithLiveness> appView, Set<DexType> enumsToUnbox) {
+  EnumUnboxingRewriter(
+      AppView<AppInfoWithLiveness> appView,
+      Set<DexType> enumsToUnbox,
+      EnumInstanceFieldDataMap unboxedEnumsInstanceFieldData) {
     this.appView = appView;
     this.factory = appView.dexItemFactory();
     EnumValueInfoMapCollection.Builder builder = EnumValueInfoMapCollection.builder();
     for (DexType toUnbox : enumsToUnbox) {
+      assert appView.appInfo().withLiveness().getEnumValueInfoMap(toUnbox) != null;
       builder.put(toUnbox, appView.appInfo().withLiveness().getEnumValueInfoMap(toUnbox));
     }
     this.enumsToUnbox = builder.build();
+    this.unboxedEnumsInstanceFieldData = unboxedEnumsInstanceFieldData;
 
     // Custom methods for java.lang.Enum methods ordinal, equals and compareTo.
     this.ordinalUtilityMethod =
@@ -144,7 +154,8 @@
             continue;
           } else if (invokedMethod == factory.enumMembers.nameMethod
               || invokedMethod == factory.enumMembers.toString) {
-            DexMethod toStringMethod = computeDefaultToStringUtilityMethod(enumType);
+            DexMethod toStringMethod =
+                computeInstanceFieldUtilityMethod(enumType, factory.enumMembers.nameField);
             iterator.replaceCurrentInstruction(
                 new InvokeStatic(
                     toStringMethod, invokeMethod.outValue(), invokeMethod.arguments()));
@@ -176,16 +187,22 @@
             convertedEnums.put(invoke, enumType);
             continue;
           }
+        } else if (invokedMethod == factory.javaLangSystemMethods.identityHashCode) {
+          assert invokeStatic.inValues().size() == 1;
+          Value argument = invokeStatic.getArgument(0);
+          DexType enumType = getEnumTypeOrNull(argument, convertedEnums);
+          if (enumType != null) {
+            invokeStatic.outValue().replaceUsers(argument);
+            iterator.removeOrReplaceByDebugLocalRead();
+          }
         }
       }
-      // Rewrites direct access to enum values into the corresponding int, $VALUES is not
-      // supported.
       if (instruction.isStaticGet()) {
         StaticGet staticGet = instruction.asStaticGet();
         DexType holder = staticGet.getField().holder;
         if (enumsToUnbox.containsEnum(holder)) {
           if (staticGet.outValue() == null) {
-            iterator.removeInstructionIgnoreOutValue();
+            iterator.removeOrReplaceByDebugLocalRead();
             continue;
           }
           EnumValueInfoMap enumValueInfoMap = enumsToUnbox.getEnumValueInfoMap(holder);
@@ -218,6 +235,26 @@
           }
         }
       }
+
+      if (instruction.isInstanceGet()) {
+        InstanceGet instanceGet = instruction.asInstanceGet();
+        DexType holder = instanceGet.getField().holder;
+        if (enumsToUnbox.containsEnum(holder)) {
+          DexMethod fieldMethod = computeInstanceFieldMethod(instanceGet.getField());
+          Value rewrittenOutValue =
+              code.createValue(
+                  TypeElement.fromDexType(
+                      fieldMethod.proto.returnType, Nullability.maybeNull(), appView));
+          InvokeStatic invoke =
+              new InvokeStatic(
+                  fieldMethod, rewrittenOutValue, ImmutableList.of(instanceGet.object()));
+          iterator.replaceCurrentInstruction(invoke);
+          if (enumsToUnbox.containsEnum(instanceGet.getField().type)) {
+            convertedEnums.put(invoke, instanceGet.getField().type);
+          }
+        }
+      }
+
       // Rewrite array accesses from MyEnum[] (OBJECT) to int[] (INT).
       if (instruction.isArrayAccess()) {
         ArrayAccess arrayAccess = instruction.asArrayAccess();
@@ -234,9 +271,19 @@
     return affectedPhis;
   }
 
+  private DexMethod computeInstanceFieldMethod(DexField field) {
+    EnumInstanceFieldKnownData enumFieldKnownData =
+        unboxedEnumsInstanceFieldData.getInstanceFieldData(field.holder, field);
+    if (enumFieldKnownData.isOrdinal()) {
+      utilityMethods.computeIfAbsent(ordinalUtilityMethod, m -> synthesizeOrdinalMethod());
+      return ordinalUtilityMethod;
+    }
+    return computeInstanceFieldUtilityMethod(field.holder, field);
+  }
+
   private void replaceEnumInvoke(
       InstructionListIterator iterator,
-      InvokeMethodWithReceiver invokeMethod,
+      InvokeMethod invokeMethod,
       DexMethod method,
       Function<DexMethod, DexEncodedMethod> synthesizor) {
     utilityMethods.computeIfAbsent(method, synthesizor);
@@ -309,6 +356,25 @@
     return synthesizeUtilityMethod(cfCode, method, true);
   }
 
+  private DexMethod computeInstanceFieldUtilityMethod(DexType enumType, DexField field) {
+    assert enumsToUnbox.containsEnum(enumType);
+    assert field.holder == enumType || field.holder == factory.enumType;
+    String methodName =
+        "get"
+            + (enumType == field.holder ? "" : "Enum$")
+            + field.name
+            + "$$"
+            + compatibleName(enumType);
+    DexMethod fieldMethod =
+        factory.createMethod(
+            factory.enumUnboxingUtilityType,
+            factory.createProto(field.type, factory.intType),
+            methodName);
+    utilityMethods.computeIfAbsent(
+        fieldMethod, m -> synthesizeInstanceFieldMethod(m, enumType, field));
+    return fieldMethod;
+  }
+
   private DexMethod computeValueOfUtilityMethod(DexType type) {
     assert enumsToUnbox.containsEnum(type);
     DexMethod valueOf =
@@ -320,17 +386,6 @@
     return valueOf;
   }
 
-  private DexMethod computeDefaultToStringUtilityMethod(DexType type) {
-    assert enumsToUnbox.containsEnum(type);
-    DexMethod toString =
-        factory.createMethod(
-            factory.enumUnboxingUtilityType,
-            factory.createProto(factory.stringType, factory.intType),
-            "toString" + compatibleName(type));
-    utilityMethods.computeIfAbsent(toString, m -> synthesizeToStringUtilityMethod(m, type));
-    return toString;
-  }
-
   private DexType getEnumTypeOrNull(ArrayAccess arrayAccess) {
     ArrayTypeElement arrayType = arrayAccess.array().getType().asArrayType();
     if (arrayType == null) {
@@ -397,24 +452,37 @@
         DexProgramClass::checksumFromType);
   }
 
-  private DexEncodedMethod synthesizeToStringUtilityMethod(DexMethod method, DexType enumType) {
+  private DexEncodedMethod synthesizeInstanceFieldMethod(
+      DexMethod method, DexType enumType, DexField field) {
+    assert method.proto.returnType == field.type;
+    assert unboxedEnumsInstanceFieldData.getInstanceFieldData(enumType, field).isMapping();
     CfCode cfCode =
-        new EnumUnboxingCfCodeProvider.EnumUnboxingDefaultToStringCfCodeProvider(
+        new EnumUnboxingCfCodeProvider.EnumUnboxingInstanceFieldCfCodeProvider(
                 appView,
                 factory.enumUnboxingUtilityType,
-                enumType,
-                enumsToUnbox.getEnumValueInfoMap(enumType))
+                field.type,
+                enumsToUnbox.getEnumValueInfoMap(enumType),
+                unboxedEnumsInstanceFieldData
+                    .getInstanceFieldData(enumType, field)
+                    .asEnumFieldMappingData())
             .generateCfCode();
     return synthesizeUtilityMethod(cfCode, method, false);
   }
 
   private DexEncodedMethod synthesizeValueOfUtilityMethod(DexMethod method, DexType enumType) {
+    assert method.proto.returnType == factory.intType;
+    assert unboxedEnumsInstanceFieldData
+        .getInstanceFieldData(enumType, factory.enumMembers.nameField)
+        .isMapping();
     CfCode cfCode =
         new EnumUnboxingCfCodeProvider.EnumUnboxingValueOfCfCodeProvider(
                 appView,
                 factory.enumUnboxingUtilityType,
                 enumType,
-                enumsToUnbox.getEnumValueInfoMap(enumType))
+                enumsToUnbox.getEnumValueInfoMap(enumType),
+                unboxedEnumsInstanceFieldData
+                    .getInstanceFieldData(enumType, factory.enumMembers.nameField)
+                    .asEnumFieldMappingData())
             .generateCfCode();
     return synthesizeUtilityMethod(cfCode, method, false);
   }
diff --git a/src/main/java/com/android/tools/r8/ir/synthetic/EnumUnboxingCfCodeProvider.java b/src/main/java/com/android/tools/r8/ir/synthetic/EnumUnboxingCfCodeProvider.java
index 5a50ca4..8b35793 100644
--- a/src/main/java/com/android/tools/r8/ir/synthetic/EnumUnboxingCfCodeProvider.java
+++ b/src/main/java/com/android/tools/r8/ir/synthetic/EnumUnboxingCfCodeProvider.java
@@ -19,6 +19,7 @@
 import com.android.tools.r8.cf.code.CfStackInstruction;
 import com.android.tools.r8.cf.code.CfStackInstruction.Opcode;
 import com.android.tools.r8.cf.code.CfThrow;
+import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.CfCode;
 import com.android.tools.r8.graph.DexField;
@@ -26,8 +27,10 @@
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.EnumValueInfoMapCollection.EnumValueInfoMap;
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.ir.code.If;
 import com.android.tools.r8.ir.code.ValueType;
+import com.android.tools.r8.ir.optimize.enums.EnumInstanceFieldData.EnumInstanceFieldMappingData;
 import java.util.ArrayList;
 import java.util.List;
 import org.objectweb.asm.Opcodes;
@@ -38,41 +41,64 @@
     super(appView, holder);
   }
 
-  public static class EnumUnboxingDefaultToStringCfCodeProvider extends EnumUnboxingCfCodeProvider {
+  void addCfInstructionsForAbstractValue(
+      List<CfInstruction> instructions, AbstractValue value, DexType returnType) {
+    // TODO(b/155368026): Support fields and const class fields.
+    // Move this to something similar than SingleValue#createMaterializingInstruction
+    if (value.isSingleStringValue()) {
+      assert returnType == appView.dexItemFactory().stringType;
+      instructions.add(new CfConstString(value.asSingleStringValue().getDexString()));
+    } else if (value.isSingleNumberValue()) {
+      instructions.add(
+          new CfConstNumber(
+              value.asSingleNumberValue().getValue(), ValueType.fromDexType(returnType)));
+    } else {
+      throw new Unreachable("Only Number and String fields in enums are supported.");
+    }
+  }
 
-    private DexType enumType;
-    private EnumValueInfoMap map;
+  public static class EnumUnboxingInstanceFieldCfCodeProvider extends EnumUnboxingCfCodeProvider {
 
-    public EnumUnboxingDefaultToStringCfCodeProvider(
-        AppView<?> appView, DexType holder, DexType enumType, EnumValueInfoMap map) {
+    private final DexType returnType;
+    private final EnumValueInfoMap enumValueInfoMap;
+    private final EnumInstanceFieldMappingData fieldDataMap;
+
+    public EnumUnboxingInstanceFieldCfCodeProvider(
+        AppView<?> appView,
+        DexType holder,
+        DexType returnType,
+        EnumValueInfoMap enumValueInfoMap,
+        EnumInstanceFieldMappingData fieldDataMap) {
       super(appView, holder);
-      this.enumType = enumType;
-      this.map = map;
+      this.returnType = returnType;
+      this.enumValueInfoMap = enumValueInfoMap;
+      this.fieldDataMap = fieldDataMap;
     }
 
     @Override
     public CfCode generateCfCode() {
-      // Generated static method, for class com.x.MyEnum {A,B} would look like:
+      // Generated static method, for class com.x.MyEnum {A(10),B(20);} would look like:
       // String UtilityClass#com.x.MyEnum_toString(int i) {
-      // if (i == 1) { return "A";}
-      // if (i == 2) { return "B";}
+      // if (i == 1) { return 10;}
+      // if (i == 2) { return 20;}
       // throw null;
       DexItemFactory factory = appView.dexItemFactory();
       List<CfInstruction> instructions = new ArrayList<>();
 
-      // if (i == 1) { return "A";}
-      // if (i == 2) { return "B";}
-      map.forEach(
+      // if (i == 1) { return 10;}
+      // if (i == 2) { return 20;}
+      enumValueInfoMap.forEach(
           (field, enumValueInfo) -> {
-            CfLabel dest = new CfLabel();
-            instructions.add(new CfLoad(ValueType.fromDexType(factory.intType), 0));
-            instructions.add(new CfConstNumber(enumValueInfo.convertToInt(), ValueType.INT));
-            instructions.add(new CfIfCmp(If.Type.NE, ValueType.INT, dest));
-            // TODO(b/160939354): Should use the value passed to the enum constructor, since this
-            //  value may be different from the enum field name.
-            instructions.add(new CfConstString(field.name));
-            instructions.add(new CfReturn(ValueType.OBJECT));
-            instructions.add(dest);
+            AbstractValue value = fieldDataMap.getData(field);
+            if (value != null) {
+              CfLabel dest = new CfLabel();
+              instructions.add(new CfLoad(ValueType.fromDexType(factory.intType), 0));
+              instructions.add(new CfConstNumber(enumValueInfo.convertToInt(), ValueType.INT));
+              instructions.add(new CfIfCmp(If.Type.NE, ValueType.INT, dest));
+              addCfInstructionsForAbstractValue(instructions, value, returnType);
+              instructions.add(new CfReturn(ValueType.fromDexType(returnType)));
+              instructions.add(dest);
+            }
           });
 
       // throw null;
@@ -87,12 +113,18 @@
 
     private DexType enumType;
     private EnumValueInfoMap map;
+    private final EnumInstanceFieldMappingData fieldDataMap;
 
     public EnumUnboxingValueOfCfCodeProvider(
-        AppView<?> appView, DexType holder, DexType enumType, EnumValueInfoMap map) {
+        AppView<?> appView,
+        DexType holder,
+        DexType enumType,
+        EnumValueInfoMap map,
+        EnumInstanceFieldMappingData fieldDataMap) {
       super(appView, holder);
       this.enumType = enumType;
       this.map = map;
+      this.fieldDataMap = fieldDataMap;
     }
 
     @Override
@@ -125,9 +157,8 @@
           (field, enumValueInfo) -> {
             CfLabel dest = new CfLabel();
             instructions.add(new CfLoad(ValueType.fromDexType(factory.stringType), 0));
-            // TODO(b/160939354): Should use the value passed to the enum constructor, since this
-            //  value may be different from the enum field name.
-            instructions.add(new CfConstString(field.name));
+            AbstractValue value = fieldDataMap.getData(field);
+            addCfInstructionsForAbstractValue(instructions, value, factory.stringType);
             instructions.add(
                 new CfInvoke(Opcodes.INVOKEVIRTUAL, factory.stringMembers.equals, false));
             instructions.add(new CfIf(If.Type.EQ, ValueType.INT, dest));
diff --git a/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java b/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java
index 7e98858..8c895f7 100644
--- a/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java
+++ b/src/main/java/com/android/tools/r8/jar/CfApplicationWriter.java
@@ -78,18 +78,16 @@
   public final ProguardMapSupplier proguardMapSupplier;
 
   public CfApplicationWriter(
-      DexApplication application,
       AppView<?> appView,
-      InternalOptions options,
       Marker marker,
       GraphLens graphLens,
       NamingLens namingLens,
       ProguardMapSupplier proguardMapSupplier) {
-    this.application = application;
+    this.application = appView.appInfo().app();
     this.appView = appView;
     this.graphLens = graphLens;
     this.namingLens = namingLens;
-    this.options = options;
+    this.options = appView.options();
     assert marker != null;
     this.marker = marker;
     this.proguardMapSupplier = proguardMapSupplier;
diff --git a/src/main/java/com/android/tools/r8/naming/SourceFileRewriter.java b/src/main/java/com/android/tools/r8/naming/SourceFileRewriter.java
index e2bf357..b8ddc06 100644
--- a/src/main/java/com/android/tools/r8/naming/SourceFileRewriter.java
+++ b/src/main/java/com/android/tools/r8/naming/SourceFileRewriter.java
@@ -83,9 +83,17 @@
 
   private DexString getSourceFileRenaming(ProguardConfiguration proguardConfiguration) {
     // If we should not be keeping the source file, null it out.
-    if (!appView.options().forceProguardCompatibility
-        && !proguardConfiguration.getKeepAttributes().sourceFile) {
-      return null;
+    if (!proguardConfiguration.getKeepAttributes().sourceFile) {
+      // For class files, we always remove the attribute
+      if (appView.options().isGeneratingClassFiles()) {
+        return null;
+      }
+      assert appView.options().isGeneratingDex();
+      // When generating DEX we only remove the attribute for full-mode to ensure that we get
+      // line-numbers printed in stack traces.
+      if (!appView.options().forceProguardCompatibility) {
+        return null;
+      }
     }
 
     String renamedSourceFileAttribute = proguardConfiguration.getRenameSourceFileAttribute();
diff --git a/src/main/java/com/android/tools/r8/optimize/MemberRebindingLens.java b/src/main/java/com/android/tools/r8/optimize/MemberRebindingLens.java
index 8883f5b..2e55916 100644
--- a/src/main/java/com/android/tools/r8/optimize/MemberRebindingLens.java
+++ b/src/main/java/com/android/tools/r8/optimize/MemberRebindingLens.java
@@ -87,14 +87,16 @@
 
   @Override
   public GraphLensLookupResult lookupMethod(DexMethod method, DexMethod context, Type type) {
-    GraphLensLookupResult previous = previousLens.lookupMethod(method, context, type);
+    GraphLensLookupResult lookup = previousLens.lookupMethod(method, context, type);
     Map<DexMethod, DexMethod> methodMap = methodMaps.getOrDefault(type, Collections.emptyMap());
-    DexMethod newMethod = methodMap.get(previous.getMethod());
-    if (newMethod != null) {
-      return new GraphLensLookupResult(
-          newMethod, mapInvocationType(newMethod, method, previous.getType()));
+    DexMethod newMethod = methodMap.get(lookup.getMethod());
+    if (newMethod == null) {
+      return lookup;
     }
-    return previous;
+    return new GraphLensLookupResult(
+        newMethod,
+        mapInvocationType(newMethod, method, lookup.getType()),
+        lookup.getPrototypeChanges());
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/optimize/PublicizerLens.java b/src/main/java/com/android/tools/r8/optimize/PublicizerLens.java
index a2c44ce..1e8eff2 100644
--- a/src/main/java/com/android/tools/r8/optimize/PublicizerLens.java
+++ b/src/main/java/com/android/tools/r8/optimize/PublicizerLens.java
@@ -41,14 +41,13 @@
 
   @Override
   public GraphLensLookupResult lookupMethod(DexMethod method, DexMethod context, Type type) {
-    GraphLensLookupResult previous = previousLens.lookupMethod(method, context, type);
-    method = previous.getMethod();
-    type = previous.getType();
-    if (type == Type.DIRECT && publicizedMethods.contains(method)) {
-      assert publicizedMethodIsPresentOnHolder(method, context);
-      return new GraphLensLookupResult(method, Type.VIRTUAL);
+    GraphLensLookupResult lookup = previousLens.lookupMethod(method, context, type);
+    if (lookup.getType() == Type.DIRECT && publicizedMethods.contains(lookup.getMethod())) {
+      assert publicizedMethodIsPresentOnHolder(lookup.getMethod(), context);
+      return new GraphLensLookupResult(
+          lookup.getMethod(), Type.VIRTUAL, lookup.getPrototypeChanges());
     }
-    return super.lookupMethod(method, context, type);
+    return lookup;
   }
 
   private boolean publicizedMethodIsPresentOnHolder(DexMethod method, DexMethod context) {
diff --git a/src/main/java/com/android/tools/r8/relocator/Relocator.java b/src/main/java/com/android/tools/r8/relocator/Relocator.java
index e45afd6..bf2bfe8 100644
--- a/src/main/java/com/android/tools/r8/relocator/Relocator.java
+++ b/src/main/java/com/android/tools/r8/relocator/Relocator.java
@@ -89,9 +89,7 @@
       new GenericSignatureRewriter(appView, namingLens).run(appInfo.classes(), executor);
 
       new CfApplicationWriter(
-              app,
               appView,
-              options,
               new Marker(Tool.Relocator),
               GraphLens.getIdentityLens(),
               namingLens,
diff --git a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
index 9e709fd..17cf952 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
@@ -1140,7 +1140,9 @@
         // if I has a supertype J. This is due to the fact that invoke-super instructions that
         // resolve to a method on an interface never hit an implementation below that interface.
         deferredRenamings.mapVirtualMethodToDirectInType(
-            oldTarget, new GraphLensLookupResult(newTarget, STATIC), target.type);
+            oldTarget,
+            prototypeChanges -> new GraphLensLookupResult(newTarget, STATIC, prototypeChanges),
+            target.type);
       } else {
         // If we merge class B into class C, and class C contains an invocation super.m(), then it
         // is insufficient to rewrite "invoke-super B.m()" to "invoke-direct C.m$B()" (the method
@@ -1159,7 +1161,9 @@
                   || appInfo.lookupSuperTarget(signatureInHolder, holder) != null;
           if (resolutionSucceeds) {
             deferredRenamings.mapVirtualMethodToDirectInType(
-                signatureInHolder, new GraphLensLookupResult(newTarget, DIRECT), target.type);
+                signatureInHolder,
+                prototypeChanges -> new GraphLensLookupResult(newTarget, DIRECT, prototypeChanges),
+                target.type);
           } else {
             break;
           }
@@ -1181,7 +1185,10 @@
                       || appInfo.lookupSuperTarget(signatureInHolder, holder) != null;
               if (resolutionSucceededBeforeMerge) {
                 deferredRenamings.mapVirtualMethodToDirectInType(
-                    signatureInType, new GraphLensLookupResult(newTarget, DIRECT), target.type);
+                    signatureInType,
+                    prototypeChanges ->
+                        new GraphLensLookupResult(newTarget, DIRECT, prototypeChanges),
+                    target.type);
               }
             }
           }
@@ -1733,27 +1740,26 @@
       // First look up the method using the existing graph lens (for example, the type will have
       // changed if the method was publicized by ClassAndMemberPublicizer).
       GraphLensLookupResult lookup = appView.graphLens().lookupMethod(method, context, type);
-      DexMethod previousMethod = lookup.getMethod();
-      Type previousType = lookup.getType();
       // Then check if there is a renaming due to the vertical class merger.
-      DexMethod newMethod = renamedMembersLens.methodMap.get(previousMethod);
-      if (newMethod != null) {
-        if (previousType == Type.INTERFACE) {
-          // If an interface has been merged into a class, invoke-interface needs to be translated
-          // to invoke-virtual.
-          DexClass clazz = appInfo.definitionFor(newMethod.holder);
-          if (clazz != null && !clazz.accessFlags.isInterface()) {
-            assert appInfo.definitionFor(method.holder).accessFlags.isInterface();
-            return new GraphLensLookupResult(newMethod, Type.VIRTUAL);
-          }
-        }
-        return new GraphLensLookupResult(newMethod, previousType);
+      DexMethod newMethod = renamedMembersLens.methodMap.get(lookup.getMethod());
+      if (newMethod == null) {
+        return lookup;
       }
-      return new GraphLensLookupResult(previousMethod, previousType);
+      if (lookup.getType() == Type.INTERFACE) {
+        // If an interface has been merged into a class, invoke-interface needs to be translated
+        // to invoke-virtual.
+        DexClass clazz = appInfo.definitionFor(newMethod.holder);
+        if (clazz != null && !clazz.accessFlags.isInterface()) {
+          assert appInfo.definitionFor(method.holder).accessFlags.isInterface();
+          return new GraphLensLookupResult(newMethod, Type.VIRTUAL, lookup.getPrototypeChanges());
+        }
+      }
+      return new GraphLensLookupResult(newMethod, lookup.getType(), lookup.getPrototypeChanges());
     }
 
     @Override
-    public RewrittenPrototypeDescription lookupPrototypeChanges(DexMethod method) {
+    public RewrittenPrototypeDescription lookupPrototypeChangesForMethodDefinition(
+        DexMethod method) {
       throw new Unreachable();
     }
 
diff --git a/src/main/java/com/android/tools/r8/shaking/VerticalClassMergerGraphLens.java b/src/main/java/com/android/tools/r8/shaking/VerticalClassMergerGraphLens.java
index db59152..683f1c9 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMergerGraphLens.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMergerGraphLens.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.GraphLens;
 import com.android.tools.r8.graph.GraphLens.NestedGraphLens;
+import com.android.tools.r8.graph.RewrittenPrototypeDescription;
 import com.android.tools.r8.ir.code.Invoke.Type;
 import com.google.common.collect.BiMap;
 import com.google.common.collect.HashBiMap;
@@ -47,9 +48,14 @@
 // For the invocation "invoke-virtual A.m()" in B.m2, this graph lens will return the method B.m.
 public class VerticalClassMergerGraphLens extends NestedGraphLens {
 
+  interface GraphLensLookupResultProvider {
+
+    abstract GraphLensLookupResult get(RewrittenPrototypeDescription prototypeChanges);
+  }
+
   private final AppView<?> appView;
 
-  private final Map<DexType, Map<DexMethod, GraphLensLookupResult>>
+  private final Map<DexType, Map<DexMethod, GraphLensLookupResultProvider>>
       contextualVirtualToDirectMethodMaps;
   private Set<DexMethod> mergedMethods;
   private final Map<DexMethod, DexMethod> originalMethodSignaturesForBridges;
@@ -60,7 +66,8 @@
       Map<DexField, DexField> fieldMap,
       Map<DexMethod, DexMethod> methodMap,
       Set<DexMethod> mergedMethods,
-      Map<DexType, Map<DexMethod, GraphLensLookupResult>> contextualVirtualToDirectMethodMaps,
+      Map<DexType, Map<DexMethod, GraphLensLookupResultProvider>>
+          contextualVirtualToDirectMethodMaps,
       BiMap<DexField, DexField> originalFieldSignatures,
       BiMap<DexMethod, DexMethod> originalMethodSignatures,
       Map<DexMethod, DexMethod> originalMethodSignaturesForBridges,
@@ -98,24 +105,31 @@
         originalMethodSignaturesForBridges.containsKey(context)
             ? originalMethodSignaturesForBridges.get(context)
             : originalMethodSignatures.getOrDefault(context, context);
-    GraphLensLookupResult previous = previousLens.lookupMethod(method, previousContext, type);
-    if (previous.getType() == Type.SUPER && !mergedMethods.contains(context)) {
-      Map<DexMethod, GraphLensLookupResult> virtualToDirectMethodMap =
+    GraphLensLookupResult lookup = previousLens.lookupMethod(method, previousContext, type);
+    if (lookup.getType() == Type.SUPER && !mergedMethods.contains(context)) {
+      Map<DexMethod, GraphLensLookupResultProvider> virtualToDirectMethodMap =
           contextualVirtualToDirectMethodMaps.get(context.holder);
       if (virtualToDirectMethodMap != null) {
-        GraphLensLookupResult lookup = virtualToDirectMethodMap.get(previous.getMethod());
-        if (lookup != null) {
+        GraphLensLookupResultProvider result = virtualToDirectMethodMap.get(lookup.getMethod());
+        if (result != null) {
           // If the super class A of the enclosing class B (i.e., context.holder())
           // has been merged into B during vertical class merging, and this invoke-super instruction
           // was resolving to a method in A, then the target method has been changed to a direct
           // method and moved into B, so that we need to use an invoke-direct instruction instead of
           // invoke-super (or invoke-static, if the method was originally a default interface
           // method).
-          return lookup;
+          return result.get(lookup.getPrototypeChanges());
         }
       }
     }
-    return super.lookupMethod(previous.getMethod(), context, previous.getType());
+    DexMethod newMethod = methodMap.get(lookup.getMethod());
+    if (newMethod == null) {
+      return lookup;
+    }
+    return new GraphLensLookupResult(
+        newMethod,
+        mapInvocationType(newMethod, lookup.getMethod(), lookup.getType()),
+        internalDescribePrototypeChanges(lookup.getPrototypeChanges(), newMethod));
   }
 
   @Override
@@ -144,7 +158,7 @@
     protected final BiMap<DexField, DexField> fieldMap = HashBiMap.create();
     protected final Map<DexMethod, DexMethod> methodMap = new IdentityHashMap<>();
     private final ImmutableSet.Builder<DexMethod> mergedMethodsBuilder = ImmutableSet.builder();
-    private final Map<DexType, Map<DexMethod, GraphLensLookupResult>>
+    private final Map<DexType, Map<DexMethod, GraphLensLookupResultProvider>>
         contextualVirtualToDirectMethodMaps = new IdentityHashMap<>();
 
     private final BiMap<DexMethod, DexMethod> originalMethodSignatures = HashBiMap.create();
@@ -173,17 +187,22 @@
         newBuilder.markMethodAsMerged(
             builder.getMethodSignatureAfterClassMerging(method, mergedClasses));
       }
-      for (Map.Entry<DexType, Map<DexMethod, GraphLensLookupResult>> entry :
+      for (Map.Entry<DexType, Map<DexMethod, GraphLensLookupResultProvider>> entry :
           builder.contextualVirtualToDirectMethodMaps.entrySet()) {
         DexType context = entry.getKey();
         assert context == builder.getTypeAfterClassMerging(context, mergedClasses);
-        for (Map.Entry<DexMethod, GraphLensLookupResult> innerEntry : entry.getValue().entrySet()) {
+        for (Map.Entry<DexMethod, GraphLensLookupResultProvider> innerEntry :
+            entry.getValue().entrySet()) {
           DexMethod from = innerEntry.getKey();
-          GraphLensLookupResult rewriting = innerEntry.getValue();
+          GraphLensLookupResult rewriting =
+              innerEntry.getValue().get(RewrittenPrototypeDescription.none());
           DexMethod to =
               builder.getMethodSignatureAfterClassMerging(rewriting.getMethod(), mergedClasses);
           newBuilder.mapVirtualMethodToDirectInType(
-              from, new GraphLensLookupResult(to, rewriting.getType()), context);
+              from,
+              prototypeChanges ->
+                  new GraphLensLookupResult(to, rewriting.getType(), prototypeChanges),
+              context);
         }
       }
       for (Map.Entry<DexMethod, DexMethod> entry : builder.originalMethodSignatures.entrySet()) {
@@ -267,7 +286,7 @@
     }
 
     public boolean hasMappingForSignatureInContext(DexProgramClass context, DexMethod signature) {
-      Map<DexMethod, GraphLensLookupResult> virtualToDirectMethodMap =
+      Map<DexMethod, GraphLensLookupResultProvider> virtualToDirectMethodMap =
           contextualVirtualToDirectMethodMaps.get(context.type);
       if (virtualToDirectMethodMap != null) {
         return virtualToDirectMethodMap.containsKey(signature);
@@ -306,8 +325,8 @@
     }
 
     public void mapVirtualMethodToDirectInType(
-        DexMethod from, GraphLensLookupResult to, DexType type) {
-      Map<DexMethod, GraphLensLookupResult> virtualToDirectMethodMap =
+        DexMethod from, GraphLensLookupResultProvider to, DexType type) {
+      Map<DexMethod, GraphLensLookupResultProvider> virtualToDirectMethodMap =
           contextualVirtualToDirectMethodMaps.computeIfAbsent(type, key -> new IdentityHashMap<>());
       virtualToDirectMethodMap.put(from, to);
     }
@@ -319,9 +338,9 @@
       originalMethodSignatures.putAll(builder.originalMethodSignatures);
       originalMethodSignaturesForBridges.putAll(builder.originalMethodSignaturesForBridges);
       for (DexType context : builder.contextualVirtualToDirectMethodMaps.keySet()) {
-        Map<DexMethod, GraphLensLookupResult> current =
+        Map<DexMethod, GraphLensLookupResultProvider> current =
             contextualVirtualToDirectMethodMaps.get(context);
-        Map<DexMethod, GraphLensLookupResult> other =
+        Map<DexMethod, GraphLensLookupResultProvider> other =
             builder.contextualVirtualToDirectMethodMaps.get(context);
         if (current != null) {
           current.putAll(other);
diff --git a/src/main/java/com/android/tools/r8/utils/ArchiveBuilder.java b/src/main/java/com/android/tools/r8/utils/ArchiveBuilder.java
index dfb625b..9a521fb 100644
--- a/src/main/java/com/android/tools/r8/utils/ArchiveBuilder.java
+++ b/src/main/java/com/android/tools/r8/utils/ArchiveBuilder.java
@@ -12,6 +12,7 @@
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.origin.PathOrigin;
 import com.google.common.io.ByteStreams;
+import java.io.BufferedOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.file.Files;
@@ -80,8 +81,11 @@
     if (stream != null) {
       return stream;
     }
-    stream = new ZipOutputStream(Files.newOutputStream(
-        archive, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING));
+    stream =
+        new ZipOutputStream(
+            new BufferedOutputStream(
+                Files.newOutputStream(
+                    archive, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)));
     return stream;
   }
 
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 bb51cc0..7f54137 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -1236,6 +1236,7 @@
     public boolean forceLibBackportsInL8CfToCf = false;
     public boolean enumUnboxingRewriteJavaCGeneratedMethod = false;
     public boolean assertConsistentRenamingOfSignature = false;
+    public boolean allowStaticInterfaceMethodsForPreNApiLevel = false;
 
     // Flag to allow processing of resources in D8. A data resource consumer still needs to be
     // specified.
diff --git a/src/main/java/com/android/tools/r8/utils/Reporter.java b/src/main/java/com/android/tools/r8/utils/Reporter.java
index f251b0c..43f4f57 100644
--- a/src/main/java/com/android/tools/r8/utils/Reporter.java
+++ b/src/main/java/com/android/tools/r8/utils/Reporter.java
@@ -3,8 +3,14 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.utils;
 
+import static com.android.tools.r8.DiagnosticsLevel.ERROR;
+import static com.android.tools.r8.DiagnosticsLevel.INFO;
+import static com.android.tools.r8.DiagnosticsLevel.WARNING;
+
 import com.android.tools.r8.Diagnostic;
 import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.DiagnosticsLevel;
+import com.android.tools.r8.errors.Unreachable;
 
 public class Reporter implements DiagnosticsHandler {
 
@@ -19,14 +25,39 @@
     this.clientHandler = clientHandler;
   }
 
+  private void handleDiagnostic(DiagnosticsLevel level, Diagnostic diagnostic) {
+    // To avoid having an entry for fatal error in the public  API enum use null to signal
+    // fatal error internally.
+    if (level != null) {
+      DiagnosticsLevel modifiedLevel = clientHandler.modifyDiagnosticsLevel(level, diagnostic);
+      level = modifiedLevel != null ? modifiedLevel : level;
+    } else {
+      level = ERROR;
+    }
+    switch (level) {
+      case INFO:
+        clientHandler.info(diagnostic);
+        break;
+      case WARNING:
+        clientHandler.warning(diagnostic);
+        break;
+      case ERROR:
+        abort = new AbortException(diagnostic);
+        clientHandler.error(diagnostic);
+        break;
+      default:
+        throw new Unreachable();
+    }
+  }
+
   @Override
   public synchronized void info(Diagnostic info) {
-    clientHandler.info(info);
+    handleDiagnostic(INFO, info);
   }
 
   @Override
   public synchronized void warning(Diagnostic warning) {
-    clientHandler.warning(warning);
+    handleDiagnostic(WARNING, warning);
   }
 
   public void warning(String message) {
@@ -35,8 +66,7 @@
 
   @Override
   public synchronized void error(Diagnostic error) {
-    abort = new AbortException(error);
-    clientHandler.error(error);
+    handleDiagnostic(ERROR, error);
   }
 
   public void error(String message) {
@@ -54,7 +84,7 @@
    * @throws AbortException always.
    */
   public RuntimeException fatalError(Diagnostic error) {
-    error(error);
+    handleDiagnostic(null, error);
     throw abort;
   }
 
diff --git a/src/main/java/com/android/tools/r8/utils/ZipUtils.java b/src/main/java/com/android/tools/r8/utils/ZipUtils.java
index acaf11f..71400bd 100644
--- a/src/main/java/com/android/tools/r8/utils/ZipUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/ZipUtils.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.errors.CompilationError;
 import com.google.common.io.ByteStreams;
 import com.google.common.io.Closer;
+import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
@@ -74,7 +75,8 @@
   }
 
   public static void zip(Path zipFile, Path inputDirectory) throws IOException {
-    try (ZipOutputStream stream = new ZipOutputStream(Files.newOutputStream(zipFile))) {
+    try (ZipOutputStream stream =
+        new ZipOutputStream(new BufferedOutputStream(Files.newOutputStream(zipFile)))) {
       List<Path> files =
           Files.walk(inputDirectory)
               .filter(path -> !Files.isDirectory(path))
diff --git a/src/test/java/com/android/tools/r8/IntermediateCfD8TestBuilder.java b/src/test/java/com/android/tools/r8/IntermediateCfD8TestBuilder.java
index fcefd23..609fad5 100644
--- a/src/test/java/com/android/tools/r8/IntermediateCfD8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/IntermediateCfD8TestBuilder.java
@@ -7,10 +7,12 @@
 import com.android.tools.r8.debug.DebugTestConfig;
 import com.android.tools.r8.errors.Unimplemented;
 import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.InternalOptions;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.Collection;
 import java.util.concurrent.ExecutionException;
+import java.util.function.Consumer;
 
 public class IntermediateCfD8TestBuilder
     extends TestBuilder<D8TestRunResult, IntermediateCfD8TestBuilder> {
@@ -31,6 +33,12 @@
         D8TestBuilder.create(state, Backend.DEX).setMinApi(apiLevel).setDisableDesugaring(true);
   }
 
+  public IntermediateCfD8TestBuilder addOptionsModification(Consumer<InternalOptions> fn) {
+    cf2cf.addOptionsModification(fn);
+    cf2dex.addOptionsModification(fn);
+    return self();
+  }
+
   @Override
   IntermediateCfD8TestBuilder self() {
     return this;
diff --git a/src/test/java/com/android/tools/r8/JvmTestBuilder.java b/src/test/java/com/android/tools/r8/JvmTestBuilder.java
index 4317ca8..e59ea66 100644
--- a/src/test/java/com/android/tools/r8/JvmTestBuilder.java
+++ b/src/test/java/com/android/tools/r8/JvmTestBuilder.java
@@ -73,12 +73,12 @@
 
   @Override
   public JvmTestBuilder addLibraryFiles(Collection<Path> files) {
-    throw new Unimplemented("No support for changing the Java runtime library.");
+    return addRunClasspathFiles(files);
   }
 
   @Override
   public JvmTestBuilder addLibraryClasses(Collection<Class<?>> classes) {
-    throw new Unimplemented("No support for changing the Java runtime library.");
+    return addRunClasspathFiles(writeClassesToJar(classes));
   }
 
   @Override
diff --git a/src/test/java/com/android/tools/r8/R8TestBuilder.java b/src/test/java/com/android/tools/r8/R8TestBuilder.java
index 935de02..3c8a16b 100644
--- a/src/test/java/com/android/tools/r8/R8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/R8TestBuilder.java
@@ -256,6 +256,7 @@
     return self();
   }
 
+  @Override
   public T addMainDexListClasses(Class<?>... classes) {
     builder.addMainDexClasses(
         Arrays.stream(classes).map(Class::getTypeName).collect(Collectors.toList()));
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index 38637cf..1bd188a 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -216,11 +216,18 @@
   }
 
   public TestBuilder<? extends TestRunResult<?>, ?> testForDesugaring(TestParameters parameters) {
-    return testForDesugaring(parameters.getRuntime().getBackend(), parameters.getApiLevel());
+    return testForDesugaring(
+        parameters.getRuntime().getBackend(), parameters.getApiLevel(), o -> {});
+  }
+
+  public TestBuilder<? extends TestRunResult<?>, ?> testForDesugaring(
+      TestParameters parameters, Consumer<InternalOptions> optionsModification) {
+    return testForDesugaring(
+        parameters.getRuntime().getBackend(), parameters.getApiLevel(), optionsModification);
   }
 
   private TestBuilder<? extends TestRunResult<?>, ?> testForDesugaring(
-      Backend backend, AndroidApiLevel apiLevel) {
+      Backend backend, AndroidApiLevel apiLevel, Consumer<InternalOptions> optionsModification) {
     assert apiLevel != null : "No API level. Add .withAllApiLevelsAlsoForCf() to test parameters?";
     TestState state = new TestState(temp);
     List<Pair<String, TestBuilder<? extends TestRunResult<?>, ?>>> builders;
@@ -228,13 +235,24 @@
       builders =
           ImmutableList.of(
               new Pair<>("JAVAC", JvmTestBuilder.create(state)),
-              new Pair<>("D8/CF", D8TestBuilder.create(state, Backend.CF).setMinApi(apiLevel)));
+              new Pair<>(
+                  "D8/CF",
+                  D8TestBuilder.create(state, Backend.CF)
+                      .setMinApi(apiLevel)
+                      .addOptionsModification(optionsModification)));
     } else {
       assert backend == Backend.DEX;
       builders =
           ImmutableList.of(
-              new Pair<>("D8/DEX", D8TestBuilder.create(state, Backend.DEX).setMinApi(apiLevel)),
-              new Pair<>("D8/DEX o D8/CF", IntermediateCfD8TestBuilder.create(state, apiLevel)));
+              new Pair<>(
+                  "D8/DEX",
+                  D8TestBuilder.create(state, Backend.DEX)
+                      .setMinApi(apiLevel)
+                      .addOptionsModification(optionsModification)),
+              new Pair<>(
+                  "D8/DEX o D8/CF",
+                  IntermediateCfD8TestBuilder.create(state, apiLevel)
+                      .addOptionsModification(optionsModification)));
     }
     return TestBuilderCollection.create(state, builders);
   }
@@ -1527,7 +1545,7 @@
     }
     Path path = temp.newFolder().toPath().resolve("classes.jar");
     ArchiveConsumer consumer = new ArchiveConsumer(path);
-    for (Class clazz : classes) {
+    for (Class<?> clazz : classes) {
       consumer.accept(
           ByteDataView.of(ToolHelper.getClassAsBytes(clazz)),
           DescriptorUtils.javaTypeToDescriptor(clazz.getTypeName()),
@@ -1537,6 +1555,24 @@
     return path;
   }
 
+  public Path buildOnDexRuntime(TestParameters parameters, byte[]... classes)
+      throws IOException, CompilationFailedException {
+    if (parameters.isDexRuntime()) {
+      return testForD8()
+          .addProgramClassFileData(classes)
+          .setMinApi(parameters.getApiLevel())
+          .compile()
+          .writeToZip();
+    }
+    Path path = temp.newFolder().toPath().resolve("classes.jar");
+    ArchiveConsumer consumer = new ArchiveConsumer(path);
+    for (byte[] clazz : classes) {
+      consumer.accept(ByteDataView.of(clazz), extractClassDescriptor(clazz), null);
+    }
+    consumer.finished(null);
+    return path;
+  }
+
   public static String binaryName(Class<?> clazz) {
     return DescriptorUtils.getBinaryNameFromJavaType(typeName(clazz));
   }
@@ -1553,6 +1589,10 @@
     return AndroidApiLevel.N;
   }
 
+  public static AndroidApiLevel apiLevelWithStaticInterfaceMethodsSupport() {
+    return AndroidApiLevel.N;
+  }
+
   public static AndroidApiLevel apiLevelWithInvokeCustomSupport() {
     return AndroidApiLevel.O;
   }
diff --git a/src/test/java/com/android/tools/r8/TestBaseBuilder.java b/src/test/java/com/android/tools/r8/TestBaseBuilder.java
index 4f512b7..4388754 100644
--- a/src/test/java/com/android/tools/r8/TestBaseBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestBaseBuilder.java
@@ -19,7 +19,7 @@
         C extends BaseCommand,
         B extends BaseCommand.Builder<C, B>,
         CR extends TestBaseResult<CR, RR>,
-        RR extends TestRunResult,
+        RR extends TestRunResult<RR>,
         T extends TestBaseBuilder<C, B, CR, RR, T>>
     extends TestBuilder<RR, T> {
 
diff --git a/src/test/java/com/android/tools/r8/TestBuilder.java b/src/test/java/com/android/tools/r8/TestBuilder.java
index 9a874c2..73a1605 100644
--- a/src/test/java/com/android/tools/r8/TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestBuilder.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8;
 
+import com.android.tools.r8.TestBase.Backend;
 import com.android.tools.r8.debug.DebugTestConfig;
 import com.android.tools.r8.errors.Unimplemented;
 import com.android.tools.r8.utils.ListUtils;
@@ -13,8 +14,9 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
+import java.util.function.BiFunction;
 
-public abstract class TestBuilder<RR extends TestRunResult, T extends TestBuilder<RR, T>> {
+public abstract class TestBuilder<RR extends TestRunResult<RR>, T extends TestBuilder<RR, T>> {
 
   private final TestState state;
 
@@ -134,6 +136,16 @@
     return addLibraryFiles(Arrays.asList(files));
   }
 
+  public T addDefaultRuntimeLibrary(TestParameters parameters) {
+    if (parameters.getBackend() == Backend.DEX) {
+      addLibraryFiles(ToolHelper.getFirstSupportedAndroidJar(parameters.getApiLevel()));
+    } else {
+      assert parameters.getBackend() == Backend.CF;
+      addLibraryFiles(ToolHelper.getJava8RuntimeJar());
+    }
+    return self();
+  }
+
   public T addClasspathClasses(Class<?>... classes) {
     return addClasspathClasses(Arrays.asList(classes));
   }
@@ -179,4 +191,10 @@
   public T addRunClasspathFiles(Path... files) {
     return addRunClasspathFiles(Arrays.asList(files));
   }
+
+  public T setDiagnosticsLevelModifier(
+      BiFunction<DiagnosticsLevel, Diagnostic, DiagnosticsLevel> modifier) {
+    getState().setDiagnosticsLevelModifier(modifier);
+    return self();
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
index da1bc91..6f6263a 100644
--- a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
@@ -34,7 +34,7 @@
         C extends BaseCompilerCommand,
         B extends BaseCompilerCommand.Builder<C, B>,
         CR extends TestCompileResult<CR, RR>,
-        RR extends TestRunResult,
+        RR extends TestRunResult<RR>,
         T extends TestCompilerBuilder<C, B, CR, RR, T>>
     extends TestBaseBuilder<C, B, CR, RR, T> {
 
diff --git a/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java b/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java
index 54ad442..ab5027b 100644
--- a/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java
+++ b/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java
@@ -16,12 +16,14 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.function.BiFunction;
 import org.hamcrest.Matcher;
 
 public class TestDiagnosticMessagesImpl implements DiagnosticsHandler, TestDiagnosticMessages {
   private final List<Diagnostic> infos = new ArrayList<>();
   private final List<Diagnostic> warnings = new ArrayList<>();
   private final List<Diagnostic> errors = new ArrayList<>();
+  BiFunction<DiagnosticsLevel, Diagnostic, DiagnosticsLevel> modifier;
 
   @Override
   public String toString() {
@@ -66,6 +68,11 @@
   }
 
   @Override
+  public DiagnosticsLevel modifyDiagnosticsLevel(DiagnosticsLevel level, Diagnostic diagnostic) {
+    return modifier == null ? level : modifier.apply(level, diagnostic);
+  }
+
+  @Override
   public List<Diagnostic> getInfos() {
     return infos;
   }
@@ -303,4 +310,9 @@
   public TestDiagnosticMessages assertAllErrorsMatch(Matcher<Diagnostic> matcher) {
     return assertAllDiagnosticsMatches(getErrors(), "error", matcher);
   }
+
+  void setDiagnosticsLevelModifier(
+      BiFunction<DiagnosticsLevel, Diagnostic, DiagnosticsLevel> modifier) {
+    this.modifier = modifier;
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/TestState.java b/src/test/java/com/android/tools/r8/TestState.java
index 6ba75d7..3e28699 100644
--- a/src/test/java/com/android/tools/r8/TestState.java
+++ b/src/test/java/com/android/tools/r8/TestState.java
@@ -5,6 +5,7 @@
 
 import java.io.IOException;
 import java.nio.file.Path;
+import java.util.function.BiFunction;
 import org.junit.rules.TemporaryFolder;
 
 public class TestState {
@@ -54,4 +55,9 @@
   void setStderr(String stderr) {
     this.stderr = stderr;
   }
+
+  void setDiagnosticsLevelModifier(
+      BiFunction<DiagnosticsLevel, Diagnostic, DiagnosticsLevel> modifier) {
+    messages.setDiagnosticsLevelModifier(modifier);
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index 9b83a88fa2..7de9a9a 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -16,6 +16,7 @@
 import com.android.tools.r8.dex.ApplicationReader;
 import com.android.tools.r8.errors.Unimplemented;
 import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.AssemblyWriter;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexItemFactory;
@@ -2086,12 +2087,11 @@
     return builder;
   }
 
-  public static void writeApplication(DexApplication application, InternalOptions options)
+  public static void writeApplication(AppView<?> appView, InternalOptions options)
       throws ExecutionException {
     R8.writeApplication(
         Executors.newSingleThreadExecutor(),
-        application,
-        null,
+        appView,
         GraphLens.getIdentityLens(),
         InitClassLens.getDefault(),
         NamingLens.getIdentityLens(),
diff --git a/src/test/java/com/android/tools/r8/cf/StackMapFlagThisUninitTest.java b/src/test/java/com/android/tools/r8/cf/StackMapFlagThisUninitTest.java
new file mode 100644
index 0000000..b3f7fe4
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/cf/StackMapFlagThisUninitTest.java
@@ -0,0 +1,131 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.cf;
+
+import static org.hamcrest.CoreMatchers.containsString;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+@RunWith(Parameterized.class)
+public class StackMapFlagThisUninitTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withCfRuntimes().build();
+  }
+
+  public StackMapFlagThisUninitTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testRuntime() throws Exception {
+    testForRuntime(parameters)
+        .addProgramClasses(Main.class)
+        .addProgramClassFileData(ADump.dump())
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatMatches(
+            containsString(
+                "Exception in thread \"main\" java.lang.VerifyError: Inconsistent stackmap frames"
+                    + " at branch target 22"));
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(Main.class)
+        .addProgramClassFileData(ADump.dump())
+        .addKeepAllClassesRule()
+        .run(parameters.getRuntime(), Main.class)
+        // TODO(b/166738818): We should generate the correct stack map entry.
+        .assertFailureWithErrorThatMatches(
+            containsString(
+                "Exception in thread \"main\" java.lang.VerifyError: Inconsistent stackmap frames"
+                    + " at branch target 22"));
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      new A(0);
+    }
+  }
+
+  public static class A {
+
+    public A(int i) {}
+  }
+
+  // TODO(b/166738818): This is the bytecode generated from the constructor merging in
+  //  https://r8-review.googlesource.com/c/r8/+/53180/3.
+  //  The important thing here is that the instantiation of this is not performed in one case
+  //  and we fail to create a proper stack map entry for uninitializedThis.
+  public static class ADump implements Opcodes {
+
+    public static byte[] dump() {
+
+      ClassWriter classWriter = new ClassWriter(0);
+      MethodVisitor methodVisitor;
+
+      classWriter.visit(
+          V1_8,
+          ACC_PUBLIC | ACC_SUPER,
+          "com/android/tools/r8/cf/StackMapFlagThisUninitTest$A",
+          null,
+          "java/lang/Object",
+          null);
+
+      {
+        methodVisitor = classWriter.visitMethod(ACC_PUBLIC, "<init>", "(I)V", null, null);
+        methodVisitor.visitCode();
+        methodVisitor.visitVarInsn(ILOAD, 1);
+        Label label0 = new Label();
+        methodVisitor.visitJumpInsn(IFEQ, label0);
+        methodVisitor.visitVarInsn(ILOAD, 1);
+        methodVisitor.visitInsn(ICONST_1);
+        Label label1 = new Label();
+        methodVisitor.visitJumpInsn(IF_ICMPNE, label1);
+        methodVisitor.visitVarInsn(ALOAD, 0);
+        methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+        methodVisitor.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+        methodVisitor.visitLdcInsn("bar");
+        methodVisitor.visitMethodInsn(
+            INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
+        methodVisitor.visitInsn(RETURN);
+        methodVisitor.visitLabel(label1);
+        methodVisitor.visitFrame(Opcodes.F_CHOP, 2, null, 0, null);
+        methodVisitor.visitInsn(ACONST_NULL);
+        methodVisitor.visitInsn(ATHROW);
+        methodVisitor.visitLabel(label0);
+        methodVisitor.visitFrame(
+            Opcodes.F_APPEND, 1, new Object[] {Opcodes.UNINITIALIZED_THIS}, 0, null);
+        methodVisitor.visitVarInsn(ALOAD, 0);
+        methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+        methodVisitor.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+        methodVisitor.visitLdcInsn("foo");
+        methodVisitor.visitMethodInsn(
+            INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
+        methodVisitor.visitInsn(RETURN);
+        methodVisitor.visitMaxs(2, 2);
+        methodVisitor.visitEnd();
+      }
+      classWriter.visitEnd();
+
+      return classWriter.toByteArray();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java
index 6414d4b..e42f33d 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/JavaTimeTest.java
@@ -23,6 +23,7 @@
 import com.android.tools.r8.utils.codeinspector.TryCatchSubject;
 import com.android.tools.r8.utils.codeinspector.TypeSubject;
 import com.google.common.collect.ImmutableSet;
+import java.nio.file.Path;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -113,6 +114,41 @@
   }
 
   @Test
+  public void testTimeD8Cf() throws Exception {
+    KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+    // Use D8 to desugar with Java classfile output.
+    Path jar =
+        testForD8(Backend.CF)
+            .addInnerClasses(JavaTimeTest.class)
+            .setMinApi(parameters.getApiLevel())
+            .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+            .compile()
+            .inspect(this::checkRewrittenInvokes)
+            .writeToZip();
+
+    // Collection keep rules is only implemented in the DEX writer.
+    String desugaredLibraryKeepRules = keepRuleConsumer.get();
+    if (desugaredLibraryKeepRules != null) {
+      assertEquals(0, desugaredLibraryKeepRules.length());
+      desugaredLibraryKeepRules = "-keep class * { *; }";
+    }
+
+    // Convert to DEX without desugaring.
+    testForD8()
+        .addProgramFiles(jar)
+        .setMinApi(parameters.getApiLevel())
+        .disableDesugaring()
+        .compile()
+        .addDesugaredCoreLibraryRunClassPath(
+            this::buildDesugaredLibrary,
+            parameters.getApiLevel(),
+            desugaredLibraryKeepRules,
+            shrinkDesugaredLibrary)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(expectedOutput);
+  }
+
+  @Test
   public void testTimeD8() throws Exception {
     KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
     testForD8()
diff --git a/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/InvokeStaticDesugarTest.java b/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/InvokeStaticDesugarTest.java
new file mode 100644
index 0000000..8bcb3a6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/InvokeStaticDesugarTest.java
@@ -0,0 +1,84 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.desugar.staticinterfacemethod;
+
+import static com.android.tools.r8.desugar.staticinterfacemethod.InvokeStaticDesugarTest.Library.foo;
+import static org.hamcrest.CoreMatchers.containsString;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.ToolHelper.DexVm;
+import com.google.common.collect.ImmutableList;
+import java.nio.file.Path;
+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 InvokeStaticDesugarTest extends TestBase {
+
+  private final TestParameters parameters;
+  private final String EXPECTED = "Hello World!";
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+  }
+
+  public InvokeStaticDesugarTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testDesugar() throws Exception {
+    final TestRunResult<?> runResult =
+        testForDesugaring(parameters)
+            .addLibraryClasses(Library.class)
+            .addProgramClasses(Main.class)
+            .addRunClasspathFiles(compileRunClassPath())
+            .run(parameters.getRuntime(), Main.class);
+    if (parameters.isDexRuntime()
+        && parameters.getRuntime().asDex().getVm().isOlderThanOrEqual(DexVm.ART_4_4_4_HOST)) {
+      runResult.assertFailureWithErrorThatMatches(containsString("java.lang.VerifyError"));
+    } else {
+      runResult.assertSuccessWithOutputLines(EXPECTED);
+    }
+  }
+
+  private Path compileRunClassPath() throws Exception {
+    if (parameters.isCfRuntime()) {
+      return compileToZip(parameters, ImmutableList.of(), Library.class);
+    } else {
+      assert parameters.isDexRuntime();
+      return testForD8(parameters.getBackend())
+          .addProgramClasses(Library.class)
+          .setMinApi(parameters.getApiLevel())
+          .disableDesugaring()
+          .addOptionsModification(
+              options -> {
+                options.testing.allowStaticInterfaceMethodsForPreNApiLevel = true;
+              })
+          .compile()
+          .writeToZip();
+    }
+  }
+
+  public interface Library {
+
+    static void foo() {
+      System.out.println("Hello World!");
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      foo();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/StaticInterfaceMethodReferenceTest.java b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/StaticInterfaceMethodReferenceTest.java
new file mode 100644
index 0000000..e7fba9d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/StaticInterfaceMethodReferenceTest.java
@@ -0,0 +1,128 @@
+// 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.desugaring.interfacemethods;
+
+import static org.junit.Assert.assertFalse;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.ToolHelper.DexVm;
+import com.android.tools.r8.utils.BooleanUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class StaticInterfaceMethodReferenceTest extends TestBase {
+
+  private final TestParameters parameters;
+  private final boolean isInterface;
+
+  @Parameterized.Parameters(name = "{0}, itf:{1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build(),
+        BooleanUtils.values());
+  }
+
+  public StaticInterfaceMethodReferenceTest(TestParameters parameters, boolean isInterface) {
+    this.parameters = parameters;
+    this.isInterface = isInterface;
+  }
+
+  @Test
+  public void test() throws Exception {
+    TestRunResult<?> result =
+        testForDesugaring(parameters, o -> o.testing.allowInvokeErrors = true)
+            .addProgramClasses(TestClass.class)
+            .addProgramClassFileData(getTarget(isInterface))
+            .run(parameters.getRuntime(), TestClass.class);
+    checkResult(result);
+  }
+
+  @Test
+  public void testTargetMissing() throws Exception {
+    TestRunResult<?> result =
+        testForDesugaring(parameters, o -> o.testing.allowInvokeErrors = true)
+            .addProgramClasses(TestClass.class)
+            .addRunClasspathFiles(buildOnDexRuntime(parameters, getTarget(isInterface)))
+            .run(parameters.getRuntime(), TestClass.class);
+    // Missing target will cause the call to remain as Target::foo rather than Target$-CC::foo.
+    // TODO(b/166726895): Support static interface invoke as no knowledge of Target is needed.
+    if (isInterface
+        && parameters.isDexRuntime()
+        && parameters.getApiLevel().isLessThan(apiLevelWithStaticInterfaceMethodsSupport())) {
+      result.assertFailureWithErrorThatThrows(
+          parameters
+                  .getRuntime()
+                  .asDex()
+                  .getVm()
+                  .getVersion()
+                  .isOlderThanOrEqual(DexVm.Version.V4_4_4)
+              // On <= 4.4.4 a verify error happens due to the static invoke on an interface.
+              ? VerifyError.class
+              : NoSuchMethodError.class);
+      return;
+    }
+    checkResult(result);
+  }
+
+  private void checkResult(TestRunResult<?> result) {
+    // If the reference is of correct type, or running on JDK8 which allows mismatch the
+    // output is the expected print.
+    if (isInterface
+        || (parameters.isCfRuntime() && parameters.getRuntime().asCf().getVm() == CfVm.JDK8)) {
+      result.assertSuccessWithOutputLines("Target::foo");
+      return;
+    }
+
+    // DEX runtimes do not check method reference types so the code will run.
+    // TODO(b/166732606): Compile to an ICCE? What about the "missing" target case?
+    assertFalse(isInterface);
+    if (parameters.isDexRuntime()) {
+      result.assertSuccessWithOutputLines("Target::foo");
+      return;
+    }
+
+    // Otherwise the run should result in an ICCE.
+    result.assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
+  }
+
+  private static byte[] getTarget(boolean isInterface) throws Exception {
+    return transformer(Target.class)
+        .setAccessFlags(
+            classAccessFlags -> {
+              if (isInterface) {
+                assert !classAccessFlags.isSuper();
+                assert classAccessFlags.isAbstract();
+                assert classAccessFlags.isInterface();
+              } else {
+                classAccessFlags.unsetAbstract();
+                classAccessFlags.unsetInterface();
+              }
+            })
+        .transform();
+  }
+
+  interface Target {
+
+    static void foo() {
+      System.out.println("Target::foo");
+    }
+  }
+
+  static class TestClass {
+
+    static void call(Runnable fn) {
+      fn.run();
+    }
+
+    public static void main(String[] args) {
+      call(Target::foo);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/diagnostics/ModifyDiagnosticsLevelTest.java b/src/test/java/com/android/tools/r8/diagnostics/ModifyDiagnosticsLevelTest.java
new file mode 100644
index 0000000..8db3e12
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/diagnostics/ModifyDiagnosticsLevelTest.java
@@ -0,0 +1,96 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.diagnostics;
+
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
+import static org.hamcrest.CoreMatchers.startsWith;
+import static org.junit.Assert.fail;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.DiagnosticsLevel;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.StringDiagnostic;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ModifyDiagnosticsLevelTest extends TestBase {
+
+  private static final String MISSING_CLASS_MESSAGE_PREFIX = "Missing class: ";
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withNoneRuntime().build();
+  }
+
+  public ModifyDiagnosticsLevelTest(TestParameters parameters) {
+    parameters.assertNoneRuntime();
+  }
+
+  @Test
+  public void testWarningToInfo() throws Exception {
+    testForR8(Backend.DEX)
+        .addProgramClasses(TestClass.class)
+        .addKeepMainRule(TestClass.class)
+        .addKeepRules("-ignorewarnings")
+        .setDiagnosticsLevelModifier(
+            (level, diagnostic) -> {
+              if (level == DiagnosticsLevel.WARNING
+                  && diagnostic instanceof StringDiagnostic
+                  && diagnostic.getDiagnosticMessage().startsWith(MISSING_CLASS_MESSAGE_PREFIX)) {
+                return DiagnosticsLevel.INFO;
+              }
+              return level;
+            })
+        .allowDiagnosticInfoMessages()
+        .compileWithExpectedDiagnostics(
+            diagnostics -> {
+              diagnostics
+                  .assertOnlyInfos()
+                  .assertInfosCount(1)
+                  .assertInfosMatch(diagnosticMessage(startsWith(MISSING_CLASS_MESSAGE_PREFIX)));
+            });
+  }
+
+  @Test
+  public void testWarningToError() throws Exception {
+    try {
+      testForR8(Backend.DEX)
+          .addProgramClasses(TestClass.class)
+          .addKeepMainRule(TestClass.class)
+          .addKeepRules("-ignorewarnings")
+          .setDiagnosticsLevelModifier(
+              (level, diagnostic) -> {
+                if (level == DiagnosticsLevel.WARNING
+                    && diagnostic instanceof StringDiagnostic
+                    && diagnostic.getDiagnosticMessage().startsWith(MISSING_CLASS_MESSAGE_PREFIX)) {
+                  return DiagnosticsLevel.ERROR;
+                }
+                return level;
+              })
+          .compileWithExpectedDiagnostics(
+              diagnostics -> {
+                diagnostics
+                    .assertOnlyErrors()
+                    .assertErrorsCount(1)
+                    .assertErrorsMatch(diagnosticMessage(startsWith(MISSING_CLASS_MESSAGE_PREFIX)));
+              });
+      fail("Expected compilation to fail");
+    } catch (CompilationFailedException e) {
+      // Expected.
+    }
+  }
+
+  static class TestClass implements I {
+
+    public static void main(String[] args) {
+      System.out.println("Hello, world!");
+    }
+  }
+
+  interface I {}
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EmptyEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EmptyEnumUnboxingTest.java
new file mode 100644
index 0000000..ddc0806
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EmptyEnumUnboxingTest.java
@@ -0,0 +1,75 @@
+// 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.enumunboxing;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestParameters;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class EmptyEnumUnboxingTest extends EnumUnboxingTestBase {
+
+  private final TestParameters parameters;
+  private final boolean enumValueOptimization;
+  private final EnumKeepRules enumKeepRules;
+
+  @Parameters(name = "{0} valueOpt: {1} keep: {2}")
+  public static List<Object[]> data() {
+    return enumUnboxingTestParameters();
+  }
+
+  public EmptyEnumUnboxingTest(
+      TestParameters parameters, boolean enumValueOptimization, EnumKeepRules enumKeepRules) {
+    this.parameters = parameters;
+    this.enumValueOptimization = enumValueOptimization;
+    this.enumKeepRules = enumKeepRules;
+  }
+
+  @Test
+  public void testEnumUnboxing() throws Exception {
+    R8TestRunResult run =
+        testForR8(parameters.getBackend())
+            .addInnerClasses(EmptyEnumUnboxingTest.class)
+            .addKeepMainRule(Main.class)
+            .addKeepRules(enumKeepRules.getKeepRules())
+            .enableNeverClassInliningAnnotations()
+            .enableInliningAnnotations()
+            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+            .allowDiagnosticInfoMessages()
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .inspectDiagnosticMessages(
+                m ->
+                    // TODO(b/166532373): Unbox enum with no cases.
+                    assertEnumIsBoxed(MyEnum.class, Main.class.getSimpleName(), m))
+            .run(parameters.getRuntime(), Main.class)
+            .assertSuccess();
+    assertLines2By2Correct(run.getStdOut());
+  }
+
+  @NeverClassInline
+  enum MyEnum {
+    ;
+
+    @NeverInline
+    static void print() {
+      System.out.println("PRINT");
+    }
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      MyEnum.print();
+      System.out.println("PRINT");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java
index bdf46e3..89395ef 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java
@@ -7,7 +7,6 @@
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.core.StringContains.containsString;
 
 import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.TestParameters;
@@ -76,32 +75,15 @@
             .allowDiagnosticInfoMessages(enumUnboxing)
             .setMinApi(parameters.getApiLevel())
             .compile();
-    if (enumKeepRules.isStudio() && enumValueOptimization && enumUnboxing) {
-      // TODO(b/160939354): Enum unboxing synthesizes a toString() method based on field names.
-      compile
-          .run(parameters.getRuntime(), AlwaysCorrectProgram.class)
-          .assertFailureWithErrorThatMatches(containsString("IllegalArgumentException"));
-    } else {
       compile
           .run(parameters.getRuntime(), AlwaysCorrectProgram.class)
           .assertSuccessWithOutputLines("0", "1", "2", "0", "1", "2", "0", "1", "2");
-    }
-    if (!enumKeepRules.isSnap() && enumUnboxing) {
-      // TODO(b/160939354): Enum unboxing synthesizes a toString() method based on field names.
-      compile
-          .run(parameters.getRuntime(), AlwaysCorrectProgram2.class)
-          .assertFailureWithErrorThatMatches(containsString("IllegalArgumentException"));
-    } else {
       compile
           .run(parameters.getRuntime(), AlwaysCorrectProgram2.class)
           .assertSuccessWithOutputLines("0", "1", "2", "0", "1", "2");
-    }
   }
 
   private void assertEnumFieldsMinified(CodeInspector codeInspector) throws Exception {
-    if (enumKeepRules.isSnap()) {
-      return;
-    }
     ClassSubject clazz = codeInspector.clazz(ToStringLib.LibEnum.class);
     assertThat(clazz, isPresent());
     for (String fieldName : new String[] {"COFFEE", "BEAN", "SUGAR"}) {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingB160535628Test.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingB160535628Test.java
index 5ccd903..590cc7c 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingB160535628Test.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingB160535628Test.java
@@ -21,16 +21,21 @@
 
   private final TestParameters parameters;
   private final boolean missingStaticMethods;
+  private final EnumKeepRules enumKeepRules;
 
-  @Parameterized.Parameters(name = "{0}")
+  @Parameterized.Parameters(name = "{0} missing: {1} keep: {2}")
   public static List<Object[]> data() {
     return buildParameters(
-        getTestParameters().withDexRuntimes().withAllApiLevels().build(), BooleanUtils.values());
+        getTestParameters().withDexRuntimes().withAllApiLevels().build(),
+        BooleanUtils.values(),
+        getAllEnumKeepRules());
   }
 
-  public EnumUnboxingB160535628Test(TestParameters parameters, boolean missingStaticMethods) {
+  public EnumUnboxingB160535628Test(
+      TestParameters parameters, boolean missingStaticMethods, EnumKeepRules enumKeepRules) {
     this.parameters = parameters;
     this.missingStaticMethods = missingStaticMethods;
+    this.enumKeepRules = enumKeepRules;
   }
 
   @Test
@@ -44,9 +49,10 @@
             .addProgramClasses(ProgramValueOf.class, ProgramStaticMethod.class)
             .addProgramFiles(javaLibShrunk)
             .addKeepMainRules(ProgramValueOf.class, ProgramStaticMethod.class)
+            .addKeepRules(enumKeepRules.getKeepRules())
             .addOptionsModification(
                 options -> {
-                  options.enableEnumUnboxing = true;
+                  assert options.enableEnumUnboxing;
                   options.testing.enableEnumUnboxingDebugLogs = true;
                 })
             .allowDiagnosticMessages()
@@ -58,18 +64,23 @@
                 this::assertEnumUnboxedIfStaticMethodsPresent);
     if (missingStaticMethods) {
       compile
-          .run(parameters.getRuntime(), ProgramValueOf.class)
-          .assertFailureWithErrorThatMatches(containsString("NoSuchMethodError"))
-          .assertFailureWithErrorThatMatches(containsString("valueOf"));
-      compile
           .run(parameters.getRuntime(), ProgramStaticMethod.class)
           .assertFailureWithErrorThatMatches(containsString("NoSuchMethodError"))
           .assertFailureWithErrorThatMatches(containsString("staticMethod"));
     } else {
-      compile.run(parameters.getRuntime(), ProgramValueOf.class).assertSuccessWithOutputLines("0");
       compile
           .run(parameters.getRuntime(), ProgramStaticMethod.class)
-          .assertSuccessWithOutputLines("42");
+          .assertSuccessWithOutputLines("0", "42");
+    }
+    if (missingStaticMethods && enumKeepRules == EnumKeepRules.NONE) {
+      compile
+          .run(parameters.getRuntime(), ProgramValueOf.class)
+          .assertFailureWithErrorThatMatches(containsString("NoSuchMethodError"))
+          .assertFailureWithErrorThatMatches(containsString("valueOf"));
+    } else {
+      compile
+          .run(parameters.getRuntime(), ProgramValueOf.class)
+          .assertSuccessWithOutputLines("0", "0");
     }
   }
 
@@ -77,6 +88,7 @@
     return testForR8(Backend.CF)
         .addProgramClasses(Lib.class, Lib.LibEnumStaticMethod.class, Lib.LibEnum.class)
         .addKeepRules("-keep enum * { <fields>; }")
+        .addKeepRules(enumKeepRules.getKeepRules())
         .addKeepRules(missingStaticMethods ? "" : "-keep enum * { static <methods>; }")
         .addOptionsModification(
             options -> {
@@ -130,13 +142,15 @@
   public static class ProgramValueOf {
 
     public static void main(String[] args) {
-      System.out.println(Lib.LibEnumStaticMethod.valueOf(Lib.LibEnum.A.name()).ordinal());
+      System.out.println(Lib.LibEnum.A.ordinal());
+      System.out.println(Lib.LibEnum.valueOf(Lib.LibEnum.A.name()).ordinal());
     }
   }
 
   public static class ProgramStaticMethod {
 
     public static void main(String[] args) {
+      System.out.println(Lib.LibEnumStaticMethod.A.ordinal());
       System.out.println(Lib.LibEnumStaticMethod.staticMethod());
     }
   }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java
index 4f724d3..1e5bd5b 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java
@@ -65,12 +65,16 @@
   }
 
   private void assertClassStaticized(CodeInspector codeInspector) {
+    String renamedMethodName = "method$enumunboxing$";
     if (parameters.isCfRuntime()) {
       // There is no class staticizer in Cf.
-      assertThat(codeInspector.clazz(Companion.class).uniqueMethodWithName("method"), isPresent());
+      assertThat(
+          codeInspector.clazz(Companion.class).uniqueMethodWithName(renamedMethodName),
+          isPresent());
       return;
     }
-    MethodSubject method = codeInspector.clazz(CompanionHost.class).uniqueMethodWithName("method");
+    MethodSubject method =
+        codeInspector.clazz(CompanionHost.class).uniqueMethodWithName(renamedMethodName);
     assertThat(method, isPresent());
     assertEquals("int", method.getMethod().method.proto.parameters.toString());
   }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingSideEffectClInitTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingSideEffectClInitTest.java
index 128466c..89621a2 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingSideEffectClInitTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingSideEffectClInitTest.java
@@ -44,15 +44,7 @@
         .setMinApi(parameters.getApiLevel())
         .compile()
         .inspectDiagnosticMessages(
-            m -> {
-              // The snap keep rule forces to keep the static MainEnum#e field, so the enum
-              // cannot be unboxed anymore.
-              if (enumKeepRules.isSnap()) {
-                assertEnumIsBoxed(ENUM_CLASS, classToTest.getSimpleName(), m);
-              } else {
-                assertEnumIsUnboxed(ENUM_CLASS, classToTest.getSimpleName(), m);
-              }
-            })
+            m -> assertEnumIsUnboxed(ENUM_CLASS, classToTest.getSimpleName(), m))
         .run(parameters.getRuntime(), classToTest)
         .assertSuccessWithOutputLines("0");
   }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingTestBase.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingTestBase.java
index f26a6be..ab837d3 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingTestBase.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingTestBase.java
@@ -23,18 +23,10 @@
           + " public static **[] values();\n"
           + " public static ** valueOf(java.lang.String);\n"
           + "}";
-  // Default keep rule present in Snap.
-  private static final String KEEP_ENUM_SNAP =
-      "-keepclassmembers enum * {\n"
-          + "<fields>;\n"
-          + " public static **[] values();\n"
-          + " public static ** valueOf(java.lang.String);\n"
-          + "}";
 
   public enum EnumKeepRules {
     NONE(""),
-    STUDIO(KEEP_ENUM_STUDIO),
-    SNAP(KEEP_ENUM_SNAP);
+    STUDIO(KEEP_ENUM_STUDIO);
 
     private final String keepRules;
 
@@ -46,10 +38,6 @@
       return this == STUDIO;
     }
 
-    public boolean isSnap() {
-      return this == SNAP;
-    }
-
     EnumKeepRules(String keepRules) {
       this.keepRules = keepRules;
     }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/FailingEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/FailingEnumUnboxingTest.java
index 08ec7bd..8bf8034 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/FailingEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/FailingEnumUnboxingTest.java
@@ -5,12 +5,8 @@
 package com.android.tools.r8.enumunboxing;
 
 import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.R8FullTestBuilder;
-import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.enumunboxing.FailingEnumUnboxingTest.EnumInstanceFieldMain.EnumInstanceField;
-import com.android.tools.r8.enumunboxing.FailingEnumUnboxingTest.EnumStaticFieldMain.EnumStaticField;
 import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -20,11 +16,6 @@
 @RunWith(Parameterized.class)
 public class FailingEnumUnboxingTest extends EnumUnboxingTestBase {
 
-  private static final Class<?>[] FAILURES = {
-    EnumStaticField.class,
-    EnumInstanceField.class,
-  };
-
   private final TestParameters parameters;
   private final boolean enumValueOptimization;
   private final EnumKeepRules enumKeepRules;
@@ -43,28 +34,25 @@
 
   @Test
   public void testEnumUnboxingFailure() throws Exception {
-    R8FullTestBuilder r8FullTestBuilder =
-        testForR8(parameters.getBackend()).addInnerClasses(FailingEnumUnboxingTest.class);
-    for (Class<?> failure : FAILURES) {
-      r8FullTestBuilder.addKeepMainRule(failure.getEnclosingClass());
-    }
-    R8TestCompileResult compile =
-        r8FullTestBuilder
+    R8TestRunResult run =
+        testForR8(parameters.getBackend())
+            .addInnerClasses(FailingEnumUnboxingTest.class)
+            .addKeepMainRule(EnumStaticFieldMain.class)
             .enableNeverClassInliningAnnotations()
             .addKeepRules(enumKeepRules.getKeepRules())
             .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
             .allowDiagnosticInfoMessages()
             .setMinApi(parameters.getApiLevel())
-            .compile();
-    for (Class<?> failure : FAILURES) {
-      R8TestRunResult run =
-          compile
-              .inspectDiagnosticMessages(
-                  m -> assertEnumIsBoxed(failure, failure.getSimpleName(), m))
-              .run(parameters.getRuntime(), failure.getEnclosingClass())
-              .assertSuccess();
-      assertLines2By2Correct(run.getStdOut());
-    }
+            .compile()
+            .inspectDiagnosticMessages(
+                m ->
+                    assertEnumIsBoxed(
+                        EnumStaticFieldMain.EnumStaticField.class,
+                        EnumStaticFieldMain.class.getSimpleName(),
+                        m))
+            .run(parameters.getRuntime(), EnumStaticFieldMain.class)
+            .assertSuccess();
+    assertLines2By2Correct(run.getStdOut());
   }
 
   static class EnumStaticFieldMain {
@@ -84,26 +72,4 @@
       static EnumStaticField X = A;
     }
   }
-
-  static class EnumInstanceFieldMain {
-
-    @NeverClassInline
-    enum EnumInstanceField {
-      A(10),
-      B(20),
-      C(30);
-      private int a;
-
-      EnumInstanceField(int i) {
-        this.a = i;
-      }
-    }
-
-    public static void main(String[] args) {
-      System.out.println(EnumInstanceField.A.ordinal());
-      System.out.println(0);
-      System.out.println(EnumInstanceField.A.a);
-      System.out.println(10);
-    }
-  }
 }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java
index e42ac65..374895c 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java
@@ -1,12 +1,10 @@
 // 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.enumunboxing;
 
 import static junit.framework.TestCase.assertTrue;
 import static org.junit.Assert.assertEquals;
-
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.R8TestCompileResult;
@@ -22,17 +20,14 @@
 
 @RunWith(Parameterized.class)
 public class FailingMethodEnumUnboxingTest extends EnumUnboxingTestBase {
-
   private static final Class<?>[] FAILURES = {
     InstanceFieldPutObject.class,
     StaticFieldPutObject.class,
-    ToString.class,
     EnumSetTest.class,
     FailingPhi.class,
     FailingReturnType.class,
     FailingParameterType.class
   };
-
   private final TestParameters parameters;
   private final boolean enumValueOptimization;
   private final EnumKeepRules enumKeepRules;
@@ -83,18 +78,15 @@
 
   private void assertEnumsAsExpected(CodeInspector inspector) {
     // Check all as expected (else we test nothing)
-
     assertEquals(
         1,
         inspector.clazz(InstanceFieldPutObject.class).getDexProgramClass().instanceFields().size());
     assertEquals(
         1, inspector.clazz(StaticFieldPutObject.class).getDexProgramClass().staticFields().size());
-
     assertTrue(inspector.clazz(FailingPhi.class).uniqueMethodWithName("switchOn").isPresent());
   }
 
   static class InstanceFieldPutObject {
-
     @NeverClassInline
     enum MyEnum {
       A,
@@ -119,7 +111,6 @@
   }
 
   static class StaticFieldPutObject {
-
     @NeverClassInline
     enum MyEnum {
       A,
@@ -142,24 +133,7 @@
     }
   }
 
-  static class ToString {
-
-    @NeverClassInline
-    enum MyEnum {
-      A,
-      B,
-      C
-    }
-
-    public static void main(String[] args) {
-      MyEnum e1 = MyEnum.A;
-      System.out.println(e1.toString());
-      System.out.println("A");
-    }
-  }
-
   static class EnumSetTest {
-
     @NeverClassInline
     enum MyEnum {
       A,
@@ -175,7 +149,6 @@
   }
 
   static class FailingPhi {
-
     @NeverClassInline
     enum MyEnum {
       A,
@@ -189,7 +162,6 @@
       System.out.println(switchOn(2));
       System.out.println("class java.lang.Object");
     }
-
     // Avoid removing the switch entirely.
     @NeverInline
     static Object switchOn(int i) {
@@ -205,7 +177,6 @@
   }
 
   static class FailingReturnType {
-
     @NeverClassInline
     enum MyEnum {
       A,
@@ -227,7 +198,6 @@
   }
 
   static class FailingParameterType {
-
     @NeverClassInline
     enum MyEnum {
       A,
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/InstanceFieldsEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/InstanceFieldsEnumUnboxingTest.java
new file mode 100644
index 0000000..e91be2b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/InstanceFieldsEnumUnboxingTest.java
@@ -0,0 +1,549 @@
+// 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.enumunboxing;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestParameters;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class InstanceFieldsEnumUnboxingTest extends EnumUnboxingTestBase {
+
+  private static final Class<?>[] FAILURES = {
+    FailureIntField.class,
+    FailurePrivateIntField.class,
+    FailureBoxedInnerEnumField.class,
+    FailureUnboxedEnumField.class,
+    FailureTooManyUsedFields.class
+  };
+
+  private static final Class<?>[] SUCCESSES = {
+    SuccessUnusedField.class,
+    SuccessIntField.class,
+    SuccessDoubleField.class,
+    SuccessIntFieldOrdinal.class,
+    SuccessIntFieldInitializerInit.class,
+    SuccessStringField.class,
+    SuccessMultiConstructorIntField.class
+  };
+
+  private final TestParameters parameters;
+  private final boolean enumValueOptimization;
+  private final EnumKeepRules enumKeepRules;
+
+  @Parameters(name = "{0} valueOpt: {1} keep: {2}")
+  public static List<Object[]> data() {
+    return enumUnboxingTestParameters();
+  }
+
+  public InstanceFieldsEnumUnboxingTest(
+      TestParameters parameters, boolean enumValueOptimization, EnumKeepRules enumKeepRules) {
+    this.parameters = parameters;
+    this.enumValueOptimization = enumValueOptimization;
+    this.enumKeepRules = enumKeepRules;
+  }
+
+  @Test
+  public void testEnumUnboxing() throws Exception {
+    R8TestCompileResult compile =
+        testForR8(parameters.getBackend())
+            .addInnerClasses(InstanceFieldsEnumUnboxingTest.class)
+            .addKeepMainRules(SUCCESSES)
+            .addKeepMainRules(FAILURES)
+            .noMinification()
+            .enableInliningAnnotations()
+            .enableNeverClassInliningAnnotations()
+            .addKeepRules(enumKeepRules.getKeepRules())
+            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+            .allowDiagnosticInfoMessages()
+            .setMinApi(parameters.getApiLevel())
+            .compile();
+    for (Class<?> failure : FAILURES) {
+      testClass(compile, failure, true);
+    }
+    for (Class<?> success : SUCCESSES) {
+      testClass(compile, success, success != SuccessUnusedField.class);
+    }
+  }
+
+  private void testClass(R8TestCompileResult compile, Class<?> testClass, boolean failure)
+      throws Exception {
+    R8TestRunResult run =
+        compile
+            .inspectDiagnosticMessages(
+                m -> {
+                  for (Class<?> declaredClass : testClass.getDeclaredClasses()) {
+                    if (declaredClass.isEnum()
+                        && !declaredClass.getSimpleName().equals("InnerEnum")) {
+                      if (failure) {
+                        assertEnumIsBoxed(declaredClass, testClass.getSimpleName(), m);
+                      } else {
+                        assertEnumIsUnboxed(declaredClass, testClass.getSimpleName(), m);
+                      }
+                    }
+                  }
+                })
+            .run(parameters.getRuntime(), testClass)
+            .assertSuccess();
+    assertLines2By2Correct(run.getStdOut());
+  }
+
+  static class SuccessUnusedField {
+
+    public static void main(String[] args) {
+      System.out.println(getEnumA().ordinal());
+      System.out.println(0);
+      System.out.println(getEnumB().ordinal());
+      System.out.println(1);
+    }
+
+    @NeverInline
+    static EnumField getEnumA() {
+      return System.currentTimeMillis() > 0 ? EnumField.A : EnumField.B;
+    }
+
+    @NeverInline
+    static EnumField getEnumB() {
+      return System.currentTimeMillis() > 0 ? EnumField.B : EnumField.A;
+    }
+
+    @NeverClassInline
+    enum EnumField {
+      A(10),
+      B(20);
+
+      int field;
+
+      EnumField(int i) {
+        this.field = i;
+      }
+    }
+  }
+
+  static class SuccessIntField {
+
+    public static void main(String[] args) {
+      System.out.println(getEnumA().field);
+      System.out.println(10);
+      System.out.println(getEnumB().field);
+      System.out.println(20);
+    }
+
+    @NeverInline
+    static EnumField getEnumA() {
+      return System.currentTimeMillis() > 0 ? EnumField.A : EnumField.B;
+    }
+
+    @NeverInline
+    static EnumField getEnumB() {
+      return System.currentTimeMillis() > 0 ? EnumField.B : EnumField.A;
+    }
+
+    @NeverClassInline
+    enum EnumField {
+      A(10),
+      B(20);
+
+      int field;
+
+      EnumField(int i) {
+        this.field = i;
+      }
+    }
+  }
+
+  static class FailurePrivateIntField {
+
+    public static void main(String[] args) {
+      System.out.println(getEnumA().field);
+      System.out.println(10);
+      System.out.println(getEnumB().field);
+      System.out.println(20);
+    }
+
+    @NeverInline
+    static EnumField getEnumA() {
+      return System.currentTimeMillis() > 0 ? EnumField.A : EnumField.B;
+    }
+
+    @NeverInline
+    static EnumField getEnumB() {
+      return System.currentTimeMillis() > 0 ? EnumField.B : EnumField.A;
+    }
+
+    @NeverClassInline
+    enum EnumField {
+      A(10),
+      B(20);
+
+      private int field;
+
+      EnumField(int i) {
+        this.field = i;
+      }
+    }
+  }
+
+  static class SuccessDoubleField {
+
+    public static void main(String[] args) {
+      System.out.println(getEnumA().field);
+      System.out.println(10.0);
+      System.out.println(getEnumB().field);
+      System.out.println(20.0);
+    }
+
+    @NeverInline
+    static EnumField getEnumA() {
+      return System.currentTimeMillis() > 0 ? EnumField.A : EnumField.B;
+    }
+
+    @NeverInline
+    static EnumField getEnumB() {
+      return System.currentTimeMillis() > 0 ? EnumField.B : EnumField.A;
+    }
+
+    @NeverClassInline
+    enum EnumField {
+      A(10.0),
+      B(20.0);
+
+      double field;
+
+      EnumField(double d) {
+        this.field = d;
+      }
+    }
+  }
+
+  static class SuccessIntFieldInitializerInit {
+
+    public static void main(String[] args) {
+      System.out.println(getEnumA().field);
+      System.out.println(10);
+      System.out.println(getEnumB().field);
+      System.out.println(10);
+    }
+
+    @NeverInline
+    static EnumField getEnumA() {
+      return System.currentTimeMillis() > 0 ? EnumField.A : EnumField.B;
+    }
+
+    @NeverInline
+    static EnumField getEnumB() {
+      return System.currentTimeMillis() > 0 ? EnumField.B : EnumField.A;
+    }
+
+    @NeverClassInline
+    enum EnumField {
+      A,
+      B,
+      C;
+
+      int field;
+
+      EnumField() {
+        this.field = 10;
+      }
+    }
+  }
+
+  // This class test an optimization where the ordinal is re-used instead of the int field.
+  static class SuccessIntFieldOrdinal {
+
+    public static void main(String[] args) {
+      System.out.println(getEnumA().field);
+      System.out.println(0);
+      System.out.println(getEnumB().field);
+      System.out.println(1);
+    }
+
+    @NeverInline
+    static EnumField getEnumA() {
+      return System.currentTimeMillis() > 0 ? EnumField.A : EnumField.B;
+    }
+
+    @NeverInline
+    static EnumField getEnumB() {
+      return System.currentTimeMillis() > 0 ? EnumField.B : EnumField.A;
+    }
+
+    @NeverClassInline
+    enum EnumField {
+      A(0),
+      B(1),
+      C(2);
+
+      int field;
+
+      EnumField(int i) {
+        this.field = i;
+      }
+    }
+  }
+
+  static class FailureIntField {
+
+    public static void main(String[] args) {
+      System.out.println(getEnumA().field);
+      System.out.println(30);
+      System.out.println(getEnumB().field);
+      System.out.println(60);
+    }
+
+    @NeverInline
+    static EnumField getEnumA() {
+      return System.currentTimeMillis() > 0 ? EnumField.A : EnumField.B;
+    }
+
+    @NeverInline
+    static EnumField getEnumB() {
+      return System.currentTimeMillis() > 0 ? EnumField.B : EnumField.A;
+    }
+
+    @NeverClassInline
+    enum EnumField {
+      A(getRandom(10)),
+      B(getRandom(20)),
+      C(getRandom(30));
+
+      @NeverInline
+      static int getRandom(int i) {
+        return i * (System.currentTimeMillis() > 0 ? 3 : -3);
+      }
+
+      int field;
+
+      EnumField(int i) {
+        this.field = i;
+      }
+    }
+  }
+
+  static class FailureTooManyUsedFields {
+
+    public static void main(String[] args) {
+      System.out.println(getEnumA().field0);
+      System.out.println(0);
+      System.out.println(getEnumA().field1);
+      System.out.println(9);
+      System.out.println(getEnumA().field2);
+      System.out.println(8);
+      System.out.println(getEnumA().field3);
+      System.out.println(7);
+      System.out.println(getEnumA().field4);
+      System.out.println(6);
+      System.out.println(getEnumA().field5);
+      System.out.println(5);
+      System.out.println(getEnumA().field6);
+      System.out.println(4);
+      System.out.println(getEnumA().field7);
+      System.out.println(3);
+      System.out.println(getEnumA().field8);
+      System.out.println(2);
+      System.out.println(getEnumA().field9);
+      System.out.println(1);
+    }
+
+    @NeverInline
+    static EnumField getEnumA() {
+      return System.currentTimeMillis() > 0 ? EnumField.A : EnumField.B;
+    }
+
+    @NeverClassInline
+    enum EnumField {
+      A(1, 2, 3, 4, 5, 6, 7, 8, 9, 0),
+      B(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+
+      int field0;
+      int field1;
+      int field2;
+      int field3;
+      int field4;
+      int field5;
+      int field6;
+      int field7;
+      int field8;
+      int field9;
+
+      EnumField(int i9, int i8, int i7, int i6, int i5, int i4, int i3, int i2, int i1, int i0) {
+        this.field0 = i0;
+        this.field1 = i1;
+        this.field2 = i2;
+        this.field3 = i3;
+        this.field4 = i4;
+        this.field5 = i5;
+        this.field6 = i6;
+        this.field7 = i7;
+        this.field8 = i8;
+        this.field9 = i9;
+      }
+    }
+  }
+
+  static class SuccessMultiConstructorIntField {
+
+    public static void main(String[] args) {
+      System.out.println(getEnumA().field0);
+      System.out.println(10);
+      System.out.println(getEnumA().field1);
+      System.out.println(-1);
+      System.out.println(getEnumB().field0);
+      System.out.println(20);
+      System.out.println(getEnumB().field1);
+      System.out.println(30);
+    }
+
+    @NeverInline
+    static EnumField getEnumA() {
+      return System.currentTimeMillis() > 0 ? EnumField.A : EnumField.B;
+    }
+
+    @NeverInline
+    static EnumField getEnumB() {
+      return System.currentTimeMillis() > 0 ? EnumField.B : EnumField.A;
+    }
+
+    @NeverClassInline
+    enum EnumField {
+      A(10),
+      B(20, 30);
+
+      int field0;
+      int field1;
+
+      EnumField(int i0) {
+        this.field0 = i0;
+        this.field1 = -1;
+      }
+
+      EnumField(int i0, int i1) {
+        this.field0 = i0;
+        this.field1 = i1;
+      }
+    }
+  }
+
+  static class SuccessStringField {
+
+    public static void main(String[] args) {
+      System.out.println(getEnumA().field);
+      System.out.println("AA");
+      System.out.println(getEnumB().field);
+      System.out.println("BB");
+    }
+
+    @NeverInline
+    static EnumField getEnumA() {
+      return System.currentTimeMillis() > 0 ? EnumField.A : EnumField.B;
+    }
+
+    @NeverInline
+    static EnumField getEnumB() {
+      return System.currentTimeMillis() > 0 ? EnumField.B : EnumField.A;
+    }
+
+    @NeverClassInline
+    enum EnumField {
+      A("AA"),
+      B("BB"),
+      C("CC");
+
+      String field;
+
+      EnumField(String s) {
+        this.field = s;
+      }
+    }
+  }
+
+  static class FailureBoxedInnerEnumField {
+
+    public static void main(String[] args) {
+      System.out.println(getEnumA().field);
+      System.out.println("X");
+      System.out.println(getEnumB().field);
+      System.out.println("Y");
+    }
+
+    @NeverInline
+    static EnumField getEnumA() {
+      return System.currentTimeMillis() > 0 ? EnumField.A : EnumField.B;
+    }
+
+    @NeverInline
+    static EnumField getEnumB() {
+      return System.currentTimeMillis() > 0 ? EnumField.B : EnumField.A;
+    }
+
+    @NeverClassInline
+    enum InnerEnum {
+      X,
+      Y,
+      Z;
+    }
+
+    @NeverClassInline
+    enum EnumField {
+      A(InnerEnum.X),
+      B(InnerEnum.Y),
+      C(InnerEnum.Z);
+
+      InnerEnum field;
+
+      EnumField(InnerEnum s) {
+        this.field = s;
+      }
+    }
+  }
+
+  static class FailureUnboxedEnumField {
+
+    public static void main(String[] args) {
+      System.out.println(getEnumA().field.ordinal());
+      System.out.println(0);
+      System.out.println(getEnumB().field.ordinal());
+      System.out.println(1);
+    }
+
+    @NeverInline
+    static EnumField getEnumA() {
+      return System.currentTimeMillis() > 0 ? EnumField.A : EnumField.B;
+    }
+
+    @NeverInline
+    static EnumField getEnumB() {
+      return System.currentTimeMillis() > 0 ? EnumField.B : EnumField.A;
+    }
+
+    @NeverClassInline
+    enum InnerEnum {
+      X,
+      Y,
+      Z;
+    }
+
+    @NeverClassInline
+    enum EnumField {
+      A(InnerEnum.X),
+      B(InnerEnum.Y),
+      C(InnerEnum.Z);
+
+      InnerEnum field;
+
+      EnumField(InnerEnum s) {
+        this.field = s;
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/OrdinalHashCodeEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/OrdinalHashCodeEnumUnboxingTest.java
index 79f9176..1946116 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/OrdinalHashCodeEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/OrdinalHashCodeEnumUnboxingTest.java
@@ -5,6 +5,7 @@
 package com.android.tools.r8.enumunboxing;
 
 import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
@@ -43,6 +44,7 @@
             .addKeepMainRule(classToTest)
             .addKeepRules(enumKeepRules.getKeepRules())
             .enableNeverClassInliningAnnotations()
+            .enableInliningAnnotations()
             .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
             .allowDiagnosticInfoMessages()
             .setMinApi(parameters.getApiLevel())
@@ -66,8 +68,29 @@
     public static void main(String[] args) {
       System.out.println(MyEnum.A.ordinal());
       System.out.println(0);
-      System.out.println(MyEnum.A.hashCode());
+      System.out.println(ordinal(MyEnum.A));
       System.out.println(0);
+      System.out.println(ordinal(MyEnum.B));
+      System.out.println(1);
+      System.out.println(MyEnum.A.hashCode());
+      System.out.println(MyEnum.A.hashCode());
+      System.out.println(hash(MyEnum.A));
+      System.out.println(System.identityHashCode(MyEnum.A));
+      System.out.println(hash(null));
+      System.out.println(0);
+      Object o = new Object();
+      System.out.println(System.identityHashCode(o));
+      System.out.println(o.hashCode());
+    }
+
+    @NeverInline
+    private static int hash(MyEnum e) {
+      return System.identityHashCode(e);
+    }
+
+    @NeverInline
+    private static int ordinal(MyEnum e) {
+      return e.ordinal();
     }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/UnusedCaseEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/UnusedCaseEnumUnboxingTest.java
new file mode 100644
index 0000000..a6b7027
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/UnusedCaseEnumUnboxingTest.java
@@ -0,0 +1,98 @@
+// 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.enumunboxing;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class UnusedCaseEnumUnboxingTest extends EnumUnboxingTestBase {
+  private final TestParameters parameters;
+  private final boolean enumValueOptimization;
+  private final EnumKeepRules enumKeepRules;
+
+  @Parameterized.Parameters(name = "{0} valueOpt: {1} keep: {2}")
+  public static List<Object[]> data() {
+    return enumUnboxingTestParameters();
+  }
+
+  public UnusedCaseEnumUnboxingTest(
+      TestParameters parameters, boolean enumValueOptimization, EnumKeepRules enumKeepRules) {
+    this.parameters = parameters;
+    this.enumValueOptimization = enumValueOptimization;
+    this.enumKeepRules = enumKeepRules;
+  }
+
+  @Test
+  public void testEnumUnboxing() throws Exception {
+    R8TestRunResult run =
+        testForR8(parameters.getBackend())
+            .addInnerClasses(UnusedCaseEnumUnboxingTest.class)
+            .addKeepMainRule(Main.class)
+            .enableNeverClassInliningAnnotations()
+            .enableInliningAnnotations()
+            .addKeepRules(enumKeepRules.getKeepRules())
+            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+            .allowDiagnosticInfoMessages()
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .inspect(this::assertFieldsRemoved)
+            .inspectDiagnosticMessages(
+                m -> assertEnumIsUnboxed(MyEnum.class, Main.class.getSimpleName(), m))
+            .run(parameters.getRuntime(), Main.class)
+            .assertSuccess();
+    assertLines2By2Correct(run.getStdOut());
+  }
+
+  private void assertFieldsRemoved(CodeInspector codeInspector) {
+    codeInspector.clazz(Main.class);
+  }
+
+  @NeverClassInline
+  enum MyEnum {
+    USED1("used1"),
+    UNUSED1("unused1"),
+    USED2("used2"),
+    UNUSED2("unused2");
+
+    final String myField;
+
+    MyEnum(String data) {
+      this.myField = data;
+    }
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      printEnumField(MyEnum.USED1);
+      System.out.println("used1");
+      printEnumField(MyEnum.USED2);
+      System.out.println("used2");
+
+      printOrdinal(MyEnum.USED1);
+      System.out.println("0");
+      printOrdinal(MyEnum.USED2);
+      System.out.println("2");
+    }
+
+    @NeverInline
+    private static void printEnumField(MyEnum e) {
+      System.out.println(e.myField);
+    }
+
+    @NeverInline
+    private static void printOrdinal(MyEnum e) {
+      System.out.println(e.ordinal());
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/internal/YouTubeCompilationBase.java b/src/test/java/com/android/tools/r8/internal/YouTubeCompilationBase.java
index a6dd6b0..c8be865 100644
--- a/src/test/java/com/android/tools/r8/internal/YouTubeCompilationBase.java
+++ b/src/test/java/com/android/tools/r8/internal/YouTubeCompilationBase.java
@@ -22,6 +22,7 @@
   static final String PG_MAP = "YouTubeRelease_proguard.map";
   static final String PG_CONF = "YouTubeRelease_proguard.config";
   static final String PG_PROTO_CONF = "YouTubeRelease_proto_safety.pgconf";
+  static final String PG_MISSING_CLASSES_CONF = "YouTubeRelease_proguard_missing_classes.config";
 
   final String base;
 
@@ -38,9 +39,11 @@
     ImmutableList.Builder<Path> builder = ImmutableList.builder();
     builder.add(Paths.get(base).resolve(PG_CONF));
     builder.add(Paths.get(ToolHelper.PROGUARD_SETTINGS_FOR_INTERNAL_APPS).resolve(PG_CONF));
-    Path config = Paths.get(base).resolve(PG_PROTO_CONF);
-    if (config.toFile().exists()) {
-      builder.add(config);
+    for (String name : new String[] {PG_PROTO_CONF, PG_MISSING_CLASSES_CONF}) {
+      Path config = Paths.get(base).resolve(name);
+      if (config.toFile().exists()) {
+        builder.add(config);
+      }
     }
     return builder.build();
   }
diff --git a/src/test/java/com/android/tools/r8/internal/YouTubeV1533TreeShakeJarVerificationTest.java b/src/test/java/com/android/tools/r8/internal/YouTubeV1533TreeShakeJarVerificationTest.java
new file mode 100644
index 0000000..632210e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/internal/YouTubeV1533TreeShakeJarVerificationTest.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.internal;
+
+import static com.android.tools.r8.ToolHelper.isLocalDevelopment;
+import static com.android.tools.r8.ToolHelper.shouldRunSlowTests;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.analysis.ProtoApplicationStats;
+import java.nio.file.Paths;
+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 YouTubeV1533TreeShakeJarVerificationTest extends YouTubeCompilationBase {
+
+  private static final boolean DUMP = false;
+  private static final int MAX_SIZE = 27500000;
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withNoneRuntime().build();
+  }
+
+  public YouTubeV1533TreeShakeJarVerificationTest(TestParameters parameters) {
+    super(15, 33);
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    // TODO(b/141603168): Enable this on the bots.
+    assumeTrue(isLocalDevelopment());
+    assumeTrue(shouldRunSlowTests());
+
+    LibrarySanitizer librarySanitizer =
+        new LibrarySanitizer(temp)
+            .addProgramFiles(getProgramFiles())
+            .addLibraryFiles(getLibraryFiles())
+            .sanitize()
+            .assertSanitizedProguardConfigurationIsEmpty();
+
+    R8TestCompileResult compileResult =
+        testForR8(Backend.DEX)
+            .addProgramFiles(getProgramFiles())
+            .addLibraryFiles(librarySanitizer.getSanitizedLibrary())
+            .addKeepRuleFiles(getKeepRuleFiles())
+            .addMainDexRuleFiles(getMainDexRuleFiles())
+            .allowDiagnosticMessages()
+            .allowUnusedProguardConfigurationRules()
+            .setMinApi(AndroidApiLevel.H_MR2)
+            .compile();
+
+    if (ToolHelper.isLocalDevelopment()) {
+      if (DUMP) {
+        long time = System.currentTimeMillis();
+        compileResult.writeToZip(Paths.get("YouTubeV1533-" + time + ".zip"));
+        compileResult.writeProguardMap(Paths.get("YouTubeV1533-" + time + ".map"));
+      }
+
+      DexItemFactory dexItemFactory = new DexItemFactory();
+      ProtoApplicationStats original =
+          new ProtoApplicationStats(dexItemFactory, new CodeInspector(getProgramFiles()));
+      ProtoApplicationStats actual =
+          new ProtoApplicationStats(dexItemFactory, compileResult.inspector(), original);
+      ProtoApplicationStats baseline =
+          new ProtoApplicationStats(
+              dexItemFactory,
+              new CodeInspector(getReleaseApk(), getReleaseProguardMap().toString()));
+      System.out.println(actual.getStats(baseline));
+    }
+
+    int applicationSize = compileResult.app.applicationSize();
+    System.out.println(applicationSize);
+
+    assertTrue(
+        "Expected max size of " + MAX_SIZE + ", got " + applicationSize,
+        applicationSize < MAX_SIZE);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/IrInjectionTestBase.java b/src/test/java/com/android/tools/r8/ir/IrInjectionTestBase.java
index a031cf8..b351ca2 100644
--- a/src/test/java/com/android/tools/r8/ir/IrInjectionTestBase.java
+++ b/src/test/java/com/android/tools/r8/ir/IrInjectionTestBase.java
@@ -100,9 +100,10 @@
       return iterator;
     }
 
-    private AndroidApp writeDex(DexApplication application, InternalOptions options) {
+    private AndroidApp writeDex() {
       try {
-        ToolHelper.writeApplication(application, options);
+        InternalOptions options = appView.options();
+        ToolHelper.writeApplication(appView, options);
         options.signalFinishedToConsumers();
         return consumers.build();
       } catch (ExecutionException e) {
@@ -114,7 +115,7 @@
       Timing timing = Timing.empty();
       IRConverter converter = new IRConverter(appView, timing, null, MainDexClasses.NONE);
       converter.replaceCodeForTesting(method, code);
-      AndroidApp app = writeDex(application, appView.options());
+      AndroidApp app = writeDex();
       return runOnArtRaw(app, DEFAULT_MAIN_CLASS_NAME).stdout;
     }
   }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
index 1d7f782..807b061 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
@@ -359,7 +359,9 @@
     assertEquals(0, invokeCount);
 
     // The enum parameter may get unboxed.
-    m = clazz.uniqueMethodWithName("moreControlFlows");
+    m =
+        clazz.uniqueMethodWithName(
+            parameters.isCfRuntime() ? "moreControlFlows" : "moreControlFlows$enumunboxing$");
     assertTrue(m.isPresent());
 
     // Verify that a.b() is resolved to an inline instance-get.
diff --git a/src/test/java/com/android/tools/r8/naming/RenameSourceFileRetraceTest.java b/src/test/java/com/android/tools/r8/naming/RenameSourceFileRetraceTest.java
index 6f5aade..5dfd98f 100644
--- a/src/test/java/com/android/tools/r8/naming/RenameSourceFileRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/RenameSourceFileRetraceTest.java
@@ -109,11 +109,12 @@
   }
 
   private String getDefaultExpectedName(String name) {
-    if (!isCompat && !keepSourceFile) {
-      return null;
-    } else {
-      return name;
+    if (!keepSourceFile) {
+      if (parameters.getBackend() == Backend.CF || !isCompat) {
+        return null;
+      }
     }
+    return name;
   }
 
   private void inspectOutput(
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/DesugarLambdaRetraceTest.java b/src/test/java/com/android/tools/r8/naming/retrace/DesugarLambdaRetraceTest.java
index a55e1d5..3959d84 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/DesugarLambdaRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/DesugarLambdaRetraceTest.java
@@ -127,6 +127,7 @@
   @Test
   public void testLineNumberTableOnly() throws Exception {
     assumeTrue(compat);
+    assumeTrue(parameters.isDexRuntime());
     runTest(
         ImmutableList.of("-keepattributes LineNumberTable"), this::checkIsSameExceptForFileName);
   }
@@ -134,6 +135,7 @@
   @Test
   public void testNoLineNumberTable() throws Exception {
     assumeTrue(compat);
+    assumeTrue(parameters.isDexRuntime());
     runTest(ImmutableList.of(), this::checkIsSameExceptForFileNameAndLineNumber);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/InliningRetraceTest.java b/src/test/java/com/android/tools/r8/naming/retrace/InliningRetraceTest.java
index 5562395..2ffe206 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/InliningRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/InliningRetraceTest.java
@@ -61,6 +61,7 @@
   @Test
   public void testLineNumberTableOnly() throws Exception {
     assumeTrue(compat);
+    assumeTrue(parameters.isDexRuntime());
     runTest(
         ImmutableList.of("-keepattributes LineNumberTable"),
         (StackTrace actualStackTrace, StackTrace retracedStackTrace) -> {
@@ -72,6 +73,7 @@
   @Test
   public void testNoLineNumberTable() throws Exception {
     assumeTrue(compat);
+    assumeTrue(parameters.isDexRuntime());
     runTest(
         ImmutableList.of(),
         (StackTrace actualStackTrace, StackTrace retracedStackTrace) -> {
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/VerticalClassMergingRetraceTest.java b/src/test/java/com/android/tools/r8/naming/retrace/VerticalClassMergingRetraceTest.java
index 46da60b..0482945 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/VerticalClassMergingRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/VerticalClassMergingRetraceTest.java
@@ -93,6 +93,7 @@
   @Test
   public void testLineNumberTableOnly() throws Exception {
     assumeTrue(compat);
+    assumeTrue(parameters.isDexRuntime());
     runTest(
         ImmutableList.of("-keepattributes LineNumberTable"),
         (StackTrace actualStackTrace, StackTrace retracedStackTrace) -> {
@@ -132,6 +133,7 @@
     // at com.android.tools.r8.naming.retraceproguard.MainApp.main(MainApp.java:7)
     // since the synthetic bridge belongs to ResourceWrapper.foo.
     assumeTrue(compat);
+    assumeTrue(parameters.isDexRuntime());
     haveSeenLines.clear();
     runTest(
         ImmutableList.of(),
diff --git a/src/test/java/com/android/tools/r8/naming/retraceproguard/InliningRetraceTest.java b/src/test/java/com/android/tools/r8/naming/retraceproguard/InliningRetraceTest.java
index aafa229..8d94fc8 100644
--- a/src/test/java/com/android/tools/r8/naming/retraceproguard/InliningRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retraceproguard/InliningRetraceTest.java
@@ -61,6 +61,7 @@
   @Test
   public void testLineNumberTableOnly() throws Exception {
     assumeTrue(compat);
+    assumeTrue(backend == Backend.DEX);
     runTest(
         ImmutableList.of("-keepattributes LineNumberTable"),
         (StackTrace actualStackTrace, StackTrace retracedStackTrace) -> {
@@ -72,6 +73,7 @@
   @Test
   public void testNoLineNumberTable() throws Exception {
     assumeTrue(compat);
+    assumeTrue(backend == Backend.DEX);
     runTest(
         ImmutableList.of(),
         (StackTrace actualStackTrace, StackTrace retracedStackTrace) -> {
diff --git a/src/test/java/com/android/tools/r8/naming/retraceproguard/VerticalClassMergingRetraceTest.java b/src/test/java/com/android/tools/r8/naming/retraceproguard/VerticalClassMergingRetraceTest.java
index 2874bf9..41c6451 100644
--- a/src/test/java/com/android/tools/r8/naming/retraceproguard/VerticalClassMergingRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retraceproguard/VerticalClassMergingRetraceTest.java
@@ -87,6 +87,7 @@
   @Test
   public void testLineNumberTableOnly() throws Exception {
     assumeTrue(compat);
+    assumeTrue(backend == Backend.DEX);
     runTest(
         ImmutableList.of("-keepattributes LineNumberTable"),
         (StackTrace actualStackTrace, StackTrace retracedStackTrace) -> {
@@ -102,6 +103,7 @@
   @Test
   public void testNoLineNumberTable() throws Exception {
     assumeTrue(compat);
+    assumeTrue(backend == Backend.DEX);
     haveSeenLines.clear();
     runTest(
         ImmutableList.of(),
diff --git a/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/NoFieldMembersTest.java b/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/EmptyClassTest.java
similarity index 65%
copy from src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/NoFieldMembersTest.java
copy to src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/EmptyClassTest.java
index 8dfe240..e0d9a33 100644
--- a/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/NoFieldMembersTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/EmptyClassTest.java
@@ -6,20 +6,23 @@
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsNot.not;
 
-import com.android.tools.r8.*;
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.utils.BooleanUtils;
-import java.util.*;
+import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
 @RunWith(Parameterized.class)
-public class NoFieldMembersTest extends TestBase {
+public class EmptyClassTest extends TestBase {
   private final TestParameters parameters;
   private final boolean enableHorizontalClassMerging;
 
-  public NoFieldMembersTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
+  public EmptyClassTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
     this.parameters = parameters;
     this.enableHorizontalClassMerging = enableHorizontalClassMerging;
   }
@@ -33,26 +36,20 @@
   @Test
   public void testR8() throws Exception {
     testForR8(parameters.getBackend())
-        .addInnerClasses(NoFieldMembersTest.class)
+        .addInnerClasses(EmptyClassTest.class)
         .addKeepMainRule(Main.class)
         .addOptionsModification(
             options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
-        .enableInliningAnnotations()
         .enableNeverClassInliningAnnotations()
         .setMinApi(parameters.getApiLevel())
         .run(parameters.getRuntime(), Main.class)
-        .assertSuccessWithOutputLines("foo", "bar")
+        .assertSuccess()
         .inspect(
             codeInspector -> {
               if (enableHorizontalClassMerging) {
-                // TODO(b/163311975): A and B should be merged
-                //
-                //                        Class[] classes = { A.class, B.class };
-                //                        assertEquals(1, Arrays.stream(classes)
-                //                                .filter(a -> codeInspector.clazz(a).isPresent())
-                //                                .count());
                 assertThat(codeInspector.clazz(A.class), isPresent());
-                assertThat(codeInspector.clazz(B.class), isPresent());
+                assertThat(codeInspector.clazz(B.class), not(isPresent()));
+                // TODO(b/165517236): Explicitly check classes have been merged.
               } else {
                 assertThat(codeInspector.clazz(A.class), isPresent());
                 assertThat(codeInspector.clazz(B.class), isPresent());
@@ -61,27 +58,20 @@
   }
 
   @NeverClassInline
-  public static class A {
-    @NeverInline
-    public void foo() {
-      System.out.println("foo");
-    }
-  }
+  public static class A {}
 
   @NeverClassInline
   public static class B {
-    @NeverInline
-    public void bar() {
-      System.out.println("bar");
-    }
+    // TODO(b/164924717): remove non overlapping constructor requirement
+    public B(String s) {}
   }
 
   public static class Main {
     public static void main(String[] args) {
       A a = new A();
-      a.foo();
-      B b = new B();
-      b.bar();
+      System.out.println(a);
+      B b = new B("");
+      System.out.println(b);
     }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/IdenticalFieldMembersTest.java b/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/IdenticalFieldMembersTest.java
index 456c4cb..7935860 100644
--- a/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/IdenticalFieldMembersTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/IdenticalFieldMembersTest.java
@@ -42,18 +42,15 @@
         .enableNeverClassInliningAnnotations()
         .setMinApi(parameters.getApiLevel())
         .run(parameters.getRuntime(), Main.class)
-        .assertSuccessWithOutputLines("foo A", "bar B")
+        .assertSuccessWithOutputLines("foo A", "bar 2")
         .inspect(
             codeInspector -> {
               if (enableHorizontalClassMerging) {
-                // TODO(b/163311975): A and B should be merged
-                //
-                //                        Class[] classes = {A.class, B.class};
-                //                        assertEquals(1, Arrays.stream(classes)
-                //                                .filter(a -> codeInspector.clazz(a).isPresent())
-                //                                .count());
                 assertThat(codeInspector.clazz(A.class), isPresent());
                 assertThat(codeInspector.clazz(B.class), isPresent());
+                // TODO(b/163311975): A and B should be merged
+                //   assertThat(codeInspector.clazz(B.class), not(isPresent()));
+                // TODO(b/165517236): Explicitly check classes have been merged.
               } else {
                 assertThat(codeInspector.clazz(A.class), isPresent());
                 assertThat(codeInspector.clazz(B.class), isPresent());
@@ -79,8 +76,8 @@
   public static class B {
     private String field;
 
-    public B(String v) {
-      this.field = v;
+    public B(int v) {
+      this.field = Integer.toString(v);
     }
 
     @NeverInline
@@ -93,7 +90,7 @@
     public static void main(String[] args) {
       A a = new A("A");
       a.foo();
-      B b = new B("B");
+      B b = new B(2);
       b.bar();
     }
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/NoOverlappingConstructorsPolicyTest.java b/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/NoOverlappingConstructorsPolicyTest.java
new file mode 100644
index 0000000..e646087
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/NoOverlappingConstructorsPolicyTest.java
@@ -0,0 +1,102 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.shaking.horizontalclassmerging;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsNot.not;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.shaking.horizontalclassmerging.EmptyClassTest.A;
+import com.android.tools.r8.shaking.horizontalclassmerging.EmptyClassTest.B;
+import com.android.tools.r8.shaking.horizontalclassmerging.EmptyClassTest.Main;
+import com.android.tools.r8.utils.BooleanUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class NoOverlappingConstructorsPolicyTest extends TestBase {
+  private final TestParameters parameters;
+  private final boolean enableHorizontalClassMerging;
+
+  public NoOverlappingConstructorsPolicyTest(
+      TestParameters parameters, boolean enableHorizontalClassMerging) {
+    this.parameters = parameters;
+    this.enableHorizontalClassMerging = enableHorizontalClassMerging;
+  }
+
+  @Parameterized.Parameters(name = "{0}, horizontalClassMerging:{1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.values());
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(this.getClass())
+        .addKeepMainRule(Main.class)
+        .addOptionsModification(
+            options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
+        .enableNeverClassInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), Main.class)
+        .inspect(
+            codeInspector -> {
+              if (enableHorizontalClassMerging) {
+                assertThat(codeInspector.clazz(A.class), isPresent());
+                assertThat(codeInspector.clazz(B.class), isPresent());
+                assertThat(codeInspector.clazz(C.class), not(isPresent()));
+                // TODO(b/165517236): Explicitly check classes have been merged.
+              } else {
+                assertThat(codeInspector.clazz(A.class), isPresent());
+                assertThat(codeInspector.clazz(B.class), isPresent());
+                assertThat(codeInspector.clazz(C.class), isPresent());
+              }
+            });
+  }
+
+  @NeverClassInline
+  public static class A {
+    public A(String s) {
+      System.out.println(s);
+    }
+  }
+
+  @NeverClassInline
+  public static class B {
+    public B(String s) {
+      System.out.println(s);
+    }
+
+    public B(boolean b) {
+      System.out.println(b);
+    }
+  }
+
+  @NeverClassInline
+  public static class C {
+    public C(boolean b) {
+      System.out.println(b);
+    }
+  }
+
+  public static class Main {
+    public static void main(String[] args) {
+      A a = new A("foo");
+      System.out.println(a);
+      B b1 = new B("");
+      System.out.println(b1);
+      B b2 = new B(false);
+      System.out.println(b2);
+      C c = new C(true);
+      System.out.println(c);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/RemapMethodTest.java b/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/RemapMethodTest.java
new file mode 100644
index 0000000..97df366
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/RemapMethodTest.java
@@ -0,0 +1,127 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.shaking.horizontalclassmerging;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsNot.not;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.BooleanUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class RemapMethodTest extends TestBase {
+  private final TestParameters parameters;
+  private final boolean enableHorizontalClassMerging;
+
+  public RemapMethodTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
+    this.parameters = parameters;
+    this.enableHorizontalClassMerging = enableHorizontalClassMerging;
+  }
+
+  @Parameterized.Parameters(name = "{0}, horizontalClassMerging:{1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.values());
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(this.getClass())
+        .addKeepMainRule(Main.class)
+        .addOptionsModification(
+            options -> {
+              options.enableHorizontalClassMerging = enableHorizontalClassMerging;
+              options.enableVerticalClassMerging = false;
+            })
+        .enableInliningAnnotations()
+        .enableNeverClassInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        // .run(parameters.getRuntime(), Main.class)
+        // .assertSuccessWithOutputLines("foo", "foo", "bar", "bar")
+        .inspect(
+            codeInspector -> {
+              assertThat(codeInspector.clazz(A.class), isPresent());
+              assertThat(codeInspector.clazz(C.class), isPresent());
+              if (enableHorizontalClassMerging) {
+                assertThat(codeInspector.clazz(B.class), not(isPresent()));
+                assertThat(codeInspector.clazz(D.class), not(isPresent()));
+                // TODO(b/165517236): Explicitly check classes have been merged.
+              } else {
+                assertThat(codeInspector.clazz(B.class), isPresent());
+                assertThat(codeInspector.clazz(D.class), isPresent());
+              }
+            });
+  }
+
+  @NeverClassInline
+  public static class A {
+    @NeverInline
+    public void foo() {
+      System.out.println("foo");
+    }
+  }
+
+  @NeverClassInline
+  public static class B {
+    // TODO(b/164924717): remove non overlapping constructor requirement
+    public B(String s) {}
+
+    @NeverInline
+    public void bar(D d) {
+      d.bar();
+    }
+  }
+
+  @NeverClassInline
+  public static class Other {
+    String field;
+
+    public Other() {
+      field = "";
+    }
+  }
+
+  @NeverClassInline
+  public static class C extends Other {
+    @NeverInline
+    public void foo() {
+      System.out.println("foo");
+    }
+  }
+
+  @NeverClassInline
+  public static class D extends Other {
+    public D(String s) {
+      System.out.println(s);
+    }
+
+    @NeverInline
+    public void bar() {
+      System.out.println("bar");
+    }
+  }
+
+  public static class Main {
+    public static void main(String[] args) {
+      A a = new A();
+      a.foo();
+      B b = new B("bar");
+      C c = new C();
+      c.foo();
+      D d = new D("bar");
+      b.bar(d);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/NoFieldMembersTest.java b/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/VirtualMethodNotOverlappingTest.java
similarity index 76%
rename from src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/NoFieldMembersTest.java
rename to src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/VirtualMethodNotOverlappingTest.java
index 8dfe240..711f217 100644
--- a/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/NoFieldMembersTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/horizontalclassmerging/VirtualMethodNotOverlappingTest.java
@@ -6,6 +6,7 @@
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsNot.not;
 
 import com.android.tools.r8.*;
 import com.android.tools.r8.utils.BooleanUtils;
@@ -15,11 +16,12 @@
 import org.junit.runners.Parameterized;
 
 @RunWith(Parameterized.class)
-public class NoFieldMembersTest extends TestBase {
+public class VirtualMethodNotOverlappingTest extends TestBase {
   private final TestParameters parameters;
   private final boolean enableHorizontalClassMerging;
 
-  public NoFieldMembersTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
+  public VirtualMethodNotOverlappingTest(
+      TestParameters parameters, boolean enableHorizontalClassMerging) {
     this.parameters = parameters;
     this.enableHorizontalClassMerging = enableHorizontalClassMerging;
   }
@@ -33,7 +35,7 @@
   @Test
   public void testR8() throws Exception {
     testForR8(parameters.getBackend())
-        .addInnerClasses(NoFieldMembersTest.class)
+        .addInnerClasses(VirtualMethodNotOverlappingTest.class)
         .addKeepMainRule(Main.class)
         .addOptionsModification(
             options -> options.enableHorizontalClassMerging = enableHorizontalClassMerging)
@@ -45,14 +47,9 @@
         .inspect(
             codeInspector -> {
               if (enableHorizontalClassMerging) {
-                // TODO(b/163311975): A and B should be merged
-                //
-                //                        Class[] classes = { A.class, B.class };
-                //                        assertEquals(1, Arrays.stream(classes)
-                //                                .filter(a -> codeInspector.clazz(a).isPresent())
-                //                                .count());
                 assertThat(codeInspector.clazz(A.class), isPresent());
-                assertThat(codeInspector.clazz(B.class), isPresent());
+                assertThat(codeInspector.clazz(B.class), not(isPresent()));
+                // TODO(b/165517236): Explicitly check classes have been merged.
               } else {
                 assertThat(codeInspector.clazz(A.class), isPresent());
                 assertThat(codeInspector.clazz(B.class), isPresent());
@@ -70,6 +67,9 @@
 
   @NeverClassInline
   public static class B {
+    // TODO(b/164924717): remove non overlapping constructor requirement
+    public B(String s) {}
+
     @NeverInline
     public void bar() {
       System.out.println("bar");
@@ -80,7 +80,7 @@
     public static void main(String[] args) {
       A a = new A();
       a.foo();
-      B b = new B();
+      B b = new B("");
       b.bar();
     }
   }