diff --git a/src/main/java/com/android/tools/r8/D8.java b/src/main/java/com/android/tools/r8/D8.java
index 7310ecf..7335dbb 100644
--- a/src/main/java/com/android/tools/r8/D8.java
+++ b/src/main/java/com/android/tools/r8/D8.java
@@ -32,6 +32,7 @@
 import com.android.tools.r8.naming.signature.GenericSignatureRewriter;
 import com.android.tools.r8.origin.CommandLineOrigin;
 import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.synthesis.SyntheticFinalization;
 import com.android.tools.r8.synthesis.SyntheticItems;
 import com.android.tools.r8.utils.AndroidApp;
@@ -184,9 +185,9 @@
       SyntheticItems.collectSyntheticInputs(appView);
 
       if (!options.mainDexKeepRules.isEmpty()) {
-        new GenerateMainDexList(options)
-            .traceMainDex(
-                executor, appView.appInfo().app(), appView.appInfo().getMainDexClasses()::addAll);
+        MainDexInfo mainDexInfo =
+            new GenerateMainDexList(options).traceMainDex(executor, appView.appInfo().app());
+        appView.setAppInfo(appView.appInfo().rebuildWithMainDexInfo(mainDexInfo));
       }
 
       final CfgPrinter printer = options.printCfg ? new CfgPrinter() : null;
@@ -300,7 +301,7 @@
           appView.setAppInfo(
               new AppInfo(
                   appView.appInfo().getSyntheticItems().commit(app),
-                  appView.appInfo().getMainDexClasses()));
+                  appView.appInfo().getMainDexInfo()));
           namingLens = NamingLens.getIdentityLens();
         }
 
@@ -358,7 +359,7 @@
     appView.setAppInfo(
         new AppInfo(
             appView.appInfo().getSyntheticItems().commit(cfApp),
-            appView.appInfo().getMainDexClasses()));
+            appView.appInfo().getMainDexInfo()));
     ConvertedCfFiles convertedCfFiles = new ConvertedCfFiles();
     NamingLens prefixRewritingNamingLens =
         PrefixRewritingNamingLens.createPrefixRewritingNamingLens(appView);
diff --git a/src/main/java/com/android/tools/r8/D8Command.java b/src/main/java/com/android/tools/r8/D8Command.java
index da20df4..c5eac58 100644
--- a/src/main/java/com/android/tools/r8/D8Command.java
+++ b/src/main/java/com/android/tools/r8/D8Command.java
@@ -476,7 +476,6 @@
     assert !internal.enableEnumValueOptimization;
     assert !internal.outline.enabled;
     assert !internal.enableValuePropagation;
-    assert !internal.enableLambdaMerging;
     assert !internal.enableTreeShakingOfLibraryMethodOverrides;
 
     internal.desugarState = getDesugarState();
diff --git a/src/main/java/com/android/tools/r8/DexSplitterHelper.java b/src/main/java/com/android/tools/r8/DexSplitterHelper.java
index 0230729..7896d57 100644
--- a/src/main/java/com/android/tools/r8/DexSplitterHelper.java
+++ b/src/main/java/com/android/tools/r8/DexSplitterHelper.java
@@ -19,7 +19,7 @@
 import com.android.tools.r8.graph.LazyLoadedDexApplication;
 import com.android.tools.r8.naming.ClassNameMapper;
 import com.android.tools.r8.naming.NamingLens;
-import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.utils.ExceptionUtils;
 import com.android.tools.r8.utils.FeatureClassMapping;
 import com.android.tools.r8.utils.FeatureClassMapping.FeatureMappingException;
@@ -75,7 +75,7 @@
       ApplicationReader applicationReader =
           new ApplicationReader(command.getInputApp(), options, timing);
       DexApplication app = applicationReader.read(executor);
-      MainDexClasses mainDexClasses = applicationReader.readMainDexClasses(app);
+      MainDexInfo mainDexInfo = applicationReader.readMainDexClasses(app);
 
       List<Marker> markers = app.dexItemFactory.extractMarkers();
 
@@ -94,7 +94,7 @@
         // If this is the base, we add the main dex list.
         AppInfo appInfo =
             feature.equals(featureClassMapping.getBaseName())
-                ? AppInfo.createInitialAppInfo(featureApp, mainDexClasses)
+                ? AppInfo.createInitialAppInfo(featureApp, mainDexInfo)
                 : AppInfo.createInitialAppInfo(featureApp);
         AppView<AppInfo> appView = AppView.createForD8(appInfo);
 
diff --git a/src/main/java/com/android/tools/r8/GenerateMainDexList.java b/src/main/java/com/android/tools/r8/GenerateMainDexList.java
index f91a003..2ebde33 100644
--- a/src/main/java/com/android/tools/r8/GenerateMainDexList.java
+++ b/src/main/java/com/android/tools/r8/GenerateMainDexList.java
@@ -16,9 +16,9 @@
 import com.android.tools.r8.graph.SubtypingInfo;
 import com.android.tools.r8.shaking.Enqueuer;
 import com.android.tools.r8.shaking.EnqueuerFactory;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.shaking.MainDexListBuilder;
-import com.android.tools.r8.shaking.MainDexTracingResult;
-import com.android.tools.r8.shaking.RootSetUtils.RootSet;
+import com.android.tools.r8.shaking.RootSetUtils.MainDexRootSet;
 import com.android.tools.r8.shaking.WhyAreYouKeepingConsumer;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.Box;
@@ -28,20 +28,16 @@
 import com.android.tools.r8.utils.Timing;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
-import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
-import java.util.function.Consumer;
-import java.util.stream.Collectors;
 
 @Keep
 public class GenerateMainDexList {
   private final Timing timing = new Timing("maindex");
   private final InternalOptions options;
 
-  private List<String> result = null;
-
   public GenerateMainDexList(InternalOptions options) {
     this.options = options;
   }
@@ -49,32 +45,24 @@
   private List<String> run(AndroidApp app, ExecutorService executor)
       throws IOException {
     try {
+      // TODO(b/178231294): Clean up this such that we do not both return the result and call the
+      //  consumer.
       DexApplication application = new ApplicationReader(app, options, timing).read(executor);
-      traceMainDex(
-          executor,
-          application,
-          mainDexTracingResult -> {
-            result =
-                mainDexTracingResult.getClasses().stream()
-                    .map(c -> c.toSourceString().replace('.', '/') + ".class")
-                    .sorted()
-                    .collect(Collectors.toList());
-
-            if (options.mainDexListConsumer != null) {
-              options.mainDexListConsumer.accept(String.join("\n", result), options.reporter);
-              options.mainDexListConsumer.finished(options.reporter);
-            }
-          });
+      List<String> result = new ArrayList<>();
+      traceMainDex(executor, application)
+          .forEach(type -> result.add(type.toBinaryName() + ".class"));
+      Collections.sort(result);
+      if (options.mainDexListConsumer != null) {
+        options.mainDexListConsumer.accept(String.join("\n", result), options.reporter);
+        options.mainDexListConsumer.finished(options.reporter);
+      }
       return result;
     } catch (ExecutionException e) {
       throw unwrapExecutionException(e);
     }
   }
 
-  public void traceMainDex(
-      ExecutorService executor,
-      DexApplication application,
-      Consumer<MainDexTracingResult> resultConsumer)
+  public MainDexInfo traceMainDex(ExecutorService executor, DexApplication application)
       throws ExecutionException {
     AppView<? extends AppInfoWithClassHierarchy> appView =
         AppView.createForR8(application.toDirect());
@@ -84,8 +72,9 @@
 
     SubtypingInfo subtypingInfo = new SubtypingInfo(appView);
 
-    RootSet mainDexRootSet =
-        RootSet.builder(appView, subtypingInfo, options.mainDexKeepRules).build(executor);
+    MainDexRootSet mainDexRootSet =
+        MainDexRootSet.builder(appView, subtypingInfo, options.mainDexKeepRules).build(executor);
+    appView.setMainDexRootSet(mainDexRootSet);
 
     GraphConsumer graphConsumer = options.mainDexKeptGraphConsumer;
     WhyAreYouKeepingConsumer whyAreYouKeepingConsumer = null;
@@ -95,26 +84,20 @@
     }
 
     Enqueuer enqueuer =
-        EnqueuerFactory.createForFinalMainDexTracing(
-            appView, executor, subtypingInfo, graphConsumer, MainDexTracingResult.NONE);
-    Set<DexProgramClass> liveTypes = enqueuer.traceMainDex(mainDexRootSet, executor, timing);
-    // LiveTypes is the result.
-    MainDexTracingResult mainDexTracingResult = new MainDexListBuilder(liveTypes, appView).run();
-    resultConsumer.accept(mainDexTracingResult);
-
+        EnqueuerFactory.createForGenerateMainDexList(
+            appView, executor, subtypingInfo, graphConsumer);
+    MainDexInfo mainDexInfo = enqueuer.traceMainDex(executor, timing);
     R8.processWhyAreYouKeepingAndCheckDiscarded(
         mainDexRootSet,
         () -> {
           ArrayList<DexProgramClass> classes = new ArrayList<>();
           // TODO(b/131668850): This is not a deterministic order!
-          mainDexTracingResult
-              .getClasses()
-              .forEach(
-                  type -> {
-                    DexClass clazz = appView.definitionFor(type);
-                    assert clazz.isProgramClass();
-                    classes.add(clazz.asProgramClass());
-                  });
+          mainDexInfo.forEach(
+              type -> {
+                DexClass clazz = appView.definitionFor(type);
+                assert clazz.isProgramClass();
+                classes.add(clazz.asProgramClass());
+              });
           return classes;
         },
         whyAreYouKeepingConsumer,
@@ -124,6 +107,8 @@
         options,
         timing,
         executor);
+
+    return mainDexInfo;
   }
 
   /**
diff --git a/src/main/java/com/android/tools/r8/L8Command.java b/src/main/java/com/android/tools/r8/L8Command.java
index 8bf7cc6..b552bb2 100644
--- a/src/main/java/com/android/tools/r8/L8Command.java
+++ b/src/main/java/com/android/tools/r8/L8Command.java
@@ -174,7 +174,6 @@
     assert !internal.enableEnumValueOptimization;
     assert !internal.outline.enabled;
     assert !internal.enableValuePropagation;
-    assert !internal.enableLambdaMerging;
     assert !internal.enableTreeShakingOfLibraryMethodOverrides;
 
     assert internal.desugarState == DesugarState.ON;
diff --git a/src/main/java/com/android/tools/r8/PrintUses.java b/src/main/java/com/android/tools/r8/PrintUses.java
index 782094c..80b5ec7 100644
--- a/src/main/java/com/android/tools/r8/PrintUses.java
+++ b/src/main/java/com/android/tools/r8/PrintUses.java
@@ -27,7 +27,7 @@
 import com.android.tools.r8.graph.ResolutionResult;
 import com.android.tools.r8.graph.UseRegistry;
 import com.android.tools.r8.ir.desugar.LambdaDescriptor;
-import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.StringUtils;
@@ -364,7 +364,7 @@
         AppInfoWithClassHierarchy.createInitialAppInfoWithClassHierarchy(
             application,
             ClassToFeatureSplitMap.createEmptyClassToFeatureSplitMap(),
-            MainDexClasses.createEmptyMainDexClasses());
+            MainDexInfo.none());
   }
 
   private void analyze() {
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 9c93e0e..283e461 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -88,12 +88,12 @@
 import com.android.tools.r8.shaking.Enqueuer;
 import com.android.tools.r8.shaking.Enqueuer.Mode;
 import com.android.tools.r8.shaking.EnqueuerFactory;
-import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.shaking.MainDexListBuilder;
-import com.android.tools.r8.shaking.MainDexTracingResult;
 import com.android.tools.r8.shaking.MissingClasses;
 import com.android.tools.r8.shaking.ProguardConfigurationRule;
 import com.android.tools.r8.shaking.ProguardConfigurationUtils;
+import com.android.tools.r8.shaking.RootSetUtils.MainDexRootSet;
 import com.android.tools.r8.shaking.RootSetUtils.RootSet;
 import com.android.tools.r8.shaking.RootSetUtils.RootSetBuilder;
 import com.android.tools.r8.shaking.RuntimeTypeCheckInfo;
@@ -284,12 +284,12 @@
       {
         ApplicationReader applicationReader = new ApplicationReader(inputApp, options, timing);
         DirectMappedDexApplication application = applicationReader.read(executorService).toDirect();
-        MainDexClasses mainDexClasses = applicationReader.readMainDexClasses(application);
+        MainDexInfo mainDexInfo = applicationReader.readMainDexClasses(application);
 
         // Now that the dex-application is fully loaded, close any internal archive providers.
         inputApp.closeInternalArchiveProviders();
 
-        appView = AppView.createForR8(application, mainDexClasses);
+        appView = AppView.createForR8(application, mainDexInfo);
         appView.setAppServices(AppServices.builder(appView).build());
       }
 
@@ -326,7 +326,8 @@
                   .appInfo()
                   .rebuildWithClassHierarchy(
                       MissingClasses.builderForInitialMissingClasses()
-                          .addNewMissingClasses(new SubtypingInfo(appView).getMissingClasses())
+                          .legacyAddNewMissingClasses(
+                              new SubtypingInfo(appView).getMissingClasses())
                           .reportMissingClasses(appView)));
         }
 
@@ -421,23 +422,7 @@
       // Build conservative main dex content after first round of tree shaking. This is used
       // by certain optimizations to avoid introducing additional class references into main dex
       // classes, as that can cause the final number of main dex methods to grow.
-      RootSet mainDexRootSet = null;
-      MainDexTracingResult mainDexTracingResult = MainDexTracingResult.NONE;
-      if (!options.mainDexKeepRules.isEmpty()) {
-        assert appView.graphLens().isIdentityLens();
-        // Find classes which may have code executed before secondary dex files installation.
-        SubtypingInfo subtypingInfo = new SubtypingInfo(appView);
-        mainDexRootSet =
-            RootSet.builder(appView, subtypingInfo, options.mainDexKeepRules)
-                .build(executorService);
-        // Live types is the tracing result.
-        Set<DexProgramClass> mainDexBaseClasses =
-            EnqueuerFactory.createForInitialMainDexTracing(appView, executorService, subtypingInfo)
-                .traceMainDex(mainDexRootSet, executorService, timing);
-        // Calculate the automatic main dex list according to legacy multidex constraints.
-        mainDexTracingResult = new MainDexListBuilder(mainDexBaseClasses, appView).run();
-        appView.appInfo().unsetObsolete();
-      }
+      performInitialMainDexTracing(appView, executorService);
 
       // The class type lattice elements include information about the interfaces that a class
       // implements. This information can change as a result of vertical class merging, so we need
@@ -479,11 +464,7 @@
           timing.begin("VerticalClassMerger");
           VerticalClassMerger verticalClassMerger =
               new VerticalClassMerger(
-                  getDirectApp(appViewWithLiveness),
-                  appViewWithLiveness,
-                  executorService,
-                  timing,
-                  mainDexTracingResult);
+                  getDirectApp(appViewWithLiveness), appViewWithLiveness, executorService, timing);
           VerticalClassMergerGraphLens lens = verticalClassMerger.run();
           if (lens != null) {
             appView.rewriteWithLens(lens);
@@ -530,7 +511,7 @@
           DirectMappedDexApplication.Builder appBuilder =
               appView.appInfo().app().asDirect().builder();
           HorizontalClassMergerResult horizontalClassMergerResult =
-              merger.run(appBuilder, mainDexTracingResult, runtimeTypeCheckInfo);
+              merger.run(appBuilder, runtimeTypeCheckInfo);
           if (horizontalClassMergerResult != null) {
             // Must rewrite AppInfoWithLiveness before pruning the merged classes, to ensure that
             // allocations sites, fields accesses, etc. are correctly transferred to the target
@@ -547,8 +528,6 @@
                     .addRemovedClasses(appView.horizontallyMergedClasses().getSources())
                     .addNoLongerSyntheticItems(appView.horizontallyMergedClasses().getTargets())
                     .build());
-
-            mainDexTracingResult = horizontalClassMergerResult.getMainDexTracingResult();
           }
           timing.end();
         } else {
@@ -556,6 +535,9 @@
         }
       }
 
+      // Clear traced methods roots to not hold on to the main dex live method set.
+      appView.appInfo().getMainDexInfo().clearTracedMethodRoots();
+
       // None of the optimizations above should lead to the creation of type lattice elements.
       assert appView.dexItemFactory().verifyNoCachedTypeElements();
 
@@ -571,7 +553,7 @@
       timing.begin("Create IR");
       CfgPrinter printer = options.printCfg ? new CfgPrinter() : null;
       try {
-        IRConverter converter = new IRConverter(appView, timing, printer, mainDexTracingResult);
+        IRConverter converter = new IRConverter(appView, timing, printer);
         DexApplication application =
             converter.optimize(appViewWithLiveness, executorService).asDirect();
         appView.setAppInfo(appView.appInfo().rebuildWithClassHierarchy(previous -> application));
@@ -601,55 +583,6 @@
         }
       }
 
-      if (!options.mainDexKeepRules.isEmpty()) {
-        // No need to build a new main dex root set
-        assert mainDexRootSet != null;
-        GraphConsumer mainDexKeptGraphConsumer = options.mainDexKeptGraphConsumer;
-        WhyAreYouKeepingConsumer whyAreYouKeepingConsumer = null;
-        if (!mainDexRootSet.reasonAsked.isEmpty()) {
-          whyAreYouKeepingConsumer = new WhyAreYouKeepingConsumer(mainDexKeptGraphConsumer);
-          mainDexKeptGraphConsumer = whyAreYouKeepingConsumer;
-        }
-
-        Enqueuer enqueuer =
-            EnqueuerFactory.createForFinalMainDexTracing(
-                appView,
-                executorService,
-                new SubtypingInfo(appView),
-                mainDexKeptGraphConsumer,
-                mainDexTracingResult);
-        // Find classes which may have code executed before secondary dex files installation.
-        // Live types is the tracing result.
-        Set<DexProgramClass> mainDexBaseClasses =
-            enqueuer.traceMainDex(mainDexRootSet, executorService, timing);
-        // Calculate the automatic main dex list according to legacy multidex constraints.
-        mainDexTracingResult = new MainDexListBuilder(mainDexBaseClasses, appView).run();
-        final MainDexTracingResult finalMainDexClasses = mainDexTracingResult;
-
-        processWhyAreYouKeepingAndCheckDiscarded(
-            mainDexRootSet,
-            () -> {
-              ArrayList<DexProgramClass> classes = new ArrayList<>();
-              // TODO(b/131668850): This is not a deterministic order!
-              finalMainDexClasses
-                  .getClasses()
-                  .forEach(
-                      type -> {
-                        DexClass clazz = appView.definitionFor(type);
-                        assert clazz.isProgramClass();
-                        classes.add(clazz.asProgramClass());
-                      });
-              return classes;
-            },
-            whyAreYouKeepingConsumer,
-            appView,
-            enqueuer,
-            true,
-            options,
-            timing,
-            executorService);
-      }
-
       if (options.shouldRerunEnqueuer()) {
         timing.begin("Post optimization code stripping");
         try {
@@ -731,12 +664,6 @@
                 .setClassesToRetainInnerClassAttributeFor(classesToRetainInnerClassAttributeFor)
                 .build(appView.withLiveness(), removedClasses)
                 .run();
-            if (!mainDexTracingResult.isEmpty()) {
-              // Remove types that no longer exists from the computed main dex list.
-              mainDexTracingResult =
-                  mainDexTracingResult.prunedCopy(appView.appInfo().withLiveness());
-            }
-
             // Synthesize fields for triggering class initializers.
             new ClassInitFieldSynthesizer(appViewWithLiveness).run(executorService);
           }
@@ -749,7 +676,7 @@
             appView.protoShrinker().enumLiteProtoShrinker.verifyDeadEnumLiteMapsAreDead();
           }
 
-          IRConverter converter = new IRConverter(appView, timing, null, mainDexTracingResult);
+          IRConverter converter = new IRConverter(appView, timing, null);
 
           // If proto shrinking is enabled, we need to reprocess every dynamicMethod(). This ensures
           // that proto fields that have been removed by the second round of tree shaking are also
@@ -767,6 +694,8 @@
         }
       }
 
+      performFinalMainDexTracing(appView, executorService);
+
       // Remove unneeded visibility bridges that have been inserted for member rebinding.
       // This can only be done if we have AppInfoWithLiveness.
       if (appView.appInfo().hasLiveness()) {
@@ -803,11 +732,6 @@
         assert Repackaging.verifyIdentityRepackaging(appView.withLiveness());
       }
 
-      // Add automatic main dex classes to an eventual manual list of classes.
-      if (!options.mainDexKeepRules.isEmpty()) {
-        appView.appInfo().getMainDexClasses().addAll(mainDexTracingResult);
-      }
-
       if (appView.appInfo().hasLiveness()) {
         SyntheticFinalization.finalizeWithLiveness(appView.withLiveness());
       } else {
@@ -913,6 +837,71 @@
     }
   }
 
+  private void performInitialMainDexTracing(
+      AppView<AppInfoWithClassHierarchy> appView, ExecutorService executorService)
+      throws ExecutionException {
+    if (options.mainDexKeepRules.isEmpty()) {
+      return;
+    }
+    assert appView.graphLens().isIdentityLens();
+    // Find classes which may have code executed before secondary dex files installation.
+    SubtypingInfo subtypingInfo = new SubtypingInfo(appView);
+    MainDexRootSet mainDexRootSet =
+        MainDexRootSet.builder(appView, subtypingInfo, options.mainDexKeepRules)
+            .build(executorService);
+    appView.setMainDexRootSet(mainDexRootSet);
+    appView.appInfo().unsetObsolete();
+    // Live types is the tracing result.
+    MainDexInfo mainDexInfo =
+        EnqueuerFactory.createForInitialMainDexTracing(appView, executorService, subtypingInfo)
+            .traceMainDex(executorService, timing);
+    appView.setAppInfo(appView.appInfo().rebuildWithMainDexInfo(mainDexInfo));
+  }
+
+  private void performFinalMainDexTracing(
+      AppView<AppInfoWithClassHierarchy> appView, ExecutorService executorService)
+      throws ExecutionException {
+    if (options.mainDexKeepRules.isEmpty()) {
+      return;
+    }
+    // No need to build a new main dex root set
+    assert appView.getMainDexRootSet() != null;
+    GraphConsumer mainDexKeptGraphConsumer = options.mainDexKeptGraphConsumer;
+    WhyAreYouKeepingConsumer whyAreYouKeepingConsumer = null;
+    if (!appView.getMainDexRootSet().reasonAsked.isEmpty()) {
+      whyAreYouKeepingConsumer = new WhyAreYouKeepingConsumer(mainDexKeptGraphConsumer);
+      mainDexKeptGraphConsumer = whyAreYouKeepingConsumer;
+    }
+
+    Enqueuer enqueuer =
+        EnqueuerFactory.createForFinalMainDexTracing(
+            appView, executorService, new SubtypingInfo(appView), mainDexKeptGraphConsumer);
+    // Find classes which may have code executed before secondary dex files installation.
+    MainDexInfo mainDexInfo = enqueuer.traceMainDex(executorService, timing);
+    appView.setAppInfo(appView.appInfo().rebuildWithMainDexInfo(mainDexInfo));
+
+    processWhyAreYouKeepingAndCheckDiscarded(
+        appView.getMainDexRootSet(),
+        () -> {
+          ArrayList<DexProgramClass> classes = new ArrayList<>();
+          // TODO(b/131668850): This is not a deterministic order!
+          mainDexInfo.forEach(
+              type -> {
+                DexClass clazz = appView.definitionFor(type);
+                assert clazz.isProgramClass();
+                classes.add(clazz.asProgramClass());
+              });
+          return classes;
+        },
+        whyAreYouKeepingConsumer,
+        appView,
+        enqueuer,
+        true,
+        options,
+        timing,
+        executorService);
+  }
+
   private static boolean verifyMovedMethodsHaveOriginalMethodPosition(
       AppView<?> appView, DirectMappedDexApplication application) {
     application
@@ -1042,12 +1031,8 @@
       if (forMainDex) {
         enqueuer =
             EnqueuerFactory.createForFinalMainDexTracing(
-                appView,
-                executorService,
-                subtypingInfo,
-                whyAreYouKeepingConsumer,
-                MainDexTracingResult.NONE);
-        enqueuer.traceMainDex(rootSet, executorService, timing);
+                appView, executorService, subtypingInfo, whyAreYouKeepingConsumer);
+        enqueuer.traceMainDex(executorService, timing);
       } else {
         enqueuer =
             EnqueuerFactory.createForWhyAreYouKeeping(
diff --git a/src/main/java/com/android/tools/r8/R8Command.java b/src/main/java/com/android/tools/r8/R8Command.java
index 0fa55a7..8d07b18 100644
--- a/src/main/java/com/android/tools/r8/R8Command.java
+++ b/src/main/java/com/android/tools/r8/R8Command.java
@@ -834,10 +834,6 @@
     internal.desugarState = getDesugarState();
     assert internal.isShrinking() == getEnableTreeShaking();
     assert internal.isMinifying() == getEnableMinification();
-    // In current implementation we only enable lambda merger if the tree
-    // shaking is enabled. This is caused by the fact that we rely on tree
-    // shaking for removing the lambda classes which should be revised later.
-    internal.enableLambdaMerging = getEnableTreeShaking();
     assert !internal.ignoreMissingClasses;
     internal.ignoreMissingClasses =
         proguardConfiguration.isIgnoreWarnings()
@@ -871,14 +867,12 @@
       internal.enableClassStaticizer = false;
       internal.outline.enabled = false;
       internal.enableEnumUnboxing = false;
-      internal.enableLambdaMerging = false;
     }
     if (!internal.isShrinking()) {
       // If R8 is not shrinking, there is no point in running various optimizations since the
       // optimized classes will still remain in the program (the application size could increase).
       internal.enableEnumUnboxing = false;
       internal.horizontalClassMergerOptions().disable();
-      internal.enableLambdaMerging = false;
       internal.enableVerticalClassMerging = false;
     }
 
diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationReader.java b/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
index 4b035d4..21de6ac 100644
--- a/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
@@ -29,7 +29,7 @@
 import com.android.tools.r8.graph.JarClassFileReader;
 import com.android.tools.r8.graph.LazyLoadedDexApplication;
 import com.android.tools.r8.naming.ClassNameMapper;
-import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.ClassProvider;
@@ -198,8 +198,8 @@
     }
   }
 
-  public MainDexClasses readMainDexClasses(DexApplication app) {
-    MainDexClasses.Builder builder = MainDexClasses.builder();
+  public MainDexInfo readMainDexClasses(DexApplication app) {
+    MainDexInfo.Builder builder = MainDexInfo.none().builder();
     if (inputApp.hasMainDexList()) {
       for (StringResource resource : inputApp.getMainDexListResources()) {
         addToMainDexClasses(app, builder, MainDexListParser.parseList(resource, itemFactory));
@@ -211,15 +211,15 @@
               .map(clazz -> itemFactory.createType(DescriptorUtils.javaTypeToDescriptor(clazz)))
               .collect(Collectors.toList()));
     }
-    return builder.build();
+    return builder.buildList();
   }
 
   private void addToMainDexClasses(
-      DexApplication app, MainDexClasses.Builder builder, Iterable<DexType> types) {
+      DexApplication app, MainDexInfo.Builder builder, Iterable<DexType> types) {
     for (DexType type : types) {
       DexProgramClass clazz = app.programDefinitionFor(type);
       if (clazz != null) {
-        builder.add(clazz);
+        builder.addList(clazz);
       } else if (!options.ignoreMainDexMissingClasses) {
         options.reporter.warning(
             new StringDiagnostic(
diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java b/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
index ab72b04..da3b04c 100644
--- a/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
@@ -45,7 +45,7 @@
 import com.android.tools.r8.naming.ProguardMapSupplier;
 import com.android.tools.r8.naming.ProguardMapSupplier.ProguardMapId;
 import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.utils.ArrayUtils;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.ExceptionUtils;
@@ -199,7 +199,7 @@
           options.getDexFilePerClassFileConsumer().combineSyntheticClassesWithPrimaryClass());
     } else if (!options.canUseMultidex()
         && options.mainDexKeepRules.isEmpty()
-        && appView.appInfo().getMainDexClasses().isEmpty()
+        && appView.appInfo().getMainDexInfo().isEmpty()
         && options.enableMainDexListCheck) {
       distributor = new VirtualFile.MonoDexDistributor(this, options);
     } else {
@@ -688,10 +688,11 @@
   }
 
   private static String writeMainDexList(AppView<?> appView, NamingLens namingLens) {
-    MainDexClasses mainDexClasses = appView.appInfo().getMainDexClasses();
+    // TODO(b/178231294): Clean up by streaming directly to the consumer.
+    MainDexInfo mainDexInfo = appView.appInfo().getMainDexInfo();
     StringBuilder builder = new StringBuilder();
-    List<DexType> list = new ArrayList<>(mainDexClasses.size());
-    mainDexClasses.forEach(list::add);
+    List<DexType> list = new ArrayList<>(mainDexInfo.size());
+    mainDexInfo.forEach(list::add);
     list.sort(DexType::compareTo);
     list.forEach(
         type -> builder.append(mapMainDexListName(type, namingLens)).append('\n'));
diff --git a/src/main/java/com/android/tools/r8/dex/Constants.java b/src/main/java/com/android/tools/r8/dex/Constants.java
index dfa8667..8ea7319 100644
--- a/src/main/java/com/android/tools/r8/dex/Constants.java
+++ b/src/main/java/com/android/tools/r8/dex/Constants.java
@@ -135,6 +135,7 @@
   public static final int ACC_ANNOTATION = 0x2000;
   public static final int ACC_ENUM = 0x4000;
   public static final int ACC_CONSTRUCTOR = 0x10000;
+  public static final int ACC_RECORD = 0x10000;
   public static final int ACC_DECLARED_SYNCHRONIZED = 0x20000;
 
   public static final String JAVA_LANG_OBJECT_NAME = "java/lang/Object";
diff --git a/src/main/java/com/android/tools/r8/dex/VirtualFile.java b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
index 414031e..8f56827 100644
--- a/src/main/java/com/android/tools/r8/dex/VirtualFile.java
+++ b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
@@ -27,7 +27,7 @@
 import com.android.tools.r8.logging.Log;
 import com.android.tools.r8.naming.ClassNameMapper;
 import com.android.tools.r8.naming.NamingLens;
-import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.synthesis.SyntheticNaming;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.FileUtils;
@@ -394,13 +394,14 @@
     }
 
     protected void fillForMainDexList(Set<DexProgramClass> classes) {
-      MainDexClasses mainDexClasses = appView.appInfo().getMainDexClasses();
-      if (mainDexClasses.isEmpty()) {
+      MainDexInfo mainDexInfo = appView.appInfo().getMainDexInfo();
+      if (mainDexInfo.isEmpty()) {
         return;
       }
       VirtualFile mainDexFile = virtualFiles.get(0);
-      mainDexClasses.forEach(
+      mainDexInfo.forEach(
           type -> {
+            // TODO(b/178577273): We should ensure only live types in main dex.
             DexProgramClass clazz =
                 asProgramClassOrNull(appView.appInfo().definitionForWithoutExistenceAssert(type));
             if (clazz != null) {
diff --git a/src/main/java/com/android/tools/r8/graph/AppInfo.java b/src/main/java/com/android/tools/r8/graph/AppInfo.java
index 302dff4..de3d976 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfo.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfo.java
@@ -7,7 +7,7 @@
 import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.synthesis.CommittedItems;
 import com.android.tools.r8.synthesis.SyntheticItems;
 import com.android.tools.r8.utils.BooleanBox;
@@ -20,7 +20,7 @@
 
   private final DexApplication app;
   private final DexItemFactory dexItemFactory;
-  private final MainDexClasses mainDexClasses;
+  private final MainDexInfo mainDexInfo;
   private final SyntheticItems syntheticItems;
 
   // Set when a new AppInfo replaces a previous one. All public methods should verify that the
@@ -28,37 +28,36 @@
   private final BooleanBox obsolete;
 
   public static AppInfo createInitialAppInfo(DexApplication application) {
-    return createInitialAppInfo(application, MainDexClasses.createEmptyMainDexClasses());
+    return createInitialAppInfo(application, MainDexInfo.none());
   }
 
-  public static AppInfo createInitialAppInfo(
-      DexApplication application, MainDexClasses mainDexClasses) {
-    return new AppInfo(SyntheticItems.createInitialSyntheticItems(application), mainDexClasses);
+  public static AppInfo createInitialAppInfo(DexApplication application, MainDexInfo mainDexInfo) {
+    return new AppInfo(SyntheticItems.createInitialSyntheticItems(application), mainDexInfo);
   }
 
-  public AppInfo(CommittedItems committedItems, MainDexClasses mainDexClasses) {
+  public AppInfo(CommittedItems committedItems, MainDexInfo mainDexInfo) {
     this(
         committedItems.getApplication(),
         committedItems.toSyntheticItems(),
-        mainDexClasses,
+        mainDexInfo,
         new BooleanBox());
   }
 
   // For desugaring.
   // This is a view onto the app info and is the only place the pending synthetics are shared.
   AppInfo(AppInfoWithClassHierarchy.CreateDesugaringViewOnAppInfo witness, AppInfo appInfo) {
-    this(appInfo.app, appInfo.syntheticItems, appInfo.mainDexClasses, appInfo.obsolete);
+    this(appInfo.app, appInfo.syntheticItems, appInfo.mainDexInfo, appInfo.obsolete);
     assert witness != null;
   }
 
   private AppInfo(
       DexApplication application,
       SyntheticItems syntheticItems,
-      MainDexClasses mainDexClasses,
+      MainDexInfo mainDexInfo,
       BooleanBox obsolete) {
     this.app = application;
     this.dexItemFactory = application.dexItemFactory;
-    this.mainDexClasses = mainDexClasses;
+    this.mainDexInfo = mainDexInfo;
     this.syntheticItems = syntheticItems;
     this.obsolete = obsolete;
   }
@@ -72,7 +71,12 @@
     }
     return new AppInfo(
         getSyntheticItems().commitPrunedItems(prunedItems),
-        getMainDexClasses().withoutPrunedItems(prunedItems));
+        getMainDexInfo().withoutPrunedItems(prunedItems));
+  }
+
+  public AppInfo rebuildWithMainDexInfo(MainDexInfo mainDexInfo) {
+    assert checkIfObsolete();
+    return new AppInfo(app, syntheticItems, mainDexInfo, new BooleanBox());
   }
 
   protected InternalOptions options() {
@@ -107,19 +111,29 @@
     return dexItemFactory;
   }
 
-  public MainDexClasses getMainDexClasses() {
-    return mainDexClasses;
+  public MainDexInfo getMainDexInfo() {
+    assert checkIfObsolete();
+    return mainDexInfo;
   }
 
   public SyntheticItems getSyntheticItems() {
+    assert checkIfObsolete();
     return syntheticItems;
   }
 
-  public void addSynthesizedClass(DexProgramClass clazz, boolean addToMainDexClasses) {
+  public void addSynthesizedClass(DexProgramClass clazz, boolean addToMainDex) {
     assert checkIfObsolete();
     syntheticItems.addLegacySyntheticClass(clazz);
-    if (addToMainDexClasses && !mainDexClasses.isEmpty()) {
-      mainDexClasses.add(clazz);
+    if (addToMainDex) {
+      mainDexInfo.addSyntheticClass(clazz);
+    }
+  }
+
+  public void addSynthesizedClass(DexProgramClass clazz, ProgramDefinition context) {
+    assert checkIfObsolete();
+    syntheticItems.addLegacySyntheticClass(clazz);
+    if (context != null) {
+      mainDexInfo.addLegacySyntheticClass(clazz, context);
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java b/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java
index 8ff4d1e..cd90e16 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java
@@ -18,7 +18,7 @@
 import com.android.tools.r8.ir.analysis.type.InterfaceCollection;
 import com.android.tools.r8.ir.analysis.type.InterfaceCollection.Builder;
 import com.android.tools.r8.ir.desugar.LambdaDescriptor;
-import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.shaking.MissingClasses;
 import com.android.tools.r8.synthesis.CommittedItems;
 import com.android.tools.r8.synthesis.SyntheticItems;
@@ -56,11 +56,11 @@
   public static AppInfoWithClassHierarchy createInitialAppInfoWithClassHierarchy(
       DexApplication application,
       ClassToFeatureSplitMap classToFeatureSplitMap,
-      MainDexClasses mainDexClasses) {
+      MainDexInfo mainDexInfo) {
     return new AppInfoWithClassHierarchy(
         SyntheticItems.createInitialSyntheticItems(application),
         classToFeatureSplitMap,
-        mainDexClasses,
+        mainDexInfo,
         MissingClasses.empty());
   }
 
@@ -74,9 +74,9 @@
   protected AppInfoWithClassHierarchy(
       CommittedItems committedItems,
       ClassToFeatureSplitMap classToFeatureSplitMap,
-      MainDexClasses mainDexClasses,
+      MainDexInfo mainDexInfo,
       MissingClasses missingClasses) {
-    super(committedItems, mainDexClasses);
+    super(committedItems, mainDexInfo);
     this.classToFeatureSplitMap = classToFeatureSplitMap;
     this.missingClasses = missingClasses;
   }
@@ -97,27 +97,36 @@
 
   public final AppInfoWithClassHierarchy rebuildWithClassHierarchy(CommittedItems commit) {
     return new AppInfoWithClassHierarchy(
-        commit, getClassToFeatureSplitMap(), getMainDexClasses(), getMissingClasses());
+        commit, getClassToFeatureSplitMap(), getMainDexInfo(), getMissingClasses());
   }
 
   public final AppInfoWithClassHierarchy rebuildWithClassHierarchy(MissingClasses missingClasses) {
     return new AppInfoWithClassHierarchy(
         getSyntheticItems().commit(app()),
         getClassToFeatureSplitMap(),
-        getMainDexClasses(),
+        getMainDexInfo(),
         missingClasses);
   }
 
   public AppInfoWithClassHierarchy rebuildWithClassHierarchy(
       Function<DexApplication, DexApplication> fn) {
+    assert checkIfObsolete();
     return new AppInfoWithClassHierarchy(
         getSyntheticItems().commit(fn.apply(app())),
         getClassToFeatureSplitMap(),
-        getMainDexClasses(),
+        getMainDexInfo(),
         getMissingClasses());
   }
 
   @Override
+  public AppInfoWithClassHierarchy rebuildWithMainDexInfo(MainDexInfo mainDexInfo) {
+    assert getClass() == AppInfoWithClassHierarchy.class;
+    assert checkIfObsolete();
+    return new AppInfoWithClassHierarchy(
+        getSyntheticItems().commit(app()), classToFeatureSplitMap, mainDexInfo, missingClasses);
+  }
+
+  @Override
   public AppInfoWithClassHierarchy prunedCopyFrom(PrunedItems prunedItems) {
     assert getClass() == AppInfoWithClassHierarchy.class;
     assert checkIfObsolete();
@@ -128,7 +137,7 @@
     return new AppInfoWithClassHierarchy(
         getSyntheticItems().commitPrunedItems(prunedItems),
         getClassToFeatureSplitMap().withoutPrunedItems(prunedItems),
-        getMainDexClasses().withoutPrunedItems(prunedItems),
+        getMainDexInfo().withoutPrunedItems(prunedItems),
         getMissingClasses());
   }
 
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 7d574dd..b56d682 100644
--- a/src/main/java/com/android/tools/r8/graph/AppView.java
+++ b/src/main/java/com/android/tools/r8/graph/AppView.java
@@ -9,7 +9,6 @@
 import com.android.tools.r8.graph.DexValue.DexValueString;
 import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
 import com.android.tools.r8.graph.analysis.InitializedClassesInInstanceMethodsAnalysis.InitializedClassesInInstanceMethods;
-import com.android.tools.r8.graph.classmerging.HorizontallyMergedLambdaClasses;
 import com.android.tools.r8.graph.classmerging.MergedClassesCollection;
 import com.android.tools.r8.graph.classmerging.VerticallyMergedClasses;
 import com.android.tools.r8.horizontalclassmerging.HorizontallyMergedClasses;
@@ -32,8 +31,9 @@
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.shaking.KeepInfoCollection;
 import com.android.tools.r8.shaking.LibraryModeledPredicate;
-import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.shaking.ProguardCompatibilityActions;
+import com.android.tools.r8.shaking.RootSetUtils.MainDexRootSet;
 import com.android.tools.r8.shaking.RootSetUtils.RootSet;
 import com.android.tools.r8.synthesis.SyntheticItems;
 import com.android.tools.r8.utils.InternalOptions;
@@ -64,6 +64,7 @@
   private InitClassLens initClassLens;
   private ProguardCompatibilityActions proguardCompatibilityActions;
   private RootSet rootSet;
+  private MainDexRootSet mainDexRootSet = null;
   // This should perferably always be obtained via AppInfoWithLiveness.
   // Currently however the liveness may be downgraded thus loosing the computed keep info.
   private KeepInfoCollection keepInfo = null;
@@ -91,13 +92,11 @@
   private boolean allCodeProcessed = false;
   private Predicate<DexType> classesEscapingIntoLibrary = Predicates.alwaysTrue();
   private InitializedClassesInInstanceMethods initializedClassesInInstanceMethods;
-  private HorizontallyMergedLambdaClasses horizontallyMergedLambdaClasses;
   private HorizontallyMergedClasses horizontallyMergedClasses;
   private VerticallyMergedClasses verticallyMergedClasses;
   private EnumDataMap unboxedEnums = EnumDataMap.empty();
   // TODO(b/169115389): Remove
   private Set<DexMethod> cfByteCodePassThrough = ImmutableSet.of();
-
   private Map<DexType, DexValueString> sourceDebugExtensions = new IdentityHashMap<>();
 
   // When input has been (partially) desugared these are the classes which has been library
@@ -157,16 +156,16 @@
   }
 
   public static AppView<AppInfoWithClassHierarchy> createForR8(DexApplication application) {
-    return createForR8(application, MainDexClasses.createEmptyMainDexClasses());
+    return createForR8(application, MainDexInfo.none());
   }
 
   public static AppView<AppInfoWithClassHierarchy> createForR8(
-      DexApplication application, MainDexClasses mainDexClasses) {
+      DexApplication application, MainDexInfo mainDexInfo) {
     ClassToFeatureSplitMap classToFeatureSplitMap =
         ClassToFeatureSplitMap.createInitialClassToFeatureSplitMap(application.options);
     AppInfoWithClassHierarchy appInfo =
         AppInfoWithClassHierarchy.createInitialAppInfoWithClassHierarchy(
-            application, classToFeatureSplitMap, mainDexClasses);
+            application, classToFeatureSplitMap, mainDexInfo);
     return new AppView<>(
         appInfo, WholeProgramOptimizations.ON, defaultPrefixRewritingMapper(appInfo));
   }
@@ -460,6 +459,15 @@
     this.rootSet = rootSet;
   }
 
+  public void setMainDexRootSet(MainDexRootSet mainDexRootSet) {
+    assert mainDexRootSet != null : "Root set should never be recomputed";
+    this.mainDexRootSet = mainDexRootSet;
+  }
+
+  public MainDexRootSet getMainDexRootSet() {
+    return mainDexRootSet;
+  }
+
   public KeepInfoCollection getKeepInfo() {
     return keepInfo;
   }
@@ -483,9 +491,6 @@
     if (horizontallyMergedClasses != null) {
       collection.add(horizontallyMergedClasses);
     }
-    if (horizontallyMergedLambdaClasses != null) {
-      collection.add(horizontallyMergedLambdaClasses);
-    }
     if (verticallyMergedClasses != null) {
       collection.add(verticallyMergedClasses);
     }
@@ -493,23 +498,6 @@
   }
 
   /**
-   * 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;
-    testing()
-        .horizontallyMergedLambdaClassesConsumer
-        .accept(dexItemFactory(), horizontallyMergedLambdaClasses);
-  }
-
-  /**
    * Get the result of horizontal class merging. Returns null if horizontal class merging has not
    * been run.
    */
@@ -619,6 +607,9 @@
       setProguardCompatibilityActions(
           getProguardCompatibilityActions().withoutPrunedItems(prunedItems));
     }
+    if (mainDexRootSet != null) {
+      setMainDexRootSet(mainDexRootSet.withoutPrunedItems(prunedItems));
+    }
   }
 
   @SuppressWarnings("unchecked")
@@ -688,6 +679,9 @@
             appView.setProguardCompatibilityActions(
                 appView.getProguardCompatibilityActions().rewrittenWithLens(lens));
           }
+          if (appView.getMainDexRootSet() != null) {
+            appView.setMainDexRootSet(appView.getMainDexRootSet().rewrittenWithLens(lens));
+          }
         });
   }
 
diff --git a/src/main/java/com/android/tools/r8/graph/ClassAccessFlags.java b/src/main/java/com/android/tools/r8/graph/ClassAccessFlags.java
index 7998171..abeb404 100644
--- a/src/main/java/com/android/tools/r8/graph/ClassAccessFlags.java
+++ b/src/main/java/com/android/tools/r8/graph/ClassAccessFlags.java
@@ -22,9 +22,7 @@
   private static final int DEX_FLAGS
       = SHARED_FLAGS;
 
-  private static final int CF_FLAGS
-      = SHARED_FLAGS
-      | Constants.ACC_SUPER;
+  private static final int CF_FLAGS = SHARED_FLAGS | Constants.ACC_SUPER | Constants.ACC_RECORD;
 
   @Override
   protected List<String> getNames() {
@@ -35,6 +33,7 @@
         .add("annotation")
         .add("enum")
         .add("super")
+        .add("record")
         .build();
   }
 
@@ -47,6 +46,7 @@
         .add(this::isAnnotation)
         .add(this::isEnum)
         .add(this::isSuper)
+        .add(this::isRecord)
         .build();
   }
 
@@ -178,6 +178,14 @@
     set(Constants.ACC_ENUM);
   }
 
+  public boolean isRecord() {
+    return isSet(Constants.ACC_RECORD);
+  }
+
+  public void setRecord() {
+    set(Constants.ACC_RECORD);
+  }
+
   public boolean isSuper() {
     return isSet(Constants.ACC_SUPER);
   }
diff --git a/src/main/java/com/android/tools/r8/graph/ClasspathDefinition.java b/src/main/java/com/android/tools/r8/graph/ClasspathDefinition.java
new file mode 100644
index 0000000..89013fd
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/ClasspathDefinition.java
@@ -0,0 +1,23 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.graph;
+
+import java.util.function.Function;
+
+public interface ClasspathDefinition extends Definition {
+
+  @Override
+  default <T> T apply(
+      Function<ProgramDefinition, T> programFunction,
+      Function<ClasspathDefinition, T> classpathFunction,
+      Function<LibraryDefinition, T> libraryFunction) {
+    return classpathFunction.apply(this);
+  }
+
+  @Override
+  default ProgramDerivedContext asProgramDerivedContext(ProgramDerivedContext witness) {
+    return ClasspathOrLibraryContext.create(this, witness);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/graph/ClasspathField.java b/src/main/java/com/android/tools/r8/graph/ClasspathField.java
index b40e51c..ca7b15b 100644
--- a/src/main/java/com/android/tools/r8/graph/ClasspathField.java
+++ b/src/main/java/com/android/tools/r8/graph/ClasspathField.java
@@ -4,7 +4,8 @@
 
 package com.android.tools.r8.graph;
 
-public class ClasspathField extends DexClassAndField {
+public class ClasspathField extends DexClassAndField
+    implements ClasspathMember<DexEncodedField, DexField> {
 
   public ClasspathField(DexClasspathClass holder, DexEncodedField field) {
     super(holder, field);
@@ -24,4 +25,11 @@
   public boolean isClasspathMember() {
     return true;
   }
+
+  @Override
+  public DexClasspathClass getHolder() {
+    DexClass holder = super.getHolder();
+    assert holder.isClasspathClass();
+    return holder.asClasspathClass();
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/graph/ClasspathMember.java b/src/main/java/com/android/tools/r8/graph/ClasspathMember.java
new file mode 100644
index 0000000..8fad10f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/ClasspathMember.java
@@ -0,0 +1,15 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.graph;
+
+public interface ClasspathMember<D extends DexEncodedMember<D, R>, R extends DexMember<D, R>>
+    extends ClasspathDefinition {
+
+  D getDefinition();
+
+  DexClasspathClass getHolder();
+
+  DexType getHolderType();
+}
diff --git a/src/main/java/com/android/tools/r8/graph/ClasspathMethod.java b/src/main/java/com/android/tools/r8/graph/ClasspathMethod.java
index 0c58053..3f796e3 100644
--- a/src/main/java/com/android/tools/r8/graph/ClasspathMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/ClasspathMethod.java
@@ -6,7 +6,8 @@
 import com.android.tools.r8.logging.Log;
 
 /** Type representing a method definition on the classpath and its holder. */
-public final class ClasspathMethod extends DexClassAndMethod {
+public final class ClasspathMethod extends DexClassAndMethod
+    implements ClasspathMember<DexEncodedMethod, DexMethod> {
 
   public ClasspathMethod(DexClasspathClass holder, DexEncodedMethod method) {
     super(holder, method);
diff --git a/src/main/java/com/android/tools/r8/graph/ClasspathOrLibraryContext.java b/src/main/java/com/android/tools/r8/graph/ClasspathOrLibraryContext.java
new file mode 100644
index 0000000..b498837
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/ClasspathOrLibraryContext.java
@@ -0,0 +1,36 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.graph;
+
+/**
+ * A classpath or library definition that is guaranteed to be derived from the tracing of a program
+ * context.
+ */
+public class ClasspathOrLibraryContext implements ProgramDerivedContext {
+
+  private final Definition context;
+  private final ProgramDerivedContext programDerivedContext;
+
+  private ClasspathOrLibraryContext(
+      Definition context, ProgramDerivedContext programDerivedContext) {
+    this.context = context;
+    this.programDerivedContext = programDerivedContext;
+  }
+
+  public static ClasspathOrLibraryContext create(
+      ClasspathDefinition context, ProgramDerivedContext programDerivedContext) {
+    return new ClasspathOrLibraryContext(context, programDerivedContext);
+  }
+
+  public static ClasspathOrLibraryContext create(
+      LibraryDefinition context, ProgramDerivedContext programDerivedContext) {
+    return new ClasspathOrLibraryContext(context, programDerivedContext);
+  }
+
+  @Override
+  public Definition getContext() {
+    return context;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/graph/Definition.java b/src/main/java/com/android/tools/r8/graph/Definition.java
new file mode 100644
index 0000000..a7e4ed9
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/Definition.java
@@ -0,0 +1,21 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.graph;
+
+import java.util.function.Function;
+
+public interface Definition {
+
+  <T> T apply(
+      Function<ProgramDefinition, T> programFunction,
+      Function<ClasspathDefinition, T> classpathFunction,
+      Function<LibraryDefinition, T> libraryFunction);
+
+  ProgramDerivedContext asProgramDerivedContext(ProgramDerivedContext witness);
+
+  DexType getContextType();
+
+  DexReference getReference();
+}
diff --git a/src/main/java/com/android/tools/r8/graph/DexClass.java b/src/main/java/com/android/tools/r8/graph/DexClass.java
index f1c0a2f..df80a80 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -33,7 +33,7 @@
 import java.util.function.Function;
 import java.util.function.Predicate;
 
-public abstract class DexClass extends DexDefinition {
+public abstract class DexClass extends DexDefinition implements Definition {
 
   public interface FieldSetter {
     void setField(int index, DexEncodedField field);
diff --git a/src/main/java/com/android/tools/r8/graph/DexClassAndField.java b/src/main/java/com/android/tools/r8/graph/DexClassAndField.java
index cef86d0..505a7ec 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClassAndField.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClassAndField.java
@@ -4,7 +4,7 @@
 
 package com.android.tools.r8.graph;
 
-public class DexClassAndField extends DexClassAndMember<DexEncodedField, DexField> {
+public abstract class DexClassAndField extends DexClassAndMember<DexEncodedField, DexField> {
 
   DexClassAndField(DexClass holder, DexEncodedField field) {
     super(holder, field);
diff --git a/src/main/java/com/android/tools/r8/graph/DexClassAndMember.java b/src/main/java/com/android/tools/r8/graph/DexClassAndMember.java
index 83c4334..8459067 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClassAndMember.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClassAndMember.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.origin.Origin;
 
-public abstract class DexClassAndMember<
-    D extends DexEncodedMember<D, R>, R extends DexMember<D, R>> {
+public abstract class DexClassAndMember<D extends DexEncodedMember<D, R>, R extends DexMember<D, R>>
+    implements Definition {
 
   private final DexClass holder;
   private final D definition;
@@ -23,6 +23,7 @@
 
   public abstract AccessFlags<?> getAccessFlags();
 
+  @Override
   public DexType getContextType() {
     return getHolderType();
   }
@@ -43,6 +44,7 @@
     return getReference().getName();
   }
 
+  @Override
   public R getReference() {
     return definition.getReference();
   }
diff --git a/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java b/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java
index 075c1ba..d944c02 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java
@@ -4,7 +4,7 @@
 
 package com.android.tools.r8.graph;
 
-public class DexClassAndMethod extends DexClassAndMember<DexEncodedMethod, DexMethod>
+public abstract class DexClassAndMethod extends DexClassAndMember<DexEncodedMethod, DexMethod>
     implements LookupTarget {
 
   DexClassAndMethod(DexClass holder, DexEncodedMethod method) {
diff --git a/src/main/java/com/android/tools/r8/graph/DexClasspathClass.java b/src/main/java/com/android/tools/r8/graph/DexClasspathClass.java
index 7fb6023..125155e 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClasspathClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClasspathClass.java
@@ -22,7 +22,7 @@
 import java.util.function.Supplier;
 
 public class DexClasspathClass extends DexClass
-    implements Supplier<DexClasspathClass>, StructuralItem<DexClasspathClass> {
+    implements ClasspathDefinition, Supplier<DexClasspathClass>, StructuralItem<DexClasspathClass> {
 
   public DexClasspathClass(
       DexType type,
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedField.java b/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
index f933754..d15bfc7 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedField.java
@@ -18,6 +18,7 @@
 import com.android.tools.r8.ir.optimize.info.DefaultFieldOptimizationInfo;
 import com.android.tools.r8.ir.optimize.info.FieldOptimizationInfo;
 import com.android.tools.r8.ir.optimize.info.MutableFieldOptimizationInfo;
+import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackSimple;
 import com.android.tools.r8.kotlin.KotlinFieldLevelInfo;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.ConsumerUtils;
@@ -355,6 +356,7 @@
     private FieldTypeSignature genericSignature;
     private DexValue staticValue;
     private FieldOptimizationInfo optimizationInfo;
+    private Consumer<DexEncodedField> buildConsumer = ConsumerUtils.emptyConsumer();
 
     Builder(DexEncodedField from) {
       // Copy all the mutable state of a DexEncodedField here.
@@ -370,15 +372,21 @@
               : from.optimizationInfo.mutableCopy();
     }
 
-    public Builder fixupOptimizationInfo(Consumer<MutableFieldOptimizationInfo> consumer) {
-      if (optimizationInfo.isMutableFieldOptimizationInfo()) {
-        consumer.accept(optimizationInfo.asMutableFieldOptimizationInfo());
-      }
+    public Builder apply(Consumer<Builder> consumer) {
+      consumer.accept(this);
       return this;
     }
 
-    public Builder apply(Consumer<Builder> consumer) {
-      consumer.accept(this);
+    public Builder setAbstractValue(
+        AbstractValue abstractValue, AppView<AppInfoWithLiveness> appView) {
+      return addBuildConsumer(
+          fixedUpField ->
+              OptimizationFeedbackSimple.getInstance()
+                  .recordFieldHasAbstractValue(fixedUpField, appView, abstractValue));
+    }
+
+    private Builder addBuildConsumer(Consumer<DexEncodedField> consumer) {
+      this.buildConsumer = this.buildConsumer.andThen(consumer);
       return this;
     }
 
@@ -393,6 +401,7 @@
       if (optimizationInfo.isMutableFieldOptimizationInfo()) {
         dexEncodedField.setOptimizationInfo(optimizationInfo.asMutableFieldOptimizationInfo());
       }
+      buildConsumer.accept(dexEncodedField);
       return dexEncodedField;
     }
   }
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
index c736831..c7a6e70 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -44,6 +44,7 @@
 import com.android.tools.r8.errors.InternalCompilerError;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.GenericSignature.MethodTypeSignature;
+import com.android.tools.r8.ir.analysis.inlining.SimpleInliningConstraint;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Invoke;
 import com.android.tools.r8.ir.code.NumericType;
@@ -55,6 +56,7 @@
 import com.android.tools.r8.ir.optimize.info.CallSiteOptimizationInfo;
 import com.android.tools.r8.ir.optimize.info.DefaultMethodOptimizationInfo;
 import com.android.tools.r8.ir.optimize.info.MethodOptimizationInfo;
+import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackSimple;
 import com.android.tools.r8.ir.optimize.info.UpdatableMethodOptimizationInfo;
 import com.android.tools.r8.ir.optimize.inliner.WhyAreYouNotInliningReporter;
 import com.android.tools.r8.ir.regalloc.RegisterAllocator;
@@ -72,6 +74,7 @@
 import com.android.tools.r8.shaking.AnnotationRemover;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.ConsumerUtils;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.OptionalBool;
 import com.android.tools.r8.utils.Pair;
@@ -1536,6 +1539,7 @@
     private KotlinMethodLevelInfo kotlinMemberInfo;
     private final CfVersion classFileVersion;
     private boolean d8R8Synthesized;
+    private Consumer<DexEncodedMethod> buildConsumer = ConsumerUtils.emptyConsumer();
 
     private Builder(DexEncodedMethod from) {
       this(from, from.d8R8Synthesized);
@@ -1567,10 +1571,19 @@
       }
     }
 
-    public Builder fixupOptimizationInfo(Consumer<UpdatableMethodOptimizationInfo> consumer) {
-      if (optimizationInfo.isUpdatableMethodOptimizationInfo()) {
-        consumer.accept(optimizationInfo.asUpdatableMethodOptimizationInfo());
-      }
+    public Builder setSimpleInliningConstraint(
+        DexProgramClass holder, SimpleInliningConstraint simpleInliningConstraint) {
+      return addBuildConsumer(
+          newMethod ->
+              OptimizationFeedbackSimple.getInstance()
+                  .setSimpleInliningConstraint(
+                      // The method has not yet been installed so we cannot use
+                      // asProgramMethod(appView).
+                      new ProgramMethod(holder, newMethod), simpleInliningConstraint));
+    }
+
+    private Builder addBuildConsumer(Consumer<DexEncodedMethod> consumer) {
+      this.buildConsumer = this.buildConsumer.andThen(consumer);
       return this;
     }
 
@@ -1699,6 +1712,7 @@
       if (!isLibraryMethodOverride.isUnknown()) {
         result.setLibraryMethodOverride(isLibraryMethodOverride);
       }
+      buildConsumer.accept(result);
       return result;
     }
   }
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 30ac84b..18b0434 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -25,7 +25,6 @@
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.ir.desugar.nest.NestBasedAccessDesugaring;
 import com.android.tools.r8.kotlin.Kotlin;
 import com.android.tools.r8.utils.ArrayUtils;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -214,6 +213,7 @@
   public final DexString stringDescriptor = createString("Ljava/lang/String;");
   public final DexString stringArrayDescriptor = createString("[Ljava/lang/String;");
   public final DexString objectDescriptor = createString("Ljava/lang/Object;");
+  public final DexString recordDescriptor = createString("Ljava/lang/Record;");
   public final DexString objectArrayDescriptor = createString("[Ljava/lang/Object;");
   public final DexString classDescriptor = createString("Ljava/lang/Class;");
   public final DexString classLoaderDescriptor = createString("Ljava/lang/ClassLoader;");
@@ -343,6 +343,7 @@
   public final DexType stringType = createStaticallyKnownType(stringDescriptor);
   public final DexType stringArrayType = createStaticallyKnownType(stringArrayDescriptor);
   public final DexType objectType = createStaticallyKnownType(objectDescriptor);
+  public final DexType recordType = createStaticallyKnownType(recordDescriptor);
   public final DexType objectArrayType = createStaticallyKnownType(objectArrayDescriptor);
   public final DexType classArrayType = createStaticallyKnownType(classArrayDescriptor);
   public final DexType enumType = createStaticallyKnownType(enumDescriptor);
@@ -424,6 +425,26 @@
       createStaticallyKnownType(reflectiveOperationExceptionDescriptor);
   public final DexType kotlinMetadataType = createStaticallyKnownType(kotlinMetadataDescriptor);
 
+  public final DexType doubleSummaryStatisticsConversionsType =
+      createStaticallyKnownType("Ljava/util/DoubleSummaryStatisticsConversions;");
+  public final DexType intSummaryStatisticsConversionsType =
+      createStaticallyKnownType("Ljava/util/IntSummaryStatisticsConversions;");
+  public final DexType longSummaryStatisticsConversionsType =
+      createStaticallyKnownType("Ljava/util/LongSummaryStatisticsConversions;");
+  public final DexType optionalConversionsType =
+      createStaticallyKnownType("Ljava/util/OptionalConversions;");
+  public final DexType timeConversionsType =
+      createStaticallyKnownType("Ljava/time/TimeConversions;");
+
+  public Iterable<DexType> getConversionTypes() {
+    return ImmutableList.of(
+        doubleSummaryStatisticsConversionsType,
+        intSummaryStatisticsConversionsType,
+        longSummaryStatisticsConversionsType,
+        optionalConversionsType,
+        timeConversionsType);
+  }
+
   public final DexType javaIoFileType = createStaticallyKnownType("Ljava/io/File;");
   public final DexType javaMathBigIntegerType = createStaticallyKnownType("Ljava/math/BigInteger;");
   public final DexType javaNioByteOrderType = createStaticallyKnownType("Ljava/nio/ByteOrder;");
@@ -454,10 +475,6 @@
       createStaticallyKnownType("Landroid/util/Property;");
   public final DexType androidViewViewType = createStaticallyKnownType("Landroid/view/View;");
 
-  public final DexString nestConstructorDescriptor =
-      createString("L" + NestBasedAccessDesugaring.NEST_CONSTRUCTOR_NAME + ";");
-  public final DexType nestConstructorType = createStaticallyKnownType(nestConstructorDescriptor);
-
   public final StringBuildingMethods stringBuilderMethods =
       new StringBuildingMethods(stringBuilderType);
   public final StringBuildingMethods stringBufferMethods =
@@ -540,8 +557,10 @@
       createProto(voidType, throwableType, autoCloseableType);
 
   public final DexString deserializeLambdaMethodName = createString("$deserializeLambda$");
+  public final DexType serializedLambdaType =
+      createStaticallyKnownType("Ljava/lang/invoke/SerializedLambda;");
   public final DexProto deserializeLambdaMethodProto =
-      createProto(objectType, createStaticallyKnownType("Ljava/lang/invoke/SerializedLambda;"));
+      createProto(objectType, serializedLambdaType);
 
   // Dex system annotations.
   // See https://source.android.com/devices/tech/dalvik/dex-format.html#system-annotation
diff --git a/src/main/java/com/android/tools/r8/graph/DexLibraryClass.java b/src/main/java/com/android/tools/r8/graph/DexLibraryClass.java
index df36fb7..f34162c 100644
--- a/src/main/java/com/android/tools/r8/graph/DexLibraryClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexLibraryClass.java
@@ -17,7 +17,8 @@
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 
-public class DexLibraryClass extends DexClass implements Supplier<DexLibraryClass> {
+public class DexLibraryClass extends DexClass
+    implements LibraryDefinition, Supplier<DexLibraryClass> {
 
   public DexLibraryClass(
       DexType type,
diff --git a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
index 618ff5b..0fdd6ad 100644
--- a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
@@ -161,6 +161,11 @@
   }
 
   @Override
+  public DexProgramClass getContext() {
+    return this;
+  }
+
+  @Override
   public StructuralMapping<DexProgramClass> getStructuralMapping() {
     return DexProgramClass::specify;
   }
@@ -801,7 +806,7 @@
           private DexProgramClass findNext() {
             while (iterator.hasNext()) {
               DexType next = iterator.next();
-              DexClass clazz = definitions.definitionFor(next);
+              DexClass clazz = definitions.contextIndependentDefinitionFor(next);
               if (clazz != null && clazz.isProgramClass()) {
                 return clazz.asProgramClass();
               }
diff --git a/src/main/java/com/android/tools/r8/graph/DexType.java b/src/main/java/com/android/tools/r8/graph/DexType.java
index 76d2ea4..f806886 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -4,11 +4,11 @@
 package com.android.tools.r8.graph;
 
 import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
-import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_GROUP_CLASS_NAME_PREFIX;
 
 import com.android.tools.r8.dex.IndexedItemCollection;
 import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.ir.desugar.nest.NestBasedAccessDesugaring;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.structural.CompareToVisitor;
@@ -36,7 +36,9 @@
           "$-DC",
           "$$ServiceLoaderMethods",
           "com.android.tools.r8.GeneratedOutlineSupport",
-          "-$$Lambda$");
+          "-$$Nest$Constructor",
+          "-$$Lambda$",
+          "-$$LambdaGroup$");
 
   public final DexString descriptor;
   private String toStringCache = null;
@@ -46,6 +48,10 @@
     this.descriptor = descriptor;
   }
 
+  public ClassReference asClassReference() {
+    return Reference.classFromDescriptor(toDescriptorString());
+  }
+
   @Override
   public DexType self() {
     return this;
@@ -301,15 +307,7 @@
   }
 
   public boolean isLegacySynthesizedTypeAllowedDuplication() {
-    String name = toSourceString();
-    return isSynthesizedTypeThatCouldBeDuplicated(name) || oldSynthesizedName(name);
-  }
-
-  private static boolean isSynthesizedTypeThatCouldBeDuplicated(String name) {
-    // Any entry that is removed from here must be added to OLD_SYNTHESIZED_NAMES to ensure that
-    // newer releases can be used to merge previous builds.
-    return name.contains(LAMBDA_GROUP_CLASS_NAME_PREFIX) // Could collide.
-        || name.contains(NestBasedAccessDesugaring.NEST_CONSTRUCTOR_NAME); // Global singleton.
+    return oldSynthesizedName(toSourceString());
   }
 
   private boolean oldSynthesizedName(String name) {
diff --git a/src/main/java/com/android/tools/r8/graph/FieldResolutionResult.java b/src/main/java/com/android/tools/r8/graph/FieldResolutionResult.java
index 4483fc5..8b1ca9d 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldResolutionResult.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldResolutionResult.java
@@ -25,6 +25,10 @@
     return null;
   }
 
+  public DexClassAndField getResolutionPair() {
+    return null;
+  }
+
   public boolean isSuccessfulResolution() {
     return false;
   }
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 2f6c224..56d3f52 100644
--- a/src/main/java/com/android/tools/r8/graph/GraphLens.java
+++ b/src/main/java/com/android/tools/r8/graph/GraphLens.java
@@ -300,6 +300,10 @@
    */
   private GraphLens() {}
 
+  public boolean isSyntheticFinalizationGraphLens() {
+    return false;
+  }
+
   public abstract DexType getOriginalType(DexType type);
 
   public abstract Iterable<DexType> getOriginalTypes(DexType type);
@@ -413,14 +417,7 @@
   }
 
   public DexReference lookupReference(DexReference reference) {
-    if (reference.isDexType()) {
-      return lookupType(reference.asDexType());
-    } else if (reference.isDexMethod()) {
-      return lookupMethod(reference.asDexMethod());
-    } else {
-      assert reference.isDexField();
-      return lookupField(reference.asDexField());
-    }
+    return reference.apply(this::lookupType, this::lookupField, this::lookupMethod);
   }
 
   // The method lookupMethod() maps a pair INVOKE=(method signature, invoke type) to a new pair
@@ -532,14 +529,9 @@
 
   @SuppressWarnings("unchecked")
   public <T extends DexReference> T rewriteReference(T reference) {
-    if (reference.isDexField()) {
-      return (T) getRenamedFieldSignature(reference.asDexField());
-    }
-    if (reference.isDexMethod()) {
-      return (T) getRenamedMethodSignature(reference.asDexMethod());
-    }
-    assert reference.isDexType();
-    return (T) lookupType(reference.asDexType());
+    return (T)
+        reference.apply(
+            this::lookupType, this::getRenamedFieldSignature, this::getRenamedMethodSignature);
   }
 
   public Set<DexReference> rewriteReferences(Set<DexReference> references) {
diff --git a/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java b/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java
index 40b6445..1f67c4d 100644
--- a/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java
+++ b/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java
@@ -301,7 +301,8 @@
     @Override
     public RecordComponentVisitor visitRecordComponent(
         String name, String descriptor, String signature) {
-      throw new CompilationError("Records are not supported", origin);
+      // TODO(b/169645628): Support Records.
+      return super.visitRecordComponent(name, descriptor, signature);
     }
 
     @Override
@@ -326,6 +327,12 @@
       }
       this.deprecated = AsmUtils.isDeprecated(access);
       accessFlags = ClassAccessFlags.fromCfAccessFlags(cleanAccessFlags(access));
+      if (accessFlags.isRecord()) {
+        // TODO(b/169645628): Support records in all compilation.
+        if (!application.options.canUseRecords()) {
+          throw new CompilationError("Records are not supported", origin);
+        }
+      }
       type = application.getTypeFromName(name);
       // Check if constraints from
       // https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.1 are met.
diff --git a/src/main/java/com/android/tools/r8/graph/LibraryDefinition.java b/src/main/java/com/android/tools/r8/graph/LibraryDefinition.java
new file mode 100644
index 0000000..a2fb6a8
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/LibraryDefinition.java
@@ -0,0 +1,23 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.graph;
+
+import java.util.function.Function;
+
+public interface LibraryDefinition extends Definition {
+
+  @Override
+  default <T> T apply(
+      Function<ProgramDefinition, T> programFunction,
+      Function<ClasspathDefinition, T> classpathFunction,
+      Function<LibraryDefinition, T> libraryFunction) {
+    return libraryFunction.apply(this);
+  }
+
+  @Override
+  default ProgramDerivedContext asProgramDerivedContext(ProgramDerivedContext witness) {
+    return ClasspathOrLibraryContext.create(this, witness);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/graph/LibraryMember.java b/src/main/java/com/android/tools/r8/graph/LibraryMember.java
index 880da78..bf6bb03 100644
--- a/src/main/java/com/android/tools/r8/graph/LibraryMember.java
+++ b/src/main/java/com/android/tools/r8/graph/LibraryMember.java
@@ -4,7 +4,8 @@
 
 package com.android.tools.r8.graph;
 
-public interface LibraryMember<D extends DexEncodedMember<D, R>, R extends DexMember<D, R>> {
+public interface LibraryMember<D extends DexEncodedMember<D, R>, R extends DexMember<D, R>>
+    extends LibraryDefinition {
 
   D getDefinition();
 
diff --git a/src/main/java/com/android/tools/r8/graph/ProgramDefinition.java b/src/main/java/com/android/tools/r8/graph/ProgramDefinition.java
index c55ad6f..862efbc 100644
--- a/src/main/java/com/android/tools/r8/graph/ProgramDefinition.java
+++ b/src/main/java/com/android/tools/r8/graph/ProgramDefinition.java
@@ -5,19 +5,29 @@
 package com.android.tools.r8.graph;
 
 import com.android.tools.r8.origin.Origin;
+import java.util.function.Function;
 
-public interface ProgramDefinition {
+public interface ProgramDefinition extends Definition, ProgramDerivedContext {
+
+  @Override
+  default <T> T apply(
+      Function<ProgramDefinition, T> programFunction,
+      Function<ClasspathDefinition, T> classpathFunction,
+      Function<LibraryDefinition, T> libraryFunction) {
+    return programFunction.apply(this);
+  }
+
+  @Override
+  default ProgramDerivedContext asProgramDerivedContext(ProgramDerivedContext witness) {
+    return this;
+  }
 
   DexProgramClass getContextClass();
 
   AccessFlags<?> getAccessFlags();
 
-  DexType getContextType();
-
   DexDefinition getDefinition();
 
-  DexReference getReference();
-
   Origin getOrigin();
 
   default boolean isProgramClass() {
diff --git a/src/main/java/com/android/tools/r8/graph/ProgramDerivedContext.java b/src/main/java/com/android/tools/r8/graph/ProgramDerivedContext.java
new file mode 100644
index 0000000..f9ec920
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/ProgramDerivedContext.java
@@ -0,0 +1,10 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.graph;
+
+public interface ProgramDerivedContext {
+
+  Definition getContext();
+}
diff --git a/src/main/java/com/android/tools/r8/graph/ProgramField.java b/src/main/java/com/android/tools/r8/graph/ProgramField.java
index 866d230..42d2453 100644
--- a/src/main/java/com/android/tools/r8/graph/ProgramField.java
+++ b/src/main/java/com/android/tools/r8/graph/ProgramField.java
@@ -27,6 +27,11 @@
   }
 
   @Override
+  public ProgramField getContext() {
+    return this;
+  }
+
+  @Override
   public boolean isProgramField() {
     return true;
   }
diff --git a/src/main/java/com/android/tools/r8/graph/ProgramMethod.java b/src/main/java/com/android/tools/r8/graph/ProgramMethod.java
index 3dc807c..a8817dc 100644
--- a/src/main/java/com/android/tools/r8/graph/ProgramMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/ProgramMethod.java
@@ -63,6 +63,11 @@
   }
 
   @Override
+  public ProgramMethod getContext() {
+    return this;
+  }
+
+  @Override
   public boolean isProgramMember() {
     return true;
   }
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
deleted file mode 100644
index 3a9f618..0000000
--- a/src/main/java/com/android/tools/r8/graph/classmerging/HorizontallyMergedLambdaClasses.java
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.graph.classmerging;
-
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroup;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.collections.BidirectionalManyToOneHashMap;
-import com.android.tools.r8.utils.collections.BidirectionalManyToOneMap;
-import com.android.tools.r8.utils.collections.MutableBidirectionalManyToOneMap;
-import java.util.Collections;
-import java.util.Map;
-import java.util.Set;
-import java.util.function.BiConsumer;
-
-public class HorizontallyMergedLambdaClasses implements MergedClasses {
-
-  private final BidirectionalManyToOneMap<DexType, DexType> mergedClasses;
-
-  public HorizontallyMergedLambdaClasses(Map<DexType, LambdaGroup> lambdas) {
-    MutableBidirectionalManyToOneMap<DexType, DexType> mergedClasses =
-        new BidirectionalManyToOneHashMap<>();
-    lambdas.forEach((lambda, group) -> mergedClasses.put(lambda, group.getGroupClassType()));
-    this.mergedClasses = mergedClasses;
-  }
-
-  public static HorizontallyMergedLambdaClasses empty() {
-    return new HorizontallyMergedLambdaClasses(Collections.emptyMap());
-  }
-
-  @Override
-  public void forEachMergeGroup(BiConsumer<Set<DexType>, DexType> consumer) {
-    mergedClasses.forEachManyToOneMapping(consumer);
-  }
-
-  @Override
-  public boolean hasBeenMergedIntoDifferentType(DexType type) {
-    return mergedClasses.containsKey(type);
-  }
-
-  @Override
-  public boolean isMergeTarget(DexType type) {
-    return mergedClasses.containsValue(type);
-  }
-
-  @Override
-  public boolean verifyAllSourcesPruned(AppView<AppInfoWithLiveness> appView) {
-    for (DexType source : mergedClasses.keySet()) {
-      assert appView.appInfo().wasPruned(source)
-          : "Expected horizontally merged lambda class `"
-              + source.toSourceString()
-              + "` to be absent";
-    }
-    return true;
-  }
-}
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 dd0486a..d97f12f 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMerger.java
@@ -23,14 +23,14 @@
 import com.android.tools.r8.horizontalclassmerging.policies.NoInnerClasses;
 import com.android.tools.r8.horizontalclassmerging.policies.NoInterfaces;
 import com.android.tools.r8.horizontalclassmerging.policies.NoKeepRules;
-import com.android.tools.r8.horizontalclassmerging.policies.NoKotlinLambdas;
 import com.android.tools.r8.horizontalclassmerging.policies.NoKotlinMetadata;
 import com.android.tools.r8.horizontalclassmerging.policies.NoNativeMethods;
 import com.android.tools.r8.horizontalclassmerging.policies.NoServiceLoaders;
 import com.android.tools.r8.horizontalclassmerging.policies.NotMatchedByNoHorizontalClassMerging;
 import com.android.tools.r8.horizontalclassmerging.policies.NotVerticallyMergedIntoSubtype;
 import com.android.tools.r8.horizontalclassmerging.policies.PreserveMethodCharacteristics;
-import com.android.tools.r8.horizontalclassmerging.policies.PreventMergeIntoMainDex;
+import com.android.tools.r8.horizontalclassmerging.policies.PreventMergeIntoDifferentMainDexGroups;
+import com.android.tools.r8.horizontalclassmerging.policies.PreventMergeIntoMainDexList;
 import com.android.tools.r8.horizontalclassmerging.policies.PreventMethodImplementation;
 import com.android.tools.r8.horizontalclassmerging.policies.RespectPackageBoundaries;
 import com.android.tools.r8.horizontalclassmerging.policies.SameFeatureSplit;
@@ -40,7 +40,6 @@
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.shaking.FieldAccessInfoCollectionModifier;
 import com.android.tools.r8.shaking.KeepInfoCollection;
-import com.android.tools.r8.shaking.MainDexTracingResult;
 import com.android.tools.r8.shaking.RuntimeTypeCheckInfo;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
@@ -61,12 +60,11 @@
   // TODO(b/165577835): replace Collection<DexProgramClass> with MergeGroup
   public HorizontalClassMergerResult run(
       DirectMappedDexApplication.Builder appBuilder,
-      MainDexTracingResult mainDexTracingResult,
       RuntimeTypeCheckInfo runtimeTypeCheckInfo) {
     MergeGroup initialGroup = new MergeGroup(appView.appInfo().classesWithDeterministicOrder());
 
     // Run the policies on all program classes to produce a final grouping.
-    List<Policy> policies = getPolicies(mainDexTracingResult, runtimeTypeCheckInfo);
+    List<Policy> policies = getPolicies(runtimeTypeCheckInfo);
     Collection<MergeGroup> groups =
         new SimplePolicyExecutor().run(Collections.singletonList(initialGroup), policies);
 
@@ -80,8 +78,6 @@
         new HorizontallyMergedClasses.Builder();
     HorizontalClassMergerGraphLens.Builder lensBuilder =
         new HorizontalClassMergerGraphLens.Builder();
-    MainDexTracingResult.Builder mainDexTracingResultBuilder =
-        mainDexTracingResult.extensionBuilder(appView.appInfo());
 
     // Set up a class merger for each group.
     List<ClassMerger> classMergers =
@@ -92,9 +88,7 @@
 
     // Merge the classes.
     SyntheticArgumentClass syntheticArgumentClass =
-        new SyntheticArgumentClass.Builder(
-                appBuilder, appView, mainDexTracingResult, mainDexTracingResultBuilder)
-            .build(allMergeClasses);
+        new SyntheticArgumentClass.Builder(appBuilder, appView).build(allMergeClasses);
     applyClassMergers(classMergers, syntheticArgumentClass);
 
     // Generate the graph lens.
@@ -107,8 +101,7 @@
     KeepInfoCollection keepInfo = appView.appInfo().getKeepInfo();
     keepInfo.mutate(mutator -> mutator.removeKeepInfoForPrunedItems(mergedClasses.getSources()));
 
-    return new HorizontalClassMergerResult(
-        createFieldAccessInfoCollectionModifier(groups), lens, mainDexTracingResultBuilder.build());
+    return new HorizontalClassMergerResult(createFieldAccessInfoCollectionModifier(groups), lens);
   }
 
   private FieldAccessInfoCollectionModifier createFieldAccessInfoCollectionModifier(
@@ -127,9 +120,7 @@
     return builder.build();
   }
 
-  private List<Policy> getPolicies(
-      MainDexTracingResult mainDexTracingResult,
-      RuntimeTypeCheckInfo runtimeTypeCheckInfo) {
+  private List<Policy> getPolicies(RuntimeTypeCheckInfo runtimeTypeCheckInfo) {
     return ImmutableList.of(
         new NotMatchedByNoHorizontalClassMerging(appView),
         new SameInstanceFields(appView),
@@ -138,20 +129,20 @@
         new NoEnums(appView),
         new CheckAbstractClasses(appView),
         new IgnoreSynthetics(appView),
-        new NoClassesOrMembersWithAnnotations(),
+        new NoClassesOrMembersWithAnnotations(appView),
         new NoInnerClasses(),
         new NoClassInitializerWithObservableSideEffects(),
         new NoNativeMethods(),
         new NoKeepRules(appView),
         new NoKotlinMetadata(),
-        new NoKotlinLambdas(appView),
         new NoServiceLoaders(appView),
         new NotVerticallyMergedIntoSubtype(appView),
         new NoDirectRuntimeTypeChecks(runtimeTypeCheckInfo),
         new NoIndirectRuntimeTypeChecks(appView, runtimeTypeCheckInfo),
         new PreventMethodImplementation(appView),
-        new DontInlinePolicy(appView, mainDexTracingResult),
-        new PreventMergeIntoMainDex(appView, mainDexTracingResult),
+        new DontInlinePolicy(appView),
+        new PreventMergeIntoMainDexList(appView),
+        new PreventMergeIntoDifferentMainDexGroups(appView),
         new AllInstantiatedOrUninstantiated(appView),
         new SameParentClass(),
         new SameNestHost(),
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerResult.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerResult.java
index 75aafb4..820c24a 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerResult.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerResult.java
@@ -5,21 +5,17 @@
 package com.android.tools.r8.horizontalclassmerging;
 
 import com.android.tools.r8.shaking.FieldAccessInfoCollectionModifier;
-import com.android.tools.r8.shaking.MainDexTracingResult;
 
 public class HorizontalClassMergerResult {
 
   private final FieldAccessInfoCollectionModifier fieldAccessInfoCollectionModifier;
   private final HorizontalClassMergerGraphLens graphLens;
-  private final MainDexTracingResult mainDexTracingResult;
 
   HorizontalClassMergerResult(
       FieldAccessInfoCollectionModifier fieldAccessInfoCollectionModifier,
-      HorizontalClassMergerGraphLens graphLens,
-      MainDexTracingResult mainDexTracingResult) {
+      HorizontalClassMergerGraphLens graphLens) {
     this.fieldAccessInfoCollectionModifier = fieldAccessInfoCollectionModifier;
     this.graphLens = graphLens;
-    this.mainDexTracingResult = mainDexTracingResult;
   }
 
   public FieldAccessInfoCollectionModifier getFieldAccessInfoCollectionModifier() {
@@ -29,8 +25,4 @@
   public HorizontalClassMergerGraphLens getGraphLens() {
     return graphLens;
   }
-
-  public MainDexTracingResult getMainDexTracingResult() {
-    return mainDexTracingResult;
-  }
 }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/SyntheticArgumentClass.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/SyntheticArgumentClass.java
index ec64e8a..60c350a 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/SyntheticArgumentClass.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/SyntheticArgumentClass.java
@@ -17,7 +17,7 @@
 import com.android.tools.r8.graph.GenericSignature.ClassSignature;
 import com.android.tools.r8.origin.SynthesizedOrigin;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.shaking.MainDexTracingResult;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.google.common.collect.Iterables;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -57,24 +57,15 @@
 
     private final DirectMappedDexApplication.Builder appBuilder;
     private final AppView<AppInfoWithLiveness> appView;
-    private final MainDexTracingResult mainDexTracingResult;
-    private final MainDexTracingResult.Builder mainDexTracingResultBuilder;
 
-    Builder(
-        DirectMappedDexApplication.Builder appBuilder,
-        AppView<AppInfoWithLiveness> appView,
-        MainDexTracingResult mainDexTracingResult,
-        MainDexTracingResult.Builder mainDexTracingResultBuilder) {
+    Builder(DirectMappedDexApplication.Builder appBuilder, AppView<AppInfoWithLiveness> appView) {
       this.appBuilder = appBuilder;
       this.appView = appView;
-      this.mainDexTracingResult = mainDexTracingResult;
-      this.mainDexTracingResultBuilder = mainDexTracingResultBuilder;
     }
 
     private DexType synthesizeClass(
         DexProgramClass context,
         boolean requiresMainDex,
-        boolean addToMainDexTracingResult,
         int index) {
       DexType syntheticClassType =
           appView
@@ -108,10 +99,6 @@
 
       appBuilder.addSynthesizedClass(clazz);
       appView.appInfo().addSynthesizedClass(clazz, requiresMainDex);
-      if (addToMainDexTracingResult) {
-        mainDexTracingResultBuilder.addRoot(clazz);
-      }
-
       return clazz.type;
     }
 
@@ -119,20 +106,17 @@
       // Find a fresh name in an existing package.
       DexProgramClass context = mergeClasses.iterator().next();
 
-      // Add to the main dex list if one of the merged classes is in the main dex.
-      boolean requiresMainDex = appView.appInfo().getMainDexClasses().containsAnyOf(mergeClasses);
-
-      // Also add as a root to the main dex tracing result if any of the merged classes is a root.
+      // Add as a root to the main dex tracing result if any of the merged classes is a root.
       // This is needed to satisfy an assertion in the inliner that verifies that we do not inline
       // methods with references to non-roots into classes that are roots.
-      boolean addToMainDexTracingResult = Iterables.any(mergeClasses, mainDexTracingResult::isRoot);
+      MainDexInfo mainDexInfo = appView.appInfo().getMainDexInfo();
+      boolean requiresMainDex = Iterables.any(mergeClasses, mainDexInfo::isMainDex);
 
       List<DexType> syntheticArgumentTypes = new ArrayList<>();
       for (int i = 0;
           i < appView.options().horizontalClassMergerOptions().getSyntheticArgumentCount();
           i++) {
-        syntheticArgumentTypes.add(
-            synthesizeClass(context, requiresMainDex, addToMainDexTracingResult, i));
+        syntheticArgumentTypes.add(synthesizeClass(context, requiresMainDex, i));
       }
 
       return new SyntheticArgumentClass(syntheticArgumentTypes);
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/DontInlinePolicy.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/DontInlinePolicy.java
index 9612f98..f7d121a 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/DontInlinePolicy.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/DontInlinePolicy.java
@@ -12,18 +12,16 @@
 import com.android.tools.r8.horizontalclassmerging.SingleClassPolicy;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.shaking.MainDexDirectReferenceTracer;
-import com.android.tools.r8.shaking.MainDexTracingResult;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.google.common.collect.Iterables;
 
 public class DontInlinePolicy extends SingleClassPolicy {
   private final AppView<AppInfoWithLiveness> appView;
-  private final MainDexTracingResult mainDexTracingResult;
+  private final MainDexInfo mainDexInfo;
 
-  public DontInlinePolicy(
-      AppView<AppInfoWithLiveness> appView, MainDexTracingResult mainDexTracingResult) {
+  public DontInlinePolicy(AppView<AppInfoWithLiveness> appView) {
     this.appView = appView;
-    this.mainDexTracingResult = mainDexTracingResult;
+    this.mainDexInfo = appView.appInfo().getMainDexInfo();
   }
 
   private boolean disallowInlining(ProgramMethod method) {
@@ -46,14 +44,6 @@
       return true;
     }
 
-    // Constructors can have references beyond the root main dex classes. This can increase the
-    // size of the main dex dependent classes and we should bail out.
-    if (mainDexTracingResult.getRoots().contains(method.getHolderType())
-        && MainDexDirectReferenceTracer.hasReferencesOutsideFromCode(
-            appView.appInfo(), method, mainDexTracingResult.getRoots())) {
-      return true;
-    }
-
     return false;
   }
 
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoClassesOrMembersWithAnnotations.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoClassesOrMembersWithAnnotations.java
index f9d2106..f0b2a6e 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoClassesOrMembersWithAnnotations.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoClassesOrMembersWithAnnotations.java
@@ -4,12 +4,28 @@
 
 package com.android.tools.r8.horizontalclassmerging.policies;
 
+import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.horizontalclassmerging.SingleClassPolicy;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.InternalOptions.HorizontalClassMergerOptions;
 
 public class NoClassesOrMembersWithAnnotations extends SingleClassPolicy {
+
+  private final HorizontalClassMergerOptions options;
+
+  public NoClassesOrMembersWithAnnotations(AppView<AppInfoWithLiveness> appView) {
+    this.options = appView.options().horizontalClassMergerOptions();
+  }
+
   @Override
   public boolean canMerge(DexProgramClass program) {
     return !program.hasClassOrMemberAnnotations();
   }
+
+  @Override
+  public boolean shouldSkipPolicy() {
+    // TODO(b/179019716): Add support for merging in presence of annotations.
+    return options.skipNoClassesOrMembersWithAnnotationsPolicyForTesting;
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInnerClasses.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInnerClasses.java
index ddb2aef..cc9f61c 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInnerClasses.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoInnerClasses.java
@@ -11,6 +11,7 @@
 
   @Override
   public boolean canMerge(DexProgramClass program) {
+    // TODO(b/179018501): allow merging classes with inner/outer classes.
     return program.getInnerClasses().isEmpty();
   }
 }
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoKotlinLambdas.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoKotlinLambdas.java
deleted file mode 100644
index dee7a4a..0000000
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoKotlinLambdas.java
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.horizontalclassmerging.policies;
-
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.horizontalclassmerging.SingleClassPolicy;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
-
-public class NoKotlinLambdas extends SingleClassPolicy {
-  private final AppView<AppInfoWithLiveness> appView;
-
-  public NoKotlinLambdas(AppView<AppInfoWithLiveness> appView) {
-    this.appView = appView;
-  }
-
-  @Override
-  public boolean shouldSkipPolicy() {
-    return appView.options().horizontalClassMergerOptions().isKotlinLambdaMergingEnabled();
-  }
-
-  @Override
-  public boolean canMerge(DexProgramClass program) {
-    if (program.getKotlinInfo().isNoKotlinInformation()
-        || !program.getKotlinInfo().isSyntheticClass()) {
-      return true;
-    }
-
-    return !program.getKotlinInfo().asSyntheticClass().isLambda();
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoKotlinMetadata.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoKotlinMetadata.java
index 92f2938..1acad7a 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoKotlinMetadata.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/NoKotlinMetadata.java
@@ -19,12 +19,8 @@
   }
 
   private boolean verifyNoUnexpectedKotlinInfo(DexProgramClass clazz) {
-    if (clazz.getKotlinInfo().isNoKotlinInformation()) {
-      assert verifyNoUnexpectedKotlinMemberInfo(clazz);
-      return true;
-    }
-    assert clazz.getKotlinInfo().isSyntheticClass()
-        && clazz.getKotlinInfo().asSyntheticClass().isLambda();
+    assert clazz.getKotlinInfo().isNoKotlinInformation();
+    assert verifyNoUnexpectedKotlinMemberInfo(clazz);
     return true;
   }
 
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreserveMethodCharacteristics.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreserveMethodCharacteristics.java
index fcafba0..4a789ba 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreserveMethodCharacteristics.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreserveMethodCharacteristics.java
@@ -20,6 +20,7 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 
 /**
  * Policy that enforces that methods are only merged if they have the same visibility and library
@@ -32,8 +33,10 @@
     private final MethodAccessFlags accessFlags;
     private final boolean isAssumeNoSideEffectsMethod;
     private final OptionalBool isLibraryMethodOverride;
+    private final boolean isMainDexRoot;
 
-    private MethodCharacteristics(boolean isAssumeNoSideEffectsMethod, DexEncodedMethod method) {
+    private MethodCharacteristics(
+        DexEncodedMethod method, boolean isAssumeNoSideEffectsMethod, boolean isMainDexRoot) {
       this.accessFlags =
           MethodAccessFlags.builder()
               .setPrivate(method.getAccessFlags().isPrivate())
@@ -44,17 +47,24 @@
               .build();
       this.isAssumeNoSideEffectsMethod = isAssumeNoSideEffectsMethod;
       this.isLibraryMethodOverride = method.isLibraryMethodOverride();
+      this.isMainDexRoot = isMainDexRoot;
     }
 
     static MethodCharacteristics create(
         AppView<AppInfoWithLiveness> appView, DexEncodedMethod method) {
       return new MethodCharacteristics(
-          appView.appInfo().isAssumeNoSideEffectsMethod(method.getReference()), method);
+          method,
+          appView.appInfo().isAssumeNoSideEffectsMethod(method.getReference()),
+          appView.appInfo().getMainDexInfo().isTracedMethodRoot(method.getReference()));
     }
 
     @Override
     public int hashCode() {
-      return (accessFlags.hashCode() << 2) | isLibraryMethodOverride.ordinal();
+      return Objects.hash(
+          accessFlags,
+          isAssumeNoSideEffectsMethod,
+          isLibraryMethodOverride.ordinal(),
+          isMainDexRoot);
     }
 
     @Override
@@ -68,7 +78,8 @@
       MethodCharacteristics characteristics = (MethodCharacteristics) obj;
       return accessFlags.equals(characteristics.accessFlags)
           && isAssumeNoSideEffectsMethod == characteristics.isAssumeNoSideEffectsMethod
-          && isLibraryMethodOverride == characteristics.isLibraryMethodOverride;
+          && isLibraryMethodOverride == characteristics.isLibraryMethodOverride
+          && isMainDexRoot == characteristics.isMainDexRoot;
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreventMergeIntoDifferentMainDexGroups.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreventMergeIntoDifferentMainDexGroups.java
new file mode 100644
index 0000000..52a1d98
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreventMergeIntoDifferentMainDexGroups.java
@@ -0,0 +1,28 @@
+// 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.AppView;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.horizontalclassmerging.MultiClassSameReferencePolicy;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.MainDexInfo;
+import com.android.tools.r8.shaking.MainDexInfo.MainDexGroup;
+
+public class PreventMergeIntoDifferentMainDexGroups
+    extends MultiClassSameReferencePolicy<MainDexGroup> {
+
+  private final MainDexInfo mainDexInfo;
+
+  public PreventMergeIntoDifferentMainDexGroups(AppView<AppInfoWithLiveness> appView) {
+    this.mainDexInfo = appView.appInfo().getMainDexInfo();
+  }
+
+  @Override
+  public MainDexGroup getMergeKey(DexProgramClass clazz) {
+    assert !mainDexInfo.isFromList(clazz);
+    return mainDexInfo.getMergeKey(clazz);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreventMergeIntoMainDex.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreventMergeIntoMainDex.java
deleted file mode 100644
index 783ede5..0000000
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreventMergeIntoMainDex.java
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.horizontalclassmerging.policies;
-
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.horizontalclassmerging.MultiClassSameReferencePolicy;
-import com.android.tools.r8.horizontalclassmerging.policies.PreventMergeIntoMainDex.MainDexClassification;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.shaking.MainDexClasses;
-import com.android.tools.r8.shaking.MainDexTracingResult;
-
-public class PreventMergeIntoMainDex extends MultiClassSameReferencePolicy<MainDexClassification> {
-  private final MainDexClasses mainDexClasses;
-  private final MainDexTracingResult mainDexTracingResult;
-
-  enum MainDexClassification {
-    MAIN_DEX_LIST,
-    MAIN_DEX_ROOT,
-    MAIN_DEX_DEPENDENCY,
-    NOT_IN_MAIN_DEX
-  }
-
-  public PreventMergeIntoMainDex(
-      AppView<AppInfoWithLiveness> appView, MainDexTracingResult mainDexTracingResult) {
-    this.mainDexClasses = appView.appInfo().getMainDexClasses();
-    this.mainDexTracingResult = mainDexTracingResult;
-  }
-
-  @Override
-  public MainDexClassification getMergeKey(DexProgramClass clazz) {
-    if (mainDexClasses.contains(clazz)) {
-      return MainDexClassification.MAIN_DEX_LIST;
-    }
-    if (mainDexTracingResult.isRoot(clazz)) {
-      return MainDexClassification.MAIN_DEX_ROOT;
-    }
-    if (mainDexTracingResult.isDependency(clazz)) {
-      return MainDexClassification.MAIN_DEX_DEPENDENCY;
-    }
-    return MainDexClassification.NOT_IN_MAIN_DEX;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreventMergeIntoMainDexList.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreventMergeIntoMainDexList.java
new file mode 100644
index 0000000..850d02e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/policies/PreventMergeIntoMainDexList.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.AppView;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.horizontalclassmerging.SingleClassPolicy;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.MainDexInfo;
+
+public class PreventMergeIntoMainDexList extends SingleClassPolicy {
+
+  private final MainDexInfo mainDexInfo;
+
+  public PreventMergeIntoMainDexList(AppView<AppInfoWithLiveness> appView) {
+    this.mainDexInfo = appView.appInfo().getMainDexInfo();
+  }
+
+  @Override
+  public boolean canMerge(DexProgramClass program) {
+    return mainDexInfo.canMerge(program);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/proto/schema/ProtoEnqueuerExtension.java b/src/main/java/com/android/tools/r8/ir/analysis/proto/schema/ProtoEnqueuerExtension.java
index 41ae033..24b17fb 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/proto/schema/ProtoEnqueuerExtension.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/proto/schema/ProtoEnqueuerExtension.java
@@ -381,7 +381,7 @@
           // Map/required fields cannot be removed. Therefore, we mark such fields as both read and
           // written such that we cannot optimize any field reads or writes.
           enqueuer.registerReflectiveFieldAccess(valueStorage.getReference(), dynamicMethod);
-          worklist.enqueueMarkReachableFieldAction(
+          worklist.enqueueMarkInstanceFieldAsReachableAction(
               valueStorage, dynamicMethod, KeepReason.reflectiveUseIn(dynamicMethod));
           valueStorageIsLive = true;
         } else {
@@ -446,7 +446,7 @@
           // Unconditionally register the hazzer and one-of proto fields as written from
           // dynamicMethod().
           if (enqueuer.registerReflectiveFieldWrite(newlyLiveField.getReference(), dynamicMethod)) {
-            worklist.enqueueMarkReachableFieldAction(
+            worklist.enqueueMarkInstanceFieldAsReachableAction(
                 newlyLiveField, dynamicMethod, KeepReason.reflectiveUseIn(dynamicMethod));
           }
         }
@@ -566,7 +566,7 @@
     }
 
     if (enqueuer.registerReflectiveFieldWrite(oneOfField.getReference(), dynamicMethod)) {
-      worklist.enqueueMarkReachableFieldAction(
+      worklist.enqueueMarkInstanceFieldAsReachableAction(
           oneOfField, dynamicMethod, KeepReason.reflectiveUseIn(dynamicMethod));
     }
   }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/D8MethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/D8MethodProcessor.java
index 61ea47c..d8fb60c 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/D8MethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/D8MethodProcessor.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.ir.conversion;
 
+import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackIgnore;
 import com.android.tools.r8.utils.ThreadUtils;
@@ -24,9 +25,10 @@
     this.executorService = executorService;
   }
 
-  public void awaitMethodProcessing() throws ExecutionException {
-    ThreadUtils.awaitFutures(futures);
-    futures.clear();
+  @Override
+  public boolean isProcessedConcurrently(ProgramMethod method) {
+    // In D8 all methods are considered independently compiled.
+    return true;
   }
 
   @Override
@@ -43,8 +45,13 @@
             executorService));
   }
 
-  public boolean verifyAllMethodsProcessed() {
-    assert futures.isEmpty();
-    return true;
+  @Override
+  public CallSiteInformation getCallSiteInformation() {
+    throw new Unreachable("Invalid attempt to obtain call-site information in D8");
+  }
+
+  public void awaitMethodProcessing() throws ExecutionException {
+    ThreadUtils.awaitFutures(futures);
+    futures.clear();
   }
 }
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 4131111..b1e68ace 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
@@ -23,7 +23,6 @@
 import com.android.tools.r8.graph.DexTypeList;
 import com.android.tools.r8.graph.GraphLens;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.graph.classmerging.HorizontallyMergedLambdaClasses;
 import com.android.tools.r8.ir.analysis.TypeChecker;
 import com.android.tools.r8.ir.analysis.VerifyTypesHelper;
 import com.android.tools.r8.ir.analysis.constant.SparseConditionalConstantPropagation;
@@ -82,7 +81,6 @@
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackIgnore;
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackSimple;
 import com.android.tools.r8.ir.optimize.info.field.InstanceFieldInitializationInfoCollection;
-import com.android.tools.r8.ir.optimize.lambda.LambdaMerger;
 import com.android.tools.r8.ir.optimize.staticizer.ClassStaticizer;
 import com.android.tools.r8.ir.optimize.string.StringBuilderOptimizer;
 import com.android.tools.r8.ir.optimize.string.StringOptimizer;
@@ -93,7 +91,6 @@
 import com.android.tools.r8.position.MethodPosition;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.shaking.LibraryMethodOverrideAnalysis;
-import com.android.tools.r8.shaking.MainDexTracingResult;
 import com.android.tools.r8.utils.Action;
 import com.android.tools.r8.utils.CfgPrinter;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -123,7 +120,6 @@
   private static final int PEEPHOLE_OPTIMIZATION_PASSES = 2;
 
   public final AppView<?> appView;
-  public final MainDexTracingResult mainDexClasses;
 
   private final Timing timing;
   private final Outliner outliner;
@@ -140,7 +136,6 @@
   private final TwrCloseResourceRewriter twrCloseResourceRewriter;
   private final BackportedMethodRewriter backportedMethodRewriter;
   private final DesugaredLibraryRetargeter desugaredLibraryRetargeter;
-  private final LambdaMerger lambdaMerger;
   private final ClassInliner classInliner;
   private final ClassStaticizer classStaticizer;
   private final InternalOptions options;
@@ -185,8 +180,7 @@
    * The argument `appView` is used to determine if whole program optimizations are allowed or not
    * (i.e., whether we are running R8). See {@link AppView#enableWholeProgramOptimizations()}.
    */
-  public IRConverter(
-      AppView<?> appView, Timing timing, CfgPrinter printer, MainDexTracingResult mainDexClasses) {
+  public IRConverter(AppView<?> appView, Timing timing, CfgPrinter printer) {
     assert appView.appInfo().hasLiveness() || appView.graphLens().isIdentityLens();
     assert appView.options() != null;
     assert appView.options().programConsumer != null;
@@ -195,7 +189,6 @@
     this.appView = appView;
     this.options = appView.options();
     this.printer = printer;
-    this.mainDexClasses = mainDexClasses;
     this.codeRewriter = new CodeRewriter(appView, this);
     this.constantCanonicalizer = new ConstantCanonicalizer(codeRewriter);
     this.classInitializerDefaultsOptimization =
@@ -242,7 +235,6 @@
               : null;
       this.d8NestBasedAccessDesugaring =
           options.shouldDesugarNests() ? new D8NestBasedAccessDesugaring(appView) : null;
-      this.lambdaMerger = null;
       this.covariantReturnTypeAnnotationTransformer = null;
       this.dynamicTypeOptimization = null;
       this.classInliner = null;
@@ -305,12 +297,9 @@
           options.enableTreeShakingOfLibraryMethodOverrides
               ? new LibraryMethodOverrideAnalysis(appViewWithLiveness)
               : null;
-      this.lambdaMerger =
-          options.enableLambdaMerging ? new LambdaMerger(appViewWithLiveness) : null;
       this.enumUnboxer = options.enableEnumUnboxing ? new EnumUnboxer(appViewWithLiveness) : null;
       this.lensCodeRewriter = new LensCodeRewriter(appViewWithLiveness, enumUnboxer);
-      this.inliner =
-          new Inliner(appViewWithLiveness, mainDexClasses, lambdaMerger, lensCodeRewriter);
+      this.inliner = new Inliner(appViewWithLiveness, lensCodeRewriter);
       this.outliner = new Outliner(appViewWithLiveness);
       this.memberValuePropagation =
           options.enableValuePropagation ? new MemberValuePropagation(appViewWithLiveness) : null;
@@ -322,9 +311,7 @@
         this.identifierNameStringMarker = null;
       }
       this.devirtualizer =
-          options.enableDevirtualization
-              ? new Devirtualizer(appViewWithLiveness, mainDexClasses)
-              : null;
+          options.enableDevirtualization ? new Devirtualizer(appViewWithLiveness) : null;
       this.typeChecker = new TypeChecker(appViewWithLiveness, VerifyTypesHelper.create(appView));
       this.d8NestBasedAccessDesugaring = null;
       this.serviceLoaderRewriter =
@@ -346,7 +333,6 @@
       this.fieldAccessAnalysis = null;
       this.libraryMethodOverrideAnalysis = null;
       this.inliner = null;
-      this.lambdaMerger = null;
       this.outliner = null;
       this.memberValuePropagation = null;
       this.lensCodeRewriter = null;
@@ -372,16 +358,11 @@
 
   /** Create an IR converter for processing methods with full program optimization disabled. */
   public IRConverter(AppView<?> appView, Timing timing) {
-    this(appView, timing, null, MainDexTracingResult.NONE);
-  }
-
-  /** Create an IR converter for processing methods with full program optimization disabled. */
-  public IRConverter(AppView<?> appView, Timing timing, CfgPrinter printer) {
-    this(appView, timing, printer, MainDexTracingResult.NONE);
+    this(appView, timing, null);
   }
 
   public IRConverter(AppInfo appInfo, Timing timing, CfgPrinter printer) {
-    this(AppView.createForD8(appInfo), timing, printer, MainDexTracingResult.NONE);
+    this(AppView.createForD8(appInfo), timing, printer);
   }
 
   private void removeLambdaDeserializationMethods() {
@@ -398,12 +379,8 @@
     }
   }
 
-  private void finalizeNestBasedAccessDesugaring(Builder<?> builder) {
+  private void reportNestDesugarDependencies() {
     if (d8NestBasedAccessDesugaring != null) {
-      DexProgramClass nestConstructor = d8NestBasedAccessDesugaring.synthesizeNestConstructor();
-      if (nestConstructor != null) {
-        builder.addProgramClass(nestConstructor);
-      }
       d8NestBasedAccessDesugaring.reportDesugarDependencies();
     }
   }
@@ -489,10 +466,7 @@
 
     convertClasses(application, executor);
 
-    // Build a new application with jumbo string info,
-    Builder<?> builder = application.builder().setHighestSortingString(highestSortingString);
-
-    finalizeNestBasedAccessDesugaring(builder);
+    reportNestDesugarDependencies();
 
     // Synthesize lambda classes and commit to the app in full.
     synthesizeLambdaClasses(executor);
@@ -500,13 +474,14 @@
     if (appView.getSyntheticItems().hasPendingSyntheticClasses()) {
       appView.setAppInfo(
           new AppInfo(
-              appView.appInfo().getSyntheticItems().commit(builder.build()),
-              appView.appInfo().getMainDexClasses()));
+              appView.appInfo().getSyntheticItems().commit(application),
+              appView.appInfo().getMainDexInfo()));
       application = appView.appInfo().app();
-      builder = application.builder();
-      builder.setHighestSortingString(highestSortingString);
     }
 
+    // Build a new application with jumbo string info,
+    Builder<?> builder = application.builder().setHighestSortingString(highestSortingString);
+
     desugarInterfaceMethods(builder, ExcludeDexResources, executor);
     processSynthesizedJava8UtilityClasses(executor);
     synthesizeRetargetClass(builder, executor);
@@ -520,7 +495,7 @@
     appView.setAppInfo(
         new AppInfo(
             appView.appInfo().getSyntheticItems().commit(application),
-            appView.appInfo().getMainDexClasses()));
+            appView.appInfo().getMainDexInfo()));
   }
 
   private void convertClasses(DexApplication application, ExecutorService executorService)
@@ -680,7 +655,6 @@
     DexApplication application = appView.appInfo().app();
 
     computeReachabilitySensitivity(application);
-    collectLambdaMergingCandidates(application);
     collectStaticizerCandidates(application);
     workaroundAbstractMethodOnNonAbstractClassVerificationBug(
         executorService, simpleOptimizationFeedback);
@@ -806,10 +780,6 @@
     synthesizeRetargetClass(builder, executorService);
     synthesizeEnumUnboxingUtilityMethods(executorService);
 
-    printPhase("Lambda merging finalization");
-    // TODO(b/127694949): Adapt to PostOptimization.
-    finalizeLambdaMerging(application, feedback, builder, executorService, initialGraphLensForIR);
-
     printPhase("Desugared library API Conversion finalization");
     generateDesugaredLibraryAPIWrappers(builder, executorService);
 
@@ -968,28 +938,6 @@
         method, code, OptimizationFeedbackIgnore.getInstance(), Timing.empty());
   }
 
-  private void collectLambdaMergingCandidates(DexApplication application) {
-    if (lambdaMerger != null) {
-      lambdaMerger.collectGroupCandidates(application);
-    }
-  }
-
-  private void finalizeLambdaMerging(
-      DexApplication application,
-      OptimizationFeedback feedback,
-      Builder<?> builder,
-      ExecutorService executorService,
-      GraphLens appliedGraphLens)
-      throws ExecutionException {
-    if (lambdaMerger != null) {
-      lambdaMerger.applyLambdaClassMapping(
-          application, this, feedback, builder, executorService, appliedGraphLens);
-    } else {
-      appView.setHorizontallyMergedLambdaClasses(HorizontallyMergedLambdaClasses.empty());
-    }
-    assert appView.horizontallyMergedLambdaClasses() != null;
-  }
-
   private void generateDesugaredLibraryAPIWrappers(
       DexApplication.Builder<?> builder, ExecutorService executorService)
       throws ExecutionException {
@@ -1239,13 +1187,6 @@
             || !appView.appInfo().withLiveness().isNeverReprocessMethod(method.method)
         : "Illegal reprocessing due to -neverreprocess rule: " + context.toSourceString();
 
-    if (lambdaMerger != null) {
-      timing.begin("Merge lambdas");
-      lambdaMerger.rewriteCode(code.context(), code, inliner, methodProcessor);
-      timing.end();
-      assert code.isConsistentSSA();
-    }
-
     if (typeChecker != null && !typeChecker.check(code)) {
       assert appView.enableWholeProgramOptimizations();
       assert options.testing.allowTypeErrors;
@@ -1335,8 +1276,7 @@
     if (appView.appInfo().hasLiveness()) {
       // Reflection optimization 1. getClass() / forName() -> const-class
       timing.begin("Rewrite to const class");
-      ReflectionOptimizer.rewriteGetClassOrForNameToConstClass(
-          appView.withLiveness(), code, mainDexClasses);
+      ReflectionOptimizer.rewriteGetClassOrForNameToConstClass(appView.withLiveness(), code);
       timing.end();
     }
 
@@ -1548,15 +1488,6 @@
 
     previous = printMethod(code, "IR after twr close resource rewriter (SSA)", previous);
 
-    if (lambdaMerger != null) {
-      timing.begin("Analyze lambda merging");
-      lambdaMerger.analyzeCode(code.context(), code);
-      timing.end();
-      assert code.isConsistentSSA();
-    }
-
-    previous = printMethod(code, "IR after lambda merger (SSA)", previous);
-
     // TODO(b/140766440): an ideal solution would be puttting CodeOptimization for this into
     //  the list for primary processing only.
     if (options.outline.enabled && outliner != null && methodProcessor.isPrimaryMethodProcessor()) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java
index ef9a31c..3be22fa 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java
@@ -1,40 +1,21 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// Copyright (c) 2021, 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.conversion;
 
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
 
 public abstract class MethodProcessor {
 
-  protected SortedProgramMethodSet wave;
-  protected SortedProgramMethodSet waveExtension = SortedProgramMethodSet.createConcurrent();
-
-  public abstract boolean shouldApplyCodeRewritings(ProgramMethod method);
-
   public boolean isPrimaryMethodProcessor() {
     return false;
   }
 
-  public CallSiteInformation getCallSiteInformation() {
-    return CallSiteInformation.empty();
-  }
+  public abstract boolean isProcessedConcurrently(ProgramMethod method);
 
-  public boolean isProcessedConcurrently(ProgramMethod method) {
-    return wave != null && wave.contains(method);
-  }
+  public abstract boolean shouldApplyCodeRewritings(ProgramMethod method);
 
-  public void scheduleMethodForProcessingAfterCurrentWave(ProgramMethod method) {
-    waveExtension.add(method);
-  }
+  public abstract void scheduleMethodForProcessingAfterCurrentWave(ProgramMethod method);
 
-  protected void prepareForWaveExtensionProcessing() {
-    if (waveExtension.isEmpty()) {
-      wave = SortedProgramMethodSet.empty();
-    } else {
-      wave = waveExtension;
-      waveExtension = SortedProgramMethodSet.createConcurrent();
-    }
-  }
+  public abstract CallSiteInformation getCallSiteInformation();
 }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessorWithWave.java b/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessorWithWave.java
new file mode 100644
index 0000000..c50e8e3
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessorWithWave.java
@@ -0,0 +1,37 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.conversion;
+
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
+
+public abstract class MethodProcessorWithWave extends MethodProcessor {
+
+  protected SortedProgramMethodSet wave;
+  protected SortedProgramMethodSet waveExtension = SortedProgramMethodSet.createConcurrent();
+
+  @Override
+  public CallSiteInformation getCallSiteInformation() {
+    return CallSiteInformation.empty();
+  }
+
+  @Override
+  public boolean isProcessedConcurrently(ProgramMethod method) {
+    return wave != null && wave.contains(method);
+  }
+
+  @Override
+  public void scheduleMethodForProcessingAfterCurrentWave(ProgramMethod method) {
+    waveExtension.add(method);
+  }
+
+  protected void prepareForWaveExtensionProcessing() {
+    if (waveExtension.isEmpty()) {
+      wave = SortedProgramMethodSet.empty();
+    } else {
+      wave = waveExtension;
+      waveExtension = SortedProgramMethodSet.createConcurrent();
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/OneTimeMethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/OneTimeMethodProcessor.java
index a8c2e57..be427aa 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/OneTimeMethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/OneTimeMethodProcessor.java
@@ -16,7 +16,7 @@
  * A {@link MethodProcessor} that doesn't persist; rather just processes the given methods one-time,
  * along with a default abstraction of concurrent processing.
  */
-public class OneTimeMethodProcessor extends MethodProcessor {
+public class OneTimeMethodProcessor extends MethodProcessorWithWave {
 
   private final MethodProcessingId.Factory methodProcessingIdFactory;
 
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java
index 649edfd..ba7fa7f 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java
@@ -33,7 +33,7 @@
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 
-public class PostMethodProcessor extends MethodProcessor {
+public class PostMethodProcessor extends MethodProcessorWithWave {
 
   private final AppView<AppInfoWithLiveness> appView;
   private final Collection<CodeOptimization> defaultCodeOptimizations;
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java
index cb288b0..065d00b 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java
@@ -29,7 +29,7 @@
  * A {@link MethodProcessor} that processes methods in the whole program in a bottom-up manner,
  * i.e., from leaves to roots.
  */
-class PrimaryMethodProcessor extends MethodProcessor {
+class PrimaryMethodProcessor extends MethodProcessorWithWave {
 
   interface WaveStartAction {
 
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java
index 860af39..f2f255a 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryAPIConverter.java
@@ -64,7 +64,7 @@
 public class DesugaredLibraryAPIConverter {
 
   static final String VIVIFIED_PREFIX = "$-vivified-$.";
-  private static final String DESCRIPTOR_VIVIFIED_PREFIX = "L$-vivified-$/";
+  public static final String DESCRIPTOR_VIVIFIED_PREFIX = "L$-vivified-$/";
 
   private final AppView<?> appView;
   private final DexItemFactory factory;
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java
index a6606ed..6dbd525 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryRetargeter.java
@@ -701,7 +701,7 @@
     return dispatchTypeFor(method, "dispatchHolder");
   }
 
-  private static String getRetargetPackageAndClassPrefixDescriptor(
+  public static String getRetargetPackageAndClassPrefixDescriptor(
       DesugaredLibraryConfiguration config) {
     return "L"
         + config.getSynthesizedLibraryClassesPackagePrefix()
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 1b17172b5..db127f2 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
@@ -14,6 +14,7 @@
 import static com.android.tools.r8.ir.code.Opcodes.INVOKE_STATIC;
 import static com.android.tools.r8.ir.code.Opcodes.INVOKE_SUPER;
 import static com.android.tools.r8.ir.code.Opcodes.INVOKE_VIRTUAL;
+import static com.android.tools.r8.ir.desugar.DesugaredLibraryRetargeter.getRetargetPackageAndClassPrefixDescriptor;
 import static com.android.tools.r8.ir.desugar.DesugaredLibraryWrapperSynthesizer.TYPE_WRAPPER_SUFFIX;
 import static com.android.tools.r8.ir.desugar.DesugaredLibraryWrapperSynthesizer.VIVIFIED_TYPE_WRAPPER_SUFFIX;
 
@@ -72,7 +73,6 @@
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.origin.SynthesizedOrigin;
 import com.android.tools.r8.position.MethodPosition;
-import com.android.tools.r8.shaking.MainDexClasses;
 import com.android.tools.r8.synthesis.SyntheticNaming;
 import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -97,6 +97,7 @@
 import java.util.concurrent.ExecutorService;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
+import java.util.function.Predicate;
 
 //
 // Default and static interface method desugaring rewriter (note that lambda
@@ -147,6 +148,7 @@
   // Caches default interface method info for already processed interfaces.
   private final Map<DexType, DefaultMethodsHelper.Collection> cache = new ConcurrentHashMap<>();
 
+  private final Predicate<DexType> shouldIgnoreFromReportsPredicate;
   /**
    * Defines a minor variation in desugaring.
    */
@@ -168,6 +170,7 @@
     this.options = appView.options();
     this.factory = appView.dexItemFactory();
     this.emulatedInterfaces = options.desugaredLibraryConfiguration.getEmulateLibraryInterface();
+    this.shouldIgnoreFromReportsPredicate = getShouldIgnoreFromReportsPredicate(appView);
     initializeEmulatedInterfaceVariables();
   }
 
@@ -712,7 +715,6 @@
     // Emulated library interfaces should generate the Emulated Library EL dispatch class.
     Map<DexType, List<DexType>> emulatedInterfacesHierarchy = processEmulatedInterfaceHierarchy();
     AppInfo appInfo = appView.appInfo();
-    MainDexClasses mainDexClasses = appInfo.getMainDexClasses();
     for (DexType interfaceType : emulatedInterfaces.keySet()) {
       DexClass theInterface = appInfo.definitionFor(interfaceType);
       if (theInterface == null) {
@@ -724,8 +726,7 @@
                 theProgramInterface, emulatedInterfacesHierarchy);
         if (synthesizedClass != null) {
           builder.addSynthesizedClass(synthesizedClass);
-          appInfo.addSynthesizedClass(
-              synthesizedClass, mainDexClasses.contains(theProgramInterface));
+          appInfo.addSynthesizedClass(synthesizedClass, theProgramInterface);
         }
       }
     }
@@ -954,11 +955,6 @@
     return type.descriptor.toString().endsWith(EMULATE_LIBRARY_CLASS_NAME_SUFFIX + ";");
   }
 
-  public static boolean isTypeWrapper(DexType type) {
-    String name = type.toBinaryName();
-    return name.endsWith(TYPE_WRAPPER_SUFFIX) || name.endsWith(VIVIFIED_TYPE_WRAPPER_SUFFIX);
-  }
-
   // Gets the interface class for a companion class `type`.
   private DexType getInterfaceClassType(DexType type) {
     return getInterfaceClassType(type, factory);
@@ -1160,7 +1156,6 @@
     // make original default methods abstract, remove bridge methods, create dispatch
     // classes if needed.
     AppInfo appInfo = appView.appInfo();
-    MainDexClasses mainDexClasses = appInfo.getMainDexClasses();
     InterfaceProcessorNestedGraphLens.Builder graphLensBuilder =
         InterfaceProcessorNestedGraphLens.builder();
     Map<DexClass, DexProgramClass> classMapping =
@@ -1175,10 +1170,7 @@
           // Don't need to optimize synthesized class since all of its methods
           // are just moved from interfaces and don't need to be re-processed.
           builder.addSynthesizedClass(synthesizedClass);
-          boolean addToMainDexClasses =
-              interfaceClass.isProgramClass()
-                  && mainDexClasses.contains(interfaceClass.asProgramClass());
-          appInfo.addSynthesizedClass(synthesizedClass, addToMainDexClasses);
+          appInfo.addSynthesizedClass(synthesizedClass, interfaceClass.asProgramClass());
         });
     new InterfaceMethodRewriterFixup(appView, graphLens).run();
     if (appView.options().isDesugaredLibraryCompilation()) {
@@ -1291,13 +1283,34 @@
     return true;
   }
 
+  private Predicate<DexType> getShouldIgnoreFromReportsPredicate(AppView<?> appView) {
+    DexItemFactory dexItemFactory = appView.dexItemFactory();
+    InternalOptions options = appView.options();
+    DexString retargetPackageAndClassPrefixDescriptor =
+        dexItemFactory.createString(
+            getRetargetPackageAndClassPrefixDescriptor(options.desugaredLibraryConfiguration));
+    DexString typeWrapperClassNameDescriptorSuffix =
+        dexItemFactory.createString(TYPE_WRAPPER_SUFFIX + ';');
+    DexString vivifiedTypeWrapperClassNameDescriptorSuffix =
+        dexItemFactory.createString(VIVIFIED_TYPE_WRAPPER_SUFFIX + ';');
+    DexString companionClassNameDescriptorSuffix =
+        dexItemFactory.createString(COMPANION_CLASS_NAME_SUFFIX + ";");
+
+    return type -> {
+      DexString descriptor = type.getDescriptor();
+      return appView.rewritePrefix.hasRewrittenType(type, appView)
+          || descriptor.endsWith(typeWrapperClassNameDescriptorSuffix)
+          || descriptor.endsWith(vivifiedTypeWrapperClassNameDescriptorSuffix)
+          || descriptor.endsWith(companionClassNameDescriptorSuffix)
+          || emulatedInterfaces.containsValue(type)
+          || options.desugaredLibraryConfiguration.getCustomConversions().containsValue(type)
+          || appView.getDontWarnConfiguration().matches(type)
+          || descriptor.startsWith(retargetPackageAndClassPrefixDescriptor);
+    };
+  }
+
   private boolean shouldIgnoreFromReports(DexType missing) {
-    return appView.rewritePrefix.hasRewrittenType(missing, appView)
-        || isTypeWrapper(missing)
-        || isCompanionClassType(missing)
-        || emulatedInterfaces.containsValue(missing)
-        || options.desugaredLibraryConfiguration.getCustomConversions().containsValue(missing)
-        || appView.getDontWarnConfiguration().matches(missing);
+    return shouldIgnoreFromReportsPredicate.test(missing);
   }
 
   void warnMissingInterface(DexClass classToDesugar, DexClass implementing, DexType missing) {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
index 165cb52..c8c6a54 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
@@ -60,8 +60,6 @@
  */
 public class LambdaRewriter {
 
-  // Public for testing.
-  public static final String LAMBDA_GROUP_CLASS_NAME_PREFIX = "-$$LambdaGroup$";
   static final String EXPECTED_LAMBDA_METHOD_PREFIX = "lambda$";
   public static final String LAMBDA_INSTANCE_FIELD_NAME = "INSTANCE";
 
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/nest/NestBasedAccessDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/nest/NestBasedAccessDesugaring.java
index cbaa05a..c516ce8 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/nest/NestBasedAccessDesugaring.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/nest/NestBasedAccessDesugaring.java
@@ -10,18 +10,14 @@
 import com.android.tools.r8.cf.code.CfFieldInstruction;
 import com.android.tools.r8.cf.code.CfInstruction;
 import com.android.tools.r8.cf.code.CfInvoke;
-import com.android.tools.r8.dex.Constants;
 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.ClassAccessFlags;
 import com.android.tools.r8.graph.Code;
-import com.android.tools.r8.graph.DexAnnotationSet;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexClassAndField;
 import com.android.tools.r8.graph.DexClassAndMember;
 import com.android.tools.r8.graph.DexClassAndMethod;
-import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMember;
@@ -30,21 +26,20 @@
 import com.android.tools.r8.graph.DexProto;
 import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexTypeList;
-import com.android.tools.r8.graph.GenericSignature.ClassSignature;
 import com.android.tools.r8.graph.LibraryMember;
 import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.origin.SynthesizedOrigin;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Sets;
-import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Consumer;
 import org.objectweb.asm.Opcodes;
 
@@ -63,14 +58,10 @@
   private static final String NEST_ACCESS_FIELD_PUT_NAME_PREFIX = NEST_ACCESS_NAME_PREFIX + "fput";
   private static final String NEST_ACCESS_STATIC_PUT_FIELD_NAME_PREFIX =
       NEST_ACCESS_NAME_PREFIX + "sfput";
-  public static final String NEST_CONSTRUCTOR_NAME = NEST_ACCESS_NAME_PREFIX + "Constructor";
 
   protected final AppView<?> appView;
   private final DexItemFactory dexItemFactory;
-
-  // Common single empty class for nest based private constructors
-  private DexProgramClass nestConstructor;
-  private boolean nestConstructorUsed;
+  private final Map<DexType, DexType> syntheticNestConstructorTypes = new ConcurrentHashMap<>();
 
   public NestBasedAccessDesugaring(AppView<?> appView) {
     this.appView = appView;
@@ -234,40 +225,6 @@
     throw appView.options().errorMissingNestMember(nest);
   }
 
-  private DexProgramClass createNestAccessConstructor() {
-    // TODO(b/176900254): ensure hygienic synthetic class.
-    return new DexProgramClass(
-        dexItemFactory.nestConstructorType,
-        null,
-        new SynthesizedOrigin("Nest based access desugaring", getClass()),
-        // Make the synthesized class public since shared in the whole program.
-        ClassAccessFlags.fromDexAccessFlags(
-            Constants.ACC_FINAL | Constants.ACC_SYNTHETIC | Constants.ACC_PUBLIC),
-        dexItemFactory.objectType,
-        DexTypeList.empty(),
-        dexItemFactory.createString("nest"),
-        null,
-        Collections.emptyList(),
-        null,
-        Collections.emptyList(),
-        ClassSignature.noSignature(),
-        DexAnnotationSet.empty(),
-        DexEncodedField.EMPTY_ARRAY,
-        DexEncodedField.EMPTY_ARRAY,
-        DexEncodedMethod.EMPTY_ARRAY,
-        DexEncodedMethod.EMPTY_ARRAY,
-        dexItemFactory.getSkipNameValidationForTesting(),
-        DexProgramClass::checksumFromType);
-  }
-
-  public DexProgramClass synthesizeNestConstructor() {
-    if (nestConstructorUsed && nestConstructor == null) {
-      nestConstructor = createNestAccessConstructor();
-      return nestConstructor;
-    }
-    return null;
-  }
-
   DexMethod ensureFieldAccessBridge(
       DexClassAndField field, boolean isGet, NestBridgeConsumer bridgeConsumer) {
     if (field.isProgramField()) {
@@ -360,9 +317,31 @@
 
   private DexMethod getMethodBridgeReference(DexClassAndMethod method) {
     if (method.getDefinition().isInstanceInitializer()) {
-      DexProto newProto =
-          dexItemFactory.appendTypeToProto(method.getProto(), dexItemFactory.nestConstructorType);
-      nestConstructorUsed = true;
+      DexType nestConstructorType =
+          syntheticNestConstructorTypes.computeIfAbsent(
+              method.getHolderType(),
+              holder -> {
+                if (method.isProgramMethod()) {
+                  return appView
+                      .getSyntheticItems()
+                      .createFixedClass(
+                          SyntheticKind.INIT_TYPE_ARGUMENT,
+                          method.asProgramMethod().getHolder(),
+                          dexItemFactory,
+                          builder -> {})
+                      .getType();
+                } else {
+                  assert method.isClasspathMethod();
+                  return appView
+                      .getSyntheticItems()
+                      .createFixedClasspathClass(
+                          SyntheticKind.INIT_TYPE_ARGUMENT,
+                          method.asClasspathMethod().getHolder(),
+                          dexItemFactory)
+                      .getType();
+                }
+              });
+      DexProto newProto = dexItemFactory.appendTypeToProto(method.getProto(), nestConstructorType);
       return method.getReference().withProto(newProto, dexItemFactory);
     }
     DexProto proto =
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
index 79f36ad..969b5d5 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
@@ -38,7 +38,6 @@
 import com.android.tools.r8.ir.optimize.inliner.WhyAreYouNotInliningReporter;
 import com.android.tools.r8.logging.Log;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.shaking.MainDexDirectReferenceTracer;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.Timing;
@@ -199,25 +198,17 @@
     // Don't inline code with references beyond root main dex classes into a root main dex class.
     // If we do this it can increase the size of the main dex dependent classes.
     if (reason != Reason.FORCE
-        && inlineeRefersToClassesNotInMainDex(method.getHolderType(), singleTarget)) {
+        && inliner.mainDexInfo.disallowInliningIntoContext(
+            appView.appInfo(), method, singleTarget)) {
       whyAreYouNotInliningReporter.reportInlineeRefersToClassesNotInMainDex();
       return false;
     }
     assert reason != Reason.FORCE
-            || !inlineeRefersToClassesNotInMainDex(method.getHolderType(), singleTarget)
-        : MainDexDirectReferenceTracer.getFirstReferenceOutsideFromCode(
-            appView.appInfo(), singleTarget, inliner.mainDexClasses.getRoots());
+        || !inliner.mainDexInfo.disallowInliningIntoContext(
+            appView.appInfo(), method, singleTarget);
     return true;
   }
 
-  private boolean inlineeRefersToClassesNotInMainDex(DexType holder, ProgramMethod target) {
-    if (inliner.mainDexClasses.isEmpty() || !inliner.mainDexClasses.getRoots().contains(holder)) {
-      return false;
-    }
-    return MainDexDirectReferenceTracer.hasReferencesOutsideFromCode(
-        appView.appInfo(), target, inliner.mainDexClasses.getRoots());
-  }
-
   private boolean satisfiesRequirementsForSimpleInlining(
       InvokeMethod invoke, ProgramMethod target) {
     // If we are looking for a simple method, only inline if actually simple.
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java b/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java
index 7179327..f5f4d70 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java
@@ -25,7 +25,6 @@
 import com.android.tools.r8.ir.code.InvokeVirtual;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.shaking.MainDexTracingResult;
 import com.android.tools.r8.utils.InternalOptions;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
@@ -48,13 +47,10 @@
 public class Devirtualizer {
 
   private final AppView<AppInfoWithLiveness> appView;
-  private final MainDexTracingResult mainDexTracingResult;
   private final InternalOptions options;
 
-  public Devirtualizer(
-      AppView<AppInfoWithLiveness> appView, MainDexTracingResult mainDexTracingResult) {
+  public Devirtualizer(AppView<AppInfoWithLiveness> appView) {
     this.appView = appView;
-    this.mainDexTracingResult = mainDexTracingResult;
     this.options = appView.options();
   }
 
@@ -154,7 +150,7 @@
           DexClassAndMethod reboundTarget = rebindSuperInvokeToMostSpecific(invokedMethod, context);
           if (reboundTarget != null
               && reboundTarget.getReference() != invokedMethod
-              && !isRebindingNewClassIntoMainDex(invokedMethod, reboundTarget.getReference())) {
+              && !isRebindingNewClassIntoMainDex(context, reboundTarget.getReference())) {
             it.replaceCurrentInstruction(
                 new InvokeSuper(
                     reboundTarget.getReference(),
@@ -197,7 +193,7 @@
         }
 
         // Ensure that we are not adding a new main dex root
-        if (isRebindingNewClassIntoMainDex(invoke.getInvokedMethod(), target.getReference())) {
+        if (isRebindingNewClassIntoMainDex(context, target.getReference())) {
           continue;
         }
 
@@ -394,13 +390,7 @@
     return newResolutionResult.getResolvedMethod().method;
   }
 
-  private boolean isRebindingNewClassIntoMainDex(
-      DexMethod originalMethod, DexMethod reboundMethod) {
-    if (!mainDexTracingResult.isRoot(originalMethod.holder)
-        && !appView.appInfo().getMainDexClasses().contains(originalMethod.holder)) {
-      return false;
-    }
-    return !mainDexTracingResult.isRoot(reboundMethod.holder)
-        && !appView.appInfo().getMainDexClasses().contains(reboundMethod.holder);
+  private boolean isRebindingNewClassIntoMainDex(ProgramMethod context, DexMethod reboundMethod) {
+    return !appView.appInfo().getMainDexInfo().canRebindReference(context, reboundMethod);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
index 7eca624..e034587 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
@@ -57,10 +57,9 @@
 import com.android.tools.r8.ir.optimize.inliner.InliningReasonStrategy;
 import com.android.tools.r8.ir.optimize.inliner.NopWhyAreYouNotInliningReporter;
 import com.android.tools.r8.ir.optimize.inliner.WhyAreYouNotInliningReporter;
-import com.android.tools.r8.ir.optimize.lambda.LambdaMerger;
 import com.android.tools.r8.kotlin.Kotlin;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.shaking.MainDexTracingResult;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.IteratorUtils;
 import com.android.tools.r8.utils.ListUtils;
@@ -84,9 +83,8 @@
 
   protected final AppView<AppInfoWithLiveness> appView;
   private final Set<DexMethod> extraNeverInlineMethods;
-  private final LambdaMerger lambdaMerger;
   private final LensCodeRewriter lensCodeRewriter;
-  final MainDexTracingResult mainDexClasses;
+  final MainDexInfo mainDexInfo;
 
   // State for inlining methods which are known to be called twice.
   private boolean applyDoubleInlining = false;
@@ -99,8 +97,6 @@
 
   public Inliner(
       AppView<AppInfoWithLiveness> appView,
-      MainDexTracingResult mainDexClasses,
-      LambdaMerger lambdaMerger,
       LensCodeRewriter lensCodeRewriter) {
     Kotlin.Intrinsics intrinsics = appView.dexItemFactory().kotlin.intrinsics;
     this.appView = appView;
@@ -108,9 +104,8 @@
         appView.options().kotlinOptimizationOptions().disableKotlinSpecificOptimizations
             ? ImmutableSet.of()
             : ImmutableSet.of(intrinsics.throwNpe, intrinsics.throwParameterIsNullException);
-    this.lambdaMerger = lambdaMerger;
     this.lensCodeRewriter = lensCodeRewriter;
-    this.mainDexClasses = mainDexClasses;
+    this.mainDexInfo = appView.appInfo().getMainDexInfo();
     availableApiExceptions =
         appView.options().canHaveDalvikCatchHandlerVerificationBug()
             ? new AvailableApiExceptions(appView.options())
@@ -596,7 +591,6 @@
         InvokeMethod invoke,
         ProgramMethod context,
         InliningIRProvider inliningIRProvider,
-        LambdaMerger lambdaMerger,
         LensCodeRewriter lensCodeRewriter) {
       DexItemFactory dexItemFactory = appView.dexItemFactory();
       InternalOptions options = appView.options();
@@ -743,9 +737,6 @@
         assert lensCodeRewriter != null;
         lensCodeRewriter.rewrite(code, target);
       }
-      if (lambdaMerger != null) {
-        lambdaMerger.rewriteCodeForInlining(target, code, context, inliningIRProvider);
-      }
       if (options.testing.inlineeIrModifier != null) {
         options.testing.inlineeIrModifier.accept(code);
       }
@@ -1040,7 +1031,7 @@
 
           InlineeWithReason inlinee =
               action.buildInliningIR(
-                  appView, invoke, context, inliningIRProvider, lambdaMerger, lensCodeRewriter);
+                  appView, invoke, context, inliningIRProvider, lensCodeRewriter);
           if (strategy.willExceedBudget(
               code, invoke, inlinee, block, whyAreYouNotInliningReporter)) {
             assert whyAreYouNotInliningReporter.unsetReasonHasBeenReportedFlag();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ReflectionOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/ReflectionOptimizer.java
index cc5e7ed..afdf56a 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ReflectionOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ReflectionOptimizer.java
@@ -26,7 +26,6 @@
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.shaking.MainDexTracingResult;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.google.common.collect.Sets;
 import java.util.Set;
@@ -37,7 +36,7 @@
   // Rewrite getClass() to const-class if the type of the given instance is effectively final.
   // Rewrite forName() to const-class if the type is resolvable, accessible and already initialized.
   public static void rewriteGetClassOrForNameToConstClass(
-      AppView<AppInfoWithLiveness> appView, IRCode code, MainDexTracingResult mainDexClasses) {
+      AppView<AppInfoWithLiveness> appView, IRCode code) {
     if (!appView.appInfo().canUseConstClassInstructions(appView.options())) {
       return;
     }
@@ -62,14 +61,14 @@
               context,
               invoke.asInvokeStatic(),
               rewriteSingleGetClassOrForNameToConstClass(
-                  appView, code, it, invoke, affectedValues, mainDexClasses));
+                  appView, code, it, invoke, affectedValues));
         } else {
           applyTypeForGetClassTo(
               appView,
               context,
               invoke.asInvokeVirtual(),
               rewriteSingleGetClassOrForNameToConstClass(
-                  appView, code, it, invoke, affectedValues, mainDexClasses));
+                  appView, code, it, invoke, affectedValues));
         }
       }
     }
@@ -85,14 +84,15 @@
       IRCode code,
       InstructionListIterator instructionIterator,
       InvokeMethod invoke,
-      Set<Value> affectedValues,
-      MainDexTracingResult mainDexClasses) {
+      Set<Value> affectedValues) {
     return (type, baseClass) -> {
       if (invoke.getInvokedMethod().match(appView.dexItemFactory().classMethods.forName)) {
         // Bail-out if the optimization could increase the size of the main dex.
         if (baseClass.isProgramClass()
-            && !mainDexClasses.canReferenceItemFromContextWithoutIncreasingMainDexSize(
-                baseClass.asProgramClass(), code.context())) {
+            && !appView
+                .appInfo()
+                .getMainDexInfo()
+                .canRebindReference(code.context(), baseClass.getType())) {
           return;
         }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
index 19a9da1..371b79a 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
@@ -919,6 +919,12 @@
       return false;
     }
 
+    // We cannot guarantee the invoke returns the receiver or another instance and since the
+    // return value is used we have to bail out.
+    if (eligibility.returnsReceiver.isUnknown()) {
+      return false;
+    }
+
     // Add the out-value as a definite-alias if the invoke instruction is guaranteed to return the
     // receiver. Otherwise, the out-value may be an alias of the receiver, and it is added to the
     // may-alias set.
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingTreeFixer.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingTreeFixer.java
index bcd8458..17d0cc7 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingTreeFixer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingTreeFixer.java
@@ -16,6 +16,8 @@
 import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.DexValue;
+import com.android.tools.r8.ir.analysis.inlining.SimpleInliningConstraint;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.OptionalBool;
 import com.google.common.collect.Sets;
@@ -31,14 +33,14 @@
 
   private final Map<DexType, List<DexEncodedMethod>> unboxedEnumsMethods = new IdentityHashMap<>();
   private final EnumUnboxingLens.Builder lensBuilder = EnumUnboxingLens.enumUnboxingLensBuilder();
-  private final AppView<?> appView;
+  private final AppView<AppInfoWithLiveness> appView;
   private final DexItemFactory factory;
   private final Set<DexType> enumsToUnbox;
   private final UnboxedEnumMemberRelocator relocator;
   private final EnumUnboxingRewriter enumUnboxerRewriter;
 
   EnumUnboxingTreeFixer(
-      AppView<?> appView,
+      AppView<AppInfoWithLiveness> appView,
       Set<DexType> enumsToUnbox,
       UnboxedEnumMemberRelocator relocator,
       EnumUnboxingRewriter enumUnboxerRewriter) {
@@ -72,7 +74,9 @@
                 });
         clazz.getMethodCollection().removeMethods(methodsToRemove);
       } else {
-        clazz.getMethodCollection().replaceMethods(this::fixupEncodedMethod);
+        clazz
+            .getMethodCollection()
+            .replaceMethods(method -> this.fixupEncodedMethod(clazz, method));
         fixupFields(clazz.staticFields(), clazz::setStaticField);
         fixupFields(clazz.instanceFields(), clazz::setInstanceField);
       }
@@ -119,7 +123,7 @@
         newMethod, builder -> builder.setCompilationState(encodedMethod.getCompilationState()));
   }
 
-  private DexEncodedMethod fixupEncodedMethod(DexEncodedMethod method) {
+  private DexEncodedMethod fixupEncodedMethod(DexProgramClass holder, DexEncodedMethod method) {
     DexProto oldProto = method.getProto();
     DexProto newProto = fixupProto(oldProto);
     if (newProto == method.getProto()) {
@@ -143,21 +147,24 @@
                 .setCompilationState(method.getCompilationState())
                 .setIsLibraryMethodOverrideIf(
                     method.isNonPrivateVirtualMethod(), OptionalBool.FALSE)
-                .fixupOptimizationInfo(
-                    optimizationInfo -> {
-                      IntList unboxedArgumentIndices = new IntArrayList();
-                      int offset = BooleanUtils.intValue(method.isInstance());
-                      for (int i = 0; i < method.getReference().getArity(); i++) {
-                        if (oldProto.getParameter(i).isReferenceType()
-                            && newProto.getParameter(i).isPrimitiveType()) {
-                          unboxedArgumentIndices.add(i + offset);
-                        }
-                      }
-                      optimizationInfo.setSimpleInliningConstraint(
-                          optimizationInfo
-                              .getSimpleInliningConstraint()
-                              .rewrittenWithUnboxedArguments(unboxedArgumentIndices));
-                    }));
+                .setSimpleInliningConstraint(
+                    holder, getRewrittenSimpleInliningConstraint(method, oldProto, newProto)));
+  }
+
+  private SimpleInliningConstraint getRewrittenSimpleInliningConstraint(
+      DexEncodedMethod method, DexProto oldProto, DexProto newProto) {
+    IntList unboxedArgumentIndices = new IntArrayList();
+    int offset = BooleanUtils.intValue(method.isInstance());
+    for (int i = 0; i < method.getReference().getArity(); i++) {
+      if (oldProto.getParameter(i).isReferenceType()
+          && newProto.getParameter(i).isPrimitiveType()) {
+        unboxedArgumentIndices.add(i + offset);
+      }
+    }
+    return method
+        .getOptimizationInfo()
+        .getSimpleInliningConstraint()
+        .rewrittenWithUnboxedArguments(unboxedArgumentIndices);
   }
 
   private DexMethod ensureUniqueMethod(DexEncodedMethod encodedMethod, DexMethod newMethod) {
@@ -197,11 +204,8 @@
             encodedField.toTypeSubstitutedField(
                 newField,
                 builder ->
-                    builder.fixupOptimizationInfo(
-                        mutableFieldOptimizationInfo -> {
-                          mutableFieldOptimizationInfo.setAbstractValue(
-                              encodedField.getOptimizationInfo().getAbstractValue());
-                        }));
+                    builder.setAbstractValue(
+                        encodedField.getOptimizationInfo().getAbstractValue(), appView));
         setter.setField(i, newEncodedField);
         if (encodedField.isStatic() && encodedField.hasExplicitStaticValue()) {
           assert encodedField.getStaticValue() == DexValue.DexValueNull.NULL;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/UnboxedEnumMemberRelocator.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/UnboxedEnumMemberRelocator.java
index 5a8ae19..48e545c 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/UnboxedEnumMemberRelocator.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/UnboxedEnumMemberRelocator.java
@@ -5,6 +5,7 @@
 package com.android.tools.r8.ir.optimize.enums;
 
 import static com.android.tools.r8.ir.optimize.enums.EnumUnboxingRewriter.createValuesField;
+import static com.google.common.base.Predicates.alwaysTrue;
 
 import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.graph.AppView;
@@ -23,6 +24,7 @@
 import com.android.tools.r8.graph.ProgramPackageCollection;
 import com.android.tools.r8.origin.SynthesizedOrigin;
 import com.android.tools.r8.shaking.FieldAccessInfoCollectionModifier;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.utils.SetUtils;
 import com.google.common.collect.ImmutableMap;
 import java.util.ArrayList;
@@ -32,6 +34,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.Predicate;
 
 public class UnboxedEnumMemberRelocator {
 
@@ -129,9 +132,8 @@
         Set<DexProgramClass> relocatedEnums,
         DirectMappedDexApplication.Builder appBuilder,
         FieldAccessInfoCollectionModifier.Builder fieldAccessInfoCollectionModifierBuilder) {
-      DexType deterministicContextType = findDeterministicContextType(contexts);
-      assert deterministicContextType.isClassType();
-      String descriptorString = deterministicContextType.toDescriptorString();
+      DexProgramClass deterministicContext = findDeterministicContextType(contexts, alwaysTrue());
+      String descriptorString = deterministicContext.getType().toDescriptorString();
       String descriptorPrefix = descriptorString.substring(0, descriptorString.length() - 1);
       String syntheticClassDescriptor = descriptorPrefix + ENUM_UNBOXING_UTILITY_CLASS_SUFFIX + ";";
       DexType type = appView.dexItemFactory().createType(syntheticClassDescriptor);
@@ -180,20 +182,25 @@
               appView.dexItemFactory().getSkipNameValidationForTesting(),
               DexProgramClass::checksumFromType);
       appBuilder.addSynthesizedClass(syntheticClass);
+      MainDexInfo mainDexInfo = appView.appInfo().getMainDexInfo();
       appView
           .appInfo()
           .addSynthesizedClass(
-              syntheticClass, appView.appInfo().getMainDexClasses().containsAnyOf(contexts));
+              syntheticClass, findDeterministicContextType(contexts, mainDexInfo::isMainDex));
       return syntheticClass;
     }
 
-    private DexType findDeterministicContextType(Set<DexProgramClass> contexts) {
-      DexType deterministicContext = null;
+    private DexProgramClass findDeterministicContextType(
+        Set<DexProgramClass> contexts, Predicate<DexProgramClass> predicate) {
+      DexProgramClass deterministicContext = null;
       for (DexProgramClass context : contexts) {
+        if (!predicate.test(context)) {
+          continue;
+        }
         if (deterministicContext == null) {
-          deterministicContext = context.type;
-        } else if (context.type.compareTo(deterministicContext) < 0) {
-          deterministicContext = context.type;
+          deterministicContext = context;
+        } else if (context.type.compareTo(deterministicContext.type) < 0) {
+          deterministicContext = context;
         }
       }
       return deterministicContext;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java
index 3bf8d88..41ee658 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MutableFieldOptimizationInfo.java
@@ -65,7 +65,7 @@
     return abstractValue;
   }
 
-  public void setAbstractValue(AbstractValue abstractValue) {
+  void setAbstractValue(AbstractValue abstractValue) {
     this.abstractValue = abstractValue;
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
index e62b2c1..945d84a 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
@@ -66,7 +66,9 @@
   @Override
   public void recordFieldHasAbstractValue(
       DexEncodedField field, AppView<AppInfoWithLiveness> appView, AbstractValue abstractValue) {
-    // Ignored.
+    if (appView.appInfo().mayPropagateValueFor(field.field)) {
+      field.getMutableOptimizationInfo().setAbstractValue(abstractValue);
+    }
   }
 
   // METHOD OPTIMIZATION INFO.
@@ -198,7 +200,7 @@
   @Override
   public void setSimpleInliningConstraint(
       ProgramMethod method, SimpleInliningConstraint constraint) {
-    // Ignored.
+    method.getDefinition().getMutableOptimizationInfo().setSimpleInliningConstraint(constraint);
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java
index 03e83b8..a179561 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java
@@ -383,7 +383,7 @@
     setFlag(REACHABILITY_SENSITIVE_FLAG, reachabilitySensitive);
   }
 
-  public void setSimpleInliningConstraint(SimpleInliningConstraint constraint) {
+  void setSimpleInliningConstraint(SimpleInliningConstraint constraint) {
     this.simpleInliningConstraint = constraint;
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/CaptureSignature.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/CaptureSignature.java
deleted file mode 100644
index 5a39e71..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/CaptureSignature.java
+++ /dev/null
@@ -1,160 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda;
-
-import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.graph.DexEncodedField;
-import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexTypeList;
-import it.unimi.dsi.fastutil.ints.IntArrayList;
-import it.unimi.dsi.fastutil.ints.IntList;
-import it.unimi.dsi.fastutil.ints.IntLists;
-import java.util.Arrays;
-import java.util.BitSet;
-import java.util.Comparator;
-import java.util.List;
-import java.util.function.IntFunction;
-
-// While mapping fields representing lambda captures we rearrange fields to make sure
-// lambdas having different order of the fields still can be merged. We also store
-// all captures of reference types in fields of java.lang.Objects class.
-//
-// This allows us to use same lambda groups class for these two different lambdas:
-//
-//      Lambda Group Class         Lambda$1               Lambda$2
-//          Object $c0        int      foo -> $c1     char foo -> $c2
-//          int    $c1        String[] bar -> $c0     int  bar -> $c1
-//          char   $c2        char     baz -> $c2     List baz -> $c0
-//
-// Capture signature is represented by a string with sorted shorties of field
-// types, such as "CIL" for both Lambda$1 and Lambda$2 in the above example.
-//
-public final class CaptureSignature {
-  private static final IntList EMPTY_LIST = IntLists.EMPTY_LIST;
-  private static final IntList SINGLE_LIST = IntLists.singleton(0);
-
-  private CaptureSignature() {
-  }
-
-  // Returns an array representing mapping of fields of the normalized capture
-  // into fields of original capture such that:
-  //
-  //   mapping = getReverseCaptureMapping(...)
-  //   <original-capture-index> = mapping[<normalized-capture-index>]
-  public static IntList getReverseCaptureMapping(DexType[] types) {
-    if (types.length == 0) {
-      return EMPTY_LIST;
-    }
-
-    if (types.length == 1) {
-      return SINGLE_LIST;
-    }
-
-    IntList result = new IntArrayList(types.length);
-    for (int i = 0; i < types.length; i++) {
-      result.add(i);
-    }
-    // Sort the indices by shorties (sorting is stable).
-    result.sort(Comparator.comparingInt(i -> types[i].toShorty()));
-    assert verifyMapping(result);
-    return result;
-  }
-
-  // Given a capture signature and an index returns the type of the field.
-  public static DexType fieldType(DexItemFactory factory, String capture, int index) {
-    switch (capture.charAt(index)) {
-      case 'L':
-        return factory.objectType;
-      case 'Z':
-        return factory.booleanType;
-      case 'B':
-        return factory.byteType;
-      case 'S':
-        return factory.shortType;
-      case 'C':
-        return factory.charType;
-      case 'I':
-        return factory.intType;
-      case 'F':
-        return factory.floatType;
-      case 'J':
-        return factory.longType;
-      case 'D':
-        return factory.doubleType;
-      default:
-        throw new Unreachable("Invalid capture character: " + capture.charAt(index));
-    }
-  }
-
-  private static String getCaptureSignature(int size, IntFunction<DexType> type) {
-    if (size == 0) {
-      return "";
-    }
-    if (size == 1) {
-      return Character.toString(type.apply(0).toShorty());
-    }
-
-    char[] chars = new char[size];
-    for (int i = 0; i < size; i++) {
-      chars[i] = type.apply(i).toShorty();
-    }
-    Arrays.sort(chars);
-    return new String(chars);
-  }
-
-  // Compute capture signature based on lambda class capture fields.
-  public static String getCaptureSignature(List<DexEncodedField> fields) {
-    return getCaptureSignature(fields.size(), i -> fields.get(i).field.type);
-  }
-
-  // Compute capture signature based on type list.
-  public static String getCaptureSignature(DexTypeList types) {
-    return getCaptureSignature(types.values.length, i -> types.values[i]);
-  }
-
-  // Having a list of fields of lambda captured values, maps one of them into
-  // an index of the appropriate field in normalized capture signature.
-  public static int mapFieldIntoCaptureIndex(
-      String capture, List<DexEncodedField> lambdaFields, DexField fieldToMap) {
-    char fieldKind = fieldToMap.type.toShorty();
-    int numberOfSameCaptureKind = 0;
-    int result = -1;
-
-    for (DexEncodedField encodedField : lambdaFields) {
-      if (encodedField.field == fieldToMap) {
-        result = numberOfSameCaptureKind;
-        break;
-      }
-      if (encodedField.field.type.toShorty() == fieldKind) {
-        numberOfSameCaptureKind++;
-      }
-    }
-
-    assert result >= 0 : "Field was not found in the lambda class.";
-
-    for (int index = 0; index < capture.length(); index++) {
-      if (capture.charAt(index) == fieldKind) {
-        if (result == 0) {
-          return index;
-        }
-        result--;
-      }
-    }
-
-    throw new Unreachable("Were not able to map lambda field into capture index");
-  }
-
-  private static boolean verifyMapping(IntList mapping) {
-    BitSet bits = new BitSet();
-    for (Integer i : mapping) {
-      assert i >= 0 && i < mapping.size();
-      assert !bits.get(i);
-      bits.set(i);
-    }
-    return true;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/CodeProcessor.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/CodeProcessor.java
deleted file mode 100644
index 1da512d..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/CodeProcessor.java
+++ /dev/null
@@ -1,430 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda;
-
-import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.ir.code.Argument;
-import com.android.tools.r8.ir.code.BasicBlock;
-import com.android.tools.r8.ir.code.CheckCast;
-import com.android.tools.r8.ir.code.ConstClass;
-import com.android.tools.r8.ir.code.ConstMethodHandle;
-import com.android.tools.r8.ir.code.ConstMethodType;
-import com.android.tools.r8.ir.code.DefaultInstructionVisitor;
-import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.code.InitClass;
-import com.android.tools.r8.ir.code.InstanceGet;
-import com.android.tools.r8.ir.code.InstancePut;
-import com.android.tools.r8.ir.code.InstructionListIterator;
-import com.android.tools.r8.ir.code.Invoke;
-import com.android.tools.r8.ir.code.InvokeMethod;
-import com.android.tools.r8.ir.code.NewArrayEmpty;
-import com.android.tools.r8.ir.code.NewInstance;
-import com.android.tools.r8.ir.code.StaticGet;
-import com.android.tools.r8.ir.code.StaticPut;
-import com.android.tools.r8.ir.optimize.lambda.LambdaMerger.ApplyStrategy;
-import com.android.tools.r8.kotlin.Kotlin;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import java.util.ListIterator;
-import java.util.function.Function;
-
-// Performs processing of the method code (all methods) needed by lambda rewriter.
-//
-// Functionality can be modified by strategy (specific to lambda group) and lambda
-// type visitor.
-//
-// In general it is used to
-//   (a) track the code for illegal lambda type usages inside the code, and
-//   (b) patching valid lambda type references to point to lambda group classes instead.
-//
-// This class is also used inside particular strategies as a context of the instruction
-// being checked or patched, it provides access to code, block and instruction iterators.
-public abstract class CodeProcessor extends DefaultInstructionVisitor<Void> {
-  // Strategy (specific to lambda group) for detecting valid references to the
-  // lambda classes (of this group) and patching them with group class references.
-  public interface Strategy {
-    LambdaGroup group();
-
-    boolean isValidStaticFieldWrite(CodeProcessor context, DexField field);
-
-    boolean isValidStaticFieldRead(CodeProcessor context, DexField field);
-
-    boolean isValidInstanceFieldWrite(CodeProcessor context, DexField field);
-
-    boolean isValidInstanceFieldRead(CodeProcessor context, DexField field);
-
-    boolean isValidInvoke(CodeProcessor context, InvokeMethod invoke);
-
-    boolean isValidNewInstance(CodeProcessor context, NewInstance invoke);
-
-    boolean isValidInitClass(CodeProcessor context, DexType clazz);
-
-    boolean isValidHolder(CodeProcessor context, DexType holder);
-
-    void patch(ApplyStrategy context, NewInstance newInstance);
-
-    void patch(ApplyStrategy context, InvokeMethod invoke);
-
-    void patch(ApplyStrategy context, InstanceGet instanceGet);
-
-    void patch(ApplyStrategy context, StaticGet staticGet);
-
-    void patch(ApplyStrategy context, InitClass initClass);
-
-    void patch(ApplyStrategy context, Argument argument);
-  }
-
-  // No-op strategy.
-  static final Strategy NoOp =
-      new Strategy() {
-        @Override
-        public LambdaGroup group() {
-          return null;
-        }
-
-        @Override
-        public boolean isValidInstanceFieldWrite(CodeProcessor context, DexField field) {
-          return false;
-        }
-
-        @Override
-        public boolean isValidInstanceFieldRead(CodeProcessor context, DexField field) {
-          return false;
-        }
-
-        @Override
-        public boolean isValidStaticFieldWrite(CodeProcessor context, DexField field) {
-          return false;
-        }
-
-        @Override
-        public boolean isValidStaticFieldRead(CodeProcessor context, DexField field) {
-          return false;
-        }
-
-        @Override
-        public boolean isValidInvoke(CodeProcessor context, InvokeMethod invoke) {
-          return false;
-        }
-
-        @Override
-        public boolean isValidNewInstance(CodeProcessor context, NewInstance invoke) {
-          return false;
-        }
-
-        @Override
-        public boolean isValidInitClass(CodeProcessor context, DexType clazz) {
-          return false;
-        }
-
-        @Override
-        public boolean isValidHolder(CodeProcessor context, DexType holder) {
-          return false;
-        }
-
-        @Override
-        public void patch(ApplyStrategy context, NewInstance newInstance) {
-          throw new Unreachable();
-        }
-
-        @Override
-        public void patch(ApplyStrategy context, InvokeMethod invoke) {
-          throw new Unreachable();
-        }
-
-        @Override
-        public void patch(ApplyStrategy context, InstanceGet instanceGet) {
-          throw new Unreachable();
-        }
-
-        @Override
-        public void patch(ApplyStrategy context, StaticGet staticGet) {
-          throw new Unreachable();
-        }
-
-        @Override
-        public void patch(ApplyStrategy context, InitClass initClass) {
-          throw new Unreachable();
-        }
-
-        @Override
-        public void patch(ApplyStrategy context, Argument argument) {
-          throw new Unreachable();
-        }
-      };
-
-  public final AppView<AppInfoWithLiveness> appView;
-  public final DexItemFactory factory;
-  public final Kotlin kotlin;
-
-  // Defines a factory providing a strategy for a lambda type, returns
-  // NoOp strategy if the type is not a lambda.
-  private final Function<DexType, Strategy> strategyProvider;
-
-  // Visitor for lambda type references seen in unexpected places. Either
-  // invalidates the lambda or asserts depending on the processing phase.
-  private final LambdaTypeVisitor lambdaChecker;
-
-  // Specify the context of the current instruction: method/code/blocks/instructions.
-  public final ProgramMethod method;
-  public final IRCode code;
-  public final ListIterator<BasicBlock> blocks;
-  private InstructionListIterator instructions;
-
-  // The inlining context (caller), if any.
-  private final ProgramMethod context;
-
-  CodeProcessor(
-      AppView<AppInfoWithLiveness> appView,
-      Function<DexType, Strategy> strategyProvider,
-      LambdaTypeVisitor lambdaChecker,
-      ProgramMethod method,
-      IRCode code) {
-    this(appView, strategyProvider, lambdaChecker, method, code, null);
-  }
-
-  CodeProcessor(
-      AppView<AppInfoWithLiveness> appView,
-      Function<DexType, Strategy> strategyProvider,
-      LambdaTypeVisitor lambdaChecker,
-      ProgramMethod method,
-      IRCode code,
-      ProgramMethod context) {
-    this.appView = appView;
-    this.strategyProvider = strategyProvider;
-    this.factory = appView.dexItemFactory();
-    this.kotlin = factory.kotlin;
-    this.lambdaChecker = lambdaChecker;
-    this.method = method;
-    this.code = code;
-    this.blocks = code.listIterator();
-    this.context = context;
-  }
-
-  public final InstructionListIterator instructions() {
-    assert instructions != null;
-    return instructions;
-  }
-
-  void processCode() {
-    while (blocks.hasNext()) {
-      BasicBlock block = blocks.next();
-      instructions = block.listIterator(code);
-      while (instructions.hasNext()) {
-        instructions.next().accept(this);
-      }
-    }
-  }
-
-  private boolean shouldRewrite(DexField field) {
-    return shouldRewrite(field.holder);
-  }
-
-  private boolean shouldRewrite(DexMethod method) {
-    return shouldRewrite(method.holder);
-  }
-
-  private boolean shouldRewrite(DexType type) {
-    // Rewrite references to lambda classes if we are outside the class.
-    return type != (context != null ? context : method).getHolderType();
-  }
-
-  @Override
-  public Void handleInvoke(Invoke invoke) {
-    if (invoke.isInvokeNewArray()) {
-      lambdaChecker.accept(invoke.asInvokeNewArray().getReturnType());
-      return null;
-    }
-    if (invoke.isInvokeMultiNewArray()) {
-      lambdaChecker.accept(invoke.asInvokeMultiNewArray().getReturnType());
-      return null;
-    }
-    if (invoke.isInvokeCustom()) {
-      lambdaChecker.accept(invoke.asInvokeCustom().getCallSite());
-      return null;
-    }
-
-    InvokeMethod invokeMethod = invoke.asInvokeMethod();
-    Strategy strategy = strategyProvider.apply(invokeMethod.getInvokedMethod().holder);
-    if (strategy.isValidInvoke(this, invokeMethod)) {
-      // Invalidate signature, there still should not be lambda references.
-      lambdaChecker.accept(invokeMethod.getInvokedMethod().proto);
-      // Only rewrite references to lambda classes if we are outside the class.
-      if (shouldRewrite(invokeMethod.getInvokedMethod())) {
-        process(strategy, invokeMethod);
-      }
-      return null;
-    }
-
-    // For the rest invalidate any references.
-    if (invoke.isInvokePolymorphic()) {
-      lambdaChecker.accept(invoke.asInvokePolymorphic().getProto());
-    }
-    lambdaChecker.accept(invokeMethod.getInvokedMethod(), null);
-    return null;
-  }
-
-  @Override
-  public Void visit(NewInstance newInstance) {
-    Strategy strategy = strategyProvider.apply(newInstance.clazz);
-    if (strategy.isValidNewInstance(this, newInstance)) {
-      // Only rewrite references to lambda classes if we are outside the class.
-      if (shouldRewrite(newInstance.clazz)) {
-        process(strategy, newInstance);
-      }
-    }
-    return null;
-  }
-
-  @Override
-  public Void visit(CheckCast checkCast) {
-    lambdaChecker.accept(checkCast.getType());
-    return null;
-  }
-
-  @Override
-  public Void visit(NewArrayEmpty newArrayEmpty) {
-    lambdaChecker.accept(newArrayEmpty.type);
-    return null;
-  }
-
-  @Override
-  public Void visit(ConstClass constClass) {
-    lambdaChecker.accept(constClass.getValue());
-    return null;
-  }
-
-  @Override
-  public Void visit(ConstMethodType constMethodType) {
-    lambdaChecker.accept(constMethodType.getValue());
-    return null;
-  }
-
-  @Override
-  public Void visit(ConstMethodHandle constMethodHandle) {
-    lambdaChecker.accept(constMethodHandle.getValue());
-    return null;
-  }
-
-  @Override
-  public Void visit(InstanceGet instanceGet) {
-    DexField field = instanceGet.getField();
-    Strategy strategy = strategyProvider.apply(field.holder);
-    if (strategy.isValidInstanceFieldRead(this, field)) {
-      if (shouldRewrite(field)) {
-        // Only rewrite references to lambda classes if we are outside the class.
-        process(strategy, instanceGet);
-      }
-    } else {
-      lambdaChecker.accept(field.type);
-    }
-
-    // We avoid fields with type being lambda class, it is possible for
-    // a lambda to capture another lambda, but we don't support it for now.
-    lambdaChecker.accept(field.type);
-    return null;
-  }
-
-  @Override
-  public Void visit(InstancePut instancePut) {
-    DexField field = instancePut.getField();
-    Strategy strategy = strategyProvider.apply(field.holder);
-    if (strategy.isValidInstanceFieldWrite(this, field)) {
-      if (shouldRewrite(field)) {
-        // Only rewrite references to lambda classes if we are outside the class.
-        process(strategy, instancePut);
-      }
-    } else {
-      lambdaChecker.accept(field.type);
-    }
-
-    // We avoid fields with type being lambda class, it is possible for
-    // a lambda to capture another lambda, but we don't support it for now.
-    lambdaChecker.accept(field.type);
-    return null;
-  }
-
-  @Override
-  public Void visit(StaticGet staticGet) {
-    DexField field = staticGet.getField();
-    Strategy strategy = strategyProvider.apply(field.holder);
-    if (strategy.isValidStaticFieldRead(this, field)) {
-      if (shouldRewrite(field)) {
-        // Only rewrite references to lambda classes if we are outside the class.
-        process(strategy, staticGet);
-      }
-    } else {
-      lambdaChecker.accept(field.type);
-      lambdaChecker.accept(field.holder);
-    }
-    return null;
-  }
-
-  @Override
-  public Void visit(StaticPut staticPut) {
-    DexField field = staticPut.getField();
-    Strategy strategy = strategyProvider.apply(field.holder);
-    if (strategy.isValidStaticFieldWrite(this, field)) {
-      if (shouldRewrite(field)) {
-        // Only rewrite references to lambda classes if we are outside the class.
-        process(strategy, staticPut);
-      }
-    } else {
-      lambdaChecker.accept(field.type);
-      lambdaChecker.accept(field.holder);
-    }
-    return null;
-  }
-
-  @Override
-  public Void visit(InitClass initClass) {
-    DexType clazz = initClass.getClassValue();
-    Strategy strategy = strategyProvider.apply(clazz);
-    if (strategy.isValidInitClass(this, clazz)) {
-      if (shouldRewrite(clazz)) {
-        // Only rewrite references to lambda classes if we are outside the class.
-        process(strategy, initClass);
-      }
-    } else {
-      lambdaChecker.accept(clazz);
-    }
-    return null;
-  }
-
-  @Override
-  public Void visit(Argument instruction) {
-    if (instruction.outValue() != code.getThis()) {
-      return null;
-    }
-    Strategy strategy = strategyProvider.apply(method.getHolderType());
-    if (strategy.isValidHolder(this, method.getHolderType())) {
-      if (shouldRewrite(method.getHolderType())) {
-        process(strategy, instruction);
-      }
-    }
-    return null;
-  }
-
-  abstract void process(Strategy strategy, InvokeMethod invokeMethod);
-
-  abstract void process(Strategy strategy, NewInstance newInstance);
-
-  abstract void process(Strategy strategy, InstancePut instancePut);
-
-  abstract void process(Strategy strategy, InstanceGet instanceGet);
-
-  abstract void process(Strategy strategy, StaticPut staticPut);
-
-  abstract void process(Strategy strategy, StaticGet staticGet);
-
-  abstract void process(Strategy strategy, InitClass initClass);
-
-  abstract void process(Strategy strategy, Argument argument);
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroup.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroup.java
deleted file mode 100644
index cc01f83..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroup.java
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda;
-
-import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexEncodedField;
-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.graph.DexType;
-import com.android.tools.r8.ir.optimize.info.OptimizationFeedback;
-import com.android.tools.r8.ir.optimize.lambda.CodeProcessor.Strategy;
-import com.android.tools.r8.kotlin.Kotlin;
-import com.android.tools.r8.shaking.MainDexClasses;
-import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.ThrowingConsumer;
-import com.google.common.collect.Lists;
-import com.google.common.io.BaseEncoding;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.ObjectOutputStream;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-
-// Represents a group of lambda classes which potentially can be represented
-// by the same lambda _group_ class. Each lambda class inside the group is
-// assigned an integer id.
-//
-// NOTE: access to lambdas in lambda group is NOT thread-safe.
-public abstract class LambdaGroup {
-  public final LambdaGroupId id;
-
-  // Lambda group class name. Is intended to be stable and uniques.
-  // In current implementation is generated in following way:
-  //       <optional-package>.-$$LambdaGroup$<HASH>
-  // with HASH generated based on names of the lambda class names
-  // of lambdas included in the group.
-  private DexType classType;
-
-  // Maps lambda classes belonging to the group into the index inside the
-  // group. Note usage of linked hash map to keep insertion ordering stable.
-  private final Map<DexType, LambdaInfo> lambdas = new LinkedHashMap<>();
-
-  public static class LambdaInfo {
-    public int id;
-    public final DexProgramClass clazz;
-
-    LambdaInfo(int id, DexProgramClass clazz) {
-      this.id = id;
-      this.clazz = clazz;
-    }
-
-    public DexProgramClass getLambdaClass() {
-      return clazz;
-    }
-  }
-
-  public LambdaGroup(LambdaGroupId id) {
-    this.id = id;
-  }
-
-  public final DexType getGroupClassType() {
-    assert classType != null;
-    return classType;
-  }
-
-  public final int size() {
-    return lambdas.size();
-  }
-
-  public final void forEachLambda(Consumer<LambdaInfo> action) {
-    assert verifyLambdaIds(false);
-    for (LambdaInfo info : lambdas.values()) {
-      action.accept(info);
-    }
-  }
-
-  public final boolean anyLambda(Predicate<LambdaInfo> predicate) {
-    assert verifyLambdaIds(false);
-    for (LambdaInfo info : lambdas.values()) {
-      if (predicate.test(info)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  final boolean shouldAddToMainDex(AppView<?> appView) {
-    // We add the group class to main index if any of the
-    // lambda classes it replaces is added to main index.
-    MainDexClasses mainDexClasses = appView.appInfo().getMainDexClasses();
-    for (LambdaInfo info : lambdas.values()) {
-      if (mainDexClasses.contains(info.getLambdaClass())) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  public final boolean containsLambda(DexType lambda) {
-    return lambdas.containsKey(lambda);
-  }
-
-  public final int lambdaId(DexType lambda) {
-    assert lambdas.containsKey(lambda);
-    return lambdas.get(lambda).id;
-  }
-
-  protected final List<DexEncodedField> lambdaCaptureFields(DexType lambda) {
-    assert lambdas.containsKey(lambda);
-    return lambdas.get(lambda).clazz.instanceFields();
-  }
-
-  protected final DexEncodedField lambdaSingletonField(DexType lambda) {
-    assert lambdas.containsKey(lambda);
-    List<DexEncodedField> fields = lambdas.get(lambda).clazz.staticFields();
-    assert fields.size() < 2;
-    return fields.size() == 0 ? null : fields.get(0);
-  }
-
-  // Contains less than 2 elements?
-  final boolean isTrivial() {
-    return lambdas.size() < 2;
-  }
-
-  final void add(DexProgramClass lambda) {
-    assert !lambdas.containsKey(lambda.type);
-    lambdas.put(lambda.type, new LambdaInfo(lambdas.size(), lambda));
-  }
-
-  final void remove(DexType lambda) {
-    assert lambdas.containsKey(lambda);
-    lambdas.remove(lambda);
-  }
-
-  final void compact() {
-    assert verifyLambdaIds(false);
-    int lastUsed = -1;
-    int lastSeen = -1;
-    for (Entry<DexType, LambdaInfo> entry : lambdas.entrySet()) {
-      int index = entry.getValue().id;
-      assert lastUsed <= lastSeen && lastSeen < index;
-      lastUsed++;
-      lastSeen = index;
-      if (lastUsed < index) {
-        entry.getValue().id = lastUsed;
-      }
-    }
-    assert verifyLambdaIds(true);
-  }
-
-  public abstract Strategy getCodeStrategy();
-
-  public abstract ThrowingConsumer<DexClass, LambdaStructureError> lambdaClassValidator(
-      Kotlin kotlin, AppInfoWithClassHierarchy appInfo);
-
-  // Package for a lambda group class to be created in.
-  protected abstract String getTypePackage();
-
-  protected abstract String getGroupSuffix();
-
-  final DexProgramClass synthesizeClass(
-      AppView<? extends AppInfoWithClassHierarchy> appView, OptimizationFeedback feedback) {
-    assert classType == null;
-    assert verifyLambdaIds(true);
-    List<LambdaInfo> lambdas = Lists.newArrayList(this.lambdas.values());
-    classType =
-        appView
-            .dexItemFactory()
-            .createType(
-                "L"
-                    + getTypePackage()
-                    + "-$$LambdaGroup$"
-                    + getGroupSuffix()
-                    + createHash(lambdas)
-                    + ";");
-    return getBuilder(appView.dexItemFactory(), appView.options())
-        .synthesizeClass(appView, feedback);
-  }
-
-  protected abstract LambdaGroupClassBuilder<? extends LambdaGroup> getBuilder(
-      DexItemFactory factory, InternalOptions options);
-
-  private String createHash(List<LambdaInfo> lambdas) {
-    try {
-      ByteArrayOutputStream bytes = new ByteArrayOutputStream();
-      ObjectOutputStream out = new ObjectOutputStream(bytes);
-
-      // We will generate SHA-1 hash of the list of lambda classes represented in the group.
-      for (LambdaInfo lambda : lambdas) {
-        DexString descriptor = lambda.clazz.type.descriptor;
-        out.writeInt(descriptor.size); // To avoid same-prefix problem
-        out.write(descriptor.content);
-      }
-      out.close();
-
-      MessageDigest digest = MessageDigest.getInstance("SHA-1");
-      digest.update(bytes.toByteArray());
-      return BaseEncoding.base64Url().omitPadding().encode(digest.digest());
-    } catch (NoSuchAlgorithmException | IOException ex) {
-      throw new Unreachable("Cannot get SHA-1 message digest");
-    }
-  }
-
-  private boolean verifyLambdaIds(boolean strict) {
-    int previous = -1;
-    for (LambdaInfo info : lambdas.values()) {
-      assert strict ? (previous + 1) == info.id : previous < info.id;
-      previous = info.id;
-    }
-    return true;
-  }
-
-  public static class LambdaStructureError extends Exception {
-    final boolean reportable;
-
-    public LambdaStructureError(String cause) {
-      this(cause, true);
-    }
-
-    public LambdaStructureError(String cause, boolean reportable) {
-      super(cause);
-      this.reportable = reportable;
-    }
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroupClassBuilder.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroupClassBuilder.java
deleted file mode 100644
index 92f0972..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroupClassBuilder.java
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda;
-
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
-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.DexEncodedField;
-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.DexType;
-import com.android.tools.r8.graph.DexTypeList;
-import com.android.tools.r8.graph.EnclosingMethodAttribute;
-import com.android.tools.r8.graph.GenericSignature.ClassSignature;
-import com.android.tools.r8.graph.InnerClassAttribute;
-import com.android.tools.r8.ir.optimize.info.OptimizationFeedback;
-import com.android.tools.r8.origin.SynthesizedOrigin;
-import java.util.Collections;
-import java.util.List;
-
-// Encapsulates lambda group class building logic and separates
-// it from the rest of lambda group functionality.
-public abstract class LambdaGroupClassBuilder<T extends LambdaGroup> {
-  protected final T group;
-  protected final DexItemFactory factory;
-  protected final String origin;
-
-  protected LambdaGroupClassBuilder(T group, DexItemFactory factory, String origin) {
-    this.group = group;
-    this.factory = factory;
-    this.origin = origin;
-  }
-
-  public final DexProgramClass synthesizeClass(
-      AppView<? extends AppInfoWithClassHierarchy> appView, OptimizationFeedback feedback) {
-    DexType groupClassType = group.getGroupClassType();
-    DexType superClassType = getSuperClassType();
-    return new DexProgramClass(
-        groupClassType,
-        null,
-        new SynthesizedOrigin(origin, getClass()),
-        buildAccessFlags(),
-        superClassType,
-        buildInterfaces(),
-        factory.createString(origin),
-        null,
-        Collections.emptyList(),
-        buildEnclosingMethodAttribute(),
-        buildInnerClasses(),
-        buildClassSignature(),
-        DexAnnotationSet.empty(),
-        buildStaticFields(appView, feedback),
-        buildInstanceFields(),
-        buildDirectMethods(),
-        buildVirtualMethods(),
-        factory.getSkipNameValidationForTesting(),
-        // The name of the class is based on the hash of the content.
-        DexProgramClass::checksumFromType);
-  }
-
-  protected abstract DexType getSuperClassType();
-
-  protected abstract ClassAccessFlags buildAccessFlags();
-
-  protected abstract EnclosingMethodAttribute buildEnclosingMethodAttribute();
-
-  protected abstract List<InnerClassAttribute> buildInnerClasses();
-
-  protected abstract ClassSignature buildClassSignature();
-
-  protected abstract DexEncodedMethod[] buildVirtualMethods();
-
-  protected abstract DexEncodedMethod[] buildDirectMethods();
-
-  protected abstract DexEncodedField[] buildInstanceFields();
-
-  protected abstract DexEncodedField[] buildStaticFields(
-      AppView<? extends AppInfoWithClassHierarchy> appView, OptimizationFeedback feedback);
-
-  protected abstract DexTypeList buildInterfaces();
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroupId.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroupId.java
deleted file mode 100644
index 2c31541..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaGroupId.java
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda;
-
-// Represents a lambda group identifier uniquely identifying the groups
-// of potentially mergeable lambdas.
-//
-// Implements hashCode/equals in a way that guarantees that if two lambda
-// classes has equal ids they belong to the same lambda group.
-public interface LambdaGroupId {
-  LambdaGroup createGroup();
-
-  @Override
-  int hashCode();
-
-  @Override
-  boolean equals(Object obj);
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
deleted file mode 100644
index 5bccf4d4..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaMerger.java
+++ /dev/null
@@ -1,738 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda;
-
-import com.android.tools.r8.DiagnosticsHandler;
-import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexApplication;
-import com.android.tools.r8.graph.DexApplication.Builder;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexClassAndMethod;
-import com.android.tools.r8.graph.DexEncodedField;
-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.DexType;
-import com.android.tools.r8.graph.GraphLens;
-import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.graph.ResolutionResult;
-import com.android.tools.r8.graph.classmerging.HorizontallyMergedLambdaClasses;
-import com.android.tools.r8.ir.analysis.type.DestructivePhiTypeUpdater;
-import com.android.tools.r8.ir.code.Argument;
-import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.code.InitClass;
-import com.android.tools.r8.ir.code.InstanceGet;
-import com.android.tools.r8.ir.code.InstancePut;
-import com.android.tools.r8.ir.code.Instruction;
-import com.android.tools.r8.ir.code.InvokeMethod;
-import com.android.tools.r8.ir.code.InvokeVirtual;
-import com.android.tools.r8.ir.code.NewInstance;
-import com.android.tools.r8.ir.code.Phi;
-import com.android.tools.r8.ir.code.StaticGet;
-import com.android.tools.r8.ir.code.StaticPut;
-import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.ir.conversion.IRConverter;
-import com.android.tools.r8.ir.conversion.MethodProcessor;
-import com.android.tools.r8.ir.optimize.Inliner;
-import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
-import com.android.tools.r8.ir.optimize.Inliner.InliningInfo;
-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;
-import com.android.tools.r8.ir.optimize.info.OptimizationFeedback.OptimizationInfoFixer;
-import com.android.tools.r8.ir.optimize.inliner.InliningIRProvider;
-import com.android.tools.r8.ir.optimize.lambda.CodeProcessor.Strategy;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroup.LambdaStructureError;
-import com.android.tools.r8.ir.optimize.lambda.kotlin.KotlinLambdaGroupIdFactory;
-import com.android.tools.r8.kotlin.Kotlin;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.shaking.FieldAccessInfoCollectionModifier;
-import com.android.tools.r8.shaking.ProguardConfiguration;
-import com.android.tools.r8.utils.SetUtils;
-import com.android.tools.r8.utils.StringDiagnostic;
-import com.android.tools.r8.utils.ThreadUtils;
-import com.android.tools.r8.utils.ThrowingConsumer;
-import com.android.tools.r8.utils.Timing;
-import com.android.tools.r8.utils.collections.LongLivedProgramMethodSetBuilder;
-import com.android.tools.r8.utils.collections.SortedProgramMethodSet;
-import com.google.common.collect.BiMap;
-import com.google.common.collect.HashBiMap;
-import com.google.common.collect.Sets;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.Deque;
-import java.util.IdentityHashMap;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Future;
-import java.util.function.Function;
-
-// Merging lambda classes into single lambda group classes. There are three flavors
-// of lambdas we are dealing with:
-//   (a) lambda classes synthesized in desugaring, handles java lambdas
-//   (b) k-style lambda classes synthesized by kotlin compiler
-//   (c) j-style lambda classes synthesized by kotlin compiler
-//
-// Lambda merging is potentially applicable to all three of them, but
-// current implementation deals with both k- and j-style lambdas.
-//
-// In general we merge lambdas in 5 phases:
-//   1. collect all lambdas and compute group candidates. we do it synchronously
-//      and ensure that the order of lambda groups and lambdas inside each group
-//      is stable.
-//   2. analyze usages of lambdas and exclude lambdas with unexpected usage
-//      NOTE: currently we consider *all* usages outside the code invalid
-//      so we only need to patch method code when replacing the lambda class.
-//   3. exclude (invalidate) all lambda classes with usages we don't understand
-//      or support, compact the remaining lambda groups, remove trivial groups
-//      with less that 2 lambdas.
-//   4. replace lambda valid/supported class constructions with references to
-//      lambda group classes.
-//   5. synthesize group lambda classes.
-//
-public final class LambdaMerger {
-
-  private abstract static class Mode {
-
-    void rewriteCode(
-        ProgramMethod method,
-        IRCode code,
-        Inliner inliner,
-        ProgramMethod context,
-        InliningIRProvider provider) {}
-
-    void analyzeCode(ProgramMethod method, IRCode code) {}
-  }
-
-  private class AnalyzeMode extends Mode {
-
-    @Override
-    void analyzeCode(ProgramMethod method, IRCode code) {
-      new AnalysisStrategy(method, code).processCode();
-    }
-  }
-
-  private class ApplyMode extends Mode {
-
-    private final Map<DexProgramClass, LambdaGroup> lambdaGroups;
-    private final LambdaMergerOptimizationInfoFixer optimizationInfoFixer;
-
-    ApplyMode(
-        Map<DexProgramClass, LambdaGroup> lambdaGroups,
-        LambdaMergerOptimizationInfoFixer optimizationInfoFixer) {
-      this.lambdaGroups = lambdaGroups;
-      this.optimizationInfoFixer = optimizationInfoFixer;
-    }
-
-    @Override
-    void rewriteCode(
-        ProgramMethod method,
-        IRCode code,
-        Inliner inliner,
-        ProgramMethod context,
-        InliningIRProvider provider) {
-      LambdaGroup lambdaGroup = lambdaGroups.get(method.getHolder());
-      if (lambdaGroup == null) {
-        // Only rewrite the methods that have not been synthesized for the lambda group classes.
-        new ApplyStrategy(method, code, context, optimizationInfoFixer).processCode();
-        return;
-      }
-
-      if (method.getDefinition().isInitializer()) {
-        // Should not require rewriting.
-        return;
-      }
-
-      assert method.getDefinition().isNonPrivateVirtualMethod();
-      assert context == null;
-
-      Map<InvokeVirtual, InliningInfo> invokesToInline = new IdentityHashMap<>();
-      for (InvokeVirtual invoke : code.<InvokeVirtual>instructions(Instruction::isInvokeVirtual)) {
-        DexMethod invokedMethod = invoke.getInvokedMethod();
-        DexType holder = invokedMethod.holder;
-        if (lambdaGroup.containsLambda(holder)) {
-          // TODO(b/150685763): Check if we can use simpler lookup.
-          ResolutionResult resolution = appView.appInfo().resolveMethodOnClass(invokedMethod);
-          assert resolution.isSingleResolution();
-          ProgramMethod singleTarget =
-              resolution.asSingleResolution().getResolutionPair().asProgramMethod();
-          assert singleTarget != null;
-          invokesToInline.put(invoke, new InliningInfo(singleTarget, singleTarget.getHolderType()));
-        }
-      }
-
-      assert invokesToInline.size() > 1
-          || appView.options().testing.verificationSizeLimitInBytesOverride > -1;
-
-      inliner.performForcedInlining(method, code, invokesToInline, provider, Timing.empty());
-    }
-  }
-
-  // Maps lambda into a group, only contains lambdas we decided to merge.
-  // NOTE: needs synchronization.
-  private final Map<DexType, LambdaGroup> lambdas = new IdentityHashMap<>();
-  // We use linked map to ensure stable ordering of the groups
-  // when they are processed sequentially.
-  // NOTE: needs synchronization.
-  private final Map<LambdaGroupId, LambdaGroup> groups = new LinkedHashMap<>();
-
-  // Since invalidating lambdas may happen concurrently we don't remove invalidated lambdas
-  // from groups (and `lambdas`) right away since the ordering may be important. Instead we
-  // collect invalidated lambdas and remove them from groups after analysis is done.
-  private final Set<DexType> invalidatedLambdas = Sets.newConcurrentHashSet();
-
-  // Methods which need to be patched to reference lambda group classes instead of the
-  // original lambda classes. The number of methods is expected to be small since there
-  // is a 1:1 relation between lambda and method it is defined in (unless such a method
-  // was inlined by either kotlinc or r8).
-  //
-  // Note that we don't track precisely lambda -> method mapping, so it may happen that
-  // we mark a method for further processing, and then invalidate the only lambda referenced
-  // from it. In this case we will reprocess method that does not need patching, but it
-  // should not be happening very frequently and we ignore possible overhead.
-  private final LongLivedProgramMethodSetBuilder<SortedProgramMethodSet> methodsToReprocess =
-      LongLivedProgramMethodSetBuilder.createForSortedSet();
-
-  private final AppView<AppInfoWithLiveness> appView;
-  private final Kotlin kotlin;
-  private final DiagnosticsHandler reporter;
-
-  private Mode mode;
-
-  // Lambda visitor invalidating lambdas it sees.
-  private final LambdaTypeVisitor lambdaInvalidator;
-  // Lambda visitor throwing Unreachable on each lambdas it sees.
-  private final LambdaTypeVisitor lambdaChecker;
-
-  public LambdaMerger(AppView<AppInfoWithLiveness> appView) {
-    DexItemFactory factory = appView.dexItemFactory();
-    this.appView = appView;
-    this.kotlin = factory.kotlin;
-    this.reporter = appView.options().reporter;
-
-    this.lambdaInvalidator =
-        new LambdaTypeVisitor(factory, this::isMergeableLambda, this::invalidateLambda);
-    this.lambdaChecker =
-        new LambdaTypeVisitor(
-            factory,
-            this::isMergeableLambda,
-            type -> {
-              throw new Unreachable("Unexpected lambda " + type.toSourceString());
-            });
-  }
-
-  private void invalidateLambda(DexType lambda) {
-    invalidatedLambdas.add(lambda);
-  }
-
-  private synchronized boolean isMergeableLambda(DexType lambda) {
-    return lambdas.containsKey(lambda);
-  }
-
-  private synchronized LambdaGroup getLambdaGroup(DexType lambda) {
-    return lambdas.get(lambda);
-  }
-
-  private synchronized void queueForProcessing(ProgramMethod method) {
-    methodsToReprocess.add(method);
-  }
-
-  // Collect all group candidates and assign unique lambda ids inside each group.
-  // We do this before methods are being processed to guarantee stable order of
-  // lambdas inside each group.
-  public final void collectGroupCandidates(DexApplication app) {
-    // Collect lambda groups.
-    app.classes().stream()
-        .filter(cls -> !appView.appInfo().isPinned(cls.type))
-        .filter(
-            cls ->
-                appView.testing().kotlinLambdaMergerFactoryForClass.apply(cls) != null
-                    && KotlinLambdaGroupIdFactory.hasValidAnnotations(kotlin, cls)
-                    && !appView.appInfo().getClassToFeatureSplitMap().isInFeature(cls))
-        .sorted(Comparator.comparing(DexClass::getType)) // Ensure stable ordering.
-        .forEachOrdered(
-            lambda -> {
-              try {
-                KotlinLambdaGroupIdFactory lambdaGroupIdFactory =
-                    appView.testing().kotlinLambdaMergerFactoryForClass.apply(lambda);
-                LambdaGroupId id = lambdaGroupIdFactory.validateAndCreate(appView, kotlin, lambda);
-                LambdaGroup group = groups.computeIfAbsent(id, LambdaGroupId::createGroup);
-                group.add(lambda);
-                lambdas.put(lambda.type, group);
-              } catch (LambdaStructureError error) {
-                // Intentionally empty.
-              }
-            });
-
-    // Remove trivial groups.
-    removeTrivialLambdaGroups();
-
-    assert mode == null;
-    mode = new AnalyzeMode();
-  }
-
-  /**
-   * Is called by IRConverter::rewriteCode. Performs different actions depending on the current
-   * mode.
-   *
-   * <ol>
-   *   <li>in ANALYZE mode analyzes invalid usages of lambda classes inside the method code,
-   *       invalidated such lambda classes, collects methods that need to be patched.
-   *   <li>in APPLY mode does nothing.
-   * </ol>
-   */
-  public final void analyzeCode(ProgramMethod method, IRCode code) {
-    if (mode != null) {
-      mode.analyzeCode(method, code);
-    }
-  }
-
-  /**
-   * Is called by IRConverter::rewriteCode. Performs different actions depending on the current
-   * mode.
-   *
-   * <ol>
-   *   <li>in ANALYZE mode does nothing.
-   *   <li>in APPLY mode patches the code to use lambda group classes, also asserts that there are
-   *       no more invalid lambda class references.
-   * </ol>
-   */
-  public final void rewriteCode(
-      ProgramMethod method, IRCode code, Inliner inliner, MethodProcessor methodProcessor) {
-    if (mode != null) {
-      mode.rewriteCode(
-          code.context(),
-          code,
-          inliner,
-          null,
-          new InliningIRProvider(appView, method, code, methodProcessor));
-    }
-  }
-
-  /**
-   * Similar to {@link #rewriteCode(ProgramMethod, IRCode, Inliner, MethodProcessor)}, but for
-   * rewriting code for inlining. The {@param context} is the caller that {@param method} is being
-   * inlined into.
-   */
-  public final void rewriteCodeForInlining(
-      ProgramMethod method, IRCode code, ProgramMethod context, InliningIRProvider provider) {
-    if (mode != null) {
-      mode.rewriteCode(method, code, null, context, provider);
-    }
-  }
-
-  public final void applyLambdaClassMapping(
-      DexApplication app,
-      IRConverter converter,
-      OptimizationFeedback feedback,
-      Builder<?> builder,
-      ExecutorService executorService,
-      GraphLens appliedGraphLens)
-      throws ExecutionException {
-    if (lambdas.isEmpty()) {
-      appView.setHorizontallyMergedLambdaClasses(HorizontallyMergedLambdaClasses.empty());
-      return;
-    }
-
-    // Analyse references from program classes. We assume that this optimization
-    // is only used for full program analysis and there are no classpath classes.
-    ThreadUtils.processItems(app.classes(), this::analyzeClass, executorService);
-
-    // Analyse more complex aspects of lambda classes including method code.
-    analyzeLambdaClassesStructure(executorService);
-
-    // Remove invalidated lambdas, compact groups to ensure
-    // sequential lambda ids, create group lambda classes.
-    BiMap<LambdaGroup, DexProgramClass> lambdaGroupsClasses = finalizeLambdaGroups(feedback);
-
-    // Fixup optimization info to ensure that the optimization info does not refer to any merged
-    // lambdas.
-    LambdaMergerOptimizationInfoFixer optimizationInfoFixer =
-        new LambdaMergerOptimizationInfoFixer(lambdaGroupsClasses);
-    feedback.fixupOptimizationInfos(appView, executorService, optimizationInfoFixer);
-
-    // Switch to APPLY strategy.
-    this.mode = new ApplyMode(lambdaGroupsClasses.inverse(), optimizationInfoFixer);
-
-    FieldAccessInfoCollectionModifier.Builder fieldAccessInfoCollectionModifierBuilder =
-        FieldAccessInfoCollectionModifier.builder();
-
-    // Add synthesized lambda group classes to the builder.
-    for (Entry<LambdaGroup, DexProgramClass> entry : lambdaGroupsClasses.entrySet()) {
-      DexProgramClass synthesizedClass = entry.getValue();
-      appView
-          .appInfo()
-          .addSynthesizedClass(synthesizedClass, entry.getKey().shouldAddToMainDex(appView));
-      builder.addSynthesizedClass(synthesizedClass);
-
-      synthesizedClass.forEachField(
-          field ->
-              fieldAccessInfoCollectionModifierBuilder
-                  .recordFieldReadInUnknownContext(field.getReference())
-                  .recordFieldWriteInUnknownContext(field.getReference()));
-
-      // Eventually, we need to process synthesized methods in the lambda group.
-      // Otherwise, abstract SynthesizedCode will be flown to Enqueuer.
-      // But that process should not see the holder. Otherwise, lambda calls in the main dispatch
-      // method became recursive calls via the lens rewriter. They should remain, then inliner
-      // will inline methods from mergee lambdas to the main dispatch method.
-      // Then, there is a dilemma: other sub optimizations trigger subtype lookup that will throw
-      // NPE if it cannot find the holder for this synthesized lambda group.
-      // One hack here is to mark those methods `processed` so that the lens rewriter is skipped.
-      synthesizedClass.forEachMethod(
-          encodedMethod -> encodedMethod.markProcessed(ConstraintWithTarget.NEVER));
-    }
-
-    // Record field accesses for synthesized fields.
-    fieldAccessInfoCollectionModifierBuilder.build().modify(appView);
-
-    converter.optimizeSynthesizedClasses(lambdaGroupsClasses.values(), executorService);
-
-    // Rewrite lambda class references into lambda group class
-    // references inside methods from the processing queue.
-    rewriteLambdaReferences(converter, executorService, appliedGraphLens);
-    this.mode = null;
-
-    appView.setHorizontallyMergedLambdaClasses(new HorizontallyMergedLambdaClasses(lambdas));
-  }
-
-  private void analyzeLambdaClassesStructure(ExecutorService service) throws ExecutionException {
-    List<Future<?>> futures = new ArrayList<>();
-    for (LambdaGroup group : groups.values()) {
-      ThrowingConsumer<DexClass, LambdaStructureError> validator =
-          group.lambdaClassValidator(kotlin, appView.appInfo());
-      group.forEachLambda(
-          info ->
-              futures.add(
-                  service.submit(
-                      () -> {
-                        try {
-                          validator.accept(info.clazz);
-                        } catch (LambdaStructureError error) {
-                          ProguardConfiguration proguardConfiguration =
-                              appView.options().getProguardConfiguration();
-                          if (error.reportable
-                              && !proguardConfiguration
-                                  .getDontNotePatterns()
-                                  .matches(info.clazz.getType())) {
-                            reporter.info(
-                                new StringDiagnostic(
-                                    "Unexpected Kotlin lambda structure ["
-                                        + info.clazz.type.toSourceString()
-                                        + "]: "
-                                        + error.getMessage()));
-                          }
-                          invalidateLambda(info.clazz.type);
-                        }
-                      })));
-    }
-    ThreadUtils.awaitFutures(futures);
-  }
-
-  private BiMap<LambdaGroup, DexProgramClass> finalizeLambdaGroups(OptimizationFeedback feedback) {
-    for (DexType lambda : invalidatedLambdas) {
-      LambdaGroup group = lambdas.get(lambda);
-      assert group != null;
-      lambdas.remove(lambda);
-      group.remove(lambda);
-    }
-    invalidatedLambdas.clear();
-
-    // Remove new trivial lambdas.
-    removeTrivialLambdaGroups();
-
-    // Compact lambda groups, synthesize lambda group classes.
-    BiMap<LambdaGroup, DexProgramClass> result = HashBiMap.create();
-    for (LambdaGroup group : groups.values()) {
-      assert !group.isTrivial() : "No trivial group is expected here.";
-      group.compact();
-      DexProgramClass lambdaGroupClass = group.synthesizeClass(appView, feedback);
-      result.put(group, lambdaGroupClass);
-    }
-    return result;
-  }
-
-  private void removeTrivialLambdaGroups() {
-    Iterator<Entry<LambdaGroupId, LambdaGroup>> iterator = groups.entrySet().iterator();
-    while (iterator.hasNext()) {
-      Entry<LambdaGroupId, LambdaGroup> group = iterator.next();
-      if (group.getValue().isTrivial()) {
-        iterator.remove();
-        assert group.getValue().size() < 2;
-        group.getValue().forEachLambda(info -> this.lambdas.remove(info.clazz.type));
-      }
-    }
-  }
-
-  private void rewriteLambdaReferences(
-      IRConverter converter, ExecutorService executorService, GraphLens appliedGraphLens)
-      throws ExecutionException {
-    if (methodsToReprocess.isEmpty()) {
-      return;
-    }
-    SortedProgramMethodSet methods = methodsToReprocess.build(appView, appliedGraphLens);
-    converter.processMethodsConcurrently(methods, executorService);
-    assert methods.stream()
-        .map(DexClassAndMethod::getDefinition)
-        .allMatch(DexEncodedMethod::isProcessed);
-  }
-
-  private void analyzeClass(DexProgramClass clazz) {
-    lambdaInvalidator.accept(clazz.superType);
-    lambdaInvalidator.accept(clazz.interfaces);
-    lambdaInvalidator.accept(clazz.annotations());
-
-    for (DexEncodedField field : clazz.staticFields()) {
-      lambdaInvalidator.accept(field.annotations());
-      if (field.field.type != clazz.type) {
-        // Ignore static fields of the same type.
-        lambdaInvalidator.accept(field.field, clazz.type);
-      }
-    }
-    for (DexEncodedField field : clazz.instanceFields()) {
-      lambdaInvalidator.accept(field.annotations());
-      lambdaInvalidator.accept(field.field, clazz.type);
-    }
-
-    for (DexEncodedMethod method : clazz.methods()) {
-      lambdaInvalidator.accept(method.annotations());
-      lambdaInvalidator.accept(method.parameterAnnotationsList);
-      lambdaInvalidator.accept(method.method, clazz.type);
-    }
-  }
-
-  private Strategy strategyProvider(DexType type) {
-    LambdaGroup group = this.getLambdaGroup(type);
-    return group != null ? group.getCodeStrategy() : CodeProcessor.NoOp;
-  }
-
-  private final class AnalysisStrategy extends CodeProcessor {
-    private AnalysisStrategy(ProgramMethod method, IRCode code) {
-      super(
-          LambdaMerger.this.appView,
-          LambdaMerger.this::strategyProvider,
-          lambdaInvalidator,
-          method,
-          code);
-    }
-
-    @Override
-    void process(Strategy strategy, InvokeMethod invokeMethod) {
-      queueForProcessing(method);
-    }
-
-    @Override
-    void process(Strategy strategy, NewInstance newInstance) {
-      queueForProcessing(method);
-    }
-
-    @Override
-    void process(Strategy strategy, InstancePut instancePut) {
-      queueForProcessing(method);
-    }
-
-    @Override
-    void process(Strategy strategy, InstanceGet instanceGet) {
-      queueForProcessing(method);
-    }
-
-    @Override
-    void process(Strategy strategy, StaticPut staticPut) {
-      queueForProcessing(method);
-    }
-
-    @Override
-    void process(Strategy strategy, StaticGet staticGet) {
-      queueForProcessing(method);
-    }
-
-    @Override
-    void process(Strategy strategy, InitClass initClass) {
-      queueForProcessing(method);
-    }
-
-    @Override
-    void process(Strategy strategy, Argument argument) {
-      throw new Unreachable();
-    }
-  }
-
-  public final class ApplyStrategy extends CodeProcessor {
-
-    private final LambdaMergerOptimizationInfoFixer optimizationInfoFixer;
-
-    private final Set<Value> typeAffectedValues = Sets.newIdentityHashSet();
-
-    private ApplyStrategy(
-        ProgramMethod method,
-        IRCode code,
-        ProgramMethod context,
-        LambdaMergerOptimizationInfoFixer optimizationInfoFixer) {
-      super(
-          LambdaMerger.this.appView,
-          LambdaMerger.this::strategyProvider,
-          lambdaChecker,
-          method,
-          code,
-          context);
-      this.optimizationInfoFixer = optimizationInfoFixer;
-    }
-
-    public void recordTypeHasChanged(Value value) {
-      for (Value affectedValue : value.affectedValues()) {
-        if (typeMayHaveChanged(affectedValue)) {
-          typeAffectedValues.add(affectedValue);
-        }
-      }
-    }
-
-    @Override
-    void processCode() {
-      super.processCode();
-
-      if (typeAffectedValues.isEmpty()) {
-        return;
-      }
-
-      // Find all the transitively type affected values.
-      Set<Value> transitivelyTypeAffectedValues = SetUtils.newIdentityHashSet(typeAffectedValues);
-      Deque<Value> worklist = new ArrayDeque<>(typeAffectedValues);
-      while (!worklist.isEmpty()) {
-        Value value = worklist.pop();
-        assert typeMayHaveChanged(value);
-        assert transitivelyTypeAffectedValues.contains(value);
-
-        for (Value affectedValue : value.affectedValues()) {
-          if (typeMayHaveChanged(affectedValue)
-              && transitivelyTypeAffectedValues.add(affectedValue)) {
-            worklist.add(affectedValue);
-          }
-        }
-      }
-
-      // Update the types of these values if they refer to obsolete types. This is needed to be
-      // able to propagate the type information correctly, since lambda merging is neither a
-      // narrowing nor a widening.
-      for (Value value : transitivelyTypeAffectedValues) {
-        value.setType(value.getType().fixupClassTypeReferences(optimizationInfoFixer, appView));
-      }
-
-      // Filter out the type affected phis and destructively update the type of the phis. This is
-      // needed because narrowing does not work in presence of cyclic phis.
-      Set<Phi> typeAffectedPhis = Sets.newIdentityHashSet();
-      for (Value typeAffectedValue : transitivelyTypeAffectedValues) {
-        if (typeAffectedValue.isPhi()) {
-          typeAffectedPhis.add(typeAffectedValue.asPhi());
-        }
-      }
-      if (!typeAffectedPhis.isEmpty()) {
-        new DestructivePhiTypeUpdater(appView, optimizationInfoFixer)
-            .recomputeAndPropagateTypes(code, typeAffectedPhis);
-      }
-      assert code.verifyTypes(appView);
-    }
-
-    private boolean typeMayHaveChanged(Value value) {
-      return value.isPhi() || !value.definition.hasInvariantOutType();
-    }
-
-    @Override
-    void process(Strategy strategy, InvokeMethod invokeMethod) {
-      strategy.patch(this, invokeMethod);
-    }
-
-    @Override
-    void process(Strategy strategy, NewInstance newInstance) {
-      strategy.patch(this, newInstance);
-    }
-
-    @Override
-    void process(Strategy strategy, InstancePut instancePut) {
-      // Instance put should only appear in lambda class instance constructor,
-      // we should never get here since we never rewrite them.
-      throw new Unreachable();
-    }
-
-    @Override
-    void process(Strategy strategy, InstanceGet instanceGet) {
-      strategy.patch(this, instanceGet);
-    }
-
-    @Override
-    void process(Strategy strategy, StaticPut staticPut) {
-      // Static put should only appear in lambda class static initializer,
-      // we should never get here since we never rewrite them.
-      throw new Unreachable();
-    }
-
-    @Override
-    void process(Strategy strategy, StaticGet staticGet) {
-      strategy.patch(this, staticGet);
-    }
-
-    @Override
-    void process(Strategy strategy, InitClass initClass) {
-      strategy.patch(this, initClass);
-    }
-
-    @Override
-    void process(Strategy strategy, Argument argument) {
-      strategy.patch(this, argument);
-    }
-  }
-
-  private final class LambdaMergerOptimizationInfoFixer
-      implements Function<DexType, DexType>, OptimizationInfoFixer {
-
-    private final Map<LambdaGroup, DexProgramClass> lambdaGroupsClasses;
-
-    LambdaMergerOptimizationInfoFixer(Map<LambdaGroup, DexProgramClass> lambdaGroupsClasses) {
-      this.lambdaGroupsClasses = lambdaGroupsClasses;
-    }
-
-    @Override
-    public DexType apply(DexType type) {
-      LambdaGroup group = lambdas.get(type);
-      if (group != null) {
-        DexProgramClass clazz = lambdaGroupsClasses.get(group);
-        if (clazz != null) {
-          return clazz.type;
-        }
-      }
-      return type;
-    }
-
-    @Override
-    public void fixup(DexEncodedField field) {
-      FieldOptimizationInfo optimizationInfo = field.getOptimizationInfo();
-      if (optimizationInfo.isMutableFieldOptimizationInfo()) {
-        optimizationInfo.asMutableFieldOptimizationInfo().fixupClassTypeReferences(this, appView);
-      } else {
-        assert optimizationInfo.isDefaultFieldOptimizationInfo();
-      }
-    }
-
-    @Override
-    public void fixup(DexEncodedMethod method) {
-      MethodOptimizationInfo optimizationInfo = method.getOptimizationInfo();
-      if (optimizationInfo.isUpdatableMethodOptimizationInfo()) {
-        optimizationInfo
-            .asUpdatableMethodOptimizationInfo()
-            .fixupClassTypeReferences(this, appView);
-      } else {
-        assert optimizationInfo.isDefaultMethodOptimizationInfo();
-      }
-    }
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaTypeVisitor.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaTypeVisitor.java
deleted file mode 100644
index 9dce489..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/LambdaTypeVisitor.java
+++ /dev/null
@@ -1,146 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda;
-
-import com.android.tools.r8.graph.DexAnnotation;
-import com.android.tools.r8.graph.DexAnnotationElement;
-import com.android.tools.r8.graph.DexAnnotationSet;
-import com.android.tools.r8.graph.DexCallSite;
-import com.android.tools.r8.graph.DexEncodedAnnotation;
-import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexMethodHandle;
-import com.android.tools.r8.graph.DexProto;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexTypeList;
-import com.android.tools.r8.graph.DexValue;
-import com.android.tools.r8.graph.ParameterAnnotationsList;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-
-// Encapsulates the logic of visiting all lambda classes.
-final class LambdaTypeVisitor {
-  private final DexItemFactory factory;
-  private final Predicate<DexType> isLambdaType;
-  private final Consumer<DexType> onLambdaType;
-
-  LambdaTypeVisitor(DexItemFactory factory,
-      Predicate<DexType> isLambdaType, Consumer<DexType> onLambdaType) {
-    this.factory = factory;
-    this.isLambdaType = isLambdaType;
-    this.onLambdaType = onLambdaType;
-  }
-
-  void accept(DexCallSite callSite) {
-    accept(callSite.methodProto);
-    accept(callSite.bootstrapMethod);
-    for (DexValue value : callSite.bootstrapArgs) {
-      accept(value);
-    }
-  }
-
-  private void accept(DexValue value) {
-    switch (value.getValueKind()) {
-      case ARRAY:
-        for (DexValue elementValue : value.asDexValueArray().getValues()) {
-          accept(elementValue);
-        }
-        break;
-      case FIELD:
-        accept(value.asDexValueField().value, null);
-        break;
-      case METHOD:
-        accept(value.asDexValueMethod().value, null);
-        break;
-      case METHOD_HANDLE:
-        accept(value.asDexValueMethodHandle().value);
-        break;
-      case METHOD_TYPE:
-        accept(value.asDexValueMethodType().value);
-        break;
-      case TYPE:
-        accept(value.asDexValueType().value);
-        break;
-      default:
-        // Intentionally empty.
-    }
-  }
-
-  void accept(DexMethodHandle handle) {
-    if (handle.isFieldHandle()) {
-      accept(handle.asField(), null);
-    } else {
-      assert handle.isMethodHandle();
-      accept(handle.asMethod(), null);
-    }
-  }
-
-  void accept(DexField field, DexType holderToIgnore) {
-    accept(field.type);
-    if (holderToIgnore != field.holder) {
-      accept(field.holder);
-    }
-  }
-
-  void accept(DexMethod method, DexType holderToIgnore) {
-    if (holderToIgnore != method.holder) {
-      accept(method.holder);
-    }
-    accept(method.proto);
-  }
-
-  void accept(DexProto proto) {
-    accept(proto.returnType);
-    accept(proto.parameters);
-  }
-
-  void accept(DexTypeList types) {
-    for (DexType type : types.values) {
-      accept(type);
-    }
-  }
-
-  void accept(DexAnnotationSet annotationSet) {
-    for (DexAnnotation annotation : annotationSet.annotations) {
-      accept(annotation);
-    }
-  }
-
-  void accept(ParameterAnnotationsList parameterAnnotationsList) {
-    parameterAnnotationsList.forEachAnnotation(this::accept);
-  }
-
-  private void accept(DexAnnotation annotation) {
-    accept(annotation.annotation);
-  }
-
-  private void accept(DexEncodedAnnotation annotation) {
-    accept(annotation.type);
-    for (DexAnnotationElement element : annotation.elements) {
-      accept(element);
-    }
-  }
-
-  private void accept(DexAnnotationElement element) {
-    accept(element.value);
-  }
-
-  void accept(DexType type) {
-    if (type == null) {
-      return;
-    }
-    if (type.isPrimitiveType() || type.isVoidType() || type.isPrimitiveArrayType()) {
-      return;
-    }
-    if (type.isArrayType()) {
-      accept(type.toArrayElementType(factory));
-      return;
-    }
-    if (isLambdaType.test(type)) {
-      onLambdaType.accept(type);
-    }
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/ClassInitializerSourceCode.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/ClassInitializerSourceCode.java
deleted file mode 100644
index 0eec9af..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/ClassInitializerSourceCode.java
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda.kotlin;
-
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexTypeList;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
-import com.android.tools.r8.ir.code.Invoke.Type;
-import com.android.tools.r8.ir.code.Position;
-import com.android.tools.r8.ir.code.ValueType;
-import com.android.tools.r8.ir.conversion.IRBuilder;
-import com.android.tools.r8.ir.synthetic.SyntheticSourceCode;
-import com.google.common.collect.Lists;
-import java.util.List;
-
-final class ClassInitializerSourceCode extends SyntheticSourceCode {
-  private final DexItemFactory factory;
-  private final KotlinLambdaGroup group;
-
-  ClassInitializerSourceCode(
-      DexMethod method, DexItemFactory factory, KotlinLambdaGroup group, Position callerPosition) {
-    super(null, method, callerPosition);
-    assert method.proto.returnType == factory.voidType;
-    assert method.proto.parameters == DexTypeList.empty();
-    this.factory = factory;
-    this.group = group;
-  }
-
-  @Override
-  protected void prepareInstructions() {
-    DexType groupClassType = group.getGroupClassType();
-    DexMethod lambdaConstructorMethod = factory.createMethod(groupClassType,
-        factory.createProto(factory.voidType, factory.intType), factory.constructorMethodName);
-
-    int instance = nextRegister(ValueType.OBJECT);
-    int lambdaId = nextRegister(ValueType.INT);
-    List<ValueType> argTypes = Lists.newArrayList(ValueType.OBJECT, ValueType.INT);
-    List<Integer> argRegisters = Lists.newArrayList(instance, lambdaId);
-
-    group.forEachLambda(
-        info -> {
-          DexType lambda = info.clazz.type;
-          if (group.isSingletonLambda(lambda)) {
-            int id = group.lambdaId(lambda);
-            add(builder -> builder.addNewInstance(instance, groupClassType));
-            add(builder -> builder.addConst(TypeElement.getInt(), lambdaId, id));
-            add(
-                builder ->
-                    builder.addInvoke(
-                        Type.DIRECT,
-                        lambdaConstructorMethod,
-                        lambdaConstructorMethod.proto,
-                        argTypes,
-                        argRegisters,
-                        false /* isInterface*/));
-            add(
-                builder ->
-                    builder.addStaticPut(instance, group.getSingletonInstanceField(factory, id)));
-          }
-        });
-
-    assert this.nextInstructionIndex() > 0 : "no single field initialized";
-    add(IRBuilder::addReturn);
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/JStyleLambdaGroup.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/JStyleLambdaGroup.java
deleted file mode 100644
index 117ee3b..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/JStyleLambdaGroup.java
+++ /dev/null
@@ -1,238 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda.kotlin;
-
-import com.android.tools.r8.code.ReturnVoid;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
-import com.android.tools.r8.graph.AppView;
-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;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.EnclosingMethodAttribute;
-import com.android.tools.r8.graph.InnerClassAttribute;
-import com.android.tools.r8.ir.code.Invoke.Type;
-import com.android.tools.r8.ir.code.Position;
-import com.android.tools.r8.ir.code.ValueType;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroup;
-import com.android.tools.r8.ir.synthetic.SyntheticSourceCode;
-import com.android.tools.r8.kotlin.Kotlin;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.ThrowingConsumer;
-import com.google.common.collect.Lists;
-import java.util.List;
-import java.util.function.IntFunction;
-
-// Represents a j-style lambda group created to combine several lambda classes
-// generated by kotlin compiler for kotlin lambda expressions passed to java receivers,
-// like:
-//
-//      --- Java --------------------------------------------------------------
-//      public static void acceptString(Supplier<String> s) {
-//        // ...
-//      }
-//      -----------------------------------------------------------------------
-//      acceptString({ "A" })
-//      -----------------------------------------------------------------------
-//
-// Regular stateless j-style lambda class structure looks like below:
-// NOTE: stateless j-style lambdas do not always have INSTANCE field.
-//
-// -----------------------------------------------------------------------------------------------
-// signature <T:Ljava/lang/Object;>Ljava/lang/Object;
-//                    Ljava/util/function/Supplier<Ljava/lang/String;>;
-// final class lambdas/LambdasKt$foo$4 implements java/util/function/Supplier {
-//
-//     public synthetic bridge get()Ljava/lang/Object;
-//
-//     public final get()Ljava/lang/String;
-//       @Lorg/jetbrains/annotations/NotNull;() // invisible
-//
-//     <init>()V
-//
-//     public final static Llambdas/LambdasKt$foo$4; INSTANCE
-//
-//     static <clinit>()V
-//
-//     OUTERCLASS lambdas/LambdasKt foo (Ljava/lang/String;I)Lkotlin/jvm/functions/Function0;
-//     final static INNERCLASS lambdas/LambdasKt$foo$4 null null
-// }
-// -----------------------------------------------------------------------------------------------
-//
-// Regular stateful j-style lambda class structure looks like below:
-//
-// -----------------------------------------------------------------------------------------------
-// signature <T:Ljava/lang/Object;>
-//                Ljava/lang/Object;Ljava/util/function/Supplier<Ljava/lang/String;>;
-// declaration: lambdas/LambdasKt$foo$5<T> implements java.util.function.Supplier<java.lang.String>
-// final class lambdas/LambdasKt$foo$5 implements java/util/function/Supplier  {
-//
-//     public synthetic bridge get()Ljava/lang/Object;
-//
-//     public final get()Ljava/lang/String;
-//       @Lorg/jetbrains/annotations/NotNull;() // invisible
-//
-//     <init>(Ljava/lang/String;I)V
-//
-//     final synthetic Ljava/lang/String; $m
-//     final synthetic I $v
-//
-//     OUTERCLASS lambdas/LambdasKt foo (Ljava/lang/String;I)Lkotlin/jvm/functions/Function0;
-//     final static INNERCLASS lambdas/LambdasKt$foo$5 null null
-// }
-// -----------------------------------------------------------------------------------------------
-//
-// Key j-style lambda class details:
-//   - extends java.lang.Object
-//   - implements *any* functional interface (Kotlin does not seem to support scenarios when
-//     lambda can implement multiple interfaces).
-//   - lambda class is created as an anonymous inner class
-//   - lambda class carries generic signature and kotlin metadata attribute
-//   - class instance fields represent captured values and have an instance constructor
-//     with matching parameters initializing them (see the second class above)
-//   - stateless lambda *may* be implemented as a singleton with a static field storing the
-//     only instance and initialized in static class constructor (see the first class above)
-//   - main lambda method usually matches an exact lambda signature and may have
-//     generic signature attribute and nullability parameter annotations
-//   - optional bridge method created to satisfy interface implementation and
-//     forwarding call to lambda main method
-//
-final class JStyleLambdaGroup extends KotlinLambdaGroup {
-  private JStyleLambdaGroup(GroupId id) {
-    super(id);
-  }
-
-  @Override
-  protected ClassBuilder getBuilder(DexItemFactory factory, InternalOptions options) {
-    return new ClassBuilder(factory, options, "java-style lambda group");
-  }
-
-  @Override
-  public ThrowingConsumer<DexClass, LambdaStructureError> lambdaClassValidator(
-      Kotlin kotlin, AppInfoWithClassHierarchy appInfo) {
-    return new ClassValidator(kotlin, appInfo);
-  }
-
-  @Override
-  protected String getGroupSuffix() {
-    return "js$";
-  }
-
-  // Specialized group id.
-  final static class GroupId extends KotlinLambdaGroupId {
-    GroupId(
-        AppView<AppInfoWithLiveness> appView,
-        String capture,
-        DexType iface,
-        String pkg,
-        String signature,
-        DexEncodedMethod mainMethod,
-        InnerClassAttribute inner,
-        EnclosingMethodAttribute enclosing) {
-      super(appView, capture, iface, pkg, signature, mainMethod, inner, enclosing);
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-      return obj instanceof GroupId && computeEquals((KotlinLambdaGroupId) obj);
-    }
-
-    @Override
-    String getLambdaKindDescriptor() {
-      return "Kotlin j-style lambda group";
-    }
-
-    @Override
-    public LambdaGroup createGroup() {
-      return new JStyleLambdaGroup(this);
-    }
-  }
-
-  // Specialized class validator.
-  private class ClassValidator extends KotlinLambdaClassValidator {
-    ClassValidator(Kotlin kotlin, AppInfoWithClassHierarchy appInfo) {
-      super(kotlin, JStyleLambdaGroup.this, appInfo);
-    }
-
-    @Override
-    int getInstanceInitializerMaxSize(List<DexEncodedField> captures) {
-      return captures.size() + 2;
-    }
-
-    @Override
-    int validateInstanceInitializerEpilogue(
-        com.android.tools.r8.code.Instruction[] instructions, int index)
-        throws LambdaStructureError {
-      if (!(instructions[index] instanceof com.android.tools.r8.code.InvokeDirect
-              || instructions[index] instanceof com.android.tools.r8.code.InvokeDirectRange)
-          || instructions[index].getMethod() != kotlin.factory.objectMembers.constructor) {
-        throw structureError(LAMBDA_INIT_CODE_VERIFICATION_FAILED);
-      }
-      index++;
-      if (!(instructions[index] instanceof ReturnVoid)) {
-        throw structureError(LAMBDA_INIT_CODE_VERIFICATION_FAILED);
-      }
-      return index + 1;
-    }
-  }
-
-  // Specialized class builder.
-  private final class ClassBuilder extends KotlinLambdaGroupClassBuilder<JStyleLambdaGroup> {
-    ClassBuilder(DexItemFactory factory, InternalOptions options, String origin) {
-      super(JStyleLambdaGroup.this, factory, options, origin);
-    }
-
-    @Override
-    protected DexType getSuperClassType() {
-      return factory.objectType;
-    }
-
-    @Override
-    SyntheticSourceCode createInstanceInitializerSourceCode(
-        DexType groupClassType, DexMethod initializerMethod, Position callerPosition) {
-      return new InstanceInitializerSourceCode(
-          factory,
-          groupClassType,
-          group.getLambdaIdField(factory),
-          id -> group.getCaptureField(factory, id),
-          initializerMethod,
-          callerPosition);
-    }
-  }
-
-  // Specialized instance initializer code.
-  private static final class InstanceInitializerSourceCode
-      extends KotlinInstanceInitializerSourceCode {
-    private final DexMethod objectInitializer;
-
-    InstanceInitializerSourceCode(
-        DexItemFactory factory,
-        DexType lambdaGroupType,
-        DexField idField,
-        IntFunction<DexField> fieldGenerator,
-        DexMethod method,
-        Position callerPosition) {
-      super(lambdaGroupType, idField, fieldGenerator, method, callerPosition);
-      this.objectInitializer = factory.objectMembers.constructor;
-    }
-
-    @Override
-    void prepareSuperConstructorCall(int receiverRegister) {
-      add(
-          builder ->
-              builder.addInvoke(
-                  Type.DIRECT,
-                  objectInitializer,
-                  objectInitializer.proto,
-                  Lists.newArrayList(ValueType.OBJECT),
-                  Lists.newArrayList(receiverRegister),
-                  false /* isInterface */));
-    }
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/JStyleLambdaGroupIdFactory.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/JStyleLambdaGroupIdFactory.java
deleted file mode 100644
index df72677..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/JStyleLambdaGroupIdFactory.java
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda.kotlin;
-
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.ClassAccessFlags;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.InnerClassAttribute;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroup.LambdaStructureError;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroupId;
-import com.android.tools.r8.kotlin.Kotlin;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
-
-public final class JStyleLambdaGroupIdFactory extends KotlinLambdaGroupIdFactory {
-  private static final JStyleLambdaGroupIdFactory INSTANCE = new JStyleLambdaGroupIdFactory();
-
-  private JStyleLambdaGroupIdFactory() {}
-
-  public static JStyleLambdaGroupIdFactory getInstance() {
-    return INSTANCE;
-  }
-
-  @Override
-  public LambdaGroupId validateAndCreate(
-      AppView<AppInfoWithLiveness> appView, Kotlin kotlin, DexClass lambda)
-      throws LambdaStructureError {
-    boolean accessRelaxed =
-        appView.options().getProguardConfiguration().isAccessModificationAllowed();
-
-    // Ignore ACC_SUPER.
-    ClassAccessFlags copy = lambda.accessFlags.copy();
-    copy.unsetSuper();
-    checkAccessFlags("class access flags", copy, PUBLIC_LAMBDA_CLASS_FLAGS, LAMBDA_CLASS_FLAGS);
-
-    // Class and interface.
-    validateSuperclass(kotlin, lambda);
-    DexType iface = validateInterfaces(kotlin, lambda);
-
-    validateStaticFields(kotlin, lambda);
-    String captureSignature = validateInstanceFields(lambda, accessRelaxed);
-    validateDirectMethods(lambda);
-    DexEncodedMethod mainMethod = validateVirtualMethods(lambda);
-    String genericSignature = validateAnnotations(appView, kotlin, lambda);
-    InnerClassAttribute innerClass = validateInnerClasses(lambda);
-
-    return new JStyleLambdaGroup.GroupId(
-        appView,
-        captureSignature,
-        iface,
-        accessRelaxed ? "" : lambda.type.getPackageDescriptor(),
-        genericSignature,
-        mainMethod,
-        innerClass,
-        lambda.getEnclosingMethodAttribute());
-  }
-
-  @Override
-  void validateSuperclass(Kotlin kotlin, DexClass lambda) throws LambdaStructureError {
-    if (lambda.superType != kotlin.factory.objectType) {
-      throw new LambdaStructureError("implements " + lambda.superType.toSourceString() +
-          " instead of java.lang.Object");
-    }
-  }
-
-  @Override
-  DexType validateInterfaces(Kotlin kotlin, DexClass lambda) throws LambdaStructureError {
-    if (lambda.interfaces.size() == 0) {
-      throw new LambdaStructureError("does not implement any interfaces");
-    }
-    if (lambda.interfaces.size() > 1) {
-      throw new LambdaStructureError(
-          "implements more than one interface: " + lambda.interfaces.size());
-    }
-
-    // We don't validate that the interface is actually a functional interface,
-    // since it may be desugared, or optimized in any other way which should not
-    // affect lambda class merging.
-    return lambda.interfaces.values[0];
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KStyleLambdaGroup.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KStyleLambdaGroup.java
deleted file mode 100644
index cfae611..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KStyleLambdaGroup.java
+++ /dev/null
@@ -1,256 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda.kotlin;
-
-import com.android.tools.r8.code.Const16;
-import com.android.tools.r8.code.Const4;
-import com.android.tools.r8.code.ReturnVoid;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
-import com.android.tools.r8.graph.AppView;
-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;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.EnclosingMethodAttribute;
-import com.android.tools.r8.graph.InnerClassAttribute;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
-import com.android.tools.r8.ir.code.Invoke.Type;
-import com.android.tools.r8.ir.code.Position;
-import com.android.tools.r8.ir.code.ValueType;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroup;
-import com.android.tools.r8.ir.synthetic.SyntheticSourceCode;
-import com.android.tools.r8.kotlin.Kotlin;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.ThrowingConsumer;
-import com.google.common.collect.Lists;
-import java.util.List;
-import java.util.function.IntFunction;
-
-// Represents a k-style lambda group created to combine several lambda classes
-// generated by kotlin compiler for regular kotlin lambda expressions, like:
-//
-//      -----------------------------------------------------------------------
-//      fun foo(m: String, v: Int): () -> String {
-//        val lambda: (String, Int) -> String = { s, i -> s.substring(i) }
-//        return { "$m: $v" }
-//      }
-//      -----------------------------------------------------------------------
-//
-// Regular stateless k-style lambda class structure looks like below:
-// NOTE: stateless k-style lambdas do not always have INSTANCE field.
-//
-// -----------------------------------------------------------------------------------------------
-// // signature Lkotlin/jvm/internal/Lambda;Lkotlin/jvm/functions/Function2<
-//                          Ljava/lang/String;Ljava/lang/Integer;Ljava/lang/String;>;
-// final class lambdas/LambdasKt$foo$lambda1$1
-//                  extends kotlin/jvm/internal/Lambda
-//                  implements kotlin/jvm/functions/Function2  {
-//
-//     public synthetic bridge invoke(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-//
-//     public final invoke(Ljava/lang/String;I)Ljava/lang/String;
-//       @Lorg/jetbrains/annotations/NotNull;() // invisible
-//         @Lorg/jetbrains/annotations/NotNull;() // invisible, parameter 0
-//
-//     <init>()V
-//
-//     public final static Llambdas/LambdasKt$foo$lambda1$1; INSTANCE
-//
-//     static <clinit>()V
-//
-//     OUTERCLASS lambdas/LambdasKt foo (Ljava/lang/String;I)Lkotlin/jvm/functions/Function0;
-//     final static INNERCLASS lambdas/LambdasKt$foo$lambda1$1 null null
-// }
-// -----------------------------------------------------------------------------------------------
-//
-// Regular stateful k-style lambda class structure looks like below:
-//
-// -----------------------------------------------------------------------------------------------
-// // signature Lkotlin/jvm/internal/Lambda;Lkotlin/jvm/functions/Function0<Ljava/lang/String;>;
-// final class lambdas/LambdasKt$foo$1
-//                  extends kotlin/jvm/internal/Lambda
-//                  implements kotlin/jvm/functions/Function0  {
-//
-//     public synthetic bridge invoke()Ljava/lang/Object;
-//
-//     public final invoke()Ljava/lang/String;
-//       @Lorg/jetbrains/annotations/NotNull;() // invisible
-//
-//     <init>(Ljava/lang/String;I)V
-//
-//     final synthetic Ljava/lang/String; $m
-//     final synthetic I $v
-//
-//     OUTERCLASS lambdas/LambdasKt foo (Ljava/lang/String;I)Lkotlin/jvm/functions/Function0;
-//     final static INNERCLASS lambdas/LambdasKt$foo$1 null null
-// }
-// -----------------------------------------------------------------------------------------------
-//
-// Key k-style lambda class details:
-//   - extends kotlin.jvm.internal.Lambda
-//   - implements one of kotlin.jvm.functions.Function0..Function22, or FunctionN
-//     see: https://github.com/JetBrains/kotlin/blob/master/libraries/
-//                  stdlib/jvm/runtime/kotlin/jvm/functions/Functions.kt
-//     and: https://github.com/JetBrains/kotlin/blob/master/spec-docs/function-types.md
-//   - lambda class is created as an anonymous inner class
-//   - lambda class carries generic signature and kotlin metadata attribute
-//   - class instance fields represent captured values and have an instance constructor
-//     with matching parameters initializing them (see the second class above)
-//   - stateless lambda *may* be  implemented as a singleton with a static field storing the
-//     only instance and initialized in static class constructor (see the first class above)
-//   - main lambda method usually matches an exact lambda signature and may have
-//     generic signature attribute and nullability parameter annotations
-//   - optional bridge method created to satisfy interface implementation and
-//     forwarding call to lambda main method
-//
-final class KStyleLambdaGroup extends KotlinLambdaGroup {
-  private KStyleLambdaGroup(GroupId id) {
-    super(id);
-  }
-
-  @Override
-  protected ClassBuilder getBuilder(DexItemFactory factory, InternalOptions options) {
-    return new ClassBuilder(factory, options, "kotlin-style lambda group");
-  }
-
-  @Override
-  public ThrowingConsumer<DexClass, LambdaStructureError> lambdaClassValidator(
-      Kotlin kotlin, AppInfoWithClassHierarchy appInfo) {
-    return new ClassValidator(kotlin, appInfo);
-  }
-
-  @Override
-  protected String getGroupSuffix() {
-    return "ks$";
-  }
-
-  // Specialized group id.
-  final static class GroupId extends KotlinLambdaGroupId {
-    GroupId(
-        AppView<AppInfoWithLiveness> appView,
-        String capture,
-        DexType iface,
-        String pkg,
-        String signature,
-        DexEncodedMethod mainMethod,
-        InnerClassAttribute inner,
-        EnclosingMethodAttribute enclosing) {
-      super(appView, capture, iface, pkg, signature, mainMethod, inner, enclosing);
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-      return obj instanceof GroupId && computeEquals((KotlinLambdaGroupId) obj);
-    }
-
-    @Override
-    String getLambdaKindDescriptor() {
-      return "Kotlin k-style lambda group";
-    }
-
-    @Override
-    public LambdaGroup createGroup() {
-      return new KStyleLambdaGroup(this);
-    }
-  }
-
-  // Specialized class validator.
-  private final class ClassValidator extends KotlinLambdaClassValidator {
-    ClassValidator(Kotlin kotlin, AppInfoWithClassHierarchy appInfo) {
-      super(kotlin, KStyleLambdaGroup.this, appInfo);
-    }
-
-    @Override
-    int getInstanceInitializerMaxSize(List<DexEncodedField> captures) {
-      return captures.size() + 3;
-    }
-
-    @Override
-    int validateInstanceInitializerEpilogue(
-        com.android.tools.r8.code.Instruction[] instructions, int index)
-        throws LambdaStructureError {
-      if (!(instructions[index] instanceof Const4) &&
-          !(instructions[index] instanceof Const16)) {
-        throw structureError(LAMBDA_INIT_CODE_VERIFICATION_FAILED);
-      }
-      index++;
-      if (!(instructions[index] instanceof com.android.tools.r8.code.InvokeDirect
-              || instructions[index] instanceof com.android.tools.r8.code.InvokeDirectRange)
-          || instructions[index].getMethod() != kotlin.functional.lambdaInitializerMethod) {
-        throw structureError(LAMBDA_INIT_CODE_VERIFICATION_FAILED);
-      }
-      index++;
-      if (!(instructions[index] instanceof ReturnVoid)) {
-        throw structureError(LAMBDA_INIT_CODE_VERIFICATION_FAILED);
-      }
-      return index + 1;
-    }
-  }
-
-  // Specialized class builder.
-  private final class ClassBuilder extends KotlinLambdaGroupClassBuilder<KStyleLambdaGroup> {
-    ClassBuilder(DexItemFactory factory, InternalOptions options, String origin) {
-      super(KStyleLambdaGroup.this, factory, options, origin);
-    }
-
-    @Override
-    protected DexType getSuperClassType() {
-      return factory.kotlin.functional.lambdaType;
-    }
-
-    @Override
-    SyntheticSourceCode createInstanceInitializerSourceCode(
-        DexType groupClassType, DexMethod initializerMethod, Position callerPosition) {
-      return new InstanceInitializerSourceCode(
-          factory,
-          groupClassType,
-          group.getLambdaIdField(factory),
-          id -> group.getCaptureField(factory, id),
-          initializerMethod,
-          factory.kotlin.functional.getArity(id.iface),
-          callerPosition);
-    }
-  }
-
-  // Specialized instance initializer code.
-  private final static class InstanceInitializerSourceCode
-      extends KotlinInstanceInitializerSourceCode {
-    private final int arity;
-    private final DexMethod lambdaInitializer;
-
-    InstanceInitializerSourceCode(
-        DexItemFactory factory,
-        DexType lambdaGroupType,
-        DexField idField,
-        IntFunction<DexField> fieldGenerator,
-        DexMethod method,
-        int arity,
-        Position callerPosition) {
-      super(lambdaGroupType, idField, fieldGenerator, method, callerPosition);
-      this.arity = arity;
-      this.lambdaInitializer = factory.createMethod(factory.kotlin.functional.lambdaType,
-          factory.createProto(factory.voidType, factory.intType), factory.constructorMethodName);
-    }
-
-    @Override
-    void prepareSuperConstructorCall(int receiverRegister) {
-      int arityRegister = nextRegister(ValueType.INT);
-      add(builder -> builder.addConst(TypeElement.getInt(), arityRegister, arity));
-      add(
-          builder ->
-              builder.addInvoke(
-                  Type.DIRECT,
-                  lambdaInitializer,
-                  lambdaInitializer.proto,
-                  Lists.newArrayList(ValueType.OBJECT, ValueType.INT),
-                  Lists.newArrayList(receiverRegister, arityRegister),
-                  false /* isInterface */));
-    }
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KStyleLambdaGroupIdFactory.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KStyleLambdaGroupIdFactory.java
deleted file mode 100644
index cc212bf..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KStyleLambdaGroupIdFactory.java
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda.kotlin;
-
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.ClassAccessFlags;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.InnerClassAttribute;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroup.LambdaStructureError;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroupId;
-import com.android.tools.r8.kotlin.Kotlin;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
-
-public final class KStyleLambdaGroupIdFactory extends KotlinLambdaGroupIdFactory {
-  private static final KStyleLambdaGroupIdFactory INSTANCE = new KStyleLambdaGroupIdFactory();
-
-  private KStyleLambdaGroupIdFactory() {}
-
-  public static KStyleLambdaGroupIdFactory getInstance() {
-    return INSTANCE;
-  }
-
-  @Override
-  public LambdaGroupId validateAndCreate(
-      AppView<AppInfoWithLiveness> appView, Kotlin kotlin, DexClass lambda)
-      throws LambdaStructureError {
-    boolean accessRelaxed =
-        appView.options().getProguardConfiguration().isAccessModificationAllowed();
-
-    // Ignore ACC_SUPER.
-    ClassAccessFlags copy = lambda.accessFlags.copy();
-    copy.unsetSuper();
-    checkAccessFlags("class access flags", copy, PUBLIC_LAMBDA_CLASS_FLAGS, LAMBDA_CLASS_FLAGS);
-
-    // Class and interface.
-    validateSuperclass(kotlin, lambda);
-    DexType iface = validateInterfaces(kotlin, lambda);
-
-    validateStaticFields(kotlin, lambda);
-    String captureSignature = validateInstanceFields(lambda, accessRelaxed);
-    validateDirectMethods(lambda);
-    DexEncodedMethod mainMethod = validateVirtualMethods(lambda);
-    String genericSignature = validateAnnotations(appView, kotlin, lambda);
-    InnerClassAttribute innerClass = validateInnerClasses(lambda);
-
-    return new KStyleLambdaGroup.GroupId(
-        appView,
-        captureSignature,
-        iface,
-        accessRelaxed ? "" : lambda.type.getPackageDescriptor(),
-        genericSignature,
-        mainMethod,
-        innerClass,
-        lambda.getEnclosingMethodAttribute());
-  }
-
-  @Override
-  void validateSuperclass(Kotlin kotlin, DexClass lambda) throws LambdaStructureError {
-    if (lambda.superType != kotlin.functional.lambdaType) {
-      throw new LambdaStructureError("implements " + lambda.superType.toSourceString() +
-          " instead of kotlin.jvm.internal.Lambda");
-    }
-  }
-
-  @Override
-  DexType validateInterfaces(Kotlin kotlin, DexClass lambda) throws LambdaStructureError {
-    if (lambda.interfaces.size() == 0) {
-      throw new LambdaStructureError("does not implement any interfaces");
-    }
-    if (lambda.interfaces.size() > 1) {
-      throw new LambdaStructureError(
-          "implements more than one interface: " + lambda.interfaces.size());
-    }
-    DexType iface = lambda.interfaces.values[0];
-    if (!kotlin.functional.isFunctionInterface(iface)) {
-      throw new LambdaStructureError("implements " + iface.toSourceString() +
-          " instead of kotlin functional interface.");
-    }
-    return iface;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinInstanceInitializerSourceCode.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinInstanceInitializerSourceCode.java
deleted file mode 100644
index 687b081..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinInstanceInitializerSourceCode.java
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda.kotlin;
-
-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.ir.code.Position;
-import com.android.tools.r8.ir.conversion.IRBuilder;
-import com.android.tools.r8.ir.synthetic.SyntheticSourceCode;
-import java.util.function.IntFunction;
-
-abstract class KotlinInstanceInitializerSourceCode extends SyntheticSourceCode {
-  private final DexField idField;
-  private final IntFunction<DexField> fieldGenerator;
-
-  KotlinInstanceInitializerSourceCode(
-      DexType lambdaGroupType,
-      DexField idField,
-      IntFunction<DexField> fieldGenerator,
-      DexMethod method,
-      Position callerPosition) {
-    super(lambdaGroupType, method, callerPosition);
-    this.idField = idField;
-    this.fieldGenerator = fieldGenerator;
-  }
-
-  @Override
-  protected void prepareInstructions() {
-    int receiverRegister = getReceiverRegister();
-
-    // Initialize lambda id field.
-    add(builder -> builder.addInstancePut(getParamRegister(0), receiverRegister, idField));
-
-    // Initialize capture values.
-    DexType[] values = proto.parameters.values;
-    for (int i = 1; i < values.length; i++) {
-      int index = i;
-      add(builder -> builder.addInstancePut(
-          getParamRegister(index), receiverRegister, fieldGenerator.apply(index - 1)));
-    }
-
-    // Call superclass constructor.
-    prepareSuperConstructorCall(receiverRegister);
-
-    add(IRBuilder::addReturn);
-  }
-
-  abstract void prepareSuperConstructorCall(int receiverRegister);
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaClassValidator.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaClassValidator.java
deleted file mode 100644
index a956f84..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaClassValidator.java
+++ /dev/null
@@ -1,267 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda.kotlin;
-
-import com.android.tools.r8.code.Format22c;
-import com.android.tools.r8.code.Instruction;
-import com.android.tools.r8.code.Iput;
-import com.android.tools.r8.code.IputBoolean;
-import com.android.tools.r8.code.IputByte;
-import com.android.tools.r8.code.IputChar;
-import com.android.tools.r8.code.IputObject;
-import com.android.tools.r8.code.IputShort;
-import com.android.tools.r8.code.IputWide;
-import com.android.tools.r8.code.ReturnVoid;
-import com.android.tools.r8.code.SputObject;
-import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
-import com.android.tools.r8.graph.Code;
-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;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.optimize.Inliner.Reason;
-import com.android.tools.r8.ir.optimize.inliner.NopWhyAreYouNotInliningReporter;
-import com.android.tools.r8.ir.optimize.inliner.WhyAreYouNotInliningReporter;
-import com.android.tools.r8.ir.optimize.lambda.CaptureSignature;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroup.LambdaStructureError;
-import com.android.tools.r8.kotlin.Kotlin;
-import com.android.tools.r8.utils.ThrowingConsumer;
-import java.util.List;
-
-// Encapsulates the logic of deep-checking of the lambda class assumptions.
-//
-// For k- and j-style lambdas we only check the code of class and instance
-// initializers to ensure that their code performs no unexpected actions:
-//
-//  (a) Class initializer is only present for stateless lambdas and does
-//      nothing expect instantiating the instance and storing it in
-//      static instance field.
-//
-//  (b) Instance initializers stores all captured values in proper capture
-//      fields and calls the super constructor passing arity to it.
-abstract class KotlinLambdaClassValidator
-    implements ThrowingConsumer<DexClass, LambdaStructureError> {
-
-  static final String LAMBDA_INIT_CODE_VERIFICATION_FAILED =
-      "instance initializer code verification failed";
-  private static final String LAMBDA_CLINIT_CODE_VERIFICATION_FAILED =
-      "static initializer code verification failed";
-
-  final Kotlin kotlin;
-  private final KotlinLambdaGroup group;
-  private final AppInfoWithClassHierarchy appInfo;
-
-  KotlinLambdaClassValidator(
-      Kotlin kotlin, KotlinLambdaGroup group, AppInfoWithClassHierarchy appInfo) {
-    this.kotlin = kotlin;
-    this.group = group;
-    this.appInfo = appInfo;
-  }
-
-  // Report a structure error.
-  final LambdaStructureError structureError(String s) {
-    return new LambdaStructureError(s, false);
-  }
-
-  @Override
-  public void accept(DexClass lambda) throws LambdaStructureError {
-    if (!CaptureSignature.getCaptureSignature(lambda.instanceFields()).equals(group.id().capture)) {
-      throw structureError("capture signature was modified");
-    }
-
-    DexEncodedMethod classInitializer = null;
-    DexEncodedMethod instanceInitializer = null;
-    for (DexEncodedMethod method : lambda.directMethods()) {
-      // We only check bodies of class and instance initializers since we don't expect to
-      // see any static or private methods and all virtual methods will be translated into
-      // same methods dispatching on lambda id to proper code.
-      if (method.isClassInitializer()) {
-        Code code = method.getCode();
-        if (!(group.isStateless() && group.isSingletonLambda(lambda.type))) {
-          throw structureError("static initializer on non-singleton lambda");
-        }
-        if (classInitializer != null || code == null || !code.isDexCode()) {
-          throw structureError(LAMBDA_CLINIT_CODE_VERIFICATION_FAILED);
-        }
-        validateStatelessLambdaClassInitializer(lambda, code.asDexCode());
-        classInitializer = method;
-
-      } else if (method.isInstanceInitializer()) {
-        Code code = method.getCode();
-        if (instanceInitializer != null || code == null || !code.isDexCode()) {
-          throw structureError(LAMBDA_INIT_CODE_VERIFICATION_FAILED);
-        }
-        validateInstanceInitializer(lambda, code.asDexCode());
-        instanceInitializer = method;
-      }
-    }
-
-    if (group.isStateless() && group.isSingletonLambda(lambda.type) && (classInitializer == null)) {
-      throw structureError("missing static initializer on singleton lambda");
-    }
-
-    // This check is actually not required for lambda class merging, we only have to do
-    // this because group class method composition piggybacks on inlining which has
-    // assertions checking when we can inline force-inlined methods. So we double-check
-    // these assertion never triggers.
-    //
-    // NOTE: the real type name for lambda group class is not generated yet, but we
-    //       can safely use a fake one here.
-    DexType fakeLambdaGroupType = kotlin.factory.createType(
-        "L" + group.getTypePackage() + "-$$LambdaGroup$XXXX;");
-    WhyAreYouNotInliningReporter whyAreYouNotInliningReporter =
-        NopWhyAreYouNotInliningReporter.getInstance();
-    for (DexEncodedMethod method : lambda.virtualMethods()) {
-      if (!method.isInliningCandidate(
-          fakeLambdaGroupType, Reason.SIMPLE, appInfo, whyAreYouNotInliningReporter)) {
-        throw structureError("method " + method.method.toSourceString() +
-            " is not inline-able into lambda group class");
-      }
-    }
-  }
-
-  abstract int getInstanceInitializerMaxSize(List<DexEncodedField> captures);
-
-  abstract int validateInstanceInitializerEpilogue(
-      com.android.tools.r8.code.Instruction[] instructions, int index) throws LambdaStructureError;
-
-  private void validateInstanceInitializer(DexClass lambda, Code code)
-      throws LambdaStructureError {
-    List<DexEncodedField> captures = lambda.instanceFields();
-    com.android.tools.r8.code.Instruction[] instructions = code.asDexCode().instructions;
-    int index = 0;
-
-    if (instructions.length > getInstanceInitializerMaxSize(captures)) {
-      throw structureError(LAMBDA_INIT_CODE_VERIFICATION_FAILED);
-    }
-
-    // Capture field assignments: go through captured fields in assumed order
-    // and ensure they are assigned values from appropriate parameters.
-    index = validateInstanceInitializerParameterMapping(captures, instructions, index);
-
-    // Check the constructor epilogue: a call to superclass constructor.
-    index = validateInstanceInitializerEpilogue(instructions, index);
-    assert index == instructions.length;
-  }
-
-  private int validateInstanceInitializerParameterMapping(
-      List<DexEncodedField> captures, Instruction[] instructions, int index)
-      throws LambdaStructureError {
-    int dead = 0;
-    int wideFieldsSeen = 0;
-    for (DexEncodedField field : captures) {
-      if (field.getOptimizationInfo().isDead()) {
-        dead++;
-        continue;
-      }
-      switch (field.field.type.toShorty()) {
-        case 'Z':
-          if (!(instructions[index] instanceof IputBoolean)
-              || (instructions[index].getField() != field.field)
-              || (((Format22c) instructions[index]).A != (index + 1 + dead + wideFieldsSeen))) {
-            throw structureError(LAMBDA_INIT_CODE_VERIFICATION_FAILED);
-          }
-          break;
-
-        case 'B':
-          if (!(instructions[index] instanceof IputByte)
-              || (instructions[index].getField() != field.field)
-              || (((Format22c) instructions[index]).A != (index + 1 + dead + wideFieldsSeen))) {
-            throw structureError(LAMBDA_INIT_CODE_VERIFICATION_FAILED);
-          }
-          break;
-
-        case 'S':
-          if (!(instructions[index] instanceof IputShort)
-              || (instructions[index].getField() != field.field)
-              || (((Format22c) instructions[index]).A != (index + 1 + dead + wideFieldsSeen))) {
-            throw structureError(LAMBDA_INIT_CODE_VERIFICATION_FAILED);
-          }
-          break;
-
-        case 'C':
-          if (!(instructions[index] instanceof IputChar)
-              || (instructions[index].getField() != field.field)
-              || (((Format22c) instructions[index]).A != (index + 1 + dead + wideFieldsSeen))) {
-            throw structureError(LAMBDA_INIT_CODE_VERIFICATION_FAILED);
-          }
-          break;
-
-        case 'I':
-        case 'F':
-          if (!(instructions[index] instanceof Iput)
-              || (instructions[index].getField() != field.field)
-              || (((Format22c) instructions[index]).A != (index + 1 + dead + wideFieldsSeen))) {
-            throw structureError(LAMBDA_INIT_CODE_VERIFICATION_FAILED);
-          }
-          break;
-
-        case 'J':
-        case 'D':
-          if (!(instructions[index] instanceof IputWide)
-              || (instructions[index].getField() != field.field)
-              || (((Format22c) instructions[index]).A != (index + 1 + dead + wideFieldsSeen))) {
-            throw structureError(LAMBDA_INIT_CODE_VERIFICATION_FAILED);
-          }
-          wideFieldsSeen++;
-          break;
-
-        case 'L':
-          if (!(instructions[index] instanceof IputObject)
-              || (instructions[index].getField() != field.field)
-              || (((Format22c) instructions[index]).A != (index + 1 + dead + wideFieldsSeen))) {
-            throw structureError(LAMBDA_INIT_CODE_VERIFICATION_FAILED);
-          }
-          break;
-
-        default:
-          throw new Unreachable();
-      }
-      index++;
-    }
-    return index;
-  }
-
-  private void validateStatelessLambdaClassInitializer(DexClass lambda, Code code)
-      throws LambdaStructureError {
-    assert group.isStateless() && group.isSingletonLambda(lambda.type);
-    com.android.tools.r8.code.Instruction[] instructions = code.asDexCode().instructions;
-    if (instructions.length != 4) {
-      throw structureError(LAMBDA_CLINIT_CODE_VERIFICATION_FAILED);
-    }
-    if (!(instructions[0] instanceof com.android.tools.r8.code.NewInstance)
-        || ((com.android.tools.r8.code.NewInstance) instructions[0]).getType() != lambda.type) {
-      throw structureError(LAMBDA_CLINIT_CODE_VERIFICATION_FAILED);
-    }
-    if (!(instructions[1] instanceof com.android.tools.r8.code.InvokeDirect
-            || instructions[1] instanceof com.android.tools.r8.code.InvokeDirectRange)
-        || !isLambdaInitializerMethod(lambda, instructions[1].getMethod())) {
-      throw structureError(LAMBDA_CLINIT_CODE_VERIFICATION_FAILED);
-    }
-    if (!(instructions[2] instanceof SputObject)
-        || !isLambdaSingletonField(lambda, instructions[2].getField())) {
-      throw structureError(LAMBDA_CLINIT_CODE_VERIFICATION_FAILED);
-    }
-    if (!(instructions[3] instanceof ReturnVoid)) {
-      throw structureError(LAMBDA_CLINIT_CODE_VERIFICATION_FAILED);
-    }
-  }
-
-  private boolean isLambdaSingletonField(DexClass lambda, DexField field) {
-    return field.type == lambda.type
-        && field.holder == lambda.type
-        && field.name == kotlin.functional.kotlinStyleLambdaInstanceName;
-  }
-
-  private boolean isLambdaInitializerMethod(DexClass holder, DexMethod method) {
-    return method.holder == holder.type
-        && method.name == kotlin.factory.constructorMethodName
-        && method.proto.parameters.isEmpty()
-        && method.proto.returnType == kotlin.factory.voidType;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaConstants.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaConstants.java
deleted file mode 100644
index 9ac5ca7..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaConstants.java
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda.kotlin;
-
-import com.android.tools.r8.dex.Constants;
-import com.android.tools.r8.graph.ClassAccessFlags;
-import com.android.tools.r8.graph.FieldAccessFlags;
-import com.android.tools.r8.graph.MethodAccessFlags;
-
-interface KotlinLambdaConstants {
-  // Default lambda class flags.
-  ClassAccessFlags LAMBDA_CLASS_FLAGS =
-      ClassAccessFlags.fromDexAccessFlags(Constants.ACC_FINAL);
-  // Access-relaxed lambda class flags.
-  ClassAccessFlags PUBLIC_LAMBDA_CLASS_FLAGS =
-      ClassAccessFlags.fromDexAccessFlags(Constants.ACC_PUBLIC + Constants.ACC_FINAL);
-
-  // Default lambda class initializer flags.
-  MethodAccessFlags CLASS_INITIALIZER_FLAGS =
-      MethodAccessFlags.fromSharedAccessFlags(Constants.ACC_STATIC, true);
-  // Default lambda class constructor flags.
-  MethodAccessFlags CONSTRUCTOR_FLAGS =
-      MethodAccessFlags.fromSharedAccessFlags(0, true);
-  // Access-relaxed lambda class constructor flags.
-  MethodAccessFlags CONSTRUCTOR_FLAGS_RELAXED =
-      MethodAccessFlags.fromSharedAccessFlags(Constants.ACC_PUBLIC, true);
-
-  // Default main lambda method flags.
-  MethodAccessFlags MAIN_METHOD_FLAGS =
-      MethodAccessFlags.fromSharedAccessFlags(
-          Constants.ACC_PUBLIC + Constants.ACC_FINAL, false);
-  // Default bridge lambda method flags.
-  MethodAccessFlags BRIDGE_METHOD_FLAGS =
-      MethodAccessFlags.fromSharedAccessFlags(
-          Constants.ACC_PUBLIC + Constants.ACC_SYNTHETIC + Constants.ACC_BRIDGE, false);
-  // Bridge lambda method flags after inliner.
-  MethodAccessFlags BRIDGE_METHOD_FLAGS_FIXED =
-      MethodAccessFlags.fromSharedAccessFlags(Constants.ACC_PUBLIC, false);
-
-  // Default singleton instance folding field flags.
-  FieldAccessFlags SINGLETON_FIELD_FLAGS =
-      FieldAccessFlags.fromSharedAccessFlags(
-          Constants.ACC_PUBLIC + Constants.ACC_STATIC + Constants.ACC_FINAL);
-  // Default instance (lambda capture) field flags.
-  FieldAccessFlags CAPTURE_FIELD_FLAGS =
-      FieldAccessFlags.fromSharedAccessFlags(
-          Constants.ACC_FINAL + Constants.ACC_SYNTHETIC);
-  // access-relaxed instance (lambda capture) field flags.
-  FieldAccessFlags CAPTURE_FIELD_FLAGS_RELAXED =
-      FieldAccessFlags.fromSharedAccessFlags(
-          Constants.ACC_PUBLIC + Constants.ACC_FINAL + Constants.ACC_SYNTHETIC);
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroup.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroup.java
deleted file mode 100644
index fc3f2bd..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroup.java
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda.kotlin;
-
-import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexProto;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.optimize.lambda.CaptureSignature;
-import com.android.tools.r8.ir.optimize.lambda.CodeProcessor.Strategy;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroup;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroupId;
-
-// Represents a lambda group created to combine several lambda classes generated
-// by kotlin compiler for either regular kotlin lambda expressions (k-style lambdas)
-// or lambda expressions created to implement java SAM interface.
-abstract class KotlinLambdaGroup extends LambdaGroup {
-  private final Strategy strategy = new KotlinLambdaGroupCodeStrategy(this);
-
-  KotlinLambdaGroup(LambdaGroupId id) {
-    super(id);
-  }
-
-  final KotlinLambdaGroupId id() {
-    return (KotlinLambdaGroupId) id;
-  }
-
-  final boolean isStateless() {
-    return id().capture.isEmpty();
-  }
-
-  final boolean hasAnySingletons() {
-    assert isStateless();
-    return anyLambda(info -> this.isSingletonLambda(info.clazz.type));
-  }
-
-  final boolean isSingletonLambda(DexType lambda) {
-    assert isStateless();
-    return lambdaSingletonField(lambda) != null;
-  }
-
-  // Field referencing singleton instance for a lambda with specified id.
-  final DexField getSingletonInstanceField(DexItemFactory factory, int id) {
-    return factory.createField(this.getGroupClassType(),
-        this.getGroupClassType(), factory.createString("INSTANCE$" + id));
-  }
-
-  @Override
-  protected String getTypePackage() {
-    String pkg = id().pkg;
-    return pkg.isEmpty() ? "" : (pkg + "/");
-  }
-
-  final DexProto createConstructorProto(DexItemFactory factory) {
-    String capture = id().capture;
-    DexType[] newParameters = new DexType[capture.length() + 1];
-    newParameters[0] = factory.intType; // Lambda id.
-    for (int i = 0; i < capture.length(); i++) {
-      newParameters[i + 1] = CaptureSignature.fieldType(factory, capture, i);
-    }
-    return factory.createProto(factory.voidType, newParameters);
-  }
-
-  final DexField getLambdaIdField(DexItemFactory factory) {
-    return factory.createField(this.getGroupClassType(), factory.intType, "$id$");
-  }
-
-  final int mapFieldIntoCaptureIndex(DexType lambda, DexField field) {
-    return CaptureSignature.mapFieldIntoCaptureIndex(
-        id().capture, lambdaCaptureFields(lambda), field);
-  }
-
-  final DexField getCaptureField(DexItemFactory factory, int index) {
-    assert index >= 0 && index < id().capture.length();
-    return factory.createField(this.getGroupClassType(),
-        CaptureSignature.fieldType(factory, id().capture, index), "$capture$" + index);
-  }
-
-  @Override
-  public Strategy getCodeStrategy() {
-    return strategy;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupClassBuilder.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupClassBuilder.java
deleted file mode 100644
index 977bdcf..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupClassBuilder.java
+++ /dev/null
@@ -1,354 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda.kotlin;
-
-import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
-
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.ClassAccessFlags;
-import com.android.tools.r8.graph.Code;
-import com.android.tools.r8.graph.DexAnnotationSet;
-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.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexProto;
-import com.android.tools.r8.graph.DexString;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexTypeList;
-import com.android.tools.r8.graph.DexValue.DexValueNull;
-import com.android.tools.r8.graph.EnclosingMethodAttribute;
-import com.android.tools.r8.graph.GenericSignature;
-import com.android.tools.r8.graph.GenericSignature.ClassSignature;
-import com.android.tools.r8.graph.GenericSignature.FieldTypeSignature;
-import com.android.tools.r8.graph.GenericSignature.MethodTypeSignature;
-import com.android.tools.r8.graph.InnerClassAttribute;
-import com.android.tools.r8.graph.MethodAccessFlags;
-import com.android.tools.r8.graph.ParameterAnnotationsList;
-import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
-import com.android.tools.r8.ir.code.IntSwitch;
-import com.android.tools.r8.ir.code.Position;
-import com.android.tools.r8.ir.optimize.info.OptimizationFeedback;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroupClassBuilder;
-import com.android.tools.r8.ir.synthetic.SynthesizedCode;
-import com.android.tools.r8.ir.synthetic.SyntheticSourceCode;
-import com.android.tools.r8.origin.SynthesizedOrigin;
-import com.android.tools.r8.utils.Box;
-import com.android.tools.r8.utils.IntBox;
-import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.TriConsumer;
-import com.google.common.collect.Lists;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-
-// Builds components of kotlin lambda group class.
-abstract class KotlinLambdaGroupClassBuilder<T extends KotlinLambdaGroup>
-    extends LambdaGroupClassBuilder<T> implements KotlinLambdaConstants {
-
-  final KotlinLambdaGroupId id;
-  final InternalOptions options;
-
-  KotlinLambdaGroupClassBuilder(
-      T group, DexItemFactory factory, InternalOptions options, String origin) {
-    super(group, factory, origin);
-    this.id = group.id();
-    this.options = options;
-  }
-
-  abstract SyntheticSourceCode createInstanceInitializerSourceCode(
-      DexType groupClassType, DexMethod initializerMethod, Position callerPosition);
-
-  // Always generate public final classes.
-  @Override
-  protected ClassAccessFlags buildAccessFlags() {
-    return PUBLIC_LAMBDA_CLASS_FLAGS;
-  }
-
-  // Take the attribute from the group, if exists.
-  @Override
-  protected EnclosingMethodAttribute buildEnclosingMethodAttribute() {
-    return id.enclosing;
-  }
-
-  // Take the attribute from the group, if exists.
-  @Override
-  protected List<InnerClassAttribute> buildInnerClasses() {
-    return !id.hasInnerClassAttribute()
-        ? Collections.emptyList()
-        : Lists.newArrayList(
-            new InnerClassAttribute(id.innerClassAccess, group.getGroupClassType(), null, null));
-  }
-
-  @Override
-  protected ClassSignature buildClassSignature() {
-    // Kotlin-style lambdas supported by the merged may only contain optional signature and
-    // kotlin metadata annotations. We remove the latter, but keep the signature if present.
-    return GenericSignature.parseClassSignature(
-        origin, id.signature, new SynthesizedOrigin(origin, getClass()), factory, options.reporter);
-  }
-
-  @Override
-  protected DexEncodedMethod[] buildVirtualMethods() {
-    // All virtual method are dispatched on $id$ field.
-    //
-    // For each of the virtual method name/signatures seen in the group
-    // we generate a correspondent method in lambda group class with same
-    // name/signatures dispatching the call to appropriate code taken
-    // from the lambda class.
-
-    Map<DexString, Map<DexProto, List<DexEncodedMethod>>> methods = collectVirtualMethods();
-    List<DexEncodedMethod> result = new ArrayList<>();
-
-    for (Entry<DexString, Map<DexProto, List<DexEncodedMethod>>> upper : methods.entrySet()) {
-      DexString methodName = upper.getKey();
-      for (Entry<DexProto, List<DexEncodedMethod>> inner : upper.getValue().entrySet()) {
-        // Methods for unique name/signature pair.
-        DexProto methodProto = inner.getKey();
-        List<DexEncodedMethod> implMethods = inner.getValue();
-
-        boolean isMainMethod =
-            id.mainMethodName == methodName && id.mainMethodProto == methodProto;
-
-        // Merging lambdas can introduce methods with too many instructions for the verifier on
-        // ART to give up statically verifying the method. We therefore split up the implementation
-        // methods and chain them with fallthrough:
-        // function <method>() {
-        //   switch(field.id) {
-        //     case 1:
-        //     case 2:
-        //     ...
-        //     case n:
-        //     default: <method$1>()
-        // }
-        //
-        // function <method$1>() {
-        //     case n + 1:
-        //     case n + 2:
-        //     ...
-        //     case n + m:
-        //     default: throw null
-        // }
-        IntBox counter = new IntBox(0);
-        Box<DexMethod> currentMethodBox =
-            new Box<>(factory.createMethod(group.getGroupClassType(), methodProto, methodName));
-        splitIntoGroupsBasedOnInstructionSize(
-            implMethods,
-            (implMethodsToAdd, methodsSoFar, methodsRemaining) -> {
-              assert currentMethodBox.isSet();
-              // For bridge methods we still use same PUBLIC FINAL as for the main method,
-              // since inlining removes BRIDGE & SYNTHETIC attributes from the bridge methods
-              // anyways and our new method is a product of inlining.
-              MethodAccessFlags accessFlags = MAIN_METHOD_FLAGS.copy();
-              DexMethod method = currentMethodBox.get();
-              DexMethod fallthrough =
-                  methodsRemaining
-                      ? factory.createMethod(
-                          group.getGroupClassType(),
-                          methodProto,
-                          methodName.toString() + "$" + counter.getAndIncrement())
-                      : null;
-              result.add(
-                  new DexEncodedMethod(
-                      method,
-                      accessFlags,
-                      MethodTypeSignature.noSignature(),
-                      isMainMethod ? id.mainMethodAnnotations : DexAnnotationSet.empty(),
-                      isMainMethod
-                          ? id.mainMethodParamAnnotations
-                          : ParameterAnnotationsList.empty(),
-                      new SynthesizedCode(
-                          callerPosition ->
-                              new KotlinLambdaVirtualMethodSourceCode(
-                                  factory,
-                                  group.getGroupClassType(),
-                                  method,
-                                  group.getLambdaIdField(factory),
-                                  implMethodsToAdd,
-                                  fallthrough,
-                                  methodsSoFar,
-                                  callerPosition)),
-                      true));
-              currentMethodBox.set(fallthrough);
-            });
-        assert !currentMethodBox.isSet();
-      }
-    }
-    return result.toArray(DexEncodedMethod.EMPTY_ARRAY);
-  }
-
-  private void splitIntoGroupsBasedOnInstructionSize(
-      List<DexEncodedMethod> implMethods,
-      TriConsumer<List<DexEncodedMethod>, Integer, Boolean> consumer) {
-    List<DexEncodedMethod> methods = new ArrayList<>();
-    // Upper bound in DEX for reading the field for switching on the group id.
-    final int fieldLoadInstructionSize = 10;
-    int verificationSizeLimitInBytes = options.verificationSizeLimitInBytes();
-    int currentInstructionsSize = fieldLoadInstructionSize;
-    int implMethodsCommitted = 0;
-    for (DexEncodedMethod implMethod : implMethods) {
-      int packedSwitchPayloadSize =
-          (int)
-              (IntSwitch.basePackedSize(options.getInternalOutputMode())
-                  + IntSwitch.packedPayloadSize(options.getInternalOutputMode(), methods.size()));
-      Code code = implMethod.getCode();
-      // We only do lambda merging for DEX. If we started doing lambda merging for CF, we would
-      // have to compute a size.
-      assert code.isDexCode();
-      int codeSize = code.asDexCode().codeSizeInBytes();
-      int estimatedMethodSize = currentInstructionsSize + codeSize + packedSwitchPayloadSize;
-      if (methods.size() > 0 && estimatedMethodSize > verificationSizeLimitInBytes) {
-        consumer.accept(methods, implMethodsCommitted, true);
-        currentInstructionsSize = fieldLoadInstructionSize;
-        implMethodsCommitted += methods.size();
-        methods = new ArrayList<>();
-      }
-      methods.add(implMethod);
-      currentInstructionsSize += codeSize;
-    }
-    consumer.accept(methods, implMethodsCommitted, false);
-  }
-
-  // Build a map of virtual methods with unique name/proto pointing to a list of methods
-  // from lambda classes implementing appropriate logic. The indices in the list correspond
-  // to lambda ids. Note that some of the slots in the lists may be empty, indicating the
-  // fact that corresponding lambda does not have a virtual method with this signature.
-  private Map<DexString, Map<DexProto, List<DexEncodedMethod>>> collectVirtualMethods() {
-    Map<DexString, Map<DexProto, List<DexEncodedMethod>>> methods = new LinkedHashMap<>();
-    int size = group.size();
-    group.forEachLambda(info -> {
-      for (DexEncodedMethod method : info.clazz.virtualMethods()) {
-        List<DexEncodedMethod> list = methods
-            .computeIfAbsent(method.method.name,
-                k -> new LinkedHashMap<>())
-            .computeIfAbsent(method.method.proto,
-                k -> Lists.newArrayList(Collections.nCopies(size, null)));
-        assert list.get(info.id) == null;
-        list.set(info.id, method);
-      }
-    });
-    return methods;
-  }
-
-  @Override
-  protected DexEncodedMethod[] buildDirectMethods() {
-    // We only build an instance initializer and optional class
-    // initializer for stateless lambdas.
-
-    boolean needsSingletonInstances = group.isStateless() && group.hasAnySingletons();
-    DexType groupClassType = group.getGroupClassType();
-
-    DexEncodedMethod[] result = new DexEncodedMethod[needsSingletonInstances ? 2 : 1];
-    // Instance initializer mapping parameters into capture fields.
-    DexProto initializerProto = group.createConstructorProto(factory);
-    DexMethod initializerMethod =
-        factory.createMethod(groupClassType, initializerProto, factory.constructorMethodName);
-    result[0] =
-        new DexEncodedMethod(
-            initializerMethod,
-            CONSTRUCTOR_FLAGS_RELAXED, // always create access-relaxed constructor.
-            MethodTypeSignature.noSignature(),
-            DexAnnotationSet.empty(),
-            ParameterAnnotationsList.empty(),
-            new SynthesizedCode(
-                callerPosition ->
-                    createInstanceInitializerSourceCode(
-                        groupClassType, initializerMethod, callerPosition)),
-            true);
-
-    // Static class initializer for stateless lambdas.
-    if (needsSingletonInstances) {
-      DexMethod method =
-          factory.createMethod(
-              groupClassType,
-              factory.createProto(factory.voidType),
-              factory.classConstructorMethodName);
-      result[1] =
-          new DexEncodedMethod(
-              method,
-              CLASS_INITIALIZER_FLAGS,
-              MethodTypeSignature.noSignature(),
-              DexAnnotationSet.empty(),
-              ParameterAnnotationsList.empty(),
-              new SynthesizedCode(
-                  callerPosition ->
-                      new ClassInitializerSourceCode(method, factory, group, callerPosition)),
-              true);
-    }
-
-    return result;
-  }
-
-  @Override
-  protected DexEncodedField[] buildInstanceFields() {
-    // Lambda id field plus other fields defined by the capture signature.
-    String capture = id.capture;
-    int size = capture.length();
-    DexEncodedField[] result = new DexEncodedField[1 + size];
-
-    result[0] =
-        new DexEncodedField(
-            group.getLambdaIdField(factory),
-            CAPTURE_FIELD_FLAGS_RELAXED,
-            FieldTypeSignature.noSignature(),
-            DexAnnotationSet.empty(),
-            null);
-
-    for (int id = 0; id < size; id++) {
-      result[id + 1] =
-          new DexEncodedField(
-              group.getCaptureField(factory, id),
-              CAPTURE_FIELD_FLAGS_RELAXED,
-              FieldTypeSignature.noSignature(),
-              DexAnnotationSet.empty(),
-              null);
-    }
-
-    return result;
-  }
-
-  @Override
-  protected DexEncodedField[] buildStaticFields(
-      AppView<? extends AppInfoWithClassHierarchy> appView, OptimizationFeedback feedback) {
-    if (!group.isStateless()) {
-      return DexEncodedField.EMPTY_ARRAY;
-    }
-    // One field for each singleton lambda in the group.
-    List<DexEncodedField> result = new ArrayList<>(group.size());
-    group.forEachLambda(
-        info -> {
-          if (group.isSingletonLambda(info.clazz.type)) {
-            DexField field = group.getSingletonInstanceField(factory, info.id);
-            DexEncodedField encodedField =
-                new DexEncodedField(
-                    field,
-                    SINGLETON_FIELD_FLAGS,
-                    FieldTypeSignature.noSignature(),
-                    DexAnnotationSet.empty(),
-                    DexValueNull.NULL);
-            result.add(encodedField);
-
-            // Record that the field is definitely not null. It is guaranteed to be assigned in the
-            // class initializer of the enclosing class before it is read.
-            ClassTypeElement exactType =
-                ClassTypeElement.create(field.type, definitelyNotNull(), appView);
-            feedback.markFieldHasDynamicLowerBoundType(encodedField, exactType);
-            feedback.markFieldHasDynamicUpperBoundType(encodedField, exactType);
-          }
-        });
-    assert result.isEmpty() == !group.hasAnySingletons();
-    return result.toArray(DexEncodedField.EMPTY_ARRAY);
-  }
-
-  @Override
-  protected DexTypeList buildInterfaces() {
-    return new DexTypeList(new DexType[]{id.iface});
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupCodeStrategy.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupCodeStrategy.java
deleted file mode 100644
index 2c88700..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupCodeStrategy.java
+++ /dev/null
@@ -1,310 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda.kotlin;
-
-import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
-import static com.android.tools.r8.ir.analysis.type.Nullability.maybeNull;
-
-import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexProto;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
-import com.android.tools.r8.ir.code.Argument;
-import com.android.tools.r8.ir.code.CheckCast;
-import com.android.tools.r8.ir.code.ConstNumber;
-import com.android.tools.r8.ir.code.InitClass;
-import com.android.tools.r8.ir.code.InstanceGet;
-import com.android.tools.r8.ir.code.Instruction;
-import com.android.tools.r8.ir.code.InvokeDirect;
-import com.android.tools.r8.ir.code.InvokeMethod;
-import com.android.tools.r8.ir.code.InvokeVirtual;
-import com.android.tools.r8.ir.code.NewInstance;
-import com.android.tools.r8.ir.code.StaticGet;
-import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.ir.optimize.lambda.CaptureSignature;
-import com.android.tools.r8.ir.optimize.lambda.CodeProcessor;
-import com.android.tools.r8.ir.optimize.lambda.CodeProcessor.Strategy;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroup;
-import com.android.tools.r8.ir.optimize.lambda.LambdaMerger.ApplyStrategy;
-import java.util.ArrayList;
-import java.util.List;
-
-// Defines the code processing strategy for kotlin lambdas.
-final class KotlinLambdaGroupCodeStrategy implements Strategy {
-  private final KotlinLambdaGroup group;
-
-  KotlinLambdaGroupCodeStrategy(KotlinLambdaGroup group) {
-    this.group = group;
-  }
-
-  @Override
-  public LambdaGroup group() {
-    return group;
-  }
-
-  @Override
-  public boolean isValidStaticFieldWrite(CodeProcessor context, DexField field) {
-    DexType lambda = field.holder;
-    assert group.containsLambda(lambda);
-    // Only support writes to singleton static field named 'INSTANCE' from lambda
-    // static class initializer.
-    return field.name == context.kotlin.functional.kotlinStyleLambdaInstanceName
-        && lambda == field.type
-        && context.method.getDefinition().isClassInitializer()
-        && context.method.getHolderType() == lambda;
-  }
-
-  @Override
-  public boolean isValidStaticFieldRead(CodeProcessor context, DexField field) {
-    DexType lambda = field.holder;
-    assert group.containsLambda(lambda);
-    // Support all reads of singleton static field named 'INSTANCE'.
-    return field.name == context.kotlin.functional.kotlinStyleLambdaInstanceName
-        && lambda == field.type;
-  }
-
-  @Override
-  public boolean isValidInstanceFieldWrite(CodeProcessor context, DexField field) {
-    DexType lambda = field.holder;
-    DexMethod method = context.method.getReference();
-    assert group.containsLambda(lambda);
-    // Support writes to capture instance fields inside lambda constructor only.
-    return method.holder == lambda && context.method.getDefinition().isInstanceInitializer();
-  }
-
-  @Override
-  public boolean isValidInstanceFieldRead(CodeProcessor context, DexField field) {
-    assert group.containsLambda(field.holder);
-    // Support all reads from capture instance fields.
-    return true;
-  }
-
-  @Override
-  public boolean isValidNewInstance(CodeProcessor context, NewInstance invoke) {
-    // Only valid for stateful lambdas.
-    return !(group.isStateless() && group.isSingletonLambda(invoke.clazz));
-  }
-
-  @Override
-  public boolean isValidInvoke(CodeProcessor context, InvokeMethod invoke) {
-    return isValidInitializerCall(context, invoke) || isValidVirtualCall(invoke);
-  }
-
-  private boolean isValidInitializerCall(CodeProcessor context, InvokeMethod invoke) {
-    DexMethod method = invoke.getInvokedMethod();
-    DexType lambda = method.holder;
-    assert group.containsLambda(lambda);
-    // Allow calls to a constructor from other classes if the lambda is singleton,
-    // otherwise allow such a call only from the same class static initializer.
-    boolean isSingletonLambda = group.isStateless() && group.isSingletonLambda(lambda);
-    return (isSingletonLambda == (context.method.getHolderType() == lambda))
-        && invoke.isInvokeDirect()
-        && context.factory.isConstructor(method)
-        && CaptureSignature.getCaptureSignature(method.proto.parameters).equals(group.id().capture);
-  }
-
-  private boolean isValidVirtualCall(InvokeMethod invoke) {
-    assert group.containsLambda(invoke.getInvokedMethod().holder);
-    // Allow all virtual calls.
-    return invoke.isInvokeVirtual();
-  }
-
-  @Override
-  public boolean isValidInitClass(CodeProcessor context, DexType clazz) {
-    assert group.containsLambda(clazz);
-    // Support all init class instructions.
-    return true;
-  }
-
-  @Override
-  public boolean isValidHolder(CodeProcessor context, DexType holder) {
-    assert group.containsLambda(holder);
-    return true;
-  }
-
-  @Override
-  public void patch(ApplyStrategy context, NewInstance newInstance) {
-    DexType oldType = newInstance.clazz;
-    DexType newType = group.getGroupClassType();
-
-    NewInstance patchedNewInstance =
-        new NewInstance(
-            newType,
-            context.code.createValue(
-                TypeElement.fromDexType(newType, definitelyNotNull(), context.appView)));
-    context.instructions().replaceCurrentInstruction(patchedNewInstance);
-
-    assert newType != oldType;
-    context.recordTypeHasChanged(patchedNewInstance.outValue());
-  }
-
-  @Override
-  public void patch(ApplyStrategy context, InvokeMethod invoke) {
-    assert group.containsLambda(invoke.getInvokedMethod().holder);
-    if (isValidInitializerCall(context, invoke)) {
-      patchInitializer(context, invoke.asInvokeDirect());
-    } else {
-      // Regular calls to virtual methods only need target method be replaced.
-      assert isValidVirtualCall(invoke);
-      DexMethod oldMethod = invoke.getInvokedMethod();
-      DexMethod newMethod = mapVirtualMethod(context.factory, oldMethod);
-
-      InvokeVirtual patchedInvokeVirtual =
-          new InvokeVirtual(
-              newMethod,
-              createValueForType(context, newMethod.proto.returnType),
-              invoke.arguments());
-      context.instructions().replaceCurrentInstruction(patchedInvokeVirtual);
-
-      // Otherwise, we need to record that the type of the out-value has changed.
-      assert newMethod.proto.returnType == oldMethod.proto.returnType;
-    }
-  }
-
-  @Override
-  public void patch(ApplyStrategy context, InstanceGet instanceGet) {
-    DexField oldField = instanceGet.getField();
-    DexField newField = mapCaptureField(context.factory, oldField.holder, oldField);
-
-    DexType oldFieldType = oldField.type;
-    DexType newFieldType = newField.type;
-
-    // We need to insert remapped values and in case the capture field
-    // of type Object optionally cast to expected field.
-    InstanceGet newInstanceGet =
-        new InstanceGet(createValueForType(context, newFieldType), instanceGet.object(), newField);
-    context.instructions().replaceCurrentInstruction(newInstanceGet);
-
-    if (oldFieldType.isPrimitiveType() || oldFieldType == context.factory.objectType) {
-      return;
-    }
-
-    // Since all captured values of non-primitive types are stored in fields of type
-    // java.lang.Object, we need to cast them to appropriate type to satisfy the verifier.
-    TypeElement castTypeLattice =
-        TypeElement.fromDexType(oldFieldType, maybeNull(), context.appView);
-    Value newValue = context.code.createValue(castTypeLattice, newInstanceGet.getLocalInfo());
-    newInstanceGet.outValue().replaceUsers(newValue);
-    CheckCast cast = new CheckCast(newValue, newInstanceGet.outValue(), oldFieldType);
-    cast.setPosition(newInstanceGet.getPosition());
-    context.instructions().add(cast);
-
-    // If the current block has catch handlers split the check cast into its own block.
-    // Since new cast is never supposed to fail, we leave catch handlers empty.
-    if (cast.getBlock().hasCatchHandlers()) {
-      context.instructions().previous();
-      context.instructions().split(context.code, 1, context.blocks);
-    }
-  }
-
-  @Override
-  public void patch(ApplyStrategy context, StaticGet staticGet) {
-    DexField oldField = staticGet.getField();
-    DexField newField = mapSingletonInstanceField(context.factory, oldField);
-
-    StaticGet patchedStaticGet =
-        new StaticGet(
-            context.code.createValue(
-                TypeElement.fromDexType(newField.type, maybeNull(), context.appView)),
-            newField);
-    context.instructions().replaceCurrentInstruction(patchedStaticGet);
-
-    assert newField.type != oldField.type;
-    context.recordTypeHasChanged(patchedStaticGet.outValue());
-  }
-
-  @Override
-  public void patch(ApplyStrategy context, InitClass initClass) {
-    InitClass pachedInitClass =
-        new InitClass(context.code.createValue(TypeElement.getInt()), group.getGroupClassType());
-    context.instructions().replaceCurrentInstruction(pachedInitClass);
-  }
-
-  @Override
-  public void patch(ApplyStrategy context, Argument argument) {
-    // An argument can be a direct operand to a phi that we potentially could not remove.
-    assert argument.getIndex() == 0;
-    // The argument value will be replaced by the invoke value.
-    argument
-        .outValue()
-        .setType(TypeElement.fromDexType(group.getGroupClassType(), maybeNull(), context.appView));
-    context.recordTypeHasChanged(argument.outValue());
-  }
-
-  private void patchInitializer(CodeProcessor context, InvokeDirect invoke) {
-    // Patching includes:
-    //  - change of methods
-    //  - adding lambda id as the first argument
-    //  - reshuffling other arguments (representing captured values)
-    //    according to capture signature of the group.
-
-    DexMethod method = invoke.getInvokedMethod();
-    DexType lambda = method.holder;
-
-    // Create constant with lambda id.
-    Value lambdaIdValue = context.code.createValue(TypeElement.getInt());
-    ConstNumber lambdaId = new ConstNumber(lambdaIdValue, group.lambdaId(lambda));
-    lambdaId.setPosition(invoke.getPosition());
-    context.instructions().previous();
-    context.instructions().add(lambdaId);
-
-    // Create a new InvokeDirect instruction.
-    Instruction next = context.instructions().next();
-    assert next == invoke;
-
-    DexMethod newTarget = mapInitializerMethod(context.factory, method);
-    List<Value> newArguments = mapInitializerArgs(lambdaIdValue, invoke.arguments(), method.proto);
-    context.instructions().replaceCurrentInstruction(
-        new InvokeDirect(newTarget, null /* no return value */, newArguments)
-    );
-  }
-
-  private Value createValueForType(CodeProcessor context, DexType returnType) {
-    return returnType == context.factory.voidType
-        ? null
-        : context.code.createValue(
-            TypeElement.fromDexType(returnType, maybeNull(), context.appView));
-  }
-
-  private List<Value> mapInitializerArgs(
-      Value lambdaIdValue, List<Value> oldArguments, DexProto proto) {
-    assert oldArguments.size() == proto.parameters.size() + 1;
-    List<Value> newArguments = new ArrayList<>();
-    newArguments.add(oldArguments.get(0)); // receiver
-    newArguments.add(lambdaIdValue); // lambda-id
-    List<Integer> reverseMapping =
-        CaptureSignature.getReverseCaptureMapping(proto.parameters.values);
-    for (int index : reverseMapping) {
-      // <original-capture-index> = mapping[<normalized-capture-index>]
-      newArguments.add(oldArguments.get(index + 1 /* after receiver */));
-    }
-    return newArguments;
-  }
-
-  // Map lambda class initializer into lambda group class initializer.
-  private DexMethod mapInitializerMethod(DexItemFactory factory, DexMethod method) {
-    assert factory.isConstructor(method);
-    assert CaptureSignature.getCaptureSignature(method.proto.parameters).equals(group.id().capture);
-    return factory.createMethod(group.getGroupClassType(),
-        group.createConstructorProto(factory), method.name);
-  }
-
-  // Map lambda class virtual method into lambda group class method.
-  private DexMethod mapVirtualMethod(DexItemFactory factory, DexMethod method) {
-    return factory.createMethod(group.getGroupClassType(), method.proto, method.name);
-  }
-
-  // Map lambda class capture field into lambda group class capture field.
-  private DexField mapCaptureField(DexItemFactory factory, DexType lambda, DexField field) {
-    return group.getCaptureField(factory, group.mapFieldIntoCaptureIndex(lambda, field));
-  }
-
-  // Map lambda class initializer into lambda group class initializer.
-  private DexField mapSingletonInstanceField(DexItemFactory factory, DexField field) {
-    return group.getSingletonInstanceField(factory, group.lambdaId(field.holder));
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupId.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupId.java
deleted file mode 100644
index 7f24d79..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupId.java
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda.kotlin;
-
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexAnnotationSet;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexProto;
-import com.android.tools.r8.graph.DexString;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.EnclosingMethodAttribute;
-import com.android.tools.r8.graph.InnerClassAttribute;
-import com.android.tools.r8.graph.ParameterAnnotationsList;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroup;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroupId;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
-
-abstract class KotlinLambdaGroupId implements LambdaGroupId {
-  private static final int MISSING_INNER_CLASS_ATTRIBUTE = -1;
-
-  private final int hash;
-
-  // Capture signature.
-  final String capture;
-  // Kotlin functional interface.
-  final DexType iface;
-  // Package (in case access relaxation is enabled root package is used).
-  final String pkg;
-  // Generic signature of the lambda class.
-  final String signature;
-
-  // Characteristics of the main lambda method. Kotlin generates one main method with
-  // the signature matching the lambda signature, and a bridge method (if needed)
-  // forwarding the call via interface to the main method. Main method may have
-  // generic signature and parameter annotations defining nullability.
-  //
-  // TODO: address cases when main method is removed after inlining.
-  // (the main method if created is supposed to be inlined, since it is always
-  //  only called from the bridge, and removed. In this case the method with
-  //  signature and annotations is removed allowing more lambda to be merged.)
-  final DexString mainMethodName;
-  final DexProto mainMethodProto;
-  final DexAnnotationSet mainMethodAnnotations;
-  final ParameterAnnotationsList mainMethodParamAnnotations;
-
-  final EnclosingMethodAttribute enclosing;
-
-  // Note that lambda classes are always created as _anonymous_ inner classes. We only
-  // need to store the fact that the class had this attribute and if it had store the
-  // access from InnerClassAttribute.
-  final int innerClassAccess;
-
-  KotlinLambdaGroupId(
-      AppView<AppInfoWithLiveness> appView,
-      String capture,
-      DexType iface,
-      String pkg,
-      String signature,
-      DexEncodedMethod mainMethod,
-      InnerClassAttribute inner,
-      EnclosingMethodAttribute enclosing) {
-    assert capture != null && iface != null && pkg != null && mainMethod != null;
-    assert inner == null || (inner.isAnonymous() && inner.getOuter() == null);
-    this.capture = capture;
-    this.iface = iface;
-    this.pkg = pkg;
-    this.signature = signature;
-    this.mainMethodName = mainMethod.method.name;
-    this.mainMethodProto = mainMethod.method.proto;
-    this.mainMethodAnnotations = mainMethod.liveAnnotations(appView);
-    this.mainMethodParamAnnotations = mainMethod.liveParameterAnnotations(appView);
-    this.innerClassAccess = inner != null ? inner.getAccess() : MISSING_INNER_CLASS_ATTRIBUTE;
-    this.enclosing = enclosing;
-    this.hash = computeHashCode();
-  }
-
-  final boolean hasInnerClassAttribute() {
-    return innerClassAccess != MISSING_INNER_CLASS_ATTRIBUTE;
-  }
-
-  @Override
-  public final int hashCode() {
-    return hash;
-  }
-
-  private int computeHashCode() {
-    int hash = capture.hashCode() * 7;
-    hash += iface.hashCode() * 17;
-    hash += pkg.hashCode() * 37;
-    hash += signature != null ? signature.hashCode() * 47 : 0;
-    hash += mainMethodName.hashCode() * 71;
-    hash += mainMethodProto.hashCode() * 89;
-    hash += mainMethodAnnotations != null ? mainMethodAnnotations.hashCode() * 101 : 0;
-    hash += mainMethodParamAnnotations != null ? mainMethodParamAnnotations.hashCode() * 113 : 0;
-    hash += innerClassAccess * 131;
-    hash += enclosing != null ? enclosing.hashCode() * 211 : 0;
-    return hash;
-  }
-
-  @Override
-  public abstract boolean equals(Object obj);
-
-  boolean computeEquals(KotlinLambdaGroupId other) {
-    return capture.equals(other.capture) &&
-        iface == other.iface &&
-        pkg.equals(other.pkg) &&
-        mainMethodName == other.mainMethodName &&
-        mainMethodProto == other.mainMethodProto &&
-        (mainMethodAnnotations == null ? other.mainMethodAnnotations == null
-            : mainMethodAnnotations.equals(other.mainMethodAnnotations)) &&
-        (mainMethodParamAnnotations == null ? other.mainMethodParamAnnotations == null
-            : mainMethodParamAnnotations.equals(other.mainMethodParamAnnotations)) &&
-        (signature == null ? other.signature == null : signature.equals(other.signature)) &&
-        innerClassAccess == other.innerClassAccess &&
-        (enclosing == null ? other.enclosing == null : enclosing.equals(other.enclosing));
-  }
-
-  @Override
-  public String toString() {
-    StringBuilder builder = new StringBuilder(getLambdaKindDescriptor())
-        .append("\n  capture: ").append(capture)
-        .append("\n  interface: ").append(iface.descriptor)
-        .append("\n  package: ").append(pkg)
-        .append("\n  signature: ").append(signature)
-        .append("\n  main method name: ").append(mainMethodName.toString())
-        .append("\n  main method: ").append(mainMethodProto.toSourceString())
-        .append("\n  main annotations: ").append(mainMethodAnnotations)
-        .append("\n  main param annotations: ").append(mainMethodParamAnnotations)
-        .append("\n  inner: ")
-        .append(innerClassAccess == MISSING_INNER_CLASS_ATTRIBUTE ? "none" : innerClassAccess);
-    if (enclosing != null) {
-      if (enclosing.getEnclosingClass() != null) {
-        builder.append("\n  enclosingClass: ")
-            .append(enclosing.getEnclosingClass().descriptor);
-      } else {
-        builder.append("\n  enclosingMethod: ")
-            .append(enclosing.getEnclosingMethod().toSourceString());
-      }
-    }
-    return builder.toString();
-  }
-
-  abstract String getLambdaKindDescriptor();
-
-  @Override
-  public abstract LambdaGroup createGroup();
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupIdFactory.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupIdFactory.java
deleted file mode 100644
index 472d861..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaGroupIdFactory.java
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda.kotlin;
-
-import com.android.tools.r8.graph.AccessFlags;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexAnnotation;
-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.DexProgramClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.InnerClassAttribute;
-import com.android.tools.r8.ir.optimize.lambda.CaptureSignature;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroup.LambdaStructureError;
-import com.android.tools.r8.ir.optimize.lambda.LambdaGroupId;
-import com.android.tools.r8.kotlin.Kotlin;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import java.util.List;
-
-public abstract class KotlinLambdaGroupIdFactory implements KotlinLambdaConstants {
-  KotlinLambdaGroupIdFactory() {
-  }
-
-  public static KotlinLambdaGroupIdFactory getFactoryForClass(DexProgramClass clazz) {
-    if (clazz.getKotlinInfo().isSyntheticClass()
-        && clazz.getKotlinInfo().asSyntheticClass().isLambda()) {
-      if (clazz.getKotlinInfo().asSyntheticClass().isKotlinStyleLambda()) {
-        return KStyleLambdaGroupIdFactory.getInstance();
-      }
-      assert clazz.getKotlinInfo().asSyntheticClass().isJavaStyleLambda();
-      return JStyleLambdaGroupIdFactory.getInstance();
-    }
-    return null;
-  }
-
-  // Creates a lambda group id for a Java or Kotlin style lambda. Never returns null, but may throw
-  // a LambdaStructureError if the lambda does not pass pre-requirements (mostly by not meeting
-  // high-level structure expectations).
-  //
-  // At this point we only perform high-level checks before qualifying the lambda as a candidate
-  // for merging and assigning lambda group id. We can NOT perform checks on method bodies since
-  // they may not be converted yet, we'll do that in KStyleLambdaClassValidator.
-  public abstract LambdaGroupId validateAndCreate(
-      AppView<AppInfoWithLiveness> appView, Kotlin kotlin, DexClass lambda)
-      throws LambdaStructureError;
-
-  abstract void validateSuperclass(Kotlin kotlin, DexClass lambda) throws LambdaStructureError;
-
-  abstract DexType validateInterfaces(Kotlin kotlin, DexClass lambda) throws LambdaStructureError;
-
-  DexEncodedMethod validateVirtualMethods(DexClass lambda) throws LambdaStructureError {
-    DexEncodedMethod mainMethod = null;
-
-    for (DexEncodedMethod method : lambda.virtualMethods()) {
-      if (method.accessFlags.materialize() == MAIN_METHOD_FLAGS.materialize()) {
-        if (mainMethod != null) {
-          throw new LambdaStructureError("more than one main method found");
-        }
-        mainMethod = method;
-      } else {
-        checkAccessFlags("unexpected virtual method access flags",
-            method.accessFlags, BRIDGE_METHOD_FLAGS, BRIDGE_METHOD_FLAGS_FIXED);
-        checkDirectMethodAnnotations(method);
-      }
-    }
-
-    if (mainMethod == null) {
-      // Missing main method may be a result of tree shaking.
-      throw new LambdaStructureError("no main method found", false);
-    }
-    return mainMethod;
-  }
-
-  InnerClassAttribute validateInnerClasses(DexClass lambda) throws LambdaStructureError {
-    List<InnerClassAttribute> innerClasses = lambda.getInnerClasses();
-    if (innerClasses != null) {
-      for (InnerClassAttribute inner : innerClasses) {
-        if (inner.getInner() == lambda.type) {
-          if (!inner.isAnonymous()) {
-            throw new LambdaStructureError("is not anonymous");
-          }
-          return inner;
-        }
-      }
-    }
-    return null;
-  }
-
-  public static boolean hasValidAnnotations(Kotlin kotlin, DexClass lambda) {
-    for (DexAnnotation annotation : lambda.annotations().annotations) {
-      if (annotation.annotation.type == kotlin.factory.kotlinMetadataType) {
-        continue;
-      }
-      return false;
-    }
-    return true;
-  }
-
-  String validateAnnotations(AppView<AppInfoWithLiveness> appView, Kotlin kotlin, DexClass lambda)
-      throws LambdaStructureError {
-    for (DexAnnotation annotation : lambda.liveAnnotations(appView).annotations) {
-      if (annotation.annotation.type == appView.dexItemFactory().kotlinMetadataType) {
-        // Ignore kotlin metadata on lambda classes. Metadata on synthetic
-        // classes exists but is not used in the current Kotlin version (1.2.21)
-        // and newly generated lambda _group_ class is not exactly a kotlin class.
-        continue;
-      }
-
-      assert !hasValidAnnotations(kotlin, lambda);
-      throw new LambdaStructureError(
-          "unexpected annotation: " + annotation.annotation.type.toSourceString());
-    }
-    assert hasValidAnnotations(kotlin, lambda);
-    return lambda.getClassSignature().toString();
-  }
-
-  void validateStaticFields(Kotlin kotlin, DexClass lambda) throws LambdaStructureError {
-    List<DexEncodedField> staticFields = lambda.staticFields();
-    if (staticFields.size() == 1) {
-      DexEncodedField field = staticFields.get(0);
-      if (field.field.name != kotlin.functional.kotlinStyleLambdaInstanceName ||
-          field.field.type != lambda.type || !field.accessFlags.isPublic() ||
-          !field.accessFlags.isFinal() || !field.accessFlags.isStatic()) {
-        throw new LambdaStructureError("unexpected static field " + field.toSourceString());
-      }
-      // No state if the lambda is a singleton.
-      if (lambda.instanceFields().size() > 0) {
-        throw new LambdaStructureError("has instance fields along with INSTANCE");
-      }
-      checkAccessFlags("static field access flags", field.accessFlags, SINGLETON_FIELD_FLAGS);
-      checkFieldAnnotations(field);
-
-    } else if (staticFields.size() > 1) {
-      throw new LambdaStructureError(
-          "only one static field max expected, found " + staticFields.size());
-    }
-  }
-
-  String validateInstanceFields(DexClass lambda, boolean accessRelaxed)
-      throws LambdaStructureError {
-    List<DexEncodedField> instanceFields = lambda.instanceFields();
-    for (DexEncodedField field : instanceFields) {
-      checkAccessFlags("capture field access flags", field.accessFlags,
-          accessRelaxed ? CAPTURE_FIELD_FLAGS_RELAXED : CAPTURE_FIELD_FLAGS);
-      checkFieldAnnotations(field);
-    }
-    return CaptureSignature.getCaptureSignature(instanceFields);
-  }
-
-  void validateDirectMethods(DexClass lambda) throws LambdaStructureError {
-    for (DexEncodedMethod method : lambda.directMethods()) {
-      if (method.isClassInitializer()) {
-        // We expect to see class initializer only if there is a singleton field.
-        if (lambda.staticFields().size() != 1) {
-          throw new LambdaStructureError("has static initializer, but no singleton field");
-        }
-        checkAccessFlags(
-            "unexpected static initializer access flags",
-            method.accessFlags.getOriginalAccessFlags(),
-            CLASS_INITIALIZER_FLAGS);
-        checkDirectMethodAnnotations(method);
-      } else if (method.isStatic()) {
-        throw new LambdaStructureError(
-            "unexpected static method: " + method.method.toSourceString());
-      } else if (method.isInstanceInitializer()) {
-        // Lambda class is expected to have one constructor
-        // with parameters matching capture signature.
-        DexType[] parameters = method.method.proto.parameters.values;
-        List<DexEncodedField> instanceFields = lambda.instanceFields();
-        if (parameters.length != instanceFields.size()) {
-          throw new LambdaStructureError("constructor parameters don't match captured values.");
-        }
-        for (int i = 0; i < parameters.length; i++) {
-          // Kotlin compiler sometimes reshuffles the parameters so that their order
-          // in the constructor don't match order of capture fields. We could add
-          // support for it, but it happens quite rarely so don't bother for now.
-          if (parameters[i] != instanceFields.get(i).field.type) {
-            throw new LambdaStructureError(
-                "constructor parameters don't match captured values.", false);
-          }
-        }
-        checkAccessFlags("unexpected constructor access flags",
-            method.accessFlags, CONSTRUCTOR_FLAGS, CONSTRUCTOR_FLAGS_RELAXED);
-        checkDirectMethodAnnotations(method);
-
-      } else if (method.isPrivateMethod()) {
-        // TODO(b/135975229)
-        throw new LambdaStructureError("private method: " + method.method.toSourceString());
-      } else {
-        assert false;
-        throw new LambdaStructureError(
-            "unexpected method encountered: " + method.method.toSourceString());
-      }
-    }
-  }
-
-  private static void checkDirectMethodAnnotations(DexEncodedMethod method)
-      throws LambdaStructureError {
-    if (!method.annotations().isEmpty()) {
-      throw new LambdaStructureError(
-          "unexpected method annotations ["
-              + method.annotations().toSmaliString()
-              + "] on "
-              + method.method.toSourceString());
-    }
-    if (!method.parameterAnnotationsList.isEmpty()) {
-      throw new LambdaStructureError(
-          "unexpected method parameters annotations ["
-              + method.parameterAnnotationsList.toSmaliString()
-              + "] on "
-              + method.method.toSourceString());
-    }
-  }
-
-  private static void checkFieldAnnotations(DexEncodedField field) throws LambdaStructureError {
-    if (field.hasAnnotation()) {
-      throw new LambdaStructureError(
-          "unexpected field annotations ["
-              + field.annotations().toSmaliString()
-              + "] on "
-              + field.field.toSourceString());
-    }
-  }
-
-  @SafeVarargs
-  static <T extends AccessFlags> void checkAccessFlags(
-      String message, T actual, T... expected) throws LambdaStructureError {
-    checkAccessFlags(message, actual.materialize(), expected);
-  }
-
-  @SafeVarargs
-  private static <T extends AccessFlags> void checkAccessFlags(
-      String message, int actual, T... expected) throws LambdaStructureError {
-    for (T flag : expected) {
-      if (actual == flag.materialize()) {
-        return;
-      }
-    }
-    throw new LambdaStructureError(message);
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaVirtualMethodSourceCode.java b/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaVirtualMethodSourceCode.java
deleted file mode 100644
index 657a796..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/lambda/kotlin/KotlinLambdaVirtualMethodSourceCode.java
+++ /dev/null
@@ -1,122 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.lambda.kotlin;
-
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.code.Invoke;
-import com.android.tools.r8.ir.code.Position;
-import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.ir.code.ValueType;
-import com.android.tools.r8.ir.conversion.IRBuilder;
-import com.android.tools.r8.ir.synthetic.SyntheticSourceCode;
-import java.util.ArrayList;
-import java.util.List;
-
-final class KotlinLambdaVirtualMethodSourceCode extends SyntheticSourceCode {
-  private final DexItemFactory factory;
-  private final DexField idField;
-  private final List<DexEncodedMethod> implMethods;
-  private final DexMethod fallThroughMethod;
-  private final int keyStart;
-
-  KotlinLambdaVirtualMethodSourceCode(
-      DexItemFactory factory,
-      DexType groupClass,
-      DexMethod method,
-      DexField idField,
-      List<DexEncodedMethod> implMethods,
-      DexMethod fallThroughMethod,
-      int keyStart,
-      Position callerPosition) {
-    super(groupClass, method, callerPosition);
-    this.factory = factory;
-    this.idField = idField;
-    this.implMethods = implMethods;
-    this.fallThroughMethod = fallThroughMethod;
-    this.keyStart = keyStart;
-  }
-
-  @Override
-  protected void prepareInstructions() {
-    int implMethodCount = implMethods.size();
-    // We generate a single switch on lambda $id value read from appropriate
-    // field, and for each lambda id generate a call to appropriate method of
-    // the lambda class. Since this methods are marked as 'force inline',
-    // they are inlined by the inliner.
-
-    // Return value register if needed.
-    DexType returnType = proto.returnType;
-    boolean returnsValue = returnType != factory.voidType;
-    ValueType retValueType = returnsValue ? ValueType.fromDexType(returnType) : null;
-    int retRegister = returnsValue ? nextRegister(retValueType) : -1;
-
-    // Lambda id register to switch on.
-    int idRegister = nextRegister(ValueType.INT);
-    add(builder -> builder.addInstanceGet(idRegister, getReceiverRegister(), idField));
-
-    // Switch on id.
-    // Note that 'keys' and 'offsets' are just captured here and filled
-    // in with values when appropriate basic blocks are created.
-    int[] keys = new int[implMethodCount];
-    int[] offsets = new int[implMethodCount];
-    int[] fallthrough = new int[1]; // Array as a container for late initialization.
-    int switchIndex = lastInstructionIndex();
-    add(builder -> builder.addSwitch(idRegister, keys, fallthrough[0], offsets),
-        builder -> endsSwitch(builder, switchIndex, fallthrough[0], offsets));
-
-    List<Value> arguments = new ArrayList<>(proto.parameters.values.length + 1);
-
-    fallthrough[0] = nextInstructionIndex();
-    if (fallThroughMethod == null) {
-      // Fallthrough treated as unreachable.
-      int nullRegister = nextRegister(ValueType.OBJECT);
-      add(builder -> builder.addNullConst(nullRegister));
-      add(builder -> builder.addThrow(nullRegister), endsBlock);
-    } else {
-      addMethodCall(fallThroughMethod, arguments, returnsValue, retRegister);
-    }
-
-    // Blocks for each lambda id.
-    for (int i = 0; i < implMethodCount; i++) {
-      keys[i] = keyStart + i;
-      DexEncodedMethod impl = implMethods.get(i);
-      if (impl == null) {
-        // Virtual method is missing in lambda class.
-        offsets[i] = fallthrough[0];
-        continue;
-      }
-      offsets[i] = nextInstructionIndex();
-      addMethodCall(impl.method, arguments, returnsValue, retRegister);
-    }
-  }
-
-  private void addMethodCall(
-      DexMethod method, List<Value> arguments, boolean returnsValue, int retRegister) {
-    // Emit fake call on `this` receiver.
-    add(
-        builder -> {
-          if (arguments.isEmpty()) {
-            arguments.add(builder.getReceiverValue());
-            List<Value> argumentValues = builder.getArgumentValues();
-            if (argumentValues != null) {
-              arguments.addAll(builder.getArgumentValues());
-            }
-          }
-          builder.addInvoke(
-              Invoke.Type.VIRTUAL, method, method.proto, arguments, false /* isInterface */);
-        });
-    // Handle return value if needed.
-    if (returnsValue) {
-      add(builder -> builder.addMoveResult(retRegister));
-      add(builder -> builder.addReturn(retRegister), endsBlock);
-    } else {
-      add(IRBuilder::addReturn, endsBlock);
-    }
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinClassMetadataReader.java b/src/main/java/com/android/tools/r8/kotlin/KotlinClassMetadataReader.java
index 6b011a6..6fc09f5 100644
--- a/src/main/java/com/android/tools/r8/kotlin/KotlinClassMetadataReader.java
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinClassMetadataReader.java
@@ -7,6 +7,7 @@
 import static com.android.tools.r8.kotlin.KotlinMetadataUtils.NO_KOTLIN_INFO;
 import static com.android.tools.r8.kotlin.KotlinSyntheticClassInfo.getFlavour;
 
+import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexAnnotation;
 import com.android.tools.r8.graph.DexAnnotationElement;
 import com.android.tools.r8.graph.DexClass;
@@ -35,11 +36,10 @@
       DexClass clazz,
       DexItemFactory factory,
       Reporter reporter,
-      boolean onlyProcessLambda,
       Consumer<DexEncodedMethod> keepByteCode) {
     DexAnnotation meta = clazz.annotations().getFirstMatching(factory.kotlinMetadataType);
     if (meta != null) {
-      return getKotlinInfo(kotlin, clazz, factory, reporter, onlyProcessLambda, keepByteCode, meta);
+      return getKotlinInfo(kotlin, clazz, factory, reporter, keepByteCode, meta);
     }
     return NO_KOTLIN_INFO;
   }
@@ -49,14 +49,10 @@
       DexClass clazz,
       DexItemFactory factory,
       Reporter reporter,
-      boolean onlyProcessLambda,
       Consumer<DexEncodedMethod> keepByteCode,
       DexAnnotation annotation) {
     try {
       KotlinClassMetadata kMetadata = toKotlinClassMetadata(kotlin, annotation.annotation);
-      if (onlyProcessLambda && !isSyntheticClassifiedLambda(kotlin, clazz, kMetadata)) {
-        return NO_KOTLIN_INFO;
-      }
       return createKotlinInfo(kotlin, clazz, kMetadata, factory, reporter, keepByteCode);
     } catch (ClassCastException | InconsistentKotlinMetadataException | MetadataError e) {
       reporter.info(
@@ -77,12 +73,18 @@
     }
   }
 
-  private static boolean isSyntheticClassifiedLambda(
-      Kotlin kotlin, DexClass clazz, KotlinClassMetadata kMetadata) {
-    if (kMetadata instanceof SyntheticClass) {
-      SyntheticClass syntheticClass = (SyntheticClass) kMetadata;
-      return syntheticClass.isLambda()
-          && getFlavour(syntheticClass, clazz, kotlin) != Flavour.Unclassified;
+  public static boolean isLambda(AppView<?> appView, DexClass clazz) {
+    DexItemFactory dexItemFactory = appView.dexItemFactory();
+    Kotlin kotlin = dexItemFactory.kotlin;
+    DexAnnotation metadataAnnotation =
+        clazz.annotations().getFirstMatching(dexItemFactory.kotlinMetadataType);
+    if (metadataAnnotation != null) {
+      KotlinClassMetadata kMetadata = toKotlinClassMetadata(kotlin, metadataAnnotation.annotation);
+      if (kMetadata instanceof SyntheticClass) {
+        SyntheticClass syntheticClass = (SyntheticClass) kMetadata;
+        return syntheticClass.isLambda()
+            && getFlavour(syntheticClass, clazz, kotlin) != Flavour.Unclassified;
+      }
     }
     return false;
   }
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinMetadataEnqueuerExtension.java b/src/main/java/com/android/tools/r8/kotlin/KotlinMetadataEnqueuerExtension.java
index f9d2d18..4eef6cb 100644
--- a/src/main/java/com/android/tools/r8/kotlin/KotlinMetadataEnqueuerExtension.java
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinMetadataEnqueuerExtension.java
@@ -18,6 +18,8 @@
 import com.android.tools.r8.graph.EnclosingMethodAttribute;
 import com.android.tools.r8.graph.ProgramDefinition;
 import com.android.tools.r8.graph.analysis.EnqueuerAnalysis;
+import com.android.tools.r8.ir.optimize.info.OptimizationFeedback;
+import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackSimple;
 import com.android.tools.r8.shaking.Enqueuer;
 import com.android.tools.r8.shaking.Enqueuer.EnqueuerDefinitionSupplier;
 import com.google.common.collect.Sets;
@@ -25,6 +27,8 @@
 
 public class KotlinMetadataEnqueuerExtension extends EnqueuerAnalysis {
 
+  private static final OptimizationFeedback feedback = OptimizationFeedbackSimple.getInstance();
+
   private final AppView<?> appView;
   private final EnqueuerDefinitionSupplier enqueuerDefinitionSupplier;
   private final Set<DexType> prunedTypes;
@@ -57,23 +61,27 @@
       Set<DexProgramClass> localOrAnonymousClasses = Sets.newIdentityHashSet();
       enqueuer.forAllLiveClasses(
           clazz -> {
-            boolean onlyProcessLambdas = !keepMetadata || !enqueuer.isPinned(clazz.type);
             assert clazz.getKotlinInfo().isNoKotlinInformation();
-            clazz.setKotlinInfo(
-                KotlinClassMetadataReader.getKotlinInfo(
-                    appView.dexItemFactory().kotlin,
-                    clazz,
-                    appView.dexItemFactory(),
-                    appView.options().reporter,
-                    onlyProcessLambdas,
-                    method -> keepByteCodeFunctions.add(method.method)));
-            if (onlyProcessLambdas) {
+            if (!keepMetadata || !enqueuer.isPinned(clazz.getType())) {
+              if (KotlinClassMetadataReader.isLambda(appView, clazz)
+                  && clazz.hasClassInitializer()) {
+                feedback.classInitializerMayBePostponed(clazz.getClassInitializer());
+              }
+              clazz.setKotlinInfo(NO_KOTLIN_INFO);
               clazz.removeAnnotations(
                   annotation -> annotation.getAnnotationType() == kotlinMetadataType);
-            }
-            if (clazz.getEnclosingMethodAttribute() != null
-                && clazz.getEnclosingMethodAttribute().getEnclosingMethod() != null) {
-              localOrAnonymousClasses.add(clazz);
+            } else {
+              clazz.setKotlinInfo(
+                  KotlinClassMetadataReader.getKotlinInfo(
+                      appView.dexItemFactory().kotlin,
+                      clazz,
+                      appView.dexItemFactory(),
+                      appView.options().reporter,
+                      method -> keepByteCodeFunctions.add(method.getReference())));
+              if (clazz.getEnclosingMethodAttribute() != null
+                  && clazz.getEnclosingMethodAttribute().getEnclosingMethod() != null) {
+                localOrAnonymousClasses.add(clazz);
+              }
             }
           });
       appView.setCfByteCodePassThrough(keepByteCodeFunctions);
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinMetadataRewriter.java b/src/main/java/com/android/tools/r8/kotlin/KotlinMetadataRewriter.java
index 1001ca9..44d6ede 100644
--- a/src/main/java/com/android/tools/r8/kotlin/KotlinMetadataRewriter.java
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinMetadataRewriter.java
@@ -139,7 +139,7 @@
           }
           final KotlinClassLevelInfo kotlinInfo =
               KotlinClassMetadataReader.getKotlinInfo(
-                  kotlin, clazz, factory, reporter, false, ConsumerUtils.emptyConsumer(), metadata);
+                  kotlin, clazz, factory, reporter, ConsumerUtils.emptyConsumer(), metadata);
           if (kotlinInfo == NO_KOTLIN_INFO) {
             return;
           }
diff --git a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
index baa1189..06c03e7 100644
--- a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
+++ b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
@@ -195,7 +195,7 @@
   AppInfoWithLiveness(
       CommittedItems syntheticItems,
       ClassToFeatureSplitMap classToFeatureSplitMap,
-      MainDexClasses mainDexClasses,
+      MainDexInfo mainDexInfo,
       Set<DexType> deadProtoTypes,
       MissingClasses missingClasses,
       Set<DexType> liveTypes,
@@ -234,7 +234,7 @@
       Map<DexField, Int2ReferenceMap<DexField>> switchMaps,
       Set<DexType> lockCandidates,
       Map<DexType, Visibility> initClassReferences) {
-    super(syntheticItems, classToFeatureSplitMap, mainDexClasses, missingClasses);
+    super(syntheticItems, classToFeatureSplitMap, mainDexInfo, missingClasses);
     this.deadProtoTypes = deadProtoTypes;
     this.liveTypes = liveTypes;
     this.targetedMethods = targetedMethods;
@@ -279,7 +279,7 @@
     this(
         committedItems,
         previous.getClassToFeatureSplitMap(),
-        previous.getMainDexClasses(),
+        previous.getMainDexInfo(),
         previous.deadProtoTypes,
         previous.getMissingClasses(),
         CollectionUtils.mergeSets(previous.liveTypes, committedItems.getCommittedProgramTypes()),
@@ -324,7 +324,7 @@
     this(
         previous.getSyntheticItems().commitPrunedItems(prunedItems),
         previous.getClassToFeatureSplitMap().withoutPrunedItems(prunedItems),
-        previous.getMainDexClasses().withoutPrunedItems(prunedItems),
+        previous.getMainDexInfo().withoutPrunedItems(prunedItems),
         previous.deadProtoTypes,
         previous.getMissingClasses(),
         prunedItems.hasRemovedClasses()
@@ -376,6 +376,52 @@
     return true;
   }
 
+  @Override
+  public AppInfoWithLiveness rebuildWithMainDexInfo(MainDexInfo mainDexInfo) {
+    return new AppInfoWithLiveness(
+        getSyntheticItems().commit(app()),
+        getClassToFeatureSplitMap(),
+        mainDexInfo,
+        deadProtoTypes,
+        getMissingClasses(),
+        liveTypes,
+        targetedMethods,
+        failedMethodResolutionTargets,
+        failedFieldResolutionTargets,
+        bootstrapMethods,
+        methodsTargetedByInvokeDynamic,
+        virtualMethodsTargetedByInvokeDirect,
+        liveMethods,
+        fieldAccessInfoCollection,
+        methodAccessInfoCollection,
+        objectAllocationInfoCollection,
+        callSites,
+        keepInfo,
+        mayHaveSideEffects,
+        noSideEffects,
+        assumedValues,
+        alwaysInline,
+        forceInline,
+        neverInline,
+        neverInlineDueToSingleCaller,
+        whyAreYouNotInlining,
+        keepConstantArguments,
+        keepUnusedArguments,
+        reprocess,
+        neverReprocess,
+        alwaysClassInline,
+        neverClassInline,
+        noClassMerging,
+        noVerticalClassMerging,
+        noHorizontalClassMerging,
+        neverPropagateValue,
+        identifierNameStrings,
+        prunedTypes,
+        switchMaps,
+        lockCandidates,
+        initClassReferences);
+  }
+
   private static KeepInfoCollection extendPinnedItems(
       AppInfoWithLiveness previous, Collection<? extends DexReference> additionalPinnedItems) {
     if (additionalPinnedItems == null || additionalPinnedItems.isEmpty()) {
@@ -418,7 +464,7 @@
     super(
         previous.getSyntheticItems().commit(previous.app()),
         previous.getClassToFeatureSplitMap(),
-        previous.getMainDexClasses(),
+        previous.getMainDexInfo(),
         previous.getMissingClasses());
     this.deadProtoTypes = previous.deadProtoTypes;
     this.liveTypes = previous.liveTypes;
@@ -999,7 +1045,7 @@
     return new AppInfoWithLiveness(
         committedItems,
         getClassToFeatureSplitMap().rewrittenWithLens(lens),
-        getMainDexClasses().rewrittenWithLens(lens),
+        getMainDexInfo().rewrittenWithLens(lens),
         deadProtoTypes,
         getMissingClasses().commitSyntheticItems(committedItems),
         lens.rewriteTypes(liveTypes),
diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index ce1dadb..9161f4f 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -61,6 +61,7 @@
 import com.android.tools.r8.graph.NestMemberClassAttribute;
 import com.android.tools.r8.graph.ObjectAllocationInfoCollectionImpl;
 import com.android.tools.r8.graph.ProgramDefinition;
+import com.android.tools.r8.graph.ProgramDerivedContext;
 import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.graph.ProgramMember;
 import com.android.tools.r8.graph.ProgramMethod;
@@ -149,7 +150,6 @@
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
@@ -177,6 +177,7 @@
     FINAL_TREE_SHAKING,
     INITIAL_MAIN_DEX_TRACING,
     FINAL_MAIN_DEX_TRACING,
+    GENERATE_MAIN_DEX_LIST,
     WHY_ARE_YOU_KEEPING;
 
     public boolean isInitialTreeShaking() {
@@ -199,8 +200,12 @@
       return this == FINAL_MAIN_DEX_TRACING;
     }
 
+    public boolean isGenerateMainDexList() {
+      return this == GENERATE_MAIN_DEX_LIST;
+    }
+
     public boolean isMainDexTracing() {
-      return isInitialMainDexTracing() || isFinalMainDexTracing();
+      return isInitialMainDexTracing() || isFinalMainDexTracing() || isGenerateMainDexList();
     }
 
     public boolean isWhyAreYouKeeping() {
@@ -345,11 +350,6 @@
   private final Map<DexProgramClass, Set<DexMethod>> reachableVirtualTargets =
       new IdentityHashMap<>();
 
-  /**
-   * A set of references we have reported missing to dedupe warnings.
-   */
-  private final Set<DexReference> reportedMissing = Sets.newIdentityHashSet();
-
   /** Collection of keep requirements for the program. */
   private final MutableKeepInfoCollection keepInfo = new MutableKeepInfoCollection();
 
@@ -398,15 +398,13 @@
   private final Map<DexMethod, ProgramMethod> methodsWithTwrCloseResource = new IdentityHashMap<>();
   private final Set<DexProgramClass> classesWithSerializableLambdas = Sets.newIdentityHashSet();
   private final ProgramMethodSet pendingDesugaring = ProgramMethodSet.create();
-  private final MainDexTracingResult previousMainDexTracingResult;
 
   Enqueuer(
       AppView<? extends AppInfoWithClassHierarchy> appView,
       ExecutorService executorService,
       SubtypingInfo subtypingInfo,
       GraphConsumer keptGraphConsumer,
-      Mode mode,
-      MainDexTracingResult previousMainDexTracingResult) {
+      Mode mode) {
     assert appView.appServices() != null;
     InternalOptions options = appView.options();
     this.appInfo = appView.appInfo();
@@ -424,7 +422,6 @@
         mode.isInitialTreeShaking() && options.forceProguardCompatibility
             ? ProguardCompatibilityActions.builder()
             : null;
-    this.previousMainDexTracingResult = previousMainDexTracingResult;
 
     if (mode.isInitialOrFinalTreeShaking()) {
       if (options.protoShrinking().enableGeneratedMessageLiteShrinking) {
@@ -549,8 +546,14 @@
     recordTypeReference(type, context, this::reportMissingClass);
   }
 
+  private void recordTypeReference(DexType type, ProgramDerivedContext context) {
+    recordTypeReference(type, context, this::reportMissingClass);
+  }
+
   private void recordTypeReference(
-      DexType type, ProgramDefinition context, Consumer<DexType> missingClassConsumer) {
+      DexType type,
+      ProgramDerivedContext context,
+      BiConsumer<DexType, ProgramDerivedContext> missingClassConsumer) {
     if (type == null) {
       return;
     }
@@ -569,7 +572,9 @@
   }
 
   private void recordMethodReference(
-      DexMethod method, ProgramDefinition context, Consumer<DexType> missingClassConsumer) {
+      DexMethod method,
+      ProgramDefinition context,
+      BiConsumer<DexType, ProgramDerivedContext> missingClassConsumer) {
     recordTypeReference(method.holder, context, missingClassConsumer);
     recordTypeReference(method.proto.returnType, context, missingClassConsumer);
     for (DexType type : method.proto.parameters.values) {
@@ -577,9 +582,9 @@
     }
   }
 
-  private void recordFieldReference(DexField field, ProgramDefinition context) {
-    recordTypeReference(field.holder, context);
-    recordTypeReference(field.type, context);
+  private void recordFieldReference(DexField field, ProgramDerivedContext context) {
+    recordTypeReference(field.getHolderType(), context);
+    recordTypeReference(field.getType(), context);
   }
 
   public DexEncodedMethod definitionFor(DexMethod method, ProgramDefinition context) {
@@ -595,15 +600,19 @@
   }
 
   private DexClass definitionFor(
-      DexType type, ProgramDefinition context, Consumer<DexType> missingClassConsumer) {
+      DexType type,
+      ProgramDerivedContext context,
+      BiConsumer<DexType, ProgramDerivedContext> missingClassConsumer) {
     return internalDefinitionFor(type, context, missingClassConsumer);
   }
 
   private DexClass internalDefinitionFor(
-      DexType type, ProgramDefinition context, Consumer<DexType> missingClassConsumer) {
+      DexType type,
+      ProgramDerivedContext context,
+      BiConsumer<DexType, ProgramDerivedContext> missingClassConsumer) {
     DexClass clazz = appInfo().definitionFor(type);
     if (clazz == null) {
-      missingClassConsumer.accept(type);
+      missingClassConsumer.accept(type, context);
       return null;
     }
     if (clazz.isNotProgramClass()) {
@@ -661,7 +670,7 @@
     }
     DexClass definition = appView.definitionFor(type);
     if (definition == null) {
-      reportMissingClass(type);
+      reportMissingClassWithoutContext(type);
       return;
     }
     if (definition.isProgramClass() || !liveNonProgramTypes.add(definition)) {
@@ -729,20 +738,6 @@
     items.forEachClass(this::enqueueRootClass);
   }
 
-  private void enqueueRootItem(Entry<DexReference, Set<ProguardKeepRuleBase>> root) {
-    DexReference reference = root.getKey();
-    Set<ProguardKeepRuleBase> rules = root.getValue();
-    if (reference.isDexField()) {
-      enqueueRootField(reference.asDexField(), rules);
-    } else if (reference.isDexMethod()) {
-      enqueueRootMethod(reference.asDexMethod(), rules);
-    } else if (reference.isDexType()) {
-      enqueueRootClass(reference.asDexType(), rules);
-    } else {
-      throw new Unreachable();
-    }
-  }
-
   // TODO(b/123923324): Verify that root items are present.
   private void enqueueRootClass(DexType type, Set<ProguardKeepRuleBase> rules) {
     DexProgramClass clazz = asProgramClassOrNull(appView.definitionFor(type));
@@ -1441,11 +1436,10 @@
       return;
     }
 
-    // Must mark the field as targeted even if it does not exist.
-    markFieldAsTargeted(fieldReference, currentMethod);
-
     FieldResolutionResult resolutionResult = resolveField(fieldReference, currentMethod);
     if (resolutionResult.isFailedOrUnknownResolution()) {
+      // Must mark the field as targeted even if it does not exist.
+      markFieldAsTargeted(fieldReference, currentMethod);
       noClassMerging.add(fieldReference.getHolderType());
       return;
     }
@@ -1471,15 +1465,12 @@
       Log.verbose(getClass(), "Register Iget `%s`.", fieldReference);
     }
 
-    // If unused interface removal is enabled, then we won't necessarily mark the actual holder of
-    // the field as live, if the holder is an interface.
-    if (appView.options().enableUnusedInterfaceRemoval) {
-      if (field.getReference() != fieldReference) {
-        markTypeAsLive(field.getHolder(), currentMethod);
-      }
+    if (field.getReference() != fieldReference) {
+      // Mark the initial resolution holder as live.
+      markTypeAsLive(resolutionResult.getInitialResolutionHolder(), currentMethod);
     }
 
-    workList.enqueueMarkReachableFieldAction(
+    workList.enqueueMarkInstanceFieldAsReachableAction(
         field, currentMethod, KeepReason.fieldReferencedIn(currentMethod));
   }
 
@@ -1497,11 +1488,10 @@
       return;
     }
 
-    // Must mark the field as targeted even if it does not exist.
-    markFieldAsTargeted(fieldReference, currentMethod);
-
     FieldResolutionResult resolutionResult = resolveField(fieldReference, currentMethod);
     if (resolutionResult.isFailedOrUnknownResolution()) {
+      // Must mark the field as targeted even if it does not exist.
+      markFieldAsTargeted(fieldReference, currentMethod);
       noClassMerging.add(fieldReference.getHolderType());
       return;
     }
@@ -1527,16 +1517,13 @@
       Log.verbose(getClass(), "Register Iput `%s`.", fieldReference);
     }
 
-    // If unused interface removal is enabled, then we won't necessarily mark the actual holder of
-    // the field as live, if the holder is an interface.
-    if (appView.options().enableUnusedInterfaceRemoval) {
-      if (field.getReference() != fieldReference) {
-        markTypeAsLive(field.getHolder(), currentMethod);
-      }
+    if (field.getReference() != fieldReference) {
+      // Mark the initial resolution holder as live.
+      markTypeAsLive(resolutionResult.getInitialResolutionHolder(), currentMethod);
     }
 
     KeepReason reason = KeepReason.fieldReferencedIn(currentMethod);
-    workList.enqueueMarkReachableFieldAction(field, currentMethod, reason);
+    workList.enqueueMarkInstanceFieldAsReachableAction(field, currentMethod, reason);
   }
 
   void traceStaticFieldRead(DexField field, ProgramMethod currentMethod) {
@@ -1598,9 +1585,9 @@
     }
 
     if (field.getReference() != fieldReference) {
-      // Mark the non-rebound field access as targeted. Note that this should only be done if the
-      // field is not a dead proto field (in which case we bail-out above).
-      markFieldAsTargeted(fieldReference, currentMethod);
+      // Mark the initial resolution holder as live. Note that this should only be done if the field
+      // is not a dead proto field (in which case we bail-out above).
+      markTypeAsLive(resolutionResult.getInitialResolutionHolder(), currentMethod);
     }
 
     markStaticFieldAsLive(field, currentMethod);
@@ -1663,9 +1650,9 @@
     }
 
     if (field.getReference() != fieldReference) {
-      // Mark the non-rebound field access as targeted. Note that this should only be done if the
-      // field is not a dead proto field (in which case we bail-out above).
-      markFieldAsTargeted(fieldReference, currentMethod);
+      // Mark the initial resolution holder as live. Note that this should only be done if the field
+      // is not a dead proto field (in which case we bail-out above).
+      markTypeAsLive(resolutionResult.getInitialResolutionHolder(), currentMethod);
     }
 
     markStaticFieldAsLive(field, currentMethod);
@@ -1733,6 +1720,13 @@
     markTypeAsLive(clazz, reason);
   }
 
+  private void markTypeAsLive(DexClass clazz, ProgramDefinition context) {
+    if (clazz.isProgramClass()) {
+      DexProgramClass programClass = clazz.asProgramClass();
+      markTypeAsLive(programClass, graphReporter.reportClassReferencedFrom(programClass, context));
+    }
+  }
+
   private void markTypeAsLive(DexProgramClass clazz, ProgramDefinition context) {
     markTypeAsLive(clazz, graphReporter.reportClassReferencedFrom(clazz, context));
   }
@@ -1754,14 +1748,20 @@
 
     assert !mode.isFinalMainDexTracing()
             || !options.testing.checkForNotExpandingMainDexTracingResult
-            || previousMainDexTracingResult.isRoot(clazz)
+            || appView.appInfo().getMainDexInfo().isTracedRoot(clazz)
             || clazz.toSourceString().contains(ENUM_UNBOXING_UTILITY_CLASS_SUFFIX)
         : "Class " + clazz.toSourceString() + " was not a main dex root in the first round";
 
     // Mark types in inner-class attributes referenced.
-    for (InnerClassAttribute innerClassAttribute : clazz.getInnerClasses()) {
-      recordTypeReference(innerClassAttribute.getInner(), clazz, this::ignoreMissingClass);
-      recordTypeReference(innerClassAttribute.getOuter(), clazz, this::ignoreMissingClass);
+    {
+      BiConsumer<DexType, ProgramDerivedContext> missingClassConsumer =
+          options.reportMissingClassesInInnerClassAttributes
+              ? this::reportMissingClass
+              : this::ignoreMissingClass;
+      for (InnerClassAttribute innerClassAttribute : clazz.getInnerClasses()) {
+        recordTypeReference(innerClassAttribute.getInner(), clazz, missingClassConsumer);
+        recordTypeReference(innerClassAttribute.getOuter(), clazz, missingClassConsumer);
+      }
     }
 
     // Mark types in nest attributes referenced.
@@ -1777,11 +1777,15 @@
     EnclosingMethodAttribute enclosingMethodAttribute = clazz.getEnclosingMethodAttribute();
     if (enclosingMethodAttribute != null) {
       DexMethod enclosingMethod = enclosingMethodAttribute.getEnclosingMethod();
+      BiConsumer<DexType, ProgramDerivedContext> missingClassConsumer =
+          options.reportMissingClassesInEnclosingMethodAttribute
+              ? this::reportMissingClass
+              : this::ignoreMissingClass;
       if (enclosingMethod != null) {
-        recordMethodReference(enclosingMethod, clazz, this::ignoreMissingClass);
+        recordMethodReference(enclosingMethod, clazz, missingClassConsumer);
       } else {
         recordTypeReference(
-            enclosingMethodAttribute.getEnclosingClass(), clazz, this::ignoreMissingClass);
+            enclosingMethodAttribute.getEnclosingClass(), clazz, missingClassConsumer);
       }
     }
 
@@ -1951,8 +1955,8 @@
       DexProgramClass holder, ProgramDefinition annotatedItem, DexAnnotation annotation) {
     assert annotatedItem == holder || annotatedItem.asProgramMember().getHolder() == holder;
     assert !holder.isDexClass() || holder.asDexClass().isProgramClass();
-    DexType type = annotation.annotation.type;
-    recordTypeReference(type, holder);
+    DexType type = annotation.getAnnotationType();
+    recordTypeReference(type, annotatedItem);
     DexClass clazz = appView.definitionFor(type);
     boolean annotationTypeIsLibraryClass = clazz == null || clazz.isNotProgramClass();
     boolean isLive = annotationTypeIsLibraryClass || liveTypes.contains(clazz.asProgramClass());
@@ -1967,17 +1971,20 @@
     graphReporter.registerAnnotation(annotation, reason);
     AnnotationReferenceMarker referenceMarker =
         new AnnotationReferenceMarker(
-            annotation.annotation.type, holder, appView.dexItemFactory(), reason);
+            annotation.getAnnotationType(), annotatedItem, appView.dexItemFactory(), reason);
     annotation.annotation.collectIndexedItems(referenceMarker);
   }
 
   private FieldResolutionResult resolveField(DexField field, ProgramDefinition context) {
     // Record the references in case they are not program types.
-    recordFieldReference(field, context);
     FieldResolutionResult resolutionResult = appInfo.resolveField(field);
-    if (resolutionResult.isFailedOrUnknownResolution()) {
-      reportMissingField(field);
+    if (resolutionResult.isSuccessfulResolution()) {
+      recordFieldReference(
+          field, resolutionResult.getResolutionPair().asProgramDerivedContext(context));
+    } else {
+      assert resolutionResult.isFailedOrUnknownResolution();
       failedFieldResolutionTargets.add(field);
+      recordFieldReference(field, context);
     }
     return resolutionResult;
   }
@@ -1988,7 +1995,6 @@
     recordMethodReference(method, context);
     ResolutionResult resolutionResult = appInfo.unsafeResolveMethodDueToDexFormat(method);
     if (resolutionResult.isFailedResolution()) {
-      reportMissingMethod(method);
       markFailedMethodResolutionTargets(
           method, resolutionResult.asFailedResolution(), context, reason);
     }
@@ -2001,7 +2007,6 @@
     recordMethodReference(method, context);
     ResolutionResult resolutionResult = appInfo.resolveMethod(method, interfaceInvoke);
     if (resolutionResult.isFailedResolution()) {
-      reportMissingMethod(method);
       markFailedMethodResolutionTargets(
           method, resolutionResult.asFailedResolution(), context, reason);
     }
@@ -2142,7 +2147,6 @@
     DexEncodedMethod encodedMethod = clazz.lookupMethod(reference);
     if (encodedMethod == null) {
       failedMethodResolutionTargets.add(reference);
-      reportMissingMethod(reference);
       return;
     }
 
@@ -2243,7 +2247,11 @@
     missingClassesBuilder.ignoreNewMissingClass(clazz);
   }
 
-  private void reportMissingClass(DexType clazz) {
+  private void ignoreMissingClass(DexType clazz, ProgramDerivedContext context) {
+    ignoreMissingClass(clazz);
+  }
+
+  private void reportMissingClass(DexType clazz, ProgramDerivedContext context) {
     assert !mode.isFinalTreeShaking()
             || missingClassesBuilder.wasAlreadyMissing(clazz)
             || appView.dexItemFactory().isPossiblyCompilerSynthesizedType(clazz)
@@ -2251,19 +2259,19 @@
             // TODO(b/157107464): See if we can clean this up.
             || (initialPrunedTypes != null && initialPrunedTypes.contains(clazz))
         : "Unexpected missing class `" + clazz.toSourceString() + "`";
-    missingClassesBuilder.addNewMissingClass(clazz);
+    missingClassesBuilder.addNewMissingClass(clazz, context);
   }
 
-  private void reportMissingMethod(DexMethod method) {
-    if (Log.ENABLED && reportedMissing.add(method)) {
-      Log.verbose(Enqueuer.class, "Method `%s` is missing.", method);
-    }
-  }
-
-  private void reportMissingField(DexField field) {
-    if (Log.ENABLED && reportedMissing.add(field)) {
-      Log.verbose(Enqueuer.class, "Field `%s` is missing.", field);
-    }
+  @Deprecated
+  private void reportMissingClassWithoutContext(DexType clazz) {
+    assert !mode.isFinalTreeShaking()
+            || missingClassesBuilder.wasAlreadyMissing(clazz)
+            || appView.dexItemFactory().isPossiblyCompilerSynthesizedType(clazz)
+            || initialDeadProtoTypes.contains(clazz)
+            // TODO(b/157107464): See if we can clean this up.
+            || (initialPrunedTypes != null && initialPrunedTypes.contains(clazz))
+        : "Unexpected missing class `" + clazz.toSourceString() + "`";
+    missingClassesBuilder.legacyAddNewMissingClass(clazz);
   }
 
   private void markMethodAsTargeted(ProgramMethod method, KeepReason reason) {
@@ -2644,9 +2652,14 @@
     }
   }
 
+  private void markFieldAsTargeted(ProgramField field) {
+    markTypeAsLive(field.getHolder(), field);
+    markTypeAsLive(field.getType(), field);
+  }
+
   private void markFieldAsTargeted(DexField field, ProgramMethod context) {
-    markTypeAsLive(field.type, context);
-    markTypeAsLive(field.holder, context);
+    markTypeAsLive(field.getHolderType(), context);
+    markTypeAsLive(field.getType(), context);
   }
 
   private void markStaticFieldAsLive(ProgramField field, ProgramMethod context) {
@@ -2655,9 +2668,8 @@
 
   private void markStaticFieldAsLive(
       ProgramField field, ProgramDefinition context, KeepReason reason) {
-    // Mark the type live here, so that the class exists at runtime.
-    markTypeAsLive(field.getHolder(), field);
-    markTypeAsLive(field.getReference().type, field);
+    // Mark the field type and holder live here, so that they exist at runtime.
+    markFieldAsTargeted(field);
 
     markDirectAndIndirectClassInitializersAsLive(field.getHolder());
 
@@ -2687,8 +2699,8 @@
 
   private void markInstanceFieldAsLive(
       ProgramField field, ProgramDefinition context, KeepReason reason) {
-    markTypeAsLive(field.getHolder(), field);
-    markTypeAsLive(field.getType(), field);
+    markFieldAsTargeted(field);
+
     if (Log.ENABLED) {
       Log.verbose(getClass(), "Adding instance field `%s` to live set.", field);
     }
@@ -2816,8 +2828,7 @@
         field.getHolder())) {
       markInstanceFieldAsLive(field, context, reason);
     } else {
-      markTypeAsLive(field.getHolder(), field);
-      markTypeAsLive(field.getReference().type, field);
+      markFieldAsTargeted(field);
 
       // Add the field to the reachable set if the type later becomes instantiated.
       reachableInstanceFields
@@ -3014,16 +3025,27 @@
   }
 
   // Returns the set of live types.
-  public Set<DexProgramClass> traceMainDex(
-      RootSet rootSet, ExecutorService executorService, Timing timing) throws ExecutionException {
+  public MainDexInfo traceMainDex(ExecutorService executorService, Timing timing)
+      throws ExecutionException {
     assert analyses.isEmpty();
     assert mode.isMainDexTracing();
-    this.rootSet = rootSet;
+    this.rootSet = appView.getMainDexRootSet();
     // Translate the result of root-set computation into enqueuer actions.
     enqueueRootItems(rootSet.noShrinking);
     trace(executorService, timing);
     options.reporter.failIfPendingErrors();
-    return liveTypes.getItems();
+    // Calculate the automatic main dex list according to legacy multidex constraints.
+    MainDexInfo.Builder builder = appView.appInfo().getMainDexInfo().builder();
+    liveTypes.getItems().forEach(builder::addRoot);
+    if (mode.isInitialMainDexTracing()) {
+      liveMethods.getItems().forEach(method -> builder.addRoot(method.method));
+    } else {
+      assert appView.appInfo().getMainDexInfo().isTracedMethodRootsCleared()
+          || mode.isGenerateMainDexList();
+    }
+    new MainDexListBuilder(appView, builder.getRoots(), builder).run();
+    MainDexInfo previousMainDexInfo = appInfo.getMainDexInfo();
+    return builder.build(previousMainDexInfo);
   }
 
   public AppInfoWithLiveness traceApplication(
@@ -3155,8 +3177,6 @@
 
     Map<DexMethod, ProgramMethod> liveMethods = new IdentityHashMap<>();
 
-    Map<DexType, DexProgramClass> syntheticProgramClasses = new IdentityHashMap<>();
-
     Map<DexType, DexClasspathClass> syntheticClasspathClasses = new IdentityHashMap<>();
 
     // Subset of live methods that need have keep requirements.
@@ -3171,7 +3191,6 @@
           desugaredMethods.isEmpty()
               && syntheticInstantiations.isEmpty()
               && liveMethods.isEmpty()
-              && syntheticProgramClasses.isEmpty()
               && syntheticClasspathClasses.isEmpty();
       assert !empty || (liveMethodsWithKeepActions.isEmpty() && mainDexTypes.isEmpty());
       return empty;
@@ -3187,11 +3206,6 @@
       assert old == null;
     }
 
-    void addProgramClass(DexProgramClass clazz) {
-      DexProgramClass old = syntheticProgramClasses.put(clazz.type, clazz);
-      assert old == null;
-    }
-
     void addLiveMethod(ProgramMethod method) {
       DexMethod signature = method.getDefinition().method;
       assert !liveMethods.containsKey(signature);
@@ -3206,13 +3220,12 @@
 
     void amendApplication(Builder appBuilder) {
       assert !isEmpty();
-      appBuilder.addProgramClasses(syntheticProgramClasses.values());
       appBuilder.addClasspathClasses(syntheticClasspathClasses.values());
     }
 
-    void amendMainDexClasses(MainDexClasses mainDexClasses) {
+    void amendMainDexClasses(MainDexInfo mainDexInfo) {
       assert !isEmpty();
-      mainDexClasses.addAll(mainDexTypes);
+      mainDexTypes.forEach(mainDexInfo::addSyntheticClass);
     }
 
     void enqueueWorkItems(Enqueuer enqueuer) {
@@ -3283,7 +3296,6 @@
     synthesizeLambdas(additions);
     synthesizeLibraryConversionWrappers(additions);
     synthesizeBackports(additions);
-    synthesizeNestConstructor(additions);
     synthesizeTwrCloseResource(additions);
     if (additions.isEmpty()) {
       return;
@@ -3297,7 +3309,7 @@
               additions.amendApplication(appBuilder);
               return appBuilder.build();
             });
-    additions.amendMainDexClasses(appInfo.getMainDexClasses());
+    additions.amendMainDexClasses(appInfo.getMainDexInfo());
     appView.setAppInfo(appInfo);
     subtypingInfo = new SubtypingInfo(appView);
 
@@ -3372,16 +3384,6 @@
     }
   }
 
-  private void synthesizeNestConstructor(SyntheticAdditions additions) {
-    if (nestBasedAccessRewriter != null) {
-      DexProgramClass nestConstructor = nestBasedAccessRewriter.synthesizeNestConstructor();
-      if (nestConstructor != null) {
-        // TODO(b/177638147): use getSyntheticItems().createClass().
-        additions.addProgramClass(nestConstructor);
-      }
-    }
-  }
-
   private void synthesizeTwrCloseResource(SyntheticAdditions additions) {
     for (ProgramMethod method : methodsWithTwrCloseResource.values()) {
       twrCloseResourceRewriter.rewriteCf(method, additions::addLiveMethod);
@@ -3501,7 +3503,7 @@
         new AppInfoWithLiveness(
             appInfo.getSyntheticItems().commit(app),
             appInfo.getClassToFeatureSplitMap(),
-            appInfo.getMainDexClasses(),
+            appInfo.getMainDexInfo(),
             deadProtoTypes,
             appView.testing().enableExperimentalMissingClassesReporting
                 ? missingClassesBuilder.reportMissingClasses(appView)
@@ -4107,15 +4109,10 @@
       DexProgramClass clazz, Supplier<KeepReason> reasonSupplier) {
     assert forceProguardCompatibility;
 
-    if (appView.hasProguardCompatibilityActions()
-        && !appView.getProguardCompatibilityActions().isCompatInstantiated(clazz)) {
+    if (!addCompatInstantiatedClass(clazz)) {
       return;
     }
 
-    if (mode.isInitialTreeShaking()) {
-      proguardCompatibilityActionsBuilder.addCompatInstantiatedType(clazz);
-    }
-
     KeepReasonWitness witness = graphReporter.registerClass(clazz, reasonSupplier.get());
     if (clazz.isAnnotation()) {
       markTypeAsLive(clazz, witness);
@@ -4133,6 +4130,25 @@
     }
   }
 
+  private boolean addCompatInstantiatedClass(DexProgramClass clazz) {
+    assert forceProguardCompatibility;
+
+    // During the first round of tree shaking, we compat-instantiate all classes referenced from
+    // check-cast, const-class, and instance-of instructions.
+    if (mode.isInitialTreeShaking()) {
+      proguardCompatibilityActionsBuilder.addCompatInstantiatedType(clazz);
+      return true;
+    }
+
+    assert proguardCompatibilityActionsBuilder == null;
+
+    // Otherwise, we only compat-instantiate classes referenced from check-cast, const-class, and
+    // instance-of instructions that were also compat-instantiated during the first round of tree
+    // shaking.
+    return appView.hasProguardCompatibilityActions()
+        && appView.getProguardCompatibilityActions().isCompatInstantiated(clazz);
+  }
+
   private void markMethodAsLiveWithCompatRule(ProgramMethod method) {
     enqueueMarkMethodLiveAction(method, method, graphReporter.reportCompatKeepMethod(method));
   }
diff --git a/src/main/java/com/android/tools/r8/shaking/EnqueuerFactory.java b/src/main/java/com/android/tools/r8/shaking/EnqueuerFactory.java
index 04fb840..cfce371 100644
--- a/src/main/java/com/android/tools/r8/shaking/EnqueuerFactory.java
+++ b/src/main/java/com/android/tools/r8/shaking/EnqueuerFactory.java
@@ -19,13 +19,7 @@
       AppView<? extends AppInfoWithClassHierarchy> appView,
       ExecutorService executorService,
       SubtypingInfo subtypingInfo) {
-    return new Enqueuer(
-        appView,
-        executorService,
-        subtypingInfo,
-        null,
-        Mode.INITIAL_TREE_SHAKING,
-        MainDexTracingResult.NONE);
+    return new Enqueuer(appView, executorService, subtypingInfo, null, Mode.INITIAL_TREE_SHAKING);
   }
 
   public static Enqueuer createForFinalTreeShaking(
@@ -36,12 +30,7 @@
       Set<DexType> initialPrunedTypes) {
     Enqueuer enqueuer =
         new Enqueuer(
-            appView,
-            executorService,
-            subtypingInfo,
-            keptGraphConsumer,
-            Mode.FINAL_TREE_SHAKING,
-            MainDexTracingResult.NONE);
+            appView, executorService, subtypingInfo, keptGraphConsumer, Mode.FINAL_TREE_SHAKING);
     appView.withProtoShrinker(
         shrinker -> enqueuer.setInitialDeadProtoTypes(shrinker.getDeadProtoTypes()));
     enqueuer.setInitialPrunedTypes(initialPrunedTypes);
@@ -53,27 +42,25 @@
       ExecutorService executorService,
       SubtypingInfo subtypingInfo) {
     return new Enqueuer(
-        appView,
-        executorService,
-        subtypingInfo,
-        null,
-        Mode.INITIAL_MAIN_DEX_TRACING,
-        MainDexTracingResult.NONE);
+        appView, executorService, subtypingInfo, null, Mode.INITIAL_MAIN_DEX_TRACING);
   }
 
   public static Enqueuer createForFinalMainDexTracing(
       AppView<? extends AppInfoWithClassHierarchy> appView,
       ExecutorService executorService,
       SubtypingInfo subtypingInfo,
-      GraphConsumer keptGraphConsumer,
-      MainDexTracingResult previousMainDexTracingResult) {
+      GraphConsumer keptGraphConsumer) {
     return new Enqueuer(
-        appView,
-        executorService,
-        subtypingInfo,
-        keptGraphConsumer,
-        Mode.FINAL_MAIN_DEX_TRACING,
-        previousMainDexTracingResult);
+        appView, executorService, subtypingInfo, keptGraphConsumer, Mode.FINAL_MAIN_DEX_TRACING);
+  }
+
+  public static Enqueuer createForGenerateMainDexList(
+      AppView<? extends AppInfoWithClassHierarchy> appView,
+      ExecutorService executorService,
+      SubtypingInfo subtypingInfo,
+      GraphConsumer keptGraphConsumer) {
+    return new Enqueuer(
+        appView, executorService, subtypingInfo, keptGraphConsumer, Mode.GENERATE_MAIN_DEX_LIST);
   }
 
   public static Enqueuer createForWhyAreYouKeeping(
@@ -82,11 +69,6 @@
       SubtypingInfo subtypingInfo,
       GraphConsumer keptGraphConsumer) {
     return new Enqueuer(
-        appView,
-        executorService,
-        subtypingInfo,
-        keptGraphConsumer,
-        Mode.WHY_ARE_YOU_KEEPING,
-        MainDexTracingResult.NONE);
+        appView, executorService, subtypingInfo, keptGraphConsumer, Mode.WHY_ARE_YOU_KEEPING);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java b/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java
index b403b54..01e415b 100644
--- a/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java
+++ b/src/main/java/com/android/tools/r8/shaking/EnqueuerWorklist.java
@@ -55,13 +55,13 @@
     }
   }
 
-  static class MarkReachableFieldAction extends EnqueuerAction {
+  static class MarkInstanceFieldAsReachableAction extends EnqueuerAction {
     private final ProgramField field;
     // TODO(b/175854431): Avoid pushing context on worklist.
     private final ProgramDefinition context;
     private final KeepReason reason;
 
-    public MarkReachableFieldAction(
+    public MarkInstanceFieldAsReachableAction(
         ProgramField field, ProgramDefinition context, KeepReason reason) {
       this.field = field;
       this.context = context;
@@ -276,9 +276,9 @@
     queue.add(new MarkReachableSuperAction(method, from));
   }
 
-  public void enqueueMarkReachableFieldAction(
+  public void enqueueMarkInstanceFieldAsReachableAction(
       ProgramField field, ProgramDefinition context, KeepReason reason) {
-    queue.add(new MarkReachableFieldAction(field, context, reason));
+    queue.add(new MarkInstanceFieldAsReachableAction(field, context, reason));
   }
 
   // TODO(b/142378367): Context is the containing method that is cause of the instantiation.
diff --git a/src/main/java/com/android/tools/r8/shaking/MainDexClasses.java b/src/main/java/com/android/tools/r8/shaking/MainDexClasses.java
deleted file mode 100644
index 9c1c529..0000000
--- a/src/main/java/com/android/tools/r8/shaking/MainDexClasses.java
+++ /dev/null
@@ -1,118 +0,0 @@
-// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.shaking;
-
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.GraphLens;
-import com.android.tools.r8.graph.PrunedItems;
-import com.google.common.collect.Sets;
-import java.util.Set;
-import java.util.function.Consumer;
-
-public class MainDexClasses {
-
-  private final Set<DexType> mainDexClasses;
-
-  private MainDexClasses() {
-    this(Sets.newIdentityHashSet());
-  }
-
-  private MainDexClasses(Set<DexType> mainDexClasses) {
-    this.mainDexClasses = mainDexClasses;
-  }
-
-  public static Builder builder() {
-    return new Builder();
-  }
-
-  public static MainDexClasses createEmptyMainDexClasses() {
-    return new MainDexClasses();
-  }
-
-  public void add(DexProgramClass clazz) {
-    mainDexClasses.add(clazz.getType());
-  }
-
-  public void addAll(MainDexClasses other) {
-    mainDexClasses.addAll(other.mainDexClasses);
-  }
-
-  public void addAll(MainDexTracingResult other) {
-    mainDexClasses.addAll(other.getClasses());
-  }
-
-  public void addAll(Iterable<DexProgramClass> classes) {
-    for (DexProgramClass clazz : classes) {
-      add(clazz);
-    }
-  }
-
-  public boolean contains(DexType type) {
-    return mainDexClasses.contains(type);
-  }
-
-  public boolean contains(DexProgramClass clazz) {
-    return contains(clazz.getType());
-  }
-
-  public boolean containsAnyOf(Iterable<DexProgramClass> classes) {
-    for (DexProgramClass clazz : classes) {
-      if (contains(clazz)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  public void forEach(Consumer<DexType> fn) {
-    mainDexClasses.forEach(fn);
-  }
-
-  public boolean isEmpty() {
-    return mainDexClasses.isEmpty();
-  }
-
-  public MainDexClasses rewrittenWithLens(GraphLens lens) {
-    MainDexClasses rewrittenMainDexClasses = createEmptyMainDexClasses();
-    for (DexType mainDexClass : mainDexClasses) {
-      DexType rewrittenMainDexClass = lens.lookupType(mainDexClass);
-      rewrittenMainDexClasses.mainDexClasses.add(rewrittenMainDexClass);
-    }
-    return rewrittenMainDexClasses;
-  }
-
-  public int size() {
-    return mainDexClasses.size();
-  }
-
-  public MainDexClasses withoutPrunedItems(PrunedItems prunedItems) {
-    if (prunedItems.isEmpty()) {
-      return this;
-    }
-    MainDexClasses mainDexClassesAfterPruning = createEmptyMainDexClasses();
-    for (DexType mainDexClass : mainDexClasses) {
-      if (!prunedItems.getRemovedClasses().contains(mainDexClass)) {
-        mainDexClassesAfterPruning.mainDexClasses.add(mainDexClass);
-      }
-    }
-    return mainDexClassesAfterPruning;
-  }
-
-  public static class Builder {
-
-    private final Set<DexType> mainDexClasses = Sets.newIdentityHashSet();
-
-    private Builder() {}
-
-    public void add(DexProgramClass clazz) {
-      mainDexClasses.add(clazz.getType());
-    }
-
-    public MainDexClasses build() {
-      return new MainDexClasses(mainDexClasses);
-    }
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/shaking/MainDexDirectReferenceTracer.java b/src/main/java/com/android/tools/r8/shaking/MainDexDirectReferenceTracer.java
index 6f7cade..459dea6 100644
--- a/src/main/java/com/android/tools/r8/shaking/MainDexDirectReferenceTracer.java
+++ b/src/main/java/com/android/tools/r8/shaking/MainDexDirectReferenceTracer.java
@@ -25,6 +25,7 @@
 import com.android.tools.r8.utils.Box;
 import java.util.Set;
 import java.util.function.Consumer;
+import java.util.function.Predicate;
 
 public class MainDexDirectReferenceTracer {
   private final AnnotationDirectReferenceCollector annotationDirectReferenceCollector =
@@ -66,19 +67,19 @@
     method.registerCodeReferences(codeDirectReferenceCollector);
   }
 
-  public static boolean hasReferencesOutsideFromCode(
-      AppInfoWithClassHierarchy appInfo, ProgramMethod method, Set<DexType> classes) {
-    return getFirstReferenceOutsideFromCode(appInfo, method, classes) != null;
+  public static boolean hasReferencesOutsideMainDexClasses(
+      AppInfoWithClassHierarchy appInfo, ProgramMethod method, Predicate<DexType> isOutside) {
+    return getFirstReferenceOutsideFromCode(appInfo, method, isOutside) != null;
   }
 
   public static DexProgramClass getFirstReferenceOutsideFromCode(
-      AppInfoWithClassHierarchy appInfo, ProgramMethod method, Set<DexType> classes) {
+      AppInfoWithClassHierarchy appInfo, ProgramMethod method, Predicate<DexType> isOutside) {
     Box<DexProgramClass> result = new Box<>();
     new MainDexDirectReferenceTracer(
             appInfo,
             type -> {
               DexType baseType = type.toBaseType(appInfo.dexItemFactory());
-              if (baseType.isClassType() && !classes.contains(baseType)) {
+              if (baseType.isClassType() && isOutside.test(baseType)) {
                 DexClass cls = appInfo.definitionFor(baseType);
                 if (cls != null && cls.isProgramClass()) {
                   result.set(cls.asProgramClass());
diff --git a/src/main/java/com/android/tools/r8/shaking/MainDexInfo.java b/src/main/java/com/android/tools/r8/shaking/MainDexInfo.java
new file mode 100644
index 0000000..58315d4
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/shaking/MainDexInfo.java
@@ -0,0 +1,427 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.shaking;
+
+import static com.android.tools.r8.shaking.MainDexInfo.MainDexGroup.MAIN_DEX_ROOT;
+import static com.android.tools.r8.utils.LensUtils.rewriteAndApplyIfNotPrimitiveType;
+import static com.android.tools.r8.utils.PredicateUtils.not;
+
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexReference;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLens;
+import com.android.tools.r8.graph.ProgramDefinition;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.PrunedItems;
+import com.android.tools.r8.utils.ConsumerUtils;
+import com.android.tools.r8.utils.SetUtils;
+import com.google.common.collect.Sets;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
+
+public class MainDexInfo {
+
+  private static final MainDexInfo NONE =
+      new MainDexInfo(
+          Collections.emptySet(),
+          Collections.emptySet(),
+          Collections.emptySet(),
+          Collections.emptySet(),
+          Collections.emptySet(),
+          false);
+
+  public enum MainDexGroup {
+    MAIN_DEX_LIST,
+    MAIN_DEX_ROOT,
+    MAIN_DEX_DEPENDENCY,
+    NOT_IN_MAIN_DEX
+  }
+
+  // Specific set of classes specified to be in main-dex
+  private final Set<DexType> classList;
+  private final Map<DexType, DexType> synthesizedClassesMap;
+  // Traced roots are traced main dex references.
+  private final Set<DexType> tracedRoots;
+  // Traced method roots are the methods visited from an initial main dex root set. The set is
+  // cleared after the mergers has run.
+  private Set<DexMethod> tracedMethodRoots;
+  // Traced dependencies are those classes that are directly referenced from traced roots, but will
+  // not be loaded before loading the remaining dex files.
+  private final Set<DexType> tracedDependencies;
+  // Bit indicating if the traced methods are cleared.
+  private boolean tracedMethodRootsCleared = false;
+
+  private MainDexInfo(Set<DexType> classList) {
+    this(
+        classList,
+        Collections.emptySet(),
+        Collections.emptySet(),
+        Collections.emptySet(),
+        /* synthesized classes - cannot be emptyset */ Sets.newIdentityHashSet(),
+        false);
+  }
+
+  private MainDexInfo(
+      Set<DexType> classList,
+      Set<DexType> tracedRoots,
+      Set<DexMethod> tracedMethodRoots,
+      Set<DexType> tracedDependencies,
+      Set<DexType> synthesizedClasses,
+      boolean tracedMethodRootsCleared) {
+    this.classList = classList;
+    this.tracedRoots = tracedRoots;
+    this.tracedMethodRoots = tracedMethodRoots;
+    this.tracedDependencies = tracedDependencies;
+    this.synthesizedClassesMap = new ConcurrentHashMap<>();
+    this.tracedMethodRootsCleared = tracedMethodRootsCleared;
+    synthesizedClasses.forEach(type -> synthesizedClassesMap.put(type, type));
+    assert tracedDependencies.stream().noneMatch(tracedRoots::contains);
+    assert tracedRoots.containsAll(synthesizedClasses);
+  }
+
+  public boolean isNone() {
+    assert none() == NONE;
+    return this == NONE;
+  }
+
+  public boolean isMainDex(ProgramDefinition definition) {
+    return isFromList(definition) || isTracedRoot(definition) || isDependency(definition);
+  }
+
+  public boolean isFromList(ProgramDefinition definition) {
+    return isFromList(definition.getContextType());
+  }
+
+  private boolean isFromList(DexReference reference) {
+    return classList.contains(reference.getContextType());
+  }
+
+  public boolean isTracedRoot(ProgramDefinition definition) {
+    return isTracedRoot(definition.getContextType());
+  }
+
+  public boolean isTracedMethodRoot(DexMethod method) {
+    assert !tracedMethodRootsCleared : "Traced method roots are cleared after mergers has run";
+    return tracedMethodRoots.contains(method);
+  }
+
+  private boolean isTracedRoot(DexReference reference) {
+    return tracedRoots.contains(reference.getContextType());
+  }
+
+  private boolean isDependency(ProgramDefinition definition) {
+    return isDependency(definition.getContextType());
+  }
+
+  private boolean isDependency(DexReference reference) {
+    return tracedDependencies.contains(reference.getContextType());
+  }
+
+  public boolean isTracedMethodRootsCleared() {
+    return tracedMethodRootsCleared;
+  }
+
+  public void clearTracedMethodRoots() {
+    this.tracedMethodRootsCleared = true;
+    this.tracedMethodRoots = Sets.newIdentityHashSet();
+  }
+
+  public boolean canRebindReference(ProgramMethod context, DexReference referenceToTarget) {
+    MainDexGroup holderGroup = getMainDexGroupInternal(context);
+    if (holderGroup == MainDexGroup.NOT_IN_MAIN_DEX
+        || holderGroup == MainDexGroup.MAIN_DEX_DEPENDENCY) {
+      // We are always free to rebind/inline into something not in main-dex or traced dependencies.
+      return true;
+    }
+    if (holderGroup == MainDexGroup.MAIN_DEX_LIST) {
+      // If the holder is in the class list, we are not allowed to make any assumptions on the
+      // holder being a root or a dependency. Therefore we cannot merge.
+      return false;
+    }
+    assert holderGroup == MAIN_DEX_ROOT;
+    // Otherwise we allow if either is both root.
+    return getMainDexGroupInternal(referenceToTarget) == MAIN_DEX_ROOT;
+  }
+
+  public boolean canMerge(ProgramDefinition candidate) {
+    return !isFromList(candidate);
+  }
+
+  public boolean canMerge(ProgramDefinition source, ProgramDefinition target) {
+    return canMerge(source.getContextType(), target.getContextType());
+  }
+
+  private boolean canMerge(DexReference source, DexReference target) {
+    MainDexGroup sourceGroup = getMainDexGroupInternal(source);
+    MainDexGroup targetGroup = getMainDexGroupInternal(target);
+    if (sourceGroup != targetGroup) {
+      return false;
+    }
+    // If the holder is in the class list, we are not allowed to make any assumptions on the holder
+    // being a root or a dependency. Therefore we cannot merge.
+    return sourceGroup != MainDexGroup.MAIN_DEX_LIST;
+  }
+
+  public MainDexGroup getMergeKey(ProgramDefinition mergeCandidate) {
+    MainDexGroup mainDexGroupInternal = getMainDexGroupInternal(mergeCandidate);
+    return mainDexGroupInternal == MainDexGroup.MAIN_DEX_LIST ? null : mainDexGroupInternal;
+  }
+
+  private MainDexGroup getMainDexGroupInternal(ProgramDefinition definition) {
+    return getMainDexGroupInternal(definition.getReference());
+  }
+
+  private MainDexGroup getMainDexGroupInternal(DexReference reference) {
+    if (isFromList(reference)) {
+      return MainDexGroup.MAIN_DEX_LIST;
+    }
+    if (isTracedRoot(reference)) {
+      return MAIN_DEX_ROOT;
+    }
+    if (isDependency(reference)) {
+      return MainDexGroup.MAIN_DEX_DEPENDENCY;
+    }
+    return MainDexGroup.NOT_IN_MAIN_DEX;
+  }
+
+  public boolean disallowInliningIntoContext(
+      AppInfoWithClassHierarchy appInfo, ProgramDefinition context, ProgramMethod method) {
+    if (context.getContextType() == method.getContextType()) {
+      return false;
+    }
+    MainDexGroup mainDexGroupInternal = getMainDexGroupInternal(context);
+    if (mainDexGroupInternal == MainDexGroup.NOT_IN_MAIN_DEX
+        || mainDexGroupInternal == MainDexGroup.MAIN_DEX_DEPENDENCY) {
+      return false;
+    }
+    if (mainDexGroupInternal == MainDexGroup.MAIN_DEX_LIST) {
+      return MainDexDirectReferenceTracer.hasReferencesOutsideMainDexClasses(
+          appInfo, method, not(this::isFromList));
+    }
+    assert mainDexGroupInternal == MAIN_DEX_ROOT;
+    return MainDexDirectReferenceTracer.hasReferencesOutsideMainDexClasses(
+        appInfo, method, not(this::isTracedRoot));
+  }
+
+  public boolean isEmpty() {
+    assert !tracedRoots.isEmpty() || tracedDependencies.isEmpty();
+    return tracedRoots.isEmpty() && classList.isEmpty();
+  }
+
+  public static MainDexInfo none() {
+    return NONE;
+  }
+
+  // TODO(b/178127572): This mutates the MainDexClasses which otherwise should be immutable.
+  public void addSyntheticClass(DexProgramClass clazz) {
+    // TODO(b/178127572): This will add a synthesized type as long as the initial set is not empty.
+    //  A better approach would be to use the context for the synthetic with a containment check.
+    assert !isNone();
+    if (!classList.isEmpty()) {
+      synthesizedClassesMap.computeIfAbsent(
+          clazz.type,
+          type -> {
+            classList.add(type);
+            return type;
+          });
+    }
+    if (!tracedRoots.isEmpty()) {
+      synthesizedClassesMap.computeIfAbsent(
+          clazz.type,
+          type -> {
+            tracedRoots.add(type);
+            return type;
+          });
+    }
+  }
+
+  public void addLegacySyntheticClass(DexProgramClass clazz, ProgramDefinition context) {
+    if (isTracedRoot(context) || isFromList(context) || isDependency(context)) {
+      addSyntheticClass(clazz);
+    }
+  }
+
+  public int size() {
+    return classList.size() + tracedRoots.size() + tracedDependencies.size();
+  }
+
+  public void forEachExcludingDependencies(Consumer<DexType> fn) {
+    // Prevent seeing duplicates in the list and roots.
+    Set<DexType> seen = Sets.newIdentityHashSet();
+    classList.forEach(ConsumerUtils.acceptIfNotSeen(fn, seen));
+    tracedRoots.forEach(ConsumerUtils.acceptIfNotSeen(fn, seen));
+  }
+
+  public void forEach(Consumer<DexType> fn) {
+    // Prevent seeing duplicates in the list and roots.
+    Set<DexType> seen = Sets.newIdentityHashSet();
+    classList.forEach(ConsumerUtils.acceptIfNotSeen(fn, seen));
+    tracedRoots.forEach(ConsumerUtils.acceptIfNotSeen(fn, seen));
+    tracedDependencies.forEach(ConsumerUtils.acceptIfNotSeen(fn, seen));
+  }
+
+  public MainDexInfo withoutPrunedItems(PrunedItems prunedItems) {
+    if (prunedItems.isEmpty()) {
+      return this;
+    }
+    Set<DexType> removedClasses = prunedItems.getRemovedClasses();
+    Set<DexType> modifiedClassList = Sets.newIdentityHashSet();
+    Set<DexType> modifiedSynthesized = Sets.newIdentityHashSet();
+    classList.forEach(type -> ifNotRemoved(type, removedClasses, modifiedClassList::add));
+    synthesizedClassesMap
+        .keySet()
+        .forEach(type -> ifNotRemoved(type, removedClasses, modifiedSynthesized::add));
+    MainDexInfo.Builder builder = builder();
+    tracedRoots.forEach(type -> ifNotRemoved(type, removedClasses, builder::addRoot));
+    // TODO(b/169927809): Methods could be pruned without the holder being pruned, however, one has
+    //  to have a reference for querying a root.
+    tracedMethodRoots.forEach(
+        method ->
+            ifNotRemoved(
+                method.getHolderType(), removedClasses, ignored -> builder.addRoot(method)));
+    tracedDependencies.forEach(type -> ifNotRemoved(type, removedClasses, builder::addDependency));
+    return builder.build(modifiedClassList, modifiedSynthesized);
+  }
+
+  private void ifNotRemoved(
+      DexType type, Set<DexType> removedClasses, Consumer<DexType> notRemoved) {
+    if (!removedClasses.contains(type)) {
+      notRemoved.accept(type);
+    }
+  }
+
+  public MainDexInfo rewrittenWithLens(GraphLens lens) {
+    Set<DexType> modifiedClassList = Sets.newIdentityHashSet();
+    Set<DexType> modifiedSynthesized = Sets.newIdentityHashSet();
+    classList.forEach(
+        type -> rewriteAndApplyIfNotPrimitiveType(lens, type, modifiedClassList::add));
+    synthesizedClassesMap.keySet().forEach(type -> modifiedSynthesized.add(lens.lookupType(type)));
+    MainDexInfo.Builder builder = builder();
+    tracedRoots.forEach(type -> rewriteAndApplyIfNotPrimitiveType(lens, type, builder::addRoot));
+    tracedMethodRoots.forEach(method -> builder.addRoot(lens.getRenamedMethodSignature(method)));
+    tracedDependencies.forEach(
+        type -> {
+          if (lens.isSyntheticFinalizationGraphLens()) {
+            // Synthetic finalization is allowed to merge identical classes into the same class. The
+            // rewritten type of a traced dependency can therefore be finalized with a traced root.
+            rewriteAndApplyIfNotPrimitiveType(lens, type, builder::addDependencyIfNotRoot);
+          } else {
+            rewriteAndApplyIfNotPrimitiveType(lens, type, builder::addDependency);
+          }
+        });
+    return builder.build(modifiedClassList, modifiedSynthesized);
+  }
+
+  public Builder builder() {
+    return new Builder(tracedMethodRootsCleared);
+  }
+
+  public static class Builder {
+
+    private final Set<DexType> list = Sets.newIdentityHashSet();
+    private final Set<DexType> roots = Sets.newIdentityHashSet();
+    private final Set<DexMethod> methodRoots = Sets.newIdentityHashSet();
+    private final Set<DexType> dependencies = Sets.newIdentityHashSet();
+    private final boolean tracedMethodRootsCleared;
+
+    private Builder(boolean tracedMethodRootsCleared) {
+      this.tracedMethodRootsCleared = tracedMethodRootsCleared;
+    }
+
+    public void addList(DexProgramClass clazz) {
+      addList(clazz.getType());
+    }
+
+    public void addList(DexType type) {
+      list.add(type);
+    }
+
+    public void addRoot(DexProgramClass clazz) {
+      addRoot(clazz.getType());
+    }
+
+    public void addRoot(DexType type) {
+      assert !dependencies.contains(type);
+      roots.add(type);
+    }
+
+    public void addRoot(DexMethod method) {
+      methodRoots.add(method);
+    }
+
+    public void addDependency(DexProgramClass clazz) {
+      addDependency(clazz.getType());
+    }
+
+    public void addDependency(DexType type) {
+      assert !roots.contains(type);
+      dependencies.add(type);
+    }
+
+    public void addDependencyIfNotRoot(DexType type) {
+      if (roots.contains(type)) {
+        return;
+      }
+      addDependency(type);
+    }
+
+    public boolean isTracedRoot(DexProgramClass clazz) {
+      return isTracedRoot(clazz.getType());
+    }
+
+    public boolean isTracedRoot(DexType type) {
+      return roots.contains(type);
+    }
+
+    public boolean isDependency(DexProgramClass clazz) {
+      return isDependency(clazz.getType());
+    }
+
+    public boolean isDependency(DexType type) {
+      return dependencies.contains(type);
+    }
+
+    public boolean contains(DexProgramClass clazz) {
+      return contains(clazz.type);
+    }
+
+    public boolean contains(DexType type) {
+      return isTracedRoot(type) || isDependency(type);
+    }
+
+    public Set<DexType> getRoots() {
+      return roots;
+    }
+
+    public MainDexInfo buildList() {
+      // When building without passing the list, the method roots and dependencies should
+      // be empty since no tracing has been done.
+      assert dependencies.isEmpty();
+      assert roots.isEmpty();
+      return new MainDexInfo(list);
+    }
+
+    public MainDexInfo build(Set<DexType> classList, Set<DexType> synthesizedClasses) {
+      // Class can contain dependencies which we should not regard as roots.
+      assert list.isEmpty();
+      return new MainDexInfo(
+          classList,
+          SetUtils.unionIdentityHashSet(roots, synthesizedClasses),
+          methodRoots,
+          Sets.difference(dependencies, synthesizedClasses),
+          synthesizedClasses,
+          tracedMethodRootsCleared);
+    }
+
+    public MainDexInfo build(MainDexInfo previous) {
+      return build(previous.classList, previous.synthesizedClassesMap.keySet());
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/shaking/MainDexListBuilder.java b/src/main/java/com/android/tools/r8/shaking/MainDexListBuilder.java
index 4fa5d3a..afb39bf 100644
--- a/src/main/java/com/android/tools/r8/shaking/MainDexListBuilder.java
+++ b/src/main/java/com/android/tools/r8/shaking/MainDexListBuilder.java
@@ -13,7 +13,6 @@
 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.utils.SetUtils;
 import java.util.IdentityHashMap;
 import java.util.Map;
 import java.util.Set;
@@ -30,7 +29,7 @@
   private final Set<DexType> roots;
   private final AppView<? extends AppInfoWithClassHierarchy> appView;
   private final Map<DexType, Boolean> annotationTypeContainEnum;
-  private final MainDexTracingResult.Builder mainDexClassesBuilder;
+  private final MainDexInfo.Builder mainDexInfoBuilder;
 
   public static void checkForAssumedLibraryTypes(AppInfo appInfo) {
     DexClass enumType = appInfo.definitionFor(appInfo.dexItemFactory().enumType);
@@ -50,11 +49,14 @@
    * @param appView the dex appplication.
    */
   public MainDexListBuilder(
-      Set<DexProgramClass> roots, AppView<? extends AppInfoWithClassHierarchy> appView) {
+      AppView<? extends AppInfoWithClassHierarchy> appView,
+      Set<DexType> roots,
+      MainDexInfo.Builder mainDexInfoBuilder) {
     this.appView = appView;
     // Only consider program classes for the root set.
-    this.roots = SetUtils.mapIdentityHashSet(roots, DexProgramClass::getType);
-    mainDexClassesBuilder = MainDexTracingResult.builder(appView.appInfo()).addRoots(this.roots);
+    assert roots.stream().allMatch(type -> appView.definitionFor(type).isProgramClass());
+    this.roots = roots;
+    this.mainDexInfoBuilder = mainDexInfoBuilder;
     annotationTypeContainEnum = new IdentityHashMap<>();
   }
 
@@ -62,18 +64,17 @@
     return appView.appInfo();
   }
 
-  public MainDexTracingResult run() {
+  public void run() {
     traceMainDexDirectDependencies();
     traceRuntimeAnnotationsWithEnumForMainDex();
-    return mainDexClassesBuilder.build();
   }
 
   private void traceRuntimeAnnotationsWithEnumForMainDex() {
     for (DexProgramClass clazz : appInfo().classes()) {
-      DexType dexType = clazz.type;
-      if (mainDexClassesBuilder.contains(dexType)) {
+      if (mainDexInfoBuilder.contains(clazz)) {
         continue;
       }
+      DexType dexType = clazz.type;
       if (isAnnotation(dexType) && isAnnotationWithEnum(dexType)) {
         addAnnotationsWithEnum(clazz);
         continue;
@@ -82,10 +83,11 @@
       // annotations with enums goes into the main dex, move annotated classes there as well.
       clazz.forEachAnnotation(
           annotation -> {
-            if (!mainDexClassesBuilder.contains(dexType)
+            if (!mainDexInfoBuilder.contains(clazz)
                 && annotation.visibility == DexAnnotation.VISIBILITY_RUNTIME
                 && isAnnotationWithEnum(annotation.annotation.type)) {
-              addClassAnnotatedWithAnnotationWithEnum(dexType);
+              // Just add classes annotated with annotations with enum as direct dependencies.
+              mainDexInfoBuilder.addDependency(clazz);
             }
           });
     }
@@ -151,16 +153,10 @@
     }
   }
 
-  private void addClassAnnotatedWithAnnotationWithEnum(DexType type) {
-    // Just add classes annotated with annotations with enum ad direct dependencies.
-    addDirectDependency(type);
-  }
-
   private void addDirectDependency(DexType type) {
     // Consider only component type of arrays
     type = type.toBaseType(appView.dexItemFactory());
-
-    if (!type.isClassType() || mainDexClassesBuilder.contains(type)) {
+    if (!type.isClassType() || mainDexInfoBuilder.contains(type)) {
       return;
     }
 
@@ -173,9 +169,8 @@
   }
 
   private void addDirectDependency(DexProgramClass dexClass) {
-    DexType type = dexClass.type;
-    assert !mainDexClassesBuilder.contains(type);
-    mainDexClassesBuilder.addDependency(type);
+    assert !mainDexInfoBuilder.contains(dexClass);
+    mainDexInfoBuilder.addDependency(dexClass);
     if (dexClass.superType != null) {
       addDirectDependency(dexClass.superType);
     }
diff --git a/src/main/java/com/android/tools/r8/shaking/MainDexTracingResult.java b/src/main/java/com/android/tools/r8/shaking/MainDexTracingResult.java
deleted file mode 100644
index 5bf287f..0000000
--- a/src/main/java/com/android/tools/r8/shaking/MainDexTracingResult.java
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.shaking;
-
-import com.android.tools.r8.graph.AppInfo;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.ProgramDefinition;
-import com.android.tools.r8.utils.SetUtils;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Sets;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Set;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-
-public class MainDexTracingResult {
-
-  public static MainDexTracingResult NONE =
-      new MainDexTracingResult(ImmutableSet.of(), ImmutableSet.of());
-
-  public static class Builder {
-    public final AppInfo appInfo;
-    public final Set<DexType> roots;
-    public final Set<DexType> dependencies;
-
-    private Builder(AppInfo appInfo) {
-      this(appInfo, Sets.newIdentityHashSet(), Sets.newIdentityHashSet());
-    }
-
-    private Builder(AppInfo appInfo, MainDexTracingResult mainDexTracingResult) {
-      this(
-          appInfo,
-          SetUtils.newIdentityHashSet(mainDexTracingResult.getRoots()),
-          SetUtils.newIdentityHashSet(mainDexTracingResult.getDependencies()));
-    }
-
-    private Builder(AppInfo appInfo, Set<DexType> roots, Set<DexType> dependencies) {
-      this.appInfo = appInfo;
-      this.roots = roots;
-      this.dependencies = dependencies;
-    }
-
-    public Builder addRoot(DexProgramClass clazz) {
-      roots.add(clazz.getType());
-      return this;
-    }
-
-    public Builder addRoot(DexType type) {
-      assert isProgramClass(type) : type.toSourceString();
-      roots.add(type);
-      return this;
-    }
-
-    public Builder addRoots(Collection<DexType> rootSet) {
-      assert rootSet.stream().allMatch(this::isProgramClass);
-      this.roots.addAll(rootSet);
-      return this;
-    }
-
-    public Builder addDependency(DexType type) {
-      assert isProgramClass(type);
-      dependencies.add(type);
-      return this;
-    }
-
-    public boolean contains(DexType type) {
-      return roots.contains(type) || dependencies.contains(type);
-    }
-
-    public MainDexTracingResult build() {
-      return new MainDexTracingResult(roots, dependencies);
-    }
-
-    private boolean isProgramClass(DexType dexType) {
-      DexClass clazz = appInfo.definitionFor(dexType);
-      return clazz != null && clazz.isProgramClass();
-    }
-  }
-
-  // The classes in the root set.
-  private final Set<DexType> roots;
-  // Additional dependencies (direct dependencies and runtime annotations with enums).
-  private final Set<DexType> dependencies;
-  // All main dex classes.
-  private final Set<DexType> classes;
-
-  private MainDexTracingResult(Set<DexType> roots, Set<DexType> dependencies) {
-    assert Sets.intersection(roots, dependencies).isEmpty();
-    this.roots = Collections.unmodifiableSet(roots);
-    this.dependencies = Collections.unmodifiableSet(dependencies);
-    this.classes = Sets.union(roots, dependencies);
-  }
-
-  public boolean canReferenceItemFromContextWithoutIncreasingMainDexSize(
-      ProgramDefinition item, ProgramDefinition context) {
-    // If the context is not a root, then additional references from inside the context will not
-    // increase the size of the main dex.
-    if (!isRoot(context)) {
-      return true;
-    }
-    // Otherwise, require that the item is a root itself.
-    return isRoot(item);
-  }
-
-  public boolean isEmpty() {
-    assert !roots.isEmpty() || dependencies.isEmpty();
-    return roots.isEmpty();
-  }
-
-  public Set<DexType> getRoots() {
-    return roots;
-  }
-
-  public Set<DexType> getDependencies() {
-    return dependencies;
-  }
-
-  public Set<DexType> getClasses() {
-    return classes;
-  }
-
-  public boolean contains(ProgramDefinition clazz) {
-    return contains(clazz.getContextType());
-  }
-
-  public boolean contains(DexType type) {
-    return getClasses().contains(type);
-  }
-
-  private void collectTypesMatching(
-      Set<DexType> types, Predicate<DexType> predicate, Consumer<DexType> consumer) {
-    types.forEach(
-        type -> {
-          if (predicate.test(type)) {
-            consumer.accept(type);
-          }
-        });
-  }
-
-  public boolean isRoot(ProgramDefinition definition) {
-    return getRoots().contains(definition.getContextType());
-  }
-
-  public boolean isRoot(DexType type) {
-    return getRoots().contains(type);
-  }
-
-  public boolean isDependency(ProgramDefinition definition) {
-    return getDependencies().contains(definition.getContextType());
-  }
-
-  public MainDexTracingResult prunedCopy(AppInfoWithLiveness appInfo) {
-    Builder builder = builder(appInfo);
-    Predicate<DexType> wasPruned = appInfo::wasPruned;
-    collectTypesMatching(roots, wasPruned.negate(), builder::addRoot);
-    collectTypesMatching(dependencies, wasPruned.negate(), builder::addDependency);
-    return builder.build();
-  }
-
-  public static Builder builder(AppInfo appInfo) {
-    return new Builder(appInfo);
-  }
-
-  public Builder extensionBuilder(AppInfo appInfo) {
-    return new Builder(appInfo, this);
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/shaking/MissingClasses.java b/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
index e296cd7..dee668f 100644
--- a/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
+++ b/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
@@ -4,15 +4,27 @@
 
 package com.android.tools.r8.shaking;
 
+import static com.android.tools.r8.ir.desugar.DesugaredLibraryAPIConverter.DESCRIPTOR_VIVIFIED_PREFIX;
+import static com.android.tools.r8.ir.desugar.DesugaredLibraryRetargeter.getRetargetPackageAndClassPrefixDescriptor;
+import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.EMULATE_LIBRARY_CLASS_NAME_SUFFIX;
+
+import com.android.tools.r8.errors.dontwarn.DontWarnConfiguration;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexReference;
+import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramDerivedContext;
 import com.android.tools.r8.synthesis.CommittedItems;
 import com.android.tools.r8.utils.InternalOptions;
-import com.google.common.collect.ImmutableList;
+import com.android.tools.r8.utils.SetUtils;
+import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
 import java.util.Collection;
+import java.util.IdentityHashMap;
+import java.util.Map;
 import java.util.Set;
+import java.util.function.Predicate;
 
 public class MissingClasses {
 
@@ -48,7 +60,7 @@
   public static class Builder {
 
     private final Set<DexType> alreadyMissingClasses;
-    private final Set<DexType> newMissingClasses = Sets.newIdentityHashSet();
+    private final Map<DexType, Set<DexReference>> newMissingClasses = new IdentityHashMap<>();
 
     // Set of missing types that are not to be reported as missing. This does not hide reports
     // if the same type is in newMissingClasses in which case it is reported regardless.
@@ -62,12 +74,27 @@
       this.alreadyMissingClasses = alreadyMissingClasses;
     }
 
-    public void addNewMissingClass(DexType type) {
-      newMissingClasses.add(type);
+    public void addNewMissingClass(DexType type, ProgramDerivedContext context) {
+      assert context != null;
+      assert context.getContext().getContextType() != type;
+      if (!alreadyMissingClasses.contains(type)) {
+        newMissingClasses
+            .computeIfAbsent(type, ignore -> Sets.newIdentityHashSet())
+            .add(context.getContext().getReference());
+      }
     }
 
-    public Builder addNewMissingClasses(Collection<DexType> types) {
-      newMissingClasses.addAll(types);
+    public void legacyAddNewMissingClass(DexType type) {
+      if (!alreadyMissingClasses.contains(type)) {
+        // The legacy reporting is context insensitive, so therefore we use the missing classes
+        // themselves as contexts.
+        newMissingClasses.computeIfAbsent(type, ignore -> Sets.newIdentityHashSet()).add(type);
+      }
+    }
+
+    @Deprecated
+    public Builder legacyAddNewMissingClasses(Collection<DexType> types) {
+      types.forEach(this::legacyAddNewMissingClass);
       return this;
     }
 
@@ -76,7 +103,7 @@
     }
 
     public boolean contains(DexType type) {
-      return alreadyMissingClasses.contains(type) || newMissingClasses.contains(type);
+      return alreadyMissingClasses.contains(type) || newMissingClasses.containsKey(type);
     }
 
     Builder removeAlreadyMissingClasses(Iterable<DexType> types) {
@@ -93,15 +120,12 @@
 
     public MissingClasses reportMissingClasses(AppView<?> appView) {
       InternalOptions options = appView.options();
-      Set<DexType> newMissingClassesWithoutDontWarn =
-          appView.getDontWarnConfiguration().getNonMatches(newMissingClasses);
-      newMissingClassesWithoutDontWarn.removeAll(alreadyMissingClasses);
-      newMissingClassesWithoutDontWarn.removeAll(
-          getAllowedMissingClasses(appView.dexItemFactory()));
-      if (!newMissingClassesWithoutDontWarn.isEmpty()) {
+      Map<DexType, Set<DexReference>> missingClassesToBeReported =
+          getMissingClassesToBeReported(appView);
+      if (!missingClassesToBeReported.isEmpty()) {
         MissingClassesDiagnostic diagnostic =
             new MissingClassesDiagnostic.Builder()
-                .addMissingClasses(newMissingClassesWithoutDontWarn)
+                .addMissingClasses(missingClassesToBeReported)
                 .setFatal(!options.ignoreMissingClasses)
                 .build();
         if (options.ignoreMissingClasses) {
@@ -113,21 +137,83 @@
       return build();
     }
 
-    private static Collection<DexType> getAllowedMissingClasses(DexItemFactory dexItemFactory) {
-      return ImmutableList.of(
-          dexItemFactory.annotationDefault,
-          dexItemFactory.annotationMethodParameters,
-          dexItemFactory.annotationSourceDebugExtension,
-          dexItemFactory.annotationThrows,
-          // TODO(b/176133674) StringConcatFactory is backported, but the class is reported as
-          //  missing because the enqueuer runs prior to backporting and thus sees the non-desugared
-          //  code.
-          dexItemFactory.stringConcatFactoryType);
+    private Map<DexType, Set<DexReference>> getMissingClassesToBeReported(AppView<?> appView) {
+      Predicate<DexType> allowedMissingClassesPredicate =
+          getIsAllowedMissingClassesPredicate(appView);
+      Map<DexType, Set<DexReference>> missingClassesToBeReported =
+          new IdentityHashMap<>(newMissingClasses.size());
+      newMissingClasses.forEach(
+          (missingClass, contexts) -> {
+            // Don't report "allowed" missing classes (e.g., classes matched by -dontwarn).
+            if (allowedMissingClassesPredicate.test(missingClass)) {
+              return;
+            }
+
+            // Remove all contexts that are matched by a -dontwarn rule (a missing class should not
+            // be reported if it os only referenced from contexts that are matched by a -dontwarn).
+            contexts.removeIf(
+                context -> appView.getDontWarnConfiguration().matches(context.getContextType()));
+
+            // If there are any contexts not matched by a -dontwarn rule, then report.
+            if (!contexts.isEmpty()) {
+              missingClassesToBeReported.put(missingClass, contexts);
+            }
+          });
+      return missingClassesToBeReported;
     }
 
+    private static Predicate<DexType> getIsAllowedMissingClassesPredicate(AppView<?> appView) {
+      Set<DexType> allowedMissingClasses = getAllowedMissingClasses(appView.dexItemFactory());
+      Predicate<DexType> compilerSynthesizedAllowingMissingClassPredicate =
+          getIsCompilerSynthesizedAllowedMissingClassesPredicate(appView);
+      DontWarnConfiguration dontWarnConfiguration = appView.getDontWarnConfiguration();
+      return type ->
+          allowedMissingClasses.contains(type)
+              || compilerSynthesizedAllowingMissingClassPredicate.test(type)
+              || dontWarnConfiguration.matches(type);
+    }
+
+    private static Set<DexType> getAllowedMissingClasses(DexItemFactory dexItemFactory) {
+      return ImmutableSet.<DexType>builder()
+          .add(
+              dexItemFactory.annotationDefault,
+              dexItemFactory.annotationMethodParameters,
+              dexItemFactory.annotationSourceDebugExtension,
+              dexItemFactory.annotationSynthesizedClass,
+              dexItemFactory.annotationSynthesizedClassMap,
+              dexItemFactory.annotationThrows,
+              dexItemFactory.serializedLambdaType,
+              // TODO(b/176133674) StringConcatFactory is backported, but the class is reported as
+              //  missing because the enqueuer runs prior to backporting and thus sees the
+              //  non-desugared code.
+              dexItemFactory.stringConcatFactoryType)
+          .addAll(dexItemFactory.getConversionTypes())
+          .build();
+    }
+
+    private static Predicate<DexType> getIsCompilerSynthesizedAllowedMissingClassesPredicate(
+        AppView<?> appView) {
+      DexItemFactory dexItemFactory = appView.dexItemFactory();
+      InternalOptions options = appView.options();
+      DexString emulatedLibraryClassNameSuffix =
+          dexItemFactory.createString(EMULATE_LIBRARY_CLASS_NAME_SUFFIX + ";");
+      DexString retargetPackageAndClassPrefixDescriptor =
+          dexItemFactory.createString(
+              getRetargetPackageAndClassPrefixDescriptor(options.desugaredLibraryConfiguration));
+      DexString vivifiedClassNamePrefix = dexItemFactory.createString(DESCRIPTOR_VIVIFIED_PREFIX);
+      return type -> {
+        DexString descriptor = type.getDescriptor();
+        return descriptor.startsWith(retargetPackageAndClassPrefixDescriptor)
+            || descriptor.startsWith(vivifiedClassNamePrefix)
+            || descriptor.endsWith(emulatedLibraryClassNameSuffix);
+      };
+    }
+
+
+
     /** Intentionally private, use {@link Builder#reportMissingClasses(AppView)}. */
     private MissingClasses build() {
-      // Extend the newMissingClasses set with all other missing classes.
+      // Return the new set of missing classes.
       //
       // We also add newIgnoredMissingClasses to newMissingClasses to be able to assert that we have
       // a closed world after the first round of tree shaking: we should never lookup a class that
@@ -137,9 +223,9 @@
       // Note: At this point, all missing classes in newMissingClasses have already been reported.
       // Thus adding newIgnoredMissingClasses to newMissingClasses will not lead to reports for the
       // classes in newIgnoredMissingClasses.
-      newMissingClasses.addAll(alreadyMissingClasses);
-      newMissingClasses.addAll(newIgnoredMissingClasses);
-      return new MissingClasses(newMissingClasses);
+      return new MissingClasses(
+          SetUtils.newIdentityHashSet(
+              alreadyMissingClasses, newMissingClasses.keySet(), newIgnoredMissingClasses));
     }
 
     public boolean wasAlreadyMissing(DexType type) {
diff --git a/src/main/java/com/android/tools/r8/shaking/MissingClassesDiagnostic.java b/src/main/java/com/android/tools/r8/shaking/MissingClassesDiagnostic.java
index 5965cc5..0f4e97b 100644
--- a/src/main/java/com/android/tools/r8/shaking/MissingClassesDiagnostic.java
+++ b/src/main/java/com/android/tools/r8/shaking/MissingClassesDiagnostic.java
@@ -4,34 +4,130 @@
 
 package com.android.tools.r8.shaking;
 
+import static com.android.tools.r8.utils.PredicateUtils.not;
+
 import com.android.tools.r8.Diagnostic;
 import com.android.tools.r8.Keep;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexReference;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.position.Position;
 import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
-import com.google.common.collect.ImmutableSortedSet;
-import java.util.Collection;
+import com.android.tools.r8.utils.FieldReferenceUtils;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedMap;
+import com.google.common.collect.Sets;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
 import java.util.Set;
-import java.util.SortedSet;
+import java.util.SortedMap;
+import java.util.function.Function;
 
 @Keep
 public class MissingClassesDiagnostic implements Diagnostic {
 
-  private final boolean fatal;
-  private final SortedSet<ClassReference> missingClasses;
+  private static class MissingClassAccessContexts {
 
-  private MissingClassesDiagnostic(boolean fatal, SortedSet<ClassReference> missingClasses) {
+    private ImmutableSet<ClassReference> classContexts;
+    private ImmutableSet<FieldReference> fieldContexts;
+    private ImmutableSet<MethodReference> methodContexts;
+
+    private MissingClassAccessContexts(
+        ImmutableSet<ClassReference> classContexts,
+        ImmutableSet<FieldReference> fieldContexts,
+        ImmutableSet<MethodReference> methodContexts) {
+      this.classContexts = classContexts;
+      this.fieldContexts = fieldContexts;
+      this.methodContexts = methodContexts;
+    }
+
+    static Builder builder() {
+      return new Builder();
+    }
+
+    String getReferencedFromMessageSuffix(ClassReference missingClass) {
+      if (!fieldContexts.isEmpty()) {
+        return " (referenced from: "
+            + FieldReferenceUtils.toSourceString(fieldContexts.iterator().next())
+            + ")";
+      }
+      if (!methodContexts.isEmpty()) {
+        return " (referenced from: "
+            + MethodReferenceUtils.toSourceString(methodContexts.iterator().next())
+            + ")";
+      }
+      // TODO(b/175543745): The legacy reporting is context insensitive, and therefore uses the
+      //  missing classes as their own context. Once legacy reporting is removed, this should be
+      //  simplified to taking the first context.
+      Optional<ClassReference> classContext =
+          classContexts.stream().filter(not(missingClass::equals)).findFirst();
+      return classContext
+          .map(classReference -> " (referenced from: " + classReference.getTypeName() + ")")
+          .orElse("");
+    }
+
+    static class Builder {
+
+      private final Set<DexReference> contexts = Sets.newIdentityHashSet();
+
+      Builder addAll(Set<DexReference> contexts) {
+        this.contexts.addAll(contexts);
+        return this;
+      }
+
+      // TODO(b/179249745): Sort on demand in getReferencedFromMessageSuffix() instead.
+      MissingClassAccessContexts build() {
+        // Sort the contexts for deterministic reporting.
+        List<DexType> classContexts = new ArrayList<>();
+        List<DexField> fieldContexts = new ArrayList<>();
+        List<DexMethod> methodContexts = new ArrayList<>();
+        contexts.forEach(
+            context -> context.apply(classContexts::add, fieldContexts::add, methodContexts::add));
+        Collections.sort(classContexts);
+        Collections.sort(fieldContexts);
+        Collections.sort(methodContexts);
+
+        // Build immutable sets (which preserve insertion order) from the sorted lists, mapping each
+        // DexType, DexField, and DexMethod to ClassReference, FieldReference, and MethodReference,
+        // respectively.
+        return new MissingClassAccessContexts(
+            toImmutableSet(classContexts, DexType::asClassReference),
+            toImmutableSet(fieldContexts, DexField::asFieldReference),
+            toImmutableSet(methodContexts, DexMethod::asMethodReference));
+      }
+
+      private <S, T> ImmutableSet<T> toImmutableSet(List<S> list, Function<S, T> fn) {
+        ImmutableSet.Builder<T> builder = ImmutableSet.builder();
+        list.forEach(element -> builder.add(fn.apply(element)));
+        return builder.build();
+      }
+    }
+  }
+
+  private final boolean fatal;
+  private final SortedMap<ClassReference, MissingClassAccessContexts> missingClasses;
+
+  private MissingClassesDiagnostic(
+      boolean fatal, SortedMap<ClassReference, MissingClassAccessContexts> missingClasses) {
     assert !missingClasses.isEmpty();
     this.fatal = fatal;
     this.missingClasses = missingClasses;
   }
 
   public Set<ClassReference> getMissingClasses() {
-    return missingClasses;
+    return missingClasses.keySet();
   }
 
   /** A missing class(es) failure can generally not be attributed to a single origin. */
@@ -46,7 +142,6 @@
     return Position.UNKNOWN;
   }
 
-  // TODO(b/175755807): Extend diagnostic message with contextual information.
   @Override
   public String getDiagnosticMessage() {
     return fatal ? getFatalDiagnosticMessage() : getNonFatalDiagnosticMessage();
@@ -54,43 +149,70 @@
 
   private String getFatalDiagnosticMessage() {
     if (missingClasses.size() == 1) {
-      return "Compilation can't be completed because the class "
-          + missingClasses.iterator().next().getTypeName()
-          + " is missing.";
+      StringBuilder builder =
+          new StringBuilder(
+              "Compilation can't be completed because the following class is missing: ");
+      writeMissingClass(builder, missingClasses.entrySet().iterator().next());
+      return builder.append(".").toString();
     }
+
     StringBuilder builder =
         new StringBuilder("Compilation can't be completed because the following ")
             .append(missingClasses.size())
             .append(" classes are missing:");
-    for (ClassReference missingClass : missingClasses) {
-      builder.append(System.lineSeparator()).append("- ").append(missingClass.getTypeName());
-    }
+    missingClasses.forEach(
+        (missingClass, contexts) ->
+            writeMissingClass(
+                builder.append(System.lineSeparator()).append("- "), missingClass, contexts));
     return builder.toString();
   }
 
   private String getNonFatalDiagnosticMessage() {
     StringBuilder builder = new StringBuilder();
-    Iterator<ClassReference> missingClassesIterator = missingClasses.iterator();
-    while (missingClassesIterator.hasNext()) {
-      ClassReference missingClass = missingClassesIterator.next();
-      builder.append("Missing class ").append(missingClass.getTypeName());
-      if (missingClassesIterator.hasNext()) {
-        builder.append(System.lineSeparator());
-      }
-    }
+    Iterator<Entry<ClassReference, MissingClassAccessContexts>> missingClassesIterator =
+        missingClasses.entrySet().iterator();
+
+    // The diagnostic is always non-empty.
+    assert missingClassesIterator.hasNext();
+
+    // Write first line.
+    writeMissingClass(builder.append("Missing class "), missingClassesIterator.next());
+
+    // Write remaining lines with line separator before.
+    missingClassesIterator.forEachRemaining(
+        missingClassInfo ->
+            writeMissingClass(
+                builder.append(System.lineSeparator()).append("Missing class "), missingClassInfo));
+
     return builder.toString();
   }
 
+  private static void writeMissingClass(
+      StringBuilder builder, Entry<ClassReference, MissingClassAccessContexts> missingClassInfo) {
+    writeMissingClass(builder, missingClassInfo.getKey(), missingClassInfo.getValue());
+  }
+
+  private static void writeMissingClass(
+      StringBuilder builder, ClassReference missingClass, MissingClassAccessContexts contexts) {
+    builder
+        .append(missingClass.getTypeName())
+        .append(contexts.getReferencedFromMessageSuffix(missingClass));
+  }
+
   public static class Builder {
 
     private boolean fatal;
-    private ImmutableSortedSet.Builder<ClassReference> missingClassesBuilder =
-        ImmutableSortedSet.orderedBy(Comparator.comparing(ClassReference::getDescriptor));
+    private ImmutableSortedMap.Builder<ClassReference, MissingClassAccessContexts>
+        missingClassesBuilder =
+            ImmutableSortedMap.orderedBy(Comparator.comparing(ClassReference::getDescriptor));
 
-    public MissingClassesDiagnostic.Builder addMissingClasses(Collection<DexType> missingClasses) {
-      for (DexType missingClass : missingClasses) {
-        missingClassesBuilder.add(Reference.classFromDescriptor(missingClass.toDescriptorString()));
-      }
+    public MissingClassesDiagnostic.Builder addMissingClasses(
+        Map<DexType, Set<DexReference>> missingClasses) {
+      missingClasses.forEach(
+          (missingClass, contexts) ->
+              missingClassesBuilder.put(
+                  Reference.classFromDescriptor(missingClass.toDescriptorString()),
+                  MissingClassAccessContexts.builder().addAll(contexts).build()));
       return this;
     }
 
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationRule.java b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationRule.java
index aac168d..fbedd8e 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationRule.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationRule.java
@@ -6,6 +6,8 @@
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexDefinitionSupplier;
+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.graph.SubtypingInfo;
@@ -22,6 +24,9 @@
 public abstract class ProguardConfigurationRule extends ProguardClassSpecification {
 
   private boolean used = false;
+  // TODO(b/164019179): Since we are using the rule language for tracing main dex we can end up in
+  //  a situation where the references to types are dead.
+  private boolean canReferenceDeadTypes = false;
 
   ProguardConfigurationRule(
       Origin origin,
@@ -101,13 +106,32 @@
     return null;
   }
 
+  public void canReferenceDeadTypes() {
+    this.canReferenceDeadTypes = true;
+  }
+
   Iterable<DexProgramClass> relevantCandidatesForRule(
       AppView<? extends AppInfoWithClassHierarchy> appView,
       SubtypingInfo subtypingInfo,
       Iterable<DexProgramClass> defaultValue) {
     List<DexType> specificTypes = getClassNames().asSpecificDexTypes();
     if (specificTypes != null) {
-      return DexProgramClass.asProgramClasses(specificTypes, appView);
+      return DexProgramClass.asProgramClasses(
+          specificTypes,
+          new DexDefinitionSupplier() {
+            @Override
+            public DexClass definitionFor(DexType type) {
+              if (canReferenceDeadTypes) {
+                return appView.appInfo().definitionForWithoutExistenceAssert(type);
+              }
+              return appView.definitionFor(type);
+            }
+
+            @Override
+            public DexItemFactory dexItemFactory() {
+              return appView.dexItemFactory();
+            }
+          });
     }
     if (hasInheritanceClassName() && getInheritanceClassName().hasSpecificType()) {
       DexType type = getInheritanceClassName().getSpecificType();
diff --git a/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java b/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java
index f4567e9..8848ece 100644
--- a/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java
+++ b/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java
@@ -4,6 +4,7 @@
 package com.android.tools.r8.shaking;
 
 import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
+import static com.android.tools.r8.utils.LensUtils.rewriteAndApplyIfNotPrimitiveType;
 
 import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.errors.AssumeNoSideEffectsRuleForObjectMembersDiagnostic;
@@ -30,6 +31,7 @@
 import com.android.tools.r8.graph.GraphLens;
 import com.android.tools.r8.graph.ProgramMember;
 import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.PrunedItems;
 import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
 import com.android.tools.r8.graph.SubtypingInfo;
 import com.android.tools.r8.ir.analysis.proto.GeneratedMessageLiteBuilderShrinker;
@@ -1765,6 +1767,37 @@
     public int size() {
       return classesWithRules.size() + fieldsWithRules.size() + methodsWithRules.size();
     }
+
+    public void forEachReference(
+        BiConsumer<? super DexReference, Set<ProguardKeepRuleBase>> consumer) {
+      forEachClass(consumer);
+      forEachMember(consumer);
+    }
+
+    private MutableItemsWithRules prune(Set<DexType> prunedClasses) {
+      MutableItemsWithRules prunedItemsWithRules = new MutableItemsWithRules();
+      forEachReference(
+          (reference, rules) -> {
+            if (!prunedClasses.contains(reference.getContextType())) {
+              prunedItemsWithRules.addReferenceWithRules(reference, rules);
+            }
+          });
+      return prunedItemsWithRules;
+    }
+
+    private MutableItemsWithRules rewrittenWithLens(GraphLens graphLens) {
+      if (graphLens.isIdentityLens()) {
+        return this;
+      }
+      MutableItemsWithRules rewrittenItemsWithRules = new MutableItemsWithRules();
+      forEachReference(
+          (reference, rules) ->
+              rewriteAndApplyIfNotPrimitiveType(
+                  graphLens,
+                  reference,
+                  rewritten -> rewrittenItemsWithRules.addReferenceWithRules(rewritten, rules)));
+      return rewrittenItemsWithRules;
+    }
   }
 
   public static class RootSet extends RootSetBase {
@@ -1889,7 +1922,7 @@
     }
 
     // Add dependent items that depend on -if rules.
-    private static void addDependentItems(
+    static void addDependentItems(
         Map<DexReference, ? extends ItemsWithRules> dependentItemsToAdd,
         Map<DexReference, MutableItemsWithRules> dependentItemsToAddTo) {
       dependentItemsToAdd.forEach(
@@ -2193,4 +2226,165 @@
       return new ConsequentRootSetBuilder(appView, subtypingInfo, enqueuer);
     }
   }
+
+  public static class MainDexRootSetBuilder extends RootSetBuilder {
+
+    private MainDexRootSetBuilder(
+        AppView<? extends AppInfoWithClassHierarchy> appView,
+        SubtypingInfo subtypingInfo,
+        Iterable<? extends ProguardConfigurationRule> rules) {
+      super(appView, subtypingInfo, rules);
+    }
+
+    @Override
+    public MainDexRootSet build(ExecutorService executorService) throws ExecutionException {
+      // Call the super builder to have if-tests calculated automatically.
+      RootSet rootSet = super.build(executorService);
+      return new MainDexRootSet(
+          rootSet.noShrinking,
+          rootSet.reasonAsked,
+          rootSet.checkDiscarded,
+          rootSet.dependentNoShrinking,
+          rootSet.ifRules,
+          rootSet.delayedRootSetActionItems);
+    }
+  }
+
+  public static class MainDexRootSet extends RootSet {
+
+    public MainDexRootSet(
+        MutableItemsWithRules noShrinking,
+        ImmutableList<DexReference> reasonAsked,
+        ImmutableList<DexReference> checkDiscarded,
+        Map<DexReference, MutableItemsWithRules> dependentNoShrinking,
+        Set<ProguardIfRule> ifRules,
+        List<DelayedRootSetActionItem> delayedRootSetActionItems) {
+      super(
+          noShrinking,
+          new MutableItemsWithRules(),
+          Collections.emptySet(),
+          reasonAsked,
+          checkDiscarded,
+          Collections.emptySet(),
+          Collections.emptySet(),
+          Collections.emptySet(),
+          Collections.emptySet(),
+          Collections.emptySet(),
+          Collections.emptySet(),
+          Collections.emptySet(),
+          Collections.emptySet(),
+          Collections.emptySet(),
+          Collections.emptySet(),
+          PredicateSet.empty(),
+          Collections.emptySet(),
+          Collections.emptySet(),
+          Collections.emptySet(),
+          Collections.emptySet(),
+          Collections.emptySet(),
+          Collections.emptyMap(),
+          Collections.emptyMap(),
+          Collections.emptyMap(),
+          dependentNoShrinking,
+          Collections.emptyMap(),
+          Collections.emptyMap(),
+          Collections.emptySet(),
+          ifRules,
+          delayedRootSetActionItems);
+    }
+
+    @Override
+    void addConsequentRootSet(ConsequentRootSet consequentRootSet, boolean addNoShrinking) {
+      if (addNoShrinking) {
+        noShrinking.addAll(consequentRootSet.noShrinking);
+      }
+      addDependentItems(consequentRootSet.dependentNoShrinking, dependentNoShrinking);
+      consequentRootSet.dependentKeepClassCompatRule.forEach(
+          (type, rules) ->
+              dependentKeepClassCompatRule
+                  .computeIfAbsent(type, k -> new HashSet<>())
+                  .addAll(rules));
+    }
+
+    public static MainDexRootSetBuilder builder(
+        AppView<? extends AppInfoWithClassHierarchy> appView,
+        SubtypingInfo subtypingInfo,
+        Iterable<? extends ProguardConfigurationRule> rules) {
+      return new MainDexRootSetBuilder(appView, subtypingInfo, rules);
+    }
+
+    @Override
+    void shouldNotBeMinified(DexReference reference) {
+      // Do nothing.
+    }
+
+    public MainDexRootSet rewrittenWithLens(GraphLens graphLens) {
+      if (graphLens.isIdentityLens()) {
+        return this;
+      }
+      Map<DexReference, MutableItemsWithRules> rewrittenDependent = new IdentityHashMap<>();
+      dependentNoShrinking.forEach(
+          (reference, rules) -> {
+            // Rewriting a reference can result in us having to merge items with rules.
+            rewriteAndApplyIfNotPrimitiveType(
+                graphLens,
+                reference,
+                rewritten -> {
+                  MutableItemsWithRules rewrittenRules =
+                      rewrittenDependent.computeIfAbsent(
+                          graphLens.lookupReference(reference),
+                          rewrittenRef -> new MutableItemsWithRules());
+                  rewrittenRules.addAll(rules.rewrittenWithLens(graphLens));
+                });
+          });
+
+      ImmutableList.Builder<DexReference> rewrittenCheckDiscarded = ImmutableList.builder();
+      checkDiscarded.forEach(
+          reference ->
+              rewriteAndApplyIfNotPrimitiveType(
+                  graphLens, reference, rewrittenCheckDiscarded::add));
+      ImmutableList.Builder<DexReference> rewrittenReasonAsked = ImmutableList.builder();
+      reasonAsked.forEach(
+          reference ->
+              rewriteAndApplyIfNotPrimitiveType(graphLens, reference, rewrittenReasonAsked::add));
+      // TODO(b/164019179): If rules can now reference dead items. These should be pruned or
+      //  rewritten
+      ifRules.forEach(ProguardIfRule::canReferenceDeadTypes);
+      // All delayed root set actions should have been processed at this point.
+      assert delayedRootSetActionItems.isEmpty();
+      return new MainDexRootSet(
+          noShrinking.rewrittenWithLens(graphLens),
+          rewrittenReasonAsked.build(),
+          rewrittenCheckDiscarded.build(),
+          rewrittenDependent,
+          ifRules,
+          delayedRootSetActionItems);
+    }
+
+    public MainDexRootSet withoutPrunedItems(PrunedItems prunedItems) {
+      if (prunedItems.isEmpty()) {
+        return this;
+      }
+      Map<DexReference, MutableItemsWithRules> prunedDependent = new IdentityHashMap<>();
+      dependentNoShrinking.forEach(
+          (ref, rules) -> {
+            if (prunedItems.getRemovedClasses().contains(ref.getContextType())) {
+              // The dependent reference has been pruned and cannot lead to any additional items
+              return;
+            }
+            prunedDependent.put(ref, rules.prune(prunedItems.getRemovedClasses()));
+          });
+      // TODO(b/164019179): If rules can now reference dead items. These should be pruned or
+      //  rewritten
+      ifRules.forEach(ProguardIfRule::canReferenceDeadTypes);
+      // All delayed root set actions should have been processed at this point.
+      assert delayedRootSetActionItems.isEmpty();
+      return new MainDexRootSet(
+          noShrinking.prune(prunedItems.getRemovedClasses()),
+          reasonAsked,
+          checkDiscarded,
+          prunedDependent,
+          ifRules,
+          delayedRootSetActionItems);
+    }
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/shaking/TreePruner.java b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
index 9155165..9b7a66b 100644
--- a/src/main/java/com/android/tools/r8/shaking/TreePruner.java
+++ b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
@@ -376,7 +376,9 @@
 
   private boolean verifyNoDeadFields(DexProgramClass clazz) {
     for (DexEncodedField field : clazz.fields()) {
-      assert !field.getOptimizationInfo().isDead()
+      // Pinned field which type is never instantiated are always null, they are marked as dead
+      // so their reads and writes are cleared, but they are still in the program.
+      assert !field.getOptimizationInfo().isDead() || appView.appInfo().isPinned(field)
           : "Expected field `" + field.field.toSourceString() + "` to be absent";
     }
     return true;
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 c52fd0f..4963f21 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
@@ -219,23 +219,22 @@
   // All the bridge methods that have been synthesized during vertical class merging.
   private final List<SynthesizedBridgeCode> synthesizedBridges = new ArrayList<>();
 
-  private final MainDexTracingResult mainDexClasses;
+  private final MainDexInfo mainDexInfo;
 
   public VerticalClassMerger(
       DexApplication application,
       AppView<AppInfoWithLiveness> appView,
       ExecutorService executorService,
-      Timing timing,
-      MainDexTracingResult mainDexClasses) {
+      Timing timing) {
     this.application = application;
     this.appInfo = appView.appInfo();
     this.appView = appView;
+    this.mainDexInfo = appInfo.getMainDexInfo();
     this.subtypingInfo = appInfo.computeSubtypingInfo();
     this.executorService = executorService;
     this.methodPoolCollection = new MethodPoolCollection(appView, subtypingInfo);
     this.lensBuilder = new VerticalClassMergerGraphLens.Builder(appView.dexItemFactory());
     this.timing = timing;
-    this.mainDexClasses = mainDexClasses;
 
     Iterable<DexProgramClass> classes = application.classesWithDeterministicOrder();
     initializePinnedTypes(classes); // Must be initialized prior to mergeCandidates.
@@ -826,20 +825,8 @@
       return;
     }
 
-    // For a main dex class in the dependent set only merge with other classes in either main dex
-    // set.
-    if ((mainDexClasses.getDependencies().contains(clazz.type)
-        || mainDexClasses.getDependencies().contains(targetClass.type))
-        && !(mainDexClasses.getClasses().contains(clazz.type)
-        && mainDexClasses.getClasses().contains(targetClass.type))) {
-      return;
-    }
-
-    // For a main dex class in the root set only merge with other classes in main dex root set.
-    if ((mainDexClasses.getRoots().contains(clazz.type)
-        || mainDexClasses.getRoots().contains(targetClass.type))
-        && !(mainDexClasses.getRoots().contains(clazz.type)
-        && mainDexClasses.getRoots().contains(targetClass.type))) {
+    // Check with main dex classes to see if we are allowed to merge.
+    if (!mainDexInfo.canMerge(clazz, targetClass)) {
       return;
     }
 
@@ -1670,9 +1657,7 @@
         }
         // Constructors can have references beyond the root main dex classes. This can increase the
         // size of the main dex dependent classes and we should bail out.
-        if (mainDexClasses.getRoots().contains(context.type)
-            && MainDexDirectReferenceTracer.hasReferencesOutsideFromCode(
-                appView.appInfo(), method, mainDexClasses.getRoots())) {
+        if (mainDexInfo.disallowInliningIntoContext(appView.appInfo(), context, method)) {
           return AbortReason.MAIN_DEX_ROOT_OUTSIDE_REFERENCE;
         }
         return null;
diff --git a/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java b/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
index 932359d..1067e93 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
@@ -14,8 +14,9 @@
 import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
 import com.android.tools.r8.graph.ProgramDefinition;
 import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.synthesis.SyntheticNaming.Phase;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
 import java.util.Comparator;
 import java.util.Set;
 
@@ -63,14 +64,27 @@
   }
 
   static SynthesizingContext fromSyntheticContextChange(
-      DexType syntheticType, SynthesizingContext oldContext, DexItemFactory factory) {
+      SyntheticKind kind,
+      DexType syntheticType,
+      SynthesizingContext oldContext,
+      DexItemFactory factory) {
     String descriptor = syntheticType.toDescriptorString();
-    int i = descriptor.indexOf(SyntheticNaming.getPhaseSeparator(Phase.INTERNAL));
-    if (i <= 0) {
-      assert false : "Unexpected synthetic without internal separator: " + syntheticType;
-      return null;
+    DexType newContext;
+    if (kind.isFixedSuffixSynthetic) {
+      int i = descriptor.lastIndexOf(kind.descriptor);
+      if (i < 0 || descriptor.length() != i + kind.descriptor.length() + 1) {
+        assert false : "Unexpected fixed synthetic with invalid suffix: " + syntheticType;
+        return null;
+      }
+      newContext = factory.createType(descriptor.substring(0, i) + ";");
+    } else {
+      int i = descriptor.indexOf(SyntheticNaming.getPhaseSeparator(Phase.INTERNAL));
+      if (i <= 0) {
+        assert false : "Unexpected synthetic without internal separator: " + syntheticType;
+        return null;
+      }
+      newContext = factory.createType(descriptor.substring(0, i) + ";");
     }
-    DexType newContext = factory.createType(descriptor.substring(0, i) + ";");
     return newContext == oldContext.getSynthesizingContextType()
         ? oldContext
         : new SynthesizingContext(newContext, newContext, oldContext.inputContextOrigin);
@@ -141,13 +155,13 @@
 
   void addIfDerivedFromMainDexClass(
       DexProgramClass externalSyntheticClass,
-      MainDexClasses mainDexClasses,
+      MainDexInfo mainDexInfo,
       Set<DexType> allMainDexTypes) {
     // The input context type (not the annotated context) determines if the derived class is to be
     // in main dex.
     // TODO(b/168584485): Once resolved allMainDexTypes == mainDexClasses.
     if (allMainDexTypes.contains(inputContextType)) {
-      mainDexClasses.add(externalSyntheticClass);
+      mainDexInfo.addSyntheticClass(externalSyntheticClass);
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
index eefe1b9..239e7d0 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
@@ -64,7 +64,7 @@
   final HashCode computeHash(
       RepresentativeMap map, boolean intermediate, ClassToFeatureSplitMap classToFeatureSplitMap) {
     Hasher hasher = Hashing.murmur3_128().newHasher();
-    if (intermediate) {
+    if (intermediate || getKind().isFixedSuffixSynthetic) {
       // If in intermediate mode, include the context type as sharing is restricted to within a
       // single context.
       getContext().getSynthesizingContextType().hashWithTypeEquivalence(hasher, map);
@@ -95,7 +95,7 @@
       boolean includeContext,
       GraphLens graphLens,
       ClassToFeatureSplitMap classToFeatureSplitMap) {
-    if (includeContext) {
+    if (includeContext || getKind().isFixedSuffixSynthetic) {
       int order = getContext().compareTo(other.getContext());
       if (order != 0) {
         return order;
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
index e2e0b55..741831e 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
@@ -23,7 +23,7 @@
 import com.android.tools.r8.graph.TreeFixerBase;
 import com.android.tools.r8.ir.code.NumberGenerator;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.SetUtils;
@@ -86,6 +86,11 @@
       this.syntheticMethodsMap = syntheticMethodsMap;
     }
 
+    @Override
+    public boolean isSyntheticFinalizationGraphLens() {
+      return true;
+    }
+
     // The mapping is many to one, so the inverse is only defined up to equivalence groups.
     // Override the access to renamed signatures to first check for synthetic mappings before
     // using the original item mappings of the
@@ -225,7 +230,7 @@
     assert !appView.appInfo().hasClassHierarchy();
     assert !appView.appInfo().hasLiveness();
     Result result = appView.getSyntheticItems().computeFinalSynthetics(appView);
-    appView.setAppInfo(new AppInfo(result.commit, appView.appInfo().getMainDexClasses()));
+    appView.setAppInfo(new AppInfo(result.commit, appView.appInfo().getMainDexInfo()));
     appView.pruneItems(result.prunedItems);
     if (result.lens != null) {
       appView.setGraphLens(result.lens);
@@ -252,7 +257,7 @@
   Result computeFinalSynthetics(AppView<?> appView) {
     assert verifyNoNestedSynthetics();
     DexApplication application;
-    MainDexClasses mainDexClasses = appView.appInfo().getMainDexClasses();
+    MainDexInfo mainDexInfo = appView.appInfo().getMainDexInfo();
     Builder lensBuilder = new Builder();
     ImmutableMap.Builder<DexType, SyntheticMethodReference> finalMethodsBuilder =
         ImmutableMap.builder();
@@ -266,7 +271,6 @@
               appView,
               computeEquivalences(appView, synthetics.getNonLegacyMethods().values(), generators),
               computeEquivalences(appView, synthetics.getNonLegacyClasses().values(), generators),
-              mainDexClasses,
               lensBuilder,
               (clazz, reference) -> {
                 finalSyntheticProgramDefinitions.add(clazz);
@@ -282,13 +286,9 @@
         finalClassesBuilder.build();
 
     handleSynthesizedClassMapping(
-        finalSyntheticProgramDefinitions,
-        application,
-        options,
-        mainDexClasses,
-        lensBuilder.typeMap);
+        finalSyntheticProgramDefinitions, application, options, mainDexInfo, lensBuilder.typeMap);
 
-    assert appView.appInfo().getMainDexClasses() == mainDexClasses;
+    assert appView.appInfo().getMainDexInfo() == mainDexInfo;
 
     Set<DexType> prunedSynthetics = Sets.newIdentityHashSet();
     synthetics.forEachNonLegacyItem(
@@ -352,14 +352,13 @@
       List<DexProgramClass> finalSyntheticClasses,
       DexApplication application,
       InternalOptions options,
-      MainDexClasses mainDexClasses,
+      MainDexInfo mainDexInfo,
       Map<DexType, DexType> derivedMainDexTypesToIgnore) {
     boolean includeSynthesizedClassMappingInOutput = shouldAnnotateSynthetics(options);
     if (includeSynthesizedClassMappingInOutput) {
       updateSynthesizedClassMapping(application, finalSyntheticClasses);
     }
-    updateMainDexListWithSynthesizedClassMap(
-        application, mainDexClasses, derivedMainDexTypesToIgnore);
+    updateMainDexListWithSynthesizedClassMap(application, mainDexInfo, derivedMainDexTypesToIgnore);
     if (!includeSynthesizedClassMappingInOutput) {
       clearSynthesizedClassMapping(application);
     }
@@ -405,13 +404,13 @@
 
   private void updateMainDexListWithSynthesizedClassMap(
       DexApplication application,
-      MainDexClasses mainDexClasses,
+      MainDexInfo mainDexInfo,
       Map<DexType, DexType> derivedMainDexTypesToIgnore) {
-    if (mainDexClasses.isEmpty()) {
+    if (mainDexInfo.isEmpty()) {
       return;
     }
     List<DexProgramClass> newMainDexClasses = new ArrayList<>();
-    mainDexClasses.forEach(
+    mainDexInfo.forEachExcludingDependencies(
         dexType -> {
           DexProgramClass programClass =
               DexProgramClass.asProgramClassOrNull(application.definitionFor(dexType));
@@ -429,7 +428,7 @@
             }
           }
         });
-    mainDexClasses.addAll(newMainDexClasses);
+    newMainDexClasses.forEach(mainDexInfo::addSyntheticClass);
   }
 
   private void clearSynthesizedClassMapping(DexApplication application) {
@@ -443,7 +442,6 @@
       AppView<?> appView,
       Map<DexType, EquivalenceGroup<SyntheticMethodDefinition>> syntheticMethodGroups,
       Map<DexType, EquivalenceGroup<SyntheticProgramClassDefinition>> syntheticClassGroups,
-      MainDexClasses mainDexClasses,
       Builder lensBuilder,
       BiConsumer<DexProgramClass, SyntheticProgramClassReference> addFinalSyntheticClass,
       BiConsumer<DexProgramClass, SyntheticMethodReference> addFinalSyntheticMethod) {
@@ -453,7 +451,8 @@
 
     // TODO(b/168584485): Remove this once class-mapping support is removed.
     Set<DexType> derivedMainDexTypes = Sets.newIdentityHashSet();
-    mainDexClasses.forEach(
+    MainDexInfo mainDexInfo = appView.appInfo().getMainDexInfo();
+    mainDexInfo.forEachExcludingDependencies(
         mainDexType -> {
           derivedMainDexTypes.add(mainDexType);
           DexProgramClass mainDexClass =
@@ -566,7 +565,7 @@
             addMainDexAndSynthesizedFromForMember(
                 member,
                 externalSyntheticClass,
-                mainDexClasses,
+                mainDexInfo,
                 derivedMainDexTypes,
                 appForLookup::programDefinitionFor);
           }
@@ -588,7 +587,7 @@
             addMainDexAndSynthesizedFromForMember(
                 member,
                 externalSyntheticClass,
-                mainDexClasses,
+                mainDexInfo,
                 derivedMainDexTypes,
                 appForLookup::programDefinitionFor);
           }
@@ -638,12 +637,12 @@
   private static void addMainDexAndSynthesizedFromForMember(
       SyntheticDefinition<?, ?, ?> member,
       DexProgramClass externalSyntheticClass,
-      MainDexClasses mainDexClasses,
+      MainDexInfo mainDexInfo,
       Set<DexType> derivedMainDexTypes,
       Function<DexType, DexProgramClass> definitions) {
     member
         .getContext()
-        .addIfDerivedFromMainDexClass(externalSyntheticClass, mainDexClasses, derivedMainDexTypes);
+        .addIfDerivedFromMainDexClass(externalSyntheticClass, mainDexInfo, derivedMainDexTypes);
     // TODO(b/168584485): Remove this once class-mapping support is removed.
     DexProgramClass from = definitions.apply(member.getContext().getSynthesizingContextType());
     if (from != null) {
@@ -765,16 +764,17 @@
       DexType representativeContext,
       Map<DexType, NumberGenerator> generators,
       AppView<?> appView) {
+    DexItemFactory factory = appView.dexItemFactory();
+    if (kind.isFixedSuffixSynthetic) {
+      return SyntheticNaming.createExternalType(kind, representativeContext, "", factory);
+    }
     NumberGenerator generator =
         generators.computeIfAbsent(representativeContext, k -> new NumberGenerator());
     DexType externalType;
     do {
       externalType =
           SyntheticNaming.createExternalType(
-              kind,
-              representativeContext,
-              Integer.toString(generator.next()),
-              appView.dexItemFactory());
+              kind, representativeContext, Integer.toString(generator.next()), factory);
       DexClass clazz = appView.appInfo().definitionForWithoutExistenceAssert(externalType);
       if (clazz != null && isNotSyntheticType(clazz.type)) {
         assert options.testing.allowConflictingSyntheticTypes
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
index c198197..14f9cf8 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
@@ -134,7 +134,7 @@
     CommittedItems commit =
         new CommittedItems(
             synthetics.nextSyntheticId, appView.appInfo().app(), committed, ImmutableList.of());
-    appView.setAppInfo(new AppInfo(commit, appView.appInfo().getMainDexClasses()));
+    appView.setAppInfo(new AppInfo(commit, appView.appInfo().getMainDexInfo()));
   }
 
   // Internal synthetic id creation helpers.
@@ -305,6 +305,36 @@
     return clazz;
   }
 
+  public DexProgramClass createFixedClass(
+      SyntheticKind kind,
+      DexProgramClass context,
+      DexItemFactory factory,
+      Consumer<SyntheticProgramClassBuilder> fn) {
+    // Obtain the outer synthesizing context in the case the context itself is synthetic.
+    // This is to ensure a flat input-type -> synthetic-item mapping.
+    SynthesizingContext outerContext = getSynthesizingContext(context);
+    DexType type = SyntheticNaming.createFixedType(kind, outerContext, factory);
+    SyntheticProgramClassBuilder classBuilder =
+        new SyntheticProgramClassBuilder(type, outerContext, factory);
+    fn.accept(classBuilder);
+    DexProgramClass clazz = classBuilder.build();
+    addPendingDefinition(new SyntheticProgramClassDefinition(kind, outerContext, clazz));
+    return clazz;
+  }
+
+  public DexClasspathClass createFixedClasspathClass(
+      SyntheticKind kind, DexClasspathClass context, DexItemFactory factory) {
+    // Obtain the outer synthesizing context in the case the context itself is synthetic.
+    // This is to ensure a flat input-type -> synthetic-item mapping.
+    SynthesizingContext outerContext = SynthesizingContext.fromNonSyntheticInputContext(context);
+    DexType type = SyntheticNaming.createFixedType(kind, outerContext, factory);
+    SyntheticClasspathClassBuilder classBuilder =
+        new SyntheticClasspathClassBuilder(type, outerContext, factory);
+    DexClasspathClass clazz = classBuilder.build();
+    addPendingDefinition(new SyntheticClasspathClassDefinition(kind, outerContext, clazz));
+    return clazz;
+  }
+
   /** Create a single synthetic method item. */
   public ProgramMethod createMethod(
       SyntheticKind kind,
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java
index 09a0f1a..0b53962 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java
@@ -66,7 +66,7 @@
     if (method != rewritten) {
       context =
           SynthesizingContext.fromSyntheticContextChange(
-              rewritten.holder, context, lens.dexItemFactory());
+              getKind(), rewritten.holder, context, lens.dexItemFactory());
       if (context == null) {
         return null;
       }
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
index fc5b278..c433ec0 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
@@ -24,6 +24,7 @@
     // Class synthetics.
     COMPANION_CLASS("CompanionClass", false),
     LAMBDA("Lambda", false),
+    INIT_TYPE_ARGUMENT("-IA", false, true),
     // Method synthetics.
     BACKPORT("Backport", true),
     STATIC_INTERFACE_CALL("StaticInterfaceCall", true),
@@ -37,10 +38,17 @@
 
     public final String descriptor;
     public final boolean isSingleSyntheticMethod;
+    public final boolean isFixedSuffixSynthetic;
 
     SyntheticKind(String descriptor, boolean isSingleSyntheticMethod) {
+      this(descriptor, isSingleSyntheticMethod, false);
+    }
+
+    SyntheticKind(
+        String descriptor, boolean isSingleSyntheticMethod, boolean isFixedSuffixSynthetic) {
       this.descriptor = descriptor;
       this.isSingleSyntheticMethod = isSingleSyntheticMethod;
+      this.isFixedSuffixSynthetic = isFixedSuffixSynthetic;
     }
 
     public static SyntheticKind fromDescriptor(String descriptor) {
@@ -73,8 +81,15 @@
         || typeName.contains(EXTERNAL_SYNTHETIC_CLASS_SEPARATOR);
   }
 
+  public static DexType createFixedType(
+      SyntheticKind kind, SynthesizingContext context, DexItemFactory factory) {
+    assert kind.isFixedSuffixSynthetic;
+    return createType("", kind, context.getSynthesizingContextType(), "", factory);
+  }
+
   static DexType createInternalType(
       SyntheticKind kind, SynthesizingContext context, String id, DexItemFactory factory) {
+    assert !kind.isFixedSuffixSynthetic;
     return createType(
         INTERNAL_SYNTHETIC_CLASS_SEPARATOR,
         kind,
@@ -85,7 +100,13 @@
 
   static DexType createExternalType(
       SyntheticKind kind, DexType context, String id, DexItemFactory factory) {
-    return createType(EXTERNAL_SYNTHETIC_CLASS_SEPARATOR, kind, context, id, factory);
+    assert kind.isFixedSuffixSynthetic == id.isEmpty();
+    return createType(
+        kind.isFixedSuffixSynthetic ? "" : EXTERNAL_SYNTHETIC_CLASS_SEPARATOR,
+        kind,
+        context,
+        id,
+        factory);
   }
 
   private static DexType createType(
@@ -134,6 +155,10 @@
 
   static boolean isSynthetic(ClassReference clazz, Phase phase, SyntheticKind kind) {
     String typeName = clazz.getTypeName();
+    if (kind.isFixedSuffixSynthetic) {
+      assert phase == null;
+      return clazz.getBinaryName().endsWith(kind.descriptor);
+    }
     String separator = getPhaseSeparator(phase);
     int i = typeName.indexOf(separator);
     return i >= 0 && checkMatchFrom(kind, typeName, i, separator, phase == Phase.EXTERNAL);
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassDefinition.java
index 8b42eb6..3506dab 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassDefinition.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassDefinition.java
@@ -48,7 +48,9 @@
 
   @Override
   public boolean isValid() {
-    return clazz.isPublic() && clazz.isFinal() && clazz.accessFlags.isSynthetic();
+    return clazz.isPublic()
+        && clazz.accessFlags.isSynthetic()
+        && (clazz.isFinal() || clazz.isAbstract());
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassReference.java
index 3472268..7e798e0 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassReference.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassReference.java
@@ -53,7 +53,8 @@
     // Ensure that if a synthetic moves its context moves consistently.
     if (type != rewritten) {
       context =
-          SynthesizingContext.fromSyntheticContextChange(rewritten, context, lens.dexItemFactory());
+          SynthesizingContext.fromSyntheticContextChange(
+              getKind(), rewritten, context, lens.dexItemFactory());
       if (context == null) {
         return null;
       }
diff --git a/src/main/java/com/android/tools/r8/tracereferences/Tracer.java b/src/main/java/com/android/tools/r8/tracereferences/Tracer.java
index 286c83d..039f28d 100644
--- a/src/main/java/com/android/tools/r8/tracereferences/Tracer.java
+++ b/src/main/java/com/android/tools/r8/tracereferences/Tracer.java
@@ -31,7 +31,7 @@
 import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.tracereferences.TraceReferencesConsumer.AccessFlags;
 import com.android.tools.r8.tracereferences.TraceReferencesConsumer.ClassAccessFlags;
 import com.android.tools.r8.tracereferences.TraceReferencesConsumer.FieldAccessFlags;
@@ -236,7 +236,7 @@
         AppInfoWithClassHierarchy.createInitialAppInfoWithClassHierarchy(
             application,
             ClassToFeatureSplitMap.createEmptyClassToFeatureSplitMap(),
-            MainDexClasses.createEmptyMainDexClasses());
+            MainDexInfo.none());
   }
 
   void run(TraceReferencesConsumer consumer) {
diff --git a/src/main/java/com/android/tools/r8/utils/FieldReferenceUtils.java b/src/main/java/com/android/tools/r8/utils/FieldReferenceUtils.java
new file mode 100644
index 0000000..cb26884
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/FieldReferenceUtils.java
@@ -0,0 +1,18 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.utils;
+
+import com.android.tools.r8.references.FieldReference;
+
+public class FieldReferenceUtils {
+
+  public static String toSourceString(FieldReference fieldReference) {
+    return fieldReference.getFieldType().getTypeName()
+        + " "
+        + fieldReference.getHolderClass().getTypeName()
+        + "."
+        + fieldReference.getFieldName();
+  }
+}
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 0d4a768..118a5b6 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -40,7 +40,6 @@
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.graph.classmerging.HorizontallyMergedLambdaClasses;
 import com.android.tools.r8.graph.classmerging.VerticallyMergedClasses;
 import com.android.tools.r8.horizontalclassmerging.HorizontallyMergedClasses;
 import com.android.tools.r8.inspector.internal.InspectorImpl;
@@ -50,7 +49,6 @@
 import com.android.tools.r8.ir.desugar.nest.Nest;
 import com.android.tools.r8.ir.optimize.Inliner;
 import com.android.tools.r8.ir.optimize.enums.EnumDataMap;
-import com.android.tools.r8.ir.optimize.lambda.kotlin.KotlinLambdaGroupIdFactory;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.position.Position;
 import com.android.tools.r8.references.Reference;
@@ -201,7 +199,6 @@
     enableClassInlining = false;
     enableClassStaticizer = false;
     enableDevirtualization = false;
-    enableLambdaMerging = false;
     horizontalClassMergerOptions.disable();
     enableVerticalClassMerging = false;
     enableEnumUnboxing = false;
@@ -488,6 +485,11 @@
     return !canUseNestBasedAccess();
   }
 
+  public boolean canUseRecords() {
+    // TODO(b/169645628): Replace by true when records are supported.
+    return testing.canUseRecords;
+  }
+
   public Set<String> extensiveLoggingFilter = getExtensiveLoggingFilter();
   public Set<String> extensiveInterfaceMethodMinifierLoggingFilter =
       getExtensiveInterfaceMethodMinifierLoggingFilter();
@@ -502,8 +504,6 @@
 
   // Flag to turn on/offLoad/store optimization in the Cf back-end.
   public boolean enableLoadStoreOptimization = true;
-  // Flag to turn on/off lambda class merging in R8.
-  public boolean enableLambdaMerging = false;
   // Flag to turn on/off desugaring in D8/R8.
   public DesugarState desugarState = DesugarState.ON;
   // Flag to turn on/off reduction of nest to improve class merging optimizations.
@@ -600,6 +600,8 @@
   public boolean printCfg = false;
   public String printCfgFile;
   public boolean ignoreMissingClasses = false;
+  public boolean reportMissingClassesInEnclosingMethodAttribute = false;
+  public boolean reportMissingClassesInInnerClassAttributes = false;
 
   // EXPERIMENTAL flag to get behaviour as close to Proguard as possible.
   public boolean forceProguardCompatibility = false;
@@ -1139,20 +1141,17 @@
     public boolean enableConstructorMerging = true;
     // TODO(b/174809311): Update or remove the option and its tests after new lambdas synthetics.
     public boolean enableJavaLambdaMerging = false;
-    public boolean enableKotlinLambdaMerging = true;
 
     public int syntheticArgumentCount = 3;
     public int maxGroupSize = 30;
 
+    // TODO(b/179019716): Add support for merging in presence of annotations.
+    public boolean skipNoClassesOrMembersWithAnnotationsPolicyForTesting = false;
+
     public void disable() {
       enable = false;
     }
 
-    @Deprecated
-    public void disableKotlinLambdaMerging() {
-      enableKotlinLambdaMerging = false;
-    }
-
     public void enable() {
       enable = true;
     }
@@ -1165,10 +1164,6 @@
       enableJavaLambdaMerging = true;
     }
 
-    public void enableKotlinLambdaMergingIf(boolean enableKotlinLambdaMerging) {
-      this.enableKotlinLambdaMerging = enableKotlinLambdaMerging;
-    }
-
     public int getMaxGroupSize() {
       return maxGroupSize;
     }
@@ -1192,10 +1187,6 @@
     public boolean isJavaLambdaMergingEnabled() {
       return enableJavaLambdaMerging;
     }
-
-    public boolean isKotlinLambdaMergingEnabled() {
-      return enableKotlinLambdaMerging;
-    }
   }
 
   public static class ProtoShrinkingOptions {
@@ -1243,9 +1234,6 @@
 
     public BiConsumer<AppInfoWithLiveness, Enqueuer.Mode> enqueuerInspector = null;
 
-    public Function<DexProgramClass, KotlinLambdaGroupIdFactory> kotlinLambdaMergerFactoryForClass =
-        KotlinLambdaGroupIdFactory::getFactoryForClass;
-
     public BiConsumer<ProgramMethod, MethodProcessingId> methodProcessingIdConsumer = null;
 
     public Function<AppView<AppInfoWithLiveness>, RepackagingConfiguration>
@@ -1257,9 +1245,6 @@
     public BiConsumer<DexItemFactory, HorizontallyMergedClasses> horizontallyMergedClassesConsumer =
         ConsumerUtils.emptyBiConsumer();
 
-    public BiConsumer<DexItemFactory, HorizontallyMergedLambdaClasses>
-        horizontallyMergedLambdaClassesConsumer = ConsumerUtils.emptyBiConsumer();
-
     public BiConsumer<DexItemFactory, EnumDataMap> unboxedEnumsConsumer =
         ConsumerUtils.emptyBiConsumer();
 
@@ -1303,6 +1288,7 @@
     public boolean enableSwitchToIfRewriting = true;
     public boolean enableEnumUnboxingDebugLogs = false;
     public boolean forceRedundantConstNumberRemoval = false;
+    public boolean canUseRecords = false;
     public boolean invertConditionals = false;
     public boolean placeExceptionalBlocksLast = false;
     public boolean dontCreateMarkerInD8 = false;
diff --git a/src/main/java/com/android/tools/r8/utils/LensUtils.java b/src/main/java/com/android/tools/r8/utils/LensUtils.java
index a039fb6..2c67ac3 100644
--- a/src/main/java/com/android/tools/r8/utils/LensUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/LensUtils.java
@@ -6,9 +6,11 @@
 
 import com.android.tools.r8.graph.DexDefinitionSupplier;
 import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexReference;
 import com.android.tools.r8.graph.GraphLens;
 import com.google.common.collect.Sets;
 import java.util.Set;
+import java.util.function.Consumer;
 
 public class LensUtils {
 
@@ -20,4 +22,15 @@
     }
     return result;
   }
+
+  public static <T extends DexReference> void rewriteAndApplyIfNotPrimitiveType(
+      GraphLens graphLens, T reference, Consumer<T> rewrittenConsumer) {
+    T rewrittenReference = graphLens.rewriteReference(reference);
+    // Enum unboxing can change a class type to int which leads to errors going forward since
+    // the root set should not have primitive types.
+    if (rewrittenReference.isDexType() && rewrittenReference.asDexType().isPrimitiveType()) {
+      return;
+    }
+    rewrittenConsumer.accept(rewrittenReference);
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/utils/MethodReferenceUtils.java b/src/main/java/com/android/tools/r8/utils/MethodReferenceUtils.java
index 7f48f2a..e76f21a 100644
--- a/src/main/java/com/android/tools/r8/utils/MethodReferenceUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/MethodReferenceUtils.java
@@ -4,21 +4,39 @@
 
 package com.android.tools.r8.utils;
 
+import com.android.tools.r8.references.ArrayReference;
+import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.references.TypeReference;
+import com.google.common.collect.ImmutableList;
 import java.util.Iterator;
 
 public class MethodReferenceUtils {
 
+  public static MethodReference mainMethod(ClassReference type) {
+    ArrayReference stringArrayType = Reference.array(Reference.classFromClass(String.class), 1);
+    return Reference.method(type, "main", ImmutableList.of(stringArrayType), null);
+  }
+
   public static String toSourceStringWithoutHolderAndReturnType(MethodReference methodReference) {
     return toSourceString(methodReference, false, false);
   }
 
+  public static String toSourceString(MethodReference methodReference) {
+    return toSourceString(methodReference, true, true);
+  }
+
   public static String toSourceString(
       MethodReference methodReference, boolean includeHolder, boolean includeReturnType) {
     StringBuilder builder = new StringBuilder();
     if (includeReturnType) {
-      builder.append(methodReference.getReturnType().getTypeName()).append(" ");
+      builder
+          .append(
+              methodReference.getReturnType() != null
+                  ? methodReference.getReturnType().getTypeName()
+                  : "void")
+          .append(" ");
     }
     if (includeHolder) {
       builder.append(methodReference.getHolderClass().getTypeName()).append(".");
diff --git a/src/main/java/com/android/tools/r8/utils/PredicateSet.java b/src/main/java/com/android/tools/r8/utils/PredicateSet.java
index da15974..0eb186d 100644
--- a/src/main/java/com/android/tools/r8/utils/PredicateSet.java
+++ b/src/main/java/com/android/tools/r8/utils/PredicateSet.java
@@ -24,6 +24,10 @@
     predicates.add(predicate);
   }
 
+  public static <T> PredicateSet<T> empty() {
+    return new PredicateSet<>();
+  }
+
   public PredicateSet<T> rewriteItems(Function<T, T> mapping) {
     PredicateSet<T> set = new PredicateSet<>();
     for (T item : elements) {
diff --git a/src/main/java/com/android/tools/r8/utils/SetUtils.java b/src/main/java/com/android/tools/r8/utils/SetUtils.java
index c67225c..a278196 100644
--- a/src/main/java/com/android/tools/r8/utils/SetUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/SetUtils.java
@@ -37,6 +37,14 @@
     return result;
   }
 
+  public static <T> Set<T> newIdentityHashSet(Iterable<T> c1, Iterable<T> c2, Iterable<T> c3) {
+    Set<T> result = Sets.newIdentityHashSet();
+    c1.forEach(result::add);
+    c2.forEach(result::add);
+    c3.forEach(result::add);
+    return result;
+  }
+
   public static <T> Set<T> newIdentityHashSet(int capacity) {
     return Collections.newSetFromMap(new IdentityHashMap<>(capacity));
   }
@@ -54,4 +62,11 @@
     }
     return out;
   }
+
+  public static <T> Set<T> unionIdentityHashSet(Set<T> one, Set<T> other) {
+    Set<T> union = Sets.newIdentityHashSet();
+    union.addAll(one);
+    union.addAll(other);
+    return union;
+  }
 }
diff --git a/src/test/examplesJava15/records/Main.java b/src/test/examplesJava15/records/EmptyRecord.java
similarity index 60%
copy from src/test/examplesJava15/records/Main.java
copy to src/test/examplesJava15/records/EmptyRecord.java
index 7be696d..5d16e44 100644
--- a/src/test/examplesJava15/records/Main.java
+++ b/src/test/examplesJava15/records/EmptyRecord.java
@@ -4,13 +4,11 @@
 
 package records;
 
-public class Main {
+public class EmptyRecord {
 
-  record Person(String name, int age) {}
+  record Empty() {}
 
   public static void main(String[] args) {
-    Person janeDoe = new Person("Jane Doe", 42);
-    System.out.println(janeDoe.name);
-    System.out.println(janeDoe.age);
+    System.out.println(new Empty());
   }
 }
diff --git a/src/test/examplesJava15/records/RecordInstanceOf.java b/src/test/examplesJava15/records/RecordInstanceOf.java
new file mode 100644
index 0000000..591192c
--- /dev/null
+++ b/src/test/examplesJava15/records/RecordInstanceOf.java
@@ -0,0 +1,21 @@
+// 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 records;
+
+public class RecordInstanceOf {
+
+  record Empty() {}
+
+  record Person(String name, int age) {}
+
+  public static void main(String[] args) {
+    Empty empty = new Empty();
+    Person janeDoe = new Person("Jane Doe", 42);
+    Object o = new Object();
+    System.out.println(janeDoe instanceof java.lang.Record);
+    System.out.println(empty instanceof java.lang.Record);
+    System.out.println(o instanceof java.lang.Record);
+  }
+}
diff --git a/src/test/examplesJava15/records/RecordInvokeCustom.java b/src/test/examplesJava15/records/RecordInvokeCustom.java
new file mode 100644
index 0000000..c460f56
--- /dev/null
+++ b/src/test/examplesJava15/records/RecordInvokeCustom.java
@@ -0,0 +1,48 @@
+// 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 records;
+
+public class RecordInvokeCustom {
+
+  record Empty() {}
+
+  record Person(String name, int age) {}
+
+  public static void main(String[] args) {
+    emptyTest();
+    equalityTest();
+    toStringTest();
+  }
+
+  private static void emptyTest() {
+    Empty empty1 = new Empty();
+    Empty empty2 = new Empty();
+    System.out.println(empty1.toString());
+    System.out.println(empty1.equals(empty2));
+    System.out.println(empty1.hashCode() == empty2.hashCode());
+    System.out.println(empty1.toString().equals(empty2.toString()));
+  }
+
+  private static void toStringTest() {
+    Person janeDoe = new Person("Jane Doe", 42);
+    System.out.println(janeDoe.toString());
+  }
+
+  private static void equalityTest() {
+    Person jane1 = new Person("Jane Doe", 42);
+    Person jane2 = new Person("Jane Doe", 42);
+    String nonIdenticalString = "Jane " + (System.currentTimeMillis() > 0 ? "Doe" : "Zan");
+    Person jane3 = new Person(nonIdenticalString, 42);
+    Person bob = new Person("Bob", 42);
+    Person youngJane = new Person("Jane Doe", 22);
+    System.out.println(jane1.equals(jane2));
+    System.out.println(jane1.toString().equals(jane2.toString()));
+    System.out.println(nonIdenticalString == "Jane Doe"); // false.
+    System.out.println(nonIdenticalString.equals("Jane Doe")); // true.
+    System.out.println(jane1.equals(jane3));
+    System.out.println(jane1.equals(bob));
+    System.out.println(jane1.equals(youngJane));
+  }
+}
diff --git a/src/test/examplesJava15/records/RecordReflection.java b/src/test/examplesJava15/records/RecordReflection.java
new file mode 100644
index 0000000..1b94a12
--- /dev/null
+++ b/src/test/examplesJava15/records/RecordReflection.java
@@ -0,0 +1,29 @@
+// 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 records;
+
+import java.util.Arrays;
+
+public class RecordReflection {
+
+  record Empty(){}
+
+  record Person(String name, int age) {}
+
+  record PersonGeneric <S extends CharSequence>(S name, int age) {}
+
+  public static void main(String[] args) {
+    System.out.println(Empty.class.isRecord());
+    System.out.println(Arrays.toString(Empty.class.getRecordComponents()));
+    System.out.println(Person.class.isRecord());
+    System.out.println(Arrays.toString(Person.class.getRecordComponents()));
+    System.out.println(PersonGeneric.class.isRecord());
+    System.out.println(Arrays.toString(PersonGeneric.class.getRecordComponents()));
+    System.out.println(Arrays.toString(PersonGeneric.class.getTypeParameters()));
+    System.out.println(Object.class.isRecord());
+    System.out.println(Arrays.toString(Object.class.getRecordComponents()));
+  }
+
+}
diff --git a/src/test/examplesJava15/records/RecordWithMembers.java b/src/test/examplesJava15/records/RecordWithMembers.java
new file mode 100644
index 0000000..6de2b99
--- /dev/null
+++ b/src/test/examplesJava15/records/RecordWithMembers.java
@@ -0,0 +1,69 @@
+// 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 records;
+
+public class RecordWithMembers {
+
+
+  record PersonWithConstructors(String name, int age) {
+
+    public PersonWithConstructors(String name, int age) {
+      this.name = name + "X";
+      this.age = age;
+    }
+
+    public PersonWithConstructors(String name) {
+      this(name, -1);
+    }
+  }
+
+  record PersonWithMethods(String name, int age) {
+    public static void staticPrint() {
+      System.out.println("print");
+    }
+
+    @Override
+    public String toString() {
+      return name + age;
+    }
+  }
+
+  record PersonWithFields(String name, int age) {
+
+    // Extra instance fields are not allowed on records.
+    public static String globalName;
+
+  }
+
+  public static void main(String[] args) {
+    personWithConstructorTest();
+    personWithMethodsTest();
+    personWithFieldsTest();
+  }
+
+  private static void personWithConstructorTest() {
+    PersonWithConstructors bob = new PersonWithConstructors("Bob", 43);
+    System.out.println(bob.name);
+    System.out.println(bob.age);
+    System.out.println(bob.name());
+    System.out.println(bob.age());
+    PersonWithConstructors felix = new PersonWithConstructors("Felix");
+    System.out.println(felix.name);
+    System.out.println(felix.age);
+    System.out.println(felix.name());
+    System.out.println(felix.age());
+  }
+
+  private static void personWithMethodsTest() {
+    PersonWithMethods.staticPrint();
+    PersonWithMethods bob = new PersonWithMethods("Bob", 43);
+    System.out.println(bob.toString());
+  }
+
+  private static void personWithFieldsTest() {
+    PersonWithFields.globalName = "extra";
+    System.out.println(PersonWithFields.globalName);
+  }
+}
diff --git a/src/test/examplesJava15/records/Main.java b/src/test/examplesJava15/records/SimpleRecord.java
similarity index 80%
rename from src/test/examplesJava15/records/Main.java
rename to src/test/examplesJava15/records/SimpleRecord.java
index 7be696d..1f8fca4 100644
--- a/src/test/examplesJava15/records/Main.java
+++ b/src/test/examplesJava15/records/SimpleRecord.java
@@ -4,7 +4,7 @@
 
 package records;
 
-public class Main {
+public class SimpleRecord {
 
   record Person(String name, int age) {}
 
@@ -12,5 +12,7 @@
     Person janeDoe = new Person("Jane Doe", 42);
     System.out.println(janeDoe.name);
     System.out.println(janeDoe.age);
+    System.out.println(janeDoe.name());
+    System.out.println(janeDoe.age());
   }
 }
diff --git a/src/test/java/com/android/tools/r8/IntermediateCfD8TestBuilder.java b/src/test/java/com/android/tools/r8/IntermediateCfD8TestBuilder.java
index 609fad5..d018732 100644
--- a/src/test/java/com/android/tools/r8/IntermediateCfD8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/IntermediateCfD8TestBuilder.java
@@ -29,8 +29,7 @@
   private IntermediateCfD8TestBuilder(TestState state, AndroidApiLevel apiLevel) {
     super(state);
     cf2cf = D8TestBuilder.create(state, Backend.CF).setMinApi(apiLevel);
-    cf2dex =
-        D8TestBuilder.create(state, Backend.DEX).setMinApi(apiLevel).setDisableDesugaring(true);
+    cf2dex = D8TestBuilder.create(state, Backend.DEX).disableDesugaring().setMinApi(apiLevel);
   }
 
   public IntermediateCfD8TestBuilder addOptionsModification(Consumer<InternalOptions> fn) {
diff --git a/src/test/java/com/android/tools/r8/KotlinTestBase.java b/src/test/java/com/android/tools/r8/KotlinTestBase.java
index f8dc222..38202a6 100644
--- a/src/test/java/com/android/tools/r8/KotlinTestBase.java
+++ b/src/test/java/com/android/tools/r8/KotlinTestBase.java
@@ -41,10 +41,12 @@
 
   protected final KotlinCompiler kotlinc;
   protected final KotlinTargetVersion targetVersion;
+  protected final KotlinTestParameters kotlinParameters;
 
-  protected KotlinTestBase(KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    this.targetVersion = targetVersion;
-    this.kotlinc = kotlinc;
+  protected KotlinTestBase(KotlinTestParameters kotlinParameters) {
+    this.targetVersion = kotlinParameters.getTargetVersion();
+    this.kotlinc = kotlinParameters.getCompiler();
+    this.kotlinParameters = kotlinParameters;
   }
 
   protected static List<Path> getKotlinFilesInTestPackage(Package pkg) throws IOException {
@@ -125,6 +127,11 @@
       return this;
     }
 
+    public Path getForConfiguration(KotlinTestParameters kotlinParameters) {
+      return getForConfiguration(
+          kotlinParameters.getCompiler(), kotlinParameters.getTargetVersion());
+    }
+
     public Path getForConfiguration(KotlinCompiler compiler, KotlinTargetVersion targetVersion) {
       Map<KotlinTargetVersion, Path> kotlinTargetVersionPathMap = compiledPaths.get(compiler);
       if (kotlinTargetVersionPathMap == null) {
diff --git a/src/test/java/com/android/tools/r8/KotlinTestParameters.java b/src/test/java/com/android/tools/r8/KotlinTestParameters.java
new file mode 100644
index 0000000..69a1cff
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/KotlinTestParameters.java
@@ -0,0 +1,95 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8;
+
+import static org.junit.Assert.assertNotNull;
+
+import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import java.util.ArrayList;
+import java.util.List;
+
+public class KotlinTestParameters {
+
+  private final int index;
+  private final KotlinCompiler kotlinc;
+  private final KotlinTargetVersion targetVersion;
+
+  private KotlinTestParameters(
+      KotlinCompiler kotlinc, KotlinTargetVersion targetVersion, int index) {
+    this.index = index;
+    this.kotlinc = kotlinc;
+    this.targetVersion = targetVersion;
+  }
+
+  public KotlinCompiler getCompiler() {
+    return kotlinc;
+  }
+
+  public KotlinTargetVersion getTargetVersion() {
+    return targetVersion;
+  }
+
+  public boolean isFirst() {
+    return index == 0;
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  @Override
+  public String toString() {
+    return kotlinc + "[target=" + targetVersion + "]";
+  }
+
+  public static class Builder {
+
+    private KotlinCompiler[] compilers;
+    private KotlinTargetVersion[] targetVersions;
+
+    private Builder() {}
+
+    public Builder withAllCompilers() {
+      compilers = ToolHelper.getKotlinCompilers();
+      return this;
+    }
+
+    public Builder withAllCompilersAndTargetVersions() {
+      return withAllCompilers().withAllTargetVersions();
+    }
+
+    public Builder withCompiler(KotlinCompiler compiler) {
+      compilers = new KotlinCompiler[] {compiler};
+      return this;
+    }
+
+    public Builder withAllTargetVersions() {
+      targetVersions = KotlinTargetVersion.values();
+      return this;
+    }
+
+    public Builder withTargetVersion(KotlinTargetVersion targetVersion) {
+      targetVersions = new KotlinTargetVersion[] {targetVersion};
+      return this;
+    }
+
+    public KotlinTestParametersCollection build() {
+      validate();
+      List<KotlinTestParameters> testParameters = new ArrayList<>();
+      int index = 0;
+      for (KotlinCompiler kotlinc : compilers) {
+        for (KotlinTargetVersion targetVersion : targetVersions) {
+          testParameters.add(new KotlinTestParameters(kotlinc, targetVersion, index++));
+        }
+      }
+      return new KotlinTestParametersCollection(testParameters);
+    }
+
+    private void validate() {
+      assertNotNull(compilers);
+      assertNotNull(targetVersions);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/KotlinTestParametersCollection.java b/src/test/java/com/android/tools/r8/KotlinTestParametersCollection.java
new file mode 100644
index 0000000..6851116
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/KotlinTestParametersCollection.java
@@ -0,0 +1,22 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8;
+
+import java.util.Collection;
+import java.util.Iterator;
+
+public class KotlinTestParametersCollection implements Iterable<KotlinTestParameters> {
+
+  private final Collection<KotlinTestParameters> parameters;
+
+  public KotlinTestParametersCollection(Collection<KotlinTestParameters> parameters) {
+    assert parameters != null;
+    this.parameters = parameters;
+  }
+
+  @Override
+  public Iterator<KotlinTestParameters> iterator() {
+    return parameters.iterator();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ProguardTestBuilder.java b/src/test/java/com/android/tools/r8/ProguardTestBuilder.java
index 7aacf12..460246c 100644
--- a/src/test/java/com/android/tools/r8/ProguardTestBuilder.java
+++ b/src/test/java/com/android/tools/r8/ProguardTestBuilder.java
@@ -272,7 +272,7 @@
   }
 
   @Override
-  public ProguardTestBuilder noDesugaring() {
+  public ProguardTestBuilder disableDesugaring() {
     throw new Unimplemented("No support for disabling desugaring");
   }
 
diff --git a/src/test/java/com/android/tools/r8/SwitchDebugLocalsConflictTest.java b/src/test/java/com/android/tools/r8/SwitchDebugLocalsConflictTest.java
index 7a76f4a..d324f38 100644
--- a/src/test/java/com/android/tools/r8/SwitchDebugLocalsConflictTest.java
+++ b/src/test/java/com/android/tools/r8/SwitchDebugLocalsConflictTest.java
@@ -33,7 +33,7 @@
   public void test() throws CompilationFailedException {
     testForD8()
         .addProgramClassFileData(Dump.dump())
-        .noDesugaring()
+        .disableDesugaring()
         .compileWithExpectedDiagnostics(
             diagnotics -> {
               diagnotics.assertNoErrors();
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index b2945dc..a80cc32 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -46,7 +46,7 @@
 import com.android.tools.r8.references.TypeReference;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.shaking.EnqueuerFactory;
-import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.shaking.MainDexInfo;
 import com.android.tools.r8.shaking.NoHorizontalClassMergingRule;
 import com.android.tools.r8.shaking.NoVerticalClassMergingRule;
 import com.android.tools.r8.shaking.ProguardClassNameList;
@@ -360,8 +360,6 @@
 
   // Actually running Proguard should only be during development.
   private static final boolean RUN_PROGUARD = System.getProperty("run_proguard") != null;
-  // Actually running r8.jar in a forked process.
-  private static final boolean RUN_R8_JAR = System.getProperty("run_r8_jar") != null;
 
   @Rule public ExpectedException thrown = ExpectedException.none();
 
@@ -395,6 +393,10 @@
     return TestParametersBuilder.builder();
   }
 
+  public static KotlinTestParameters.Builder getKotlinTestParameters() {
+    return KotlinTestParameters.builder();
+  }
+
   protected static <S, T, E extends Throwable> Function<S, T> memoizeFunction(
       ThrowingFunction<S, T, E> fn) {
     return CacheBuilder.newBuilder()
@@ -446,13 +448,6 @@
   }
 
   /**
-   * Check if tests should run R8 in a forked process when applicable.
-   */
-  protected boolean isRunR8Jar() {
-    return RUN_R8_JAR;
-  }
-
-  /**
    * Write lines of text to a temporary file.
    *
    * The file will include a line separator after the last line.
@@ -715,7 +710,7 @@
     return AppInfoWithClassHierarchy.createInitialAppInfoWithClassHierarchy(
         readApplicationForDexOutput(app, new InternalOptions()),
         ClassToFeatureSplitMap.createEmptyClassToFeatureSplitMap(),
-        MainDexClasses.createEmptyMainDexClasses());
+        MainDexInfo.none());
   }
 
   protected static AppView<AppInfoWithClassHierarchy> computeAppViewWithClassHierachy(
@@ -1662,6 +1657,10 @@
     return dexItemFactory.createType(descriptor(clazz));
   }
 
+  public static DexType toDexType(ClassReference classReference, DexItemFactory dexItemFactory) {
+    return dexItemFactory.createType(classReference.getDescriptor());
+  }
+
   public static String binaryName(Class<?> clazz) {
     return DescriptorUtils.getBinaryNameFromJavaType(typeName(clazz));
   }
diff --git a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
index b7ca275..ea3f393 100644
--- a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8;
 
+import static com.google.common.base.Predicates.not;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
@@ -20,7 +21,6 @@
 import com.android.tools.r8.utils.ThrowingOutputStream;
 import com.android.tools.r8.utils.codeinspector.EnumUnboxingInspector;
 import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
-import com.android.tools.r8.utils.codeinspector.HorizontallyMergedLambdaClassesInspector;
 import com.android.tools.r8.utils.codeinspector.VerticallyMergedClassesInspector;
 import com.google.common.base.Suppliers;
 import java.io.ByteArrayOutputStream;
@@ -124,35 +124,24 @@
   }
 
   public T addHorizontallyMergedClassesInspector(
-      Consumer<HorizontallyMergedClassesInspector> inspector) {
+      ThrowableConsumer<HorizontallyMergedClassesInspector> inspector) {
     return addOptionsModification(
         options ->
             options.testing.horizontallyMergedClassesConsumer =
                 ((dexItemFactory, horizontallyMergedClasses) ->
-                    inspector.accept(
+                    inspector.acceptWithRuntimeException(
                         new HorizontallyMergedClassesInspector(
                             dexItemFactory, horizontallyMergedClasses))));
   }
 
   public T addHorizontallyMergedClassesInspectorIf(
-      boolean condition, Consumer<HorizontallyMergedClassesInspector> inspector) {
+      boolean condition, ThrowableConsumer<HorizontallyMergedClassesInspector> inspector) {
     if (condition) {
       return addHorizontallyMergedClassesInspector(inspector);
     }
     return self();
   }
 
-  public T addHorizontallyMergedLambdaClassesInspector(
-      Consumer<HorizontallyMergedLambdaClassesInspector> inspector) {
-    return addOptionsModification(
-        options ->
-            options.testing.horizontallyMergedLambdaClassesConsumer =
-                ((dexItemFactory, horizontallyMergedLambdaClasses) ->
-                    inspector.accept(
-                        new HorizontallyMergedLambdaClassesInspector(
-                            dexItemFactory, horizontallyMergedLambdaClasses))));
-  }
-
   public T addVerticallyMergedClassesInspector(
       Consumer<VerticallyMergedClassesInspector> inspector) {
     return addOptionsModification(
@@ -323,11 +312,7 @@
   }
 
   public T disableDesugaring() {
-    return setDisableDesugaring(true);
-  }
-
-  public T setDisableDesugaring(boolean disableDesugaring) {
-    builder.setDisableDesugaring(disableDesugaring);
+    builder.setDisableDesugaring(true);
     return self();
   }
 
@@ -412,11 +397,6 @@
     return super.addLibraryProvider(provider);
   }
 
-  public T noDesugaring() {
-    builder.setDisableDesugaring(true);
-    return self();
-  }
-
   public T allowStdoutMessages() {
     allowStdoutMessages = true;
     return self();
@@ -540,6 +520,7 @@
     public void finished(DiagnosticsHandler handler) {
       mainDexClasses =
           Stream.of(builder.toString().split(System.lineSeparator()))
+              .filter(not(String::isEmpty))
               .map(
                   line -> {
                     assert line.endsWith(".class");
diff --git a/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java b/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java
index 4f8713f..997faf6 100644
--- a/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java
+++ b/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java
@@ -19,8 +19,16 @@
 
   List<Diagnostic> getWarnings();
 
+  default <D extends Diagnostic> D getWarning(int index) {
+    return (D) getWarnings().get(index);
+  }
+
   List<Diagnostic> getErrors();
 
+  default <D extends Diagnostic> D getError(int index) {
+    return (D) getErrors().get(index);
+  }
+
   TestDiagnosticMessages assertNoMessages();
 
   TestDiagnosticMessages assertOnlyInfos();
diff --git a/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java b/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
index 362941b..dbac9f1 100644
--- a/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
@@ -126,39 +126,6 @@
     return addDontWarn(clazz.getTypeName() + COMPANION_CLASS_NAME_SUFFIX);
   }
 
-  @Deprecated
-  public T addDontWarnCompanionClasses() {
-    return addDontWarn("**" + COMPANION_CLASS_NAME_SUFFIX);
-  }
-
-  @Deprecated
-  public T addDontWarnCompilerSynthesizedAnnotations() {
-    return addDontWarnCompilerSynthesizedClassAnnotation()
-        .addDontWarnCompilerSynthesizedClassMapAnnotation();
-  }
-
-  @Deprecated
-  public T addDontWarnCompilerSynthesizedClassAnnotation() {
-    return addDontWarn("com.android.tools.r8.annotations.SynthesizedClass");
-  }
-
-  @Deprecated
-  public T addDontWarnCompilerSynthesizedClassMapAnnotation() {
-    return addDontWarn("com.android.tools.r8.annotations.SynthesizedClassMap");
-  }
-
-  // TODO(b/176143558): Should not report missing classes for compiler synthesized classes.
-  @Deprecated
-  public T addDontWarnEmulatedLibraryClass(Class<?> clazz) {
-    return addDontWarn(clazz.getTypeName() + "$-EL");
-  }
-
-  // TODO(b/176143558): Should not report missing classes for compiler synthesized classes.
-  @Deprecated
-  public T addDontWarnEmulatedLibraryClasses() {
-    return addDontWarn("**$-EL");
-  }
-
   public T addDontWarnGoogle() {
     return addDontWarn("com.google.**");
   }
@@ -175,10 +142,6 @@
     return addDontWarn("java.lang.invoke.*");
   }
 
-  public T addDontWarnJavaLangInvoke(String className) {
-    return addDontWarn("java.lang.invoke." + className);
-  }
-
   public T addDontWarnJavaNioFile() {
     return addDontWarn("java.nio.file.**");
   }
@@ -213,44 +176,8 @@
     return addDontWarn("kotlin.Metadata");
   }
 
-  // TODO(b/176133676): Investigate kotlinx missing class references.
-  @Deprecated
-  public T addDontWarnKotlinx() {
-    return addDontWarn("kotlinx.**");
-  }
-
-  // TODO(b/176144018): Should not report compiler synthesized references as missing.
-  @Deprecated
-  public T addDontWarnRetargetLibraryMembers() {
-    return addDontWarn("j$.retarget.$r8$retargetLibraryMember**");
-  }
-
-  @Deprecated
-  public T addDontWarnRetargetLibraryMember(String suffix) {
-    return addDontWarn("j$.retarget.$r8$retargetLibraryMember$" + suffix);
-  }
-
-  // TODO(b/154849103): Should not warn about SerializedLambda.
-  @Deprecated
-  public T addDontWarnSerializedLambda() {
-    return addDontWarn("java.lang.invoke.SerializedLambda");
-  }
-
-  // TODO(b/176781593): Should not be reported missing.
-  @Deprecated
-  public T addDontWarnTimeConversions() {
-    return addDontWarn("java.time.TimeConversions");
-  }
-
-  // TODO(b/176144018): Should not report compiler synthesized references as missing.
-  @Deprecated
-  public T addDontWarnVivifiedClass(Class<?> clazz) {
-    return addDontWarn("$-vivified-$." + clazz.getTypeName());
-  }
-
-  @Deprecated
-  public T addDontWarnVivifiedClasses() {
-    return addDontWarn("$-vivified-$.**");
+  public T addIgnoreWarnings() {
+    return addKeepRules("-ignorewarnings");
   }
 
   public T addKeepKotlinMetadata() {
@@ -422,9 +349,17 @@
   }
 
   public T addKeepAttributes(String... attributes) {
+    return addKeepAttributes(Arrays.asList(attributes));
+  }
+
+  public T addKeepAttributes(List<String> attributes) {
     return addKeepRules("-keepattributes " + String.join(",", attributes));
   }
 
+  public T addKeepAttributeExceptions() {
+    return addKeepAttributes(ProguardKeepAttributes.EXCEPTIONS);
+  }
+
   public T addKeepAttributeInnerClassesAndEnclosingMethod() {
     return addKeepAttributes(
         ProguardKeepAttributes.INNER_CLASSES, ProguardKeepAttributes.ENCLOSING_METHOD);
diff --git a/src/test/java/com/android/tools/r8/ThrowableConsumer.java b/src/test/java/com/android/tools/r8/ThrowableConsumer.java
index 664238e..f19039b 100644
--- a/src/test/java/com/android/tools/r8/ThrowableConsumer.java
+++ b/src/test/java/com/android/tools/r8/ThrowableConsumer.java
@@ -20,4 +20,11 @@
   default void acceptWithRuntimeException(Formal formal) {
     acceptWithHandler(formal, RuntimeException::new);
   }
+
+  default ThrowableConsumer<Formal> andThen(ThrowableConsumer<Formal> consumer) {
+    return formal -> {
+      accept(formal);
+      consumer.accept(formal);
+    };
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index 08664a8..2ef51ed 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -1058,14 +1058,8 @@
     return String.join("/", parts);
   }
 
-  private static List<String> getNamePartsForTestClass(Class clazz) {
-    List<String> parts = Lists.newArrayList(clazz.getCanonicalName().split("\\."));
-    Class enclosing = clazz;
-    while (enclosing.getEnclosingClass() != null) {
-      parts.set(parts.size() - 2, parts.get(parts.size() - 2) + "$" + parts.get(parts.size() - 1));
-      parts.remove(parts.size() - 1);
-      enclosing = enclosing.getEnclosingClass();
-    }
+  private static List<String> getNamePartsForTestClass(Class<?> clazz) {
+    List<String> parts = Lists.newArrayList(clazz.getTypeName().split("\\."));
     parts.set(parts.size() - 1, parts.get(parts.size() - 1) + ".class");
     return parts;
   }
@@ -1085,7 +1079,7 @@
         .collect(Collectors.toList());
   }
 
-  public static Path getClassFileForTestClass(Class clazz) {
+  public static Path getClassFileForTestClass(Class<?> clazz) {
     List<String> parts = getNamePartsForTestClass(clazz);
     return getClassPathForTests().resolve(Paths.get("", parts.toArray(StringUtils.EMPTY_ARRAY)));
   }
diff --git a/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java b/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java
index 902d503..5d84adf 100644
--- a/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java
@@ -91,7 +91,6 @@
           "-keep class * { private static synthetic void lambda$*(); }");
     } else {
       builder
-          .applyIf(parameters.isDexRuntime(), TestShrinkerBuilder::addDontWarnSerializedLambda)
           .noMinification()
           .noTreeShaking();
     }
diff --git a/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java b/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java
index ee7ff0f..f5673dd 100644
--- a/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java
+++ b/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java
@@ -54,7 +54,6 @@
         .addProgramClasses(getClasses())
         .setMinApi(parameters.getApiLevel())
         .addKeepMainRule(getMainClass())
-        .applyIf(parameters.isDexRuntime(), TestShrinkerBuilder::addDontWarnSerializedLambda)
         .addPrintSeeds()
         .allowStdoutMessages()
         .noMinification()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java
index f878fd5..4d62a05 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java
@@ -36,9 +36,7 @@
             options ->
                 options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
         .addHorizontallyMergedClassesInspectorIf(
-            enableHorizontalClassMerging,
-            inspector ->
-                inspector.assertMerged(A.class, B.class).assertMergedIntoDifferentType(B.class))
+            enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(B.class, A.class))
         .enableInliningAnnotations()
         .enableNeverClassInliningAnnotations()
         .enableNoHorizontalClassMergingAnnotations()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessOnMergedClassTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessOnMergedClassTest.java
index ce0425e..029035e 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessOnMergedClassTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessOnMergedClassTest.java
@@ -28,12 +28,8 @@
         .addOptionsModification(
             options ->
                 options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
-        .addHorizontallyMergedClassesInspector(
-            inspector -> {
-              if (enableHorizontalClassMerging) {
-                inspector.assertMerged(C.class, D.class).assertMergedIntoDifferentType(D.class);
-              }
-            })
+        .addHorizontallyMergedClassesInspectorIf(
+            enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(D.class, C.class))
         .enableNeverClassInliningAnnotations()
         .enableNoVerticalClassMergingAnnotations()
         .setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessWithMergedTypeTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessWithMergedTypeTest.java
index 79aae15..03b99e0 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessWithMergedTypeTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessWithMergedTypeTest.java
@@ -28,13 +28,9 @@
         .addOptionsModification(
             options ->
                 options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
-        .addHorizontallyMergedClassesInspector(
-            inspector -> {
-              if (enableHorizontalClassMerging) {
-                inspector.assertMerged(HelloGreeting.class, WorldGreeting.class);
-                inspector.assertMergedIntoDifferentType(WorldGreeting.class);
-              }
-            })
+        .addHorizontallyMergedClassesInspectorIf(
+            enableHorizontalClassMerging,
+            inspector -> inspector.assertMergedInto(WorldGreeting.class, HelloGreeting.class))
         .enableNeverClassInliningAnnotations()
         .enableNoHorizontalClassMergingAnnotations()
         .enableNoVerticalClassMergingAnnotations()
diff --git a/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java b/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java
index ff841d7..86e11d0 100644
--- a/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java
+++ b/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java
@@ -29,7 +29,7 @@
   @Parameters(name = "{0}, kotlinc: {1}")
   public static List<Object[]> setup() {
     return buildParameters(
-        TestParametersBuilder.builder().withAllRuntimes().withAllApiLevels().build(),
+        TestParametersBuilder.builder().withAllRuntimesAndApiLevels().build(),
         getKotlinCompilers());
   }
 
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/BufferedReaderTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/BufferedReaderTest.java
index 2494871..f71c916 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/BufferedReaderTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/BufferedReaderTest.java
@@ -174,11 +174,6 @@
                     configurationAlternative3(options, false, parameters))
         .addInnerClasses(BufferedReaderTest.class)
         .addKeepMainRule(TestClass.class)
-        .applyIf(
-            parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
-            builder ->
-                builder.addDontWarnRetargetLibraryMember(
-                    "virtualDispatch$BufferedReader$lines$dispatchHolder"))
         .setMinApi(parameters.getApiLevel())
         .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
         .enableInliningAnnotations()
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionForwardingTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionForwardingTest.java
index 33d3f35..3c822f2 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionForwardingTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionForwardingTest.java
@@ -64,9 +64,6 @@
         .addKeepMainRule(Executor.class)
         .setMinApi(parameters.getApiLevel())
         .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
-        .applyIf(
-            parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
-            TestShrinkerBuilder::addDontWarnEmulatedLibraryClasses)
         .compile()
         .addDesugaredCoreLibraryRunClassPath(
             this::buildDesugaredLibrary,
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionInterfaceSuperTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionInterfaceSuperTest.java
index 7206b75..684998e 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionInterfaceSuperTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionInterfaceSuperTest.java
@@ -81,12 +81,6 @@
     testForR8(parameters.getBackend())
         .addInnerClasses(CustomCollectionInterfaceSuperTest.class)
         .addKeepMainRule(Main.class)
-        .applyIf(
-            parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
-            builder ->
-                builder
-                    .addDontWarnEmulatedLibraryClass(Collection.class)
-                    .addDontWarnVivifiedClass(Predicate.class))
         .setMinApi(parameters.getApiLevel())
         .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
         .compile()
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionSuperCallsTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionSuperCallsTest.java
index ce35ef0..2269987 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionSuperCallsTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionSuperCallsTest.java
@@ -108,9 +108,6 @@
         testForR8(parameters.getBackend())
             .addInnerClasses(CustomCollectionSuperCallsTest.class)
             .addKeepMainRule(Executor.class)
-            .applyIf(
-                parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
-                TestShrinkerBuilder::addDontWarnVivifiedClasses)
             .setMinApi(parameters.getApiLevel())
             .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
             .compile()
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java
index 9212761..19cd88f 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java
@@ -133,9 +133,6 @@
             .addInnerClasses(CustomCollectionTest.class)
             .setMinApi(parameters.getApiLevel())
             .addKeepClassAndMembersRules(Executor.class)
-            .applyIf(
-                requiresEmulatedInterfaceCoreLibDesugaring(parameters),
-                builder -> builder.addDontWarnEmulatedLibraryClasses().addDontWarnVivifiedClasses())
             .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
             .compile()
             .inspect(this::assertCustomCollectionCallsCorrect)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
index 8a9fc12..4de3828 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
@@ -24,7 +24,6 @@
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.ir.desugar.DesugaredLibraryConfiguration;
 import com.android.tools.r8.ir.desugar.DesugaredLibraryConfigurationParser;
-import com.android.tools.r8.ir.desugar.nest.NestBasedAccessDesugaring;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.tracereferences.TraceReferences;
 import com.android.tools.r8.utils.AndroidApiLevel;
@@ -154,15 +153,8 @@
                             .startsWith(
                                 "Invalid parameter counts in MethodParameter attributes.")));
       }
-      // TODO(b/176900254): The nest check should not be necessary.
       new CodeInspector(desugaredLib, mapping)
-          .forAllClasses(
-              clazz ->
-                  assertTrue(
-                      clazz.getFinalName().startsWith("j$.")
-                          || clazz
-                              .getOriginalName()
-                              .startsWith(NestBasedAccessDesugaring.NEST_CONSTRUCTOR_NAME)));
+          .forAllClasses(clazz -> assertTrue(clazz.getFinalName().startsWith("j$.")));
       return desugaredLib;
     } catch (Exception e) {
       // Don't wrap assumption violation so junit can catch it.
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DisableDesugarTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DisableDesugarTest.java
index 3cf6d11..a3c1e0f 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DisableDesugarTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DisableDesugarTest.java
@@ -47,7 +47,7 @@
       testForD8()
           .addInnerClasses(DisableDesugarTest.class)
           .setMinApi(parameters.getApiLevel())
-          .noDesugaring()
+          .disableDesugaring()
           .enableCoreLibraryDesugaring(AndroidApiLevel.B)
           .compileWithExpectedDiagnostics(this::checkExpectedDiagnostics);
     } catch (CompilationFailedException e) {
@@ -64,7 +64,7 @@
           .addInnerClasses(DisableDesugarTest.class)
           .addKeepMainRule(TestClass.class)
           .setMinApi(parameters.getApiLevel())
-          .noDesugaring()
+          .disableDesugaring()
           .enableCoreLibraryDesugaring(AndroidApiLevel.B)
           .compileWithExpectedDiagnostics(this::checkExpectedDiagnostics);
     } catch (CompilationFailedException e) {
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/FeatureSplitTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/FeatureSplitTest.java
index 9447057..bca207f 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/FeatureSplitTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/FeatureSplitTest.java
@@ -248,9 +248,6 @@
                   SplitterTestBase.simpleSplitProvider(
                       builder, feature2Path, temp, FeatureClass2.class))
           .addKeepAllClassesRule()
-          .applyIf(
-              parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
-              TestShrinkerBuilder::addDontWarnEmulatedLibraryClasses)
           .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
           .compile()
           .writeToZip(basePath);
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 ff7577f..7190c34 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
@@ -265,9 +265,6 @@
         testForR8(parameters.getBackend())
             .addInnerClasses(JavaTimeTest.class)
             .addKeepMainRule(TestClass.class)
-            .applyIf(
-                parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
-                TestShrinkerBuilder::addDontWarnRetargetLibraryMembers)
             .enableNoVerticalClassMergingAnnotations()
             .setMinApi(parameters.getApiLevel())
             .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/MinimalInterfaceSuperTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/MinimalInterfaceSuperTest.java
index 6c443af..ff1039f 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/MinimalInterfaceSuperTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/MinimalInterfaceSuperTest.java
@@ -46,9 +46,6 @@
     testForR8(parameters.getBackend())
         .addInnerClasses(MinimalInterfaceSuperTest.class)
         .addKeepMainRule(Main.class)
-        .applyIf(
-            parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
-            builder -> builder.addDontWarnVivifiedClass(Predicate.class))
         .setMinApi(parameters.getApiLevel())
         .enableCoreLibraryDesugaring(parameters.getApiLevel())
         .compile()
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoForwardingMethodsTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoForwardingMethodsTest.java
index da41454..625395f 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoForwardingMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/NoForwardingMethodsTest.java
@@ -66,9 +66,6 @@
         .setMinApi(parameters.getApiLevel())
         .addKeepClassAndMembersRules(Executor.class)
         .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
-        .applyIf(
-            parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
-            builder -> builder.addDontWarnEmulatedLibraryClass(Collection.class))
         .compile()
         .inspect(this::assertNoForwardingStreamMethod)
         .addDesugaredCoreLibraryRunClassPath(
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ProgramRewritingTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ProgramRewritingTest.java
index 07f4415..082253b 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ProgramRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ProgramRewritingTest.java
@@ -121,9 +121,6 @@
           testForR8(parameters.getBackend())
               .minification(minifying)
               .addKeepMainRule(TEST_CLASS)
-              .applyIf(
-                  parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
-                  TestShrinkerBuilder::addDontWarnEmulatedLibraryClasses)
               .addProgramFiles(Paths.get(ToolHelper.EXAMPLES_JAVA9_BUILD_DIR + "stream.jar"))
               .setMinApi(parameters.getApiLevel())
               .addOptionsModification(
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetOverrideTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetOverrideTest.java
index 3eb81ed..8df7620 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetOverrideTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetOverrideTest.java
@@ -63,13 +63,6 @@
         testForR8(Backend.DEX)
             .addKeepMainRule(Executor.class)
             .addInnerClasses(RetargetOverrideTest.class)
-            .applyIf(
-                parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
-                builder ->
-                    builder
-                        .addDontWarnRetargetLibraryMembers()
-                        .addDontWarnTimeConversions()
-                        .addDontWarnVivifiedClasses())
             .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
             .setMinApi(parameters.getApiLevel())
             .compile()
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/SynchronizedCollectionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/SynchronizedCollectionTest.java
index 9496b9c4..27a8590 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/SynchronizedCollectionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/SynchronizedCollectionTest.java
@@ -81,9 +81,6 @@
     testForR8(parameters.getBackend())
         .addProgramFiles(INPUT_JAR)
         .addKeepMainRule(MAIN_CLASS)
-        .applyIf(
-            parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
-            TestShrinkerBuilder::addDontWarnEmulatedLibraryClasses)
         .setMinApi(parameters.getApiLevel())
         .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
         .compile()
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/CallBackConversionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/CallBackConversionTest.java
index 42997cb..cb8c24f 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/CallBackConversionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/CallBackConversionTest.java
@@ -172,9 +172,6 @@
         .setMinApi(parameters.getApiLevel())
         .addProgramClasses(Impl.class)
         .addLibraryClasses(CustomLibClass.class)
-        .applyIf(
-            parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
-            builder -> builder.addDontWarnVivifiedClass(Consumer.class))
         .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
         .compile()
         .inspect(this::assertLibraryOverridesThere)
@@ -192,7 +189,6 @@
         .setMinApi(parameters.getApiLevel())
         .addProgramClasses(Impl.class)
         .addLibraryClasses(CustomLibClass.class)
-        .addDontWarnVivifiedClass(Consumer.class)
         .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
         .compile()
         .inspect(this::assertLibraryOverridesThere)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/ConversionIntroduceInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/ConversionIntroduceInterfaceMethodTest.java
index 1298096..ccd3cdf 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/ConversionIntroduceInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/ConversionIntroduceInterfaceMethodTest.java
@@ -154,10 +154,6 @@
                 opt.desugaredLibraryConfiguration =
                     configurationWithSupportAllCallbacksFromLibrary(
                         opt, false, parameters, supportAllCallbacksFromLibrary))
-        .applyIf(
-            parameters.getApiLevel().isLessThan(AndroidApiLevel.N)
-                && supportAllCallbacksFromLibrary,
-            builder -> builder.addDontWarnVivifiedClass(Consumer.class))
         .compile()
         .inspect(this::assertDoubleForEach)
         .inspect(this::assertWrapperMethodsPresent)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/DuplicateAPIProgramTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/DuplicateAPIProgramTest.java
index 8fa7780..b62045b 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/DuplicateAPIProgramTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/DuplicateAPIProgramTest.java
@@ -84,9 +84,6 @@
             .addKeepMainRule(Executor.class)
             .addProgramClasses(Executor.class, MyMap.class)
             .addLibraryClasses(CustomLibClass.class)
-            .applyIf(
-                parameters.getApiLevel().isLessThan(AndroidApiLevel.N),
-                builder -> builder.addDontWarnVivifiedClass(BiConsumer.class))
             .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
             .compile()
             .inspect(this::assertDupMethod)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GetGenericInterfaceTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GetGenericInterfaceTest.java
index 0e66723..70dab5d 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GetGenericInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/GetGenericInterfaceTest.java
@@ -74,11 +74,6 @@
         testForR8(Backend.DEX)
             .addInnerClasses(GetGenericInterfaceTest.class)
             .addKeepMainRule(Executor.class)
-            .applyIf(
-                parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
-                builder ->
-                    builder.addDontWarnRetargetLibraryMember(
-                        "virtualDispatch$Date$toInstant$dispatchInterface"))
             .noMinification()
             .setMinApi(parameters.getApiLevel())
             .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/kotlin/KotlinMetadataTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/kotlin/KotlinMetadataTest.java
index aa5393a..55d4763 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/kotlin/KotlinMetadataTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/kotlin/KotlinMetadataTest.java
@@ -5,7 +5,6 @@
 package com.android.tools.r8.desugar.desugaredlibrary.kotlin;
 
 import static com.android.tools.r8.KotlinTestBase.getCompileMemoizer;
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.equalTo;
@@ -16,14 +15,13 @@
 
 import com.android.tools.r8.D8TestRunResult;
 import com.android.tools.r8.DexIndexedConsumer.ArchiveConsumer;
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
 import com.android.tools.r8.KotlinTestBase.KotlinCompileMemoizer;
+import com.android.tools.r8.KotlinTestParameters;
 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.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
 import com.android.tools.r8.kotlin.KotlinMetadataWriter;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
@@ -45,30 +43,27 @@
 public class KotlinMetadataTest extends DesugaredLibraryTestBase {
 
   private static final String PKG = KotlinMetadataTest.class.getPackage().getName();
-  private final TestParameters parameters;
-  private final boolean shrinkDesugaredLibrary;
-  private final KotlinTargetVersion targetVersion;
-  private final KotlinCompiler kotlinCompiler;
   private static final String EXPECTED_OUTPUT = "Wuhuu, my special day is: 1997-8-29-2-14";
 
-  @Parameters(name = "{1}, shrinkDesugaredLibrary: {0}, target: {2}, kotlinc: {3}")
+  private final TestParameters parameters;
+  private final KotlinTestParameters kotlinParameters;
+  private final boolean shrinkDesugaredLibrary;
+
+  @Parameters(name = "{0}, {1}, shrinkDesugaredLibrary: {2}")
   public static List<Object[]> data() {
     return buildParameters(
-        BooleanUtils.values(),
         getTestParameters().withAllRuntimesAndApiLevels().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values());
   }
 
   public KotlinMetadataTest(
-      boolean shrinkDesugaredLibrary,
       TestParameters parameters,
-      KotlinTargetVersion targetVersion,
-      KotlinCompiler kotlinCompiler) {
-    this.shrinkDesugaredLibrary = shrinkDesugaredLibrary;
+      KotlinTestParameters kotlinParameters,
+      boolean shrinkDesugaredLibrary) {
     this.parameters = parameters;
-    this.targetVersion = targetVersion;
-    this.kotlinCompiler = kotlinCompiler;
+    this.kotlinParameters = kotlinParameters;
+    this.shrinkDesugaredLibrary = shrinkDesugaredLibrary;
   }
 
   private static KotlinCompileMemoizer compiledJars =
@@ -83,9 +78,9 @@
   public void testCf() throws Exception {
     assumeTrue(parameters.getRuntime().isCf());
     testForRuntime(parameters)
-        .addProgramFiles(compiledJars.getForConfiguration(kotlinCompiler, targetVersion))
-        .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinCompiler))
-        .addProgramFiles(ToolHelper.getKotlinReflectJar(kotlinCompiler))
+        .addProgramFiles(compiledJars.getForConfiguration(kotlinParameters))
+        .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinParameters.getCompiler()))
+        .addProgramFiles(ToolHelper.getKotlinReflectJar(kotlinParameters.getCompiler()))
         .run(parameters.getRuntime(), PKG + ".MainKt")
         .assertSuccessWithOutputLines(EXPECTED_OUTPUT);
   }
@@ -97,9 +92,9 @@
     final File output = temp.newFile("output.zip");
     final D8TestRunResult d8TestRunResult =
         testForD8()
-            .addProgramFiles(compiledJars.getForConfiguration(kotlinCompiler, targetVersion))
-            .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinCompiler))
-            .addProgramFiles(ToolHelper.getKotlinReflectJar(kotlinCompiler))
+            .addProgramFiles(compiledJars.getForConfiguration(kotlinParameters))
+            .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinParameters.getCompiler()))
+            .addProgramFiles(ToolHelper.getKotlinReflectJar(kotlinParameters.getCompiler()))
             .setProgramConsumer(new ArchiveConsumer(output.toPath(), true))
             .setMinApi(parameters.getApiLevel())
             .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
@@ -126,9 +121,9 @@
     boolean desugarLibrary = parameters.isDexRuntime() && requiresAnyCoreLibDesugaring(parameters);
     final R8FullTestBuilder testBuilder =
         testForR8(parameters.getBackend())
-            .addProgramFiles(compiledJars.getForConfiguration(kotlinCompiler, targetVersion))
-            .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinCompiler))
-            .addProgramFiles(ToolHelper.getKotlinReflectJar(kotlinCompiler))
+            .addProgramFiles(compiledJars.getForConfiguration(kotlinParameters))
+            .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinParameters.getCompiler()))
+            .addProgramFiles(ToolHelper.getKotlinReflectJar(kotlinParameters.getCompiler()))
             .addKeepMainRule(PKG + ".MainKt")
             .addKeepAllClassesRule()
             .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/mergedcontext/MergedContextTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/mergedcontext/MergedContextTest.java
index 35e31d5..86d541e 100644
--- a/src/test/java/com/android/tools/r8/desugar/lambdas/mergedcontext/MergedContextTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/mergedcontext/MergedContextTest.java
@@ -42,7 +42,7 @@
         .setMinApi(parameters.getApiLevel())
         .addHorizontallyMergedClassesInspector(
             inspector -> {
-              inspector.assertClassNotMerged(C.class);
+              inspector.assertClassesNotMerged(C.class);
               inspector.assertMergedInto(B.class, A.class);
             })
         .run(parameters.getRuntime(), TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java
index bf9a226..f47e524 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java
@@ -53,8 +53,7 @@
         // TODO(b/177967938): Investigate why this is needed.
         .applyIf(
             parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
-            builder -> builder.addDontWarnJavaLangInvoke().addDontWarnJavaNioFile(),
-            builder -> builder.addDontWarnJavaLangInvoke("StringConcatFactory"))
+            builder -> builder.addDontWarnJavaLangInvoke().addDontWarnJavaNioFile())
         .addOptionsModification(opt -> opt.ignoreMissingClasses = true)
         .compile()
         .inspect(this::assertNotEmpty)
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/MinimumNumberOfBridgesGenerated.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/MinimumNumberOfBridgesGenerated.java
index c55df8c..6557f52 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/MinimumNumberOfBridgesGenerated.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/MinimumNumberOfBridgesGenerated.java
@@ -13,7 +13,10 @@
 import com.android.tools.r8.TestRuntime.CfVm;
 import com.android.tools.r8.ToolHelper.DexVm;
 import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.desugar.nest.NestBasedAccessDesugaring;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
@@ -79,9 +82,14 @@
   private boolean isNestBridge(FoundMethodSubject methodSubject) {
     DexEncodedMethod method = methodSubject.getMethod();
     if (method.isInstanceInitializer()) {
-      return method.method.proto.parameters.size() > 0 && method.method.proto.parameters.values[
-          method.method.proto.parameters.size() - 1].toSourceString()
-          .contains(NestBasedAccessDesugaring.NEST_CONSTRUCTOR_NAME);
+      if (method.method.proto.parameters.isEmpty()) {
+        return false;
+      }
+      DexType[] formals = method.method.proto.parameters.values;
+      DexType lastFormal = formals[formals.length - 1];
+      return lastFormal.isClassType()
+          && SyntheticItemsTestUtils.isInitializerTypeArgument(
+              Reference.classFromDescriptor(lastFormal.toDescriptorString()));
     }
     return method.method.name.toString()
         .startsWith(NestBasedAccessDesugaring.NEST_ACCESS_NAME_PREFIX);
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java
index 66e2ec7..a9e05a3 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java
@@ -63,9 +63,7 @@
     testMissingNestHostError(true);
     testIncompleteNestError(true);
   }
-  // TODO R8:
-  // appView.options().reportMissingNestHost(clazz);
-  // clazz.clearNestHost();
+
   @Test
   public void testWarningR8() throws Exception {
     testIncompleteNestWarning(false, parameters.isDexRuntime());
@@ -98,7 +96,6 @@
           .setMinApi(parameters.getApiLevel())
           .addProgramFiles(matchingClasses)
           .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
-          .addDontWarn("java.lang.invoke.StringConcatFactory")
           .addOptionsModification(
               options -> {
                 options.ignoreMissingClasses = ignoreMissingClasses;
diff --git a/src/test/java/com/android/tools/r8/desugar/records/EmptyRecordTest.java b/src/test/java/com/android/tools/r8/desugar/records/EmptyRecordTest.java
new file mode 100644
index 0000000..92183a7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/records/EmptyRecordTest.java
@@ -0,0 +1,45 @@
+// Copyright (c) 2021, 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.records;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.utils.StringUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class EmptyRecordTest extends TestBase {
+
+  private static final String RECORD_NAME = "EmptyRecord";
+  private static final byte[][] PROGRAM_DATA = RecordTestUtils.getProgramData(RECORD_NAME);
+  private static final String MAIN_TYPE = RecordTestUtils.getMainType(RECORD_NAME);
+  private static final String EXPECTED_RESULT = StringUtils.lines("Empty[]");
+
+  private final TestParameters parameters;
+
+  public EmptyRecordTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Parameterized.Parameters(name = "{0}")
+  public static List<Object[]> data() {
+    // TODO(b/174431251): This should be replaced with .withCfRuntimes(start = jdk15).
+    return buildParameters(
+        getTestParameters().withCustomRuntime(CfRuntime.getCheckedInJdk15()).build());
+  }
+
+  @Test
+  public void testJvm() throws Exception {
+    testForJvm()
+        .addProgramClassFileData(PROGRAM_DATA)
+        .addVmArguments("--enable-preview")
+        .run(parameters.getRuntime(), MAIN_TYPE)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/records/InvalidRecordAttributeTest.java b/src/test/java/com/android/tools/r8/desugar/records/InvalidRecordAttributeTest.java
new file mode 100644
index 0000000..e936a33
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/records/InvalidRecordAttributeTest.java
@@ -0,0 +1,111 @@
+// Copyright (c) 2021, 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.records;
+
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assert.assertThrows;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import java.util.List;
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+/** Remove this test when Records are supported by default. */
+@RunWith(Parameterized.class)
+public class InvalidRecordAttributeTest extends TestBase {
+
+  private final TestParameters parameters;
+  private final Backend backend;
+
+  private static final String EMPTY_RECORD = "EmptyRecord";
+  private static final byte[][] EMPTY_RECORD_PROGRAM_DATA =
+      RecordTestUtils.getProgramData(EMPTY_RECORD);
+  private static final String SIMPLE_RECORD = "SimpleRecord";
+  private static final byte[][] SIMPLE_RECORD_PROGRAM_DATA =
+      RecordTestUtils.getProgramData(SIMPLE_RECORD);
+
+  @Parameters(name = "{0} back: {1}")
+  public static List<Object[]> data() {
+    // TODO(b/174431251): This should be replaced with .withCfRuntimes(start = jdk15).
+    return buildParameters(
+        getTestParameters().withCustomRuntime(CfRuntime.getCheckedInJdk15()).build(),
+        Backend.values());
+  }
+
+  public InvalidRecordAttributeTest(TestParameters parameters, Backend backend) {
+    this.parameters = parameters;
+    this.backend = backend;
+  }
+
+  @Test
+  public void testD8EmptyRecord() throws Exception {
+    Assume.assumeTrue(backend.isDex());
+    assertThrows(
+        CompilationFailedException.class,
+        () -> {
+          testForD8(backend)
+              .addProgramClassFileData(EMPTY_RECORD_PROGRAM_DATA)
+              .setMinApi(AndroidApiLevel.B)
+              .compileWithExpectedDiagnostics(
+                  InvalidRecordAttributeTest::assertUnsupportedRecordError);
+        });
+  }
+
+  @Test
+  public void testD8SimpleRecord() throws Exception {
+    Assume.assumeTrue(backend.isDex());
+    assertThrows(
+        CompilationFailedException.class,
+        () -> {
+          testForD8(backend)
+              .addProgramClassFileData(RecordTestUtils.getProgramData(SIMPLE_RECORD))
+              .setMinApi(AndroidApiLevel.B)
+              .compileWithExpectedDiagnostics(
+                  InvalidRecordAttributeTest::assertUnsupportedRecordError);
+        });
+  }
+
+  @Test
+  public void testR8EmptyRecord() throws Exception {
+    assertThrows(
+        CompilationFailedException.class,
+        () -> {
+          testForR8(backend)
+              .addProgramClassFileData(EMPTY_RECORD_PROGRAM_DATA)
+              .setMinApi(AndroidApiLevel.B)
+              .addKeepMainRule(RecordTestUtils.getMainType(EMPTY_RECORD))
+              .compileWithExpectedDiagnostics(
+                  InvalidRecordAttributeTest::assertUnsupportedRecordError);
+        });
+  }
+
+  @Test
+  public void testR8SimpleRecord() throws Exception {
+    assertThrows(
+        CompilationFailedException.class,
+        () -> {
+          testForR8(backend)
+              .addProgramClassFileData(SIMPLE_RECORD_PROGRAM_DATA)
+              .setMinApi(AndroidApiLevel.B)
+              .addKeepMainRule(RecordTestUtils.getMainType(SIMPLE_RECORD))
+              .compileWithExpectedDiagnostics(
+                  InvalidRecordAttributeTest::assertUnsupportedRecordError);
+        });
+  }
+
+  private static void assertUnsupportedRecordError(TestDiagnosticMessages diagnostics) {
+    diagnostics.assertErrorThatMatches(
+        diagnosticMessage(containsString("Records are not supported")));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordInstanceOfTest.java b/src/test/java/com/android/tools/r8/desugar/records/RecordInstanceOfTest.java
new file mode 100644
index 0000000..33a3b57
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordInstanceOfTest.java
@@ -0,0 +1,45 @@
+// Copyright (c) 2021, 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.records;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.utils.StringUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class RecordInstanceOfTest extends TestBase {
+
+  private static final String RECORD_NAME = "RecordInstanceOf";
+  private static final byte[][] PROGRAM_DATA = RecordTestUtils.getProgramData(RECORD_NAME);
+  private static final String MAIN_TYPE = RecordTestUtils.getMainType(RECORD_NAME);
+  private static final String EXPECTED_RESULT = StringUtils.lines("true", "true", "false");
+
+  private final TestParameters parameters;
+
+  public RecordInstanceOfTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Parameterized.Parameters(name = "{0}")
+  public static List<Object[]> data() {
+    // TODO(b/174431251): This should be replaced with .withCfRuntimes(start = jdk15).
+    return buildParameters(
+        getTestParameters().withCustomRuntime(CfRuntime.getCheckedInJdk15()).build());
+  }
+
+  @Test
+  public void testJvm() throws Exception {
+    testForJvm()
+        .addProgramClassFileData(PROGRAM_DATA)
+        .addVmArguments("--enable-preview")
+        .run(parameters.getRuntime(), MAIN_TYPE)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordInvokeCustomTest.java b/src/test/java/com/android/tools/r8/desugar/records/RecordInvokeCustomTest.java
new file mode 100644
index 0000000..1d1e785
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordInvokeCustomTest.java
@@ -0,0 +1,58 @@
+// Copyright (c) 2021, 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.records;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.utils.StringUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class RecordInvokeCustomTest extends TestBase {
+
+  private static final String RECORD_NAME = "RecordInvokeCustom";
+  private static final byte[][] PROGRAM_DATA = RecordTestUtils.getProgramData(RECORD_NAME);
+  private static final String MAIN_TYPE = RecordTestUtils.getMainType(RECORD_NAME);
+  private static final String EXPECTED_RESULT =
+      StringUtils.lines(
+          "Empty[]",
+          "true",
+          "true",
+          "true",
+          "true",
+          "true",
+          "false",
+          "true",
+          "true",
+          "false",
+          "false",
+          "Person[name=Jane Doe, age=42]");
+
+  private final TestParameters parameters;
+
+  public RecordInvokeCustomTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Parameterized.Parameters(name = "{0}")
+  public static List<Object[]> data() {
+    // TODO(b/174431251): This should be replaced with .withCfRuntimes(start = jdk15).
+    return buildParameters(
+        getTestParameters().withCustomRuntime(CfRuntime.getCheckedInJdk15()).build());
+  }
+
+  @Test
+  public void testJvm() throws Exception {
+    testForJvm()
+        .addProgramClassFileData(PROGRAM_DATA)
+        .addVmArguments("--enable-preview")
+        .run(parameters.getRuntime(), MAIN_TYPE)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordReflectionTest.java b/src/test/java/com/android/tools/r8/desugar/records/RecordReflectionTest.java
new file mode 100644
index 0000000..1bb0a1a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordReflectionTest.java
@@ -0,0 +1,55 @@
+// Copyright (c) 2021, 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.records;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.utils.StringUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class RecordReflectionTest extends TestBase {
+
+  private static final String RECORD_NAME = "RecordReflection";
+  private static final byte[][] PROGRAM_DATA = RecordTestUtils.getProgramData(RECORD_NAME);
+  private static final String MAIN_TYPE = RecordTestUtils.getMainType(RECORD_NAME);
+  private static final String EXPECTED_RESULT =
+      StringUtils.lines(
+          "true",
+          "[]",
+          "true",
+          "[java.lang.String name, int age]",
+          "true",
+          "[java.lang.CharSequence name, int age]",
+          "[S]",
+          "false",
+          "null");
+
+  private final TestParameters parameters;
+
+  public RecordReflectionTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Parameterized.Parameters(name = "{0}")
+  public static List<Object[]> data() {
+    // TODO(b/174431251): This should be replaced with .withCfRuntimes(start = jdk15).
+    return buildParameters(
+        getTestParameters().withCustomRuntime(CfRuntime.getCheckedInJdk15()).build());
+  }
+
+  @Test
+  public void testJvm() throws Exception {
+    testForJvm()
+        .addProgramClassFileData(PROGRAM_DATA)
+        .addVmArguments("--enable-preview")
+        .run(parameters.getRuntime(), MAIN_TYPE)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordTestUtils.java b/src/test/java/com/android/tools/r8/desugar/records/RecordTestUtils.java
new file mode 100644
index 0000000..d4a804b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordTestUtils.java
@@ -0,0 +1,71 @@
+// Copyright (c) 2021, 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.records;
+
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.utils.StringUtils;
+import com.google.common.io.ByteStreams;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+/**
+ * Records are compiled using: third_party/openjdk/jdk-15/linux/bin/javac --release 15
+ * --enable-preview path/to/file.java
+ */
+public class RecordTestUtils {
+
+  private static final String EXAMPLE_FOLDER = "examplesJava15";
+  private static final String RECORD_FOLDER = "records";
+
+  public static Path jar() {
+    return Paths.get(ToolHelper.TESTS_BUILD_DIR, EXAMPLE_FOLDER, RECORD_FOLDER + ".jar");
+  }
+
+  public static byte[][] getProgramData(String mainClassSimpleName) {
+    byte[][] bytes = classDataFromPrefix(RECORD_FOLDER + "/" + mainClassSimpleName);
+    assert bytes.length > 0 : "Did not find any program data for " + mainClassSimpleName;
+    return bytes;
+  }
+
+  public static String getMainType(String mainClassSimpleName) {
+    return RECORD_FOLDER + "." + mainClassSimpleName;
+  }
+
+  private static byte[][] classDataFromPrefix(String prefix) {
+    Path examplePath = jar();
+    if (!Files.exists(examplePath)) {
+      throw new RuntimeException(
+          "Could not find path "
+              + examplePath
+              + ". Build "
+              + EXAMPLE_FOLDER
+              + " by running tools/gradle.py build"
+              + StringUtils.capitalize(EXAMPLE_FOLDER));
+    }
+    List<byte[]> result = new ArrayList<>();
+    try (ZipFile zipFile = new ZipFile(examplePath.toFile())) {
+      Enumeration<? extends ZipEntry> entries = zipFile.entries();
+      while (entries.hasMoreElements()) {
+        ZipEntry zipEntry = entries.nextElement();
+        if (zipEntry.getName().startsWith(prefix)) {
+          result.add(ByteStreams.toByteArray(zipFile.getInputStream(zipEntry)));
+        }
+      }
+    } catch (IOException e) {
+      throw new RuntimeException("Could not read zip-entry from " + examplePath.toString(), e);
+    }
+    if (result.isEmpty()) {
+      throw new RuntimeException("Did not find any class with prefix " + prefix);
+    }
+    return result.toArray(new byte[0][0]);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordWithMembersTest.java b/src/test/java/com/android/tools/r8/desugar/records/RecordWithMembersTest.java
new file mode 100644
index 0000000..c0ca829
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordWithMembersTest.java
@@ -0,0 +1,47 @@
+// Copyright (c) 2021, 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.records;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.utils.StringUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class RecordWithMembersTest extends TestBase {
+
+  private static final String RECORD_NAME = "RecordWithMembers";
+  private static final byte[][] PROGRAM_DATA = RecordTestUtils.getProgramData(RECORD_NAME);
+  private static final String MAIN_TYPE = RecordTestUtils.getMainType(RECORD_NAME);
+  private static final String EXPECTED_RESULT =
+      StringUtils.lines(
+          "BobX", "43", "BobX", "43", "FelixX", "-1", "FelixX", "-1", "print", "Bob43", "extra");
+
+  private final TestParameters parameters;
+
+  public RecordWithMembersTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Parameterized.Parameters(name = "{0}")
+  public static List<Object[]> data() {
+    // TODO(b/174431251): This should be replaced with .withCfRuntimes(start = jdk15).
+    return buildParameters(
+        getTestParameters().withCustomRuntime(CfRuntime.getCheckedInJdk15()).build());
+  }
+
+  @Test
+  public void testJvm() throws Exception {
+    testForJvm()
+        .addProgramClassFileData(PROGRAM_DATA)
+        .addVmArguments("--enable-preview")
+        .run(parameters.getRuntime(), MAIN_TYPE)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordsAttributeTest.java b/src/test/java/com/android/tools/r8/desugar/records/RecordsAttributeTest.java
deleted file mode 100644
index 831c426..0000000
--- a/src/test/java/com/android/tools/r8/desugar/records/RecordsAttributeTest.java
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.desugar.records;
-
-import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.junit.Assert.assertThrows;
-import static org.junit.Assume.assumeFalse;
-import static org.junit.Assume.assumeTrue;
-
-import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestRuntime.CfRuntime;
-import com.android.tools.r8.examples.jdk15.Records;
-import com.android.tools.r8.utils.AndroidApiLevel;
-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 RecordsAttributeTest extends TestBase {
-
-  private final Backend backend;
-  private final TestParameters parameters;
-
-  @Parameters(name = "{0}")
-  public static List<Object[]> data() {
-    // TODO(b/174431251): This should be replaced with .withCfRuntimes(start = jdk15).
-    return buildParameters(
-        getTestParameters().withCustomRuntime(CfRuntime.getCheckedInJdk15()).build(),
-        Backend.values());
-  }
-
-  public RecordsAttributeTest(TestParameters parameters, Backend backend) {
-    this.parameters = parameters;
-    this.backend = backend;
-  }
-
-  @Test
-  public void testJvm() throws Exception {
-    assumeFalse(parameters.isNoneRuntime());
-    assumeTrue(backend == Backend.CF);
-    testForJvm()
-        .addRunClasspathFiles(Records.jar())
-        .addVmArguments("--enable-preview")
-        .run(parameters.getRuntime(), Records.Main.typeName())
-        .assertSuccessWithOutputLines("Jane Doe", "42");
-  }
-
-  @Test
-  public void testD8() throws Exception {
-    assertThrows(
-        CompilationFailedException.class,
-        () -> {
-          testForD8(backend)
-              .addProgramClassFileData(Records.Main.bytes(), Records.Main$Person.bytes())
-              .setMinApi(AndroidApiLevel.B)
-              .compileWithExpectedDiagnostics(
-                  diagnostics -> {
-                    diagnostics.assertErrorThatMatches(
-                        diagnosticMessage(containsString("Records are not supported")));
-                  });
-        });
-  }
-
-  @Test
-  public void testR8() throws Exception {
-    assertThrows(
-        CompilationFailedException.class,
-        () -> {
-          testForR8(backend)
-              .addProgramClassFileData(Records.Main.bytes(), Records.Main$Person.bytes())
-              .setMinApi(AndroidApiLevel.B)
-              .addKeepMainRule(Records.Main.typeName())
-              .compileWithExpectedDiagnostics(
-                  diagnostics -> {
-                    diagnostics.assertErrorThatMatches(
-                        diagnosticMessage(containsString("Records are not supported")));
-                  });
-        });
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/desugar/records/SimpleRecordTest.java b/src/test/java/com/android/tools/r8/desugar/records/SimpleRecordTest.java
new file mode 100644
index 0000000..35ce924
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/records/SimpleRecordTest.java
@@ -0,0 +1,46 @@
+// Copyright (c) 2021, 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.records;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.utils.StringUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class SimpleRecordTest extends TestBase {
+
+  private static final String RECORD_NAME = "SimpleRecord";
+  private static final byte[][] PROGRAM_DATA = RecordTestUtils.getProgramData(RECORD_NAME);
+  private static final String MAIN_TYPE = RecordTestUtils.getMainType(RECORD_NAME);
+  private static final String EXPECTED_RESULT =
+      StringUtils.lines("Jane Doe", "42", "Jane Doe", "42");
+
+  private final TestParameters parameters;
+
+  public SimpleRecordTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Parameterized.Parameters(name = "{0}")
+  public static List<Object[]> data() {
+    // TODO(b/174431251): This should be replaced with .withCfRuntimes(start = jdk15).
+    return buildParameters(
+        getTestParameters().withCustomRuntime(CfRuntime.getCheckedInJdk15()).build());
+  }
+
+  @Test
+  public void testJvm() throws Exception {
+    testForJvm()
+        .addProgramClassFileData(PROGRAM_DATA)
+        .addVmArguments("--enable-preview")
+        .run(parameters.getRuntime(), MAIN_TYPE)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/kotlin/SimpleKotlinEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/kotlin/SimpleKotlinEnumUnboxingTest.java
index 3c48865..6f4b565 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/kotlin/SimpleKotlinEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/kotlin/SimpleKotlinEnumUnboxingTest.java
@@ -6,15 +6,13 @@
 
 import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
 import static com.android.tools.r8.KotlinTestBase.getCompileMemoizer;
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static org.hamcrest.core.StringContains.containsString;
 import static org.junit.Assume.assumeTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
 import com.android.tools.r8.KotlinTestBase.KotlinCompileMemoizer;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.enumunboxing.EnumUnboxingTestBase;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -29,10 +27,9 @@
 public class SimpleKotlinEnumUnboxingTest extends EnumUnboxingTestBase {
 
   private final TestParameters parameters;
+  private final KotlinTestParameters kotlinParameters;
   private final boolean enumValueOptimization;
   private final EnumKeepRules enumKeepRules;
-  private final KotlinTargetVersion targetVersion;
-  private final KotlinCompiler kotlinCompiler;
 
   private static final String PKG = SimpleKotlinEnumUnboxingTest.class.getPackage().getName();
   private static final KotlinCompileMemoizer jars =
@@ -43,27 +40,24 @@
               DescriptorUtils.getBinaryNameFromJavaType(PKG),
               "Main.kt"));
 
-  @Parameters(name = "{0}, valueOpt: {1}, keep: {2}, kotlin targetVersion: {3}, kotlinc: {4}")
+  @Parameters(name = "{0}, {1}, valueOpt: {2}, keep: {3}")
   public static List<Object[]> enumUnboxingTestParameters() {
     return buildParameters(
         getTestParameters().withAllRuntimesAndApiLevels().build(),
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
         BooleanUtils.values(),
-        getAllEnumKeepRules(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getAllEnumKeepRules());
   }
 
   public SimpleKotlinEnumUnboxingTest(
       TestParameters parameters,
+      KotlinTestParameters kotlinParameters,
       boolean enumValueOptimization,
-      EnumKeepRules enumKeepRules,
-      KotlinTargetVersion targetVersion,
-      KotlinCompiler kotlinCompiler) {
+      EnumKeepRules enumKeepRules) {
     this.parameters = parameters;
+    this.kotlinParameters = kotlinParameters;
     this.enumValueOptimization = enumValueOptimization;
     this.enumKeepRules = enumKeepRules;
-    this.targetVersion = targetVersion;
-    this.kotlinCompiler = kotlinCompiler;
   }
 
   @Test
@@ -71,8 +65,8 @@
     assumeTrue(parameters.isDexRuntime());
     testForR8(parameters.getBackend())
         .addProgramFiles(
-            jars.getForConfiguration(kotlinCompiler, targetVersion),
-            ToolHelper.getKotlinStdlibJar(kotlinCompiler))
+            jars.getForConfiguration(kotlinParameters),
+            ToolHelper.getKotlinStdlibJar(kotlinParameters.getCompiler()))
         .addKeepMainRule(PKG + ".MainKt")
         .addKeepRules(enumKeepRules.getKeepRules())
         .addKeepRuntimeVisibleAnnotations()
diff --git a/src/test/java/com/android/tools/r8/graph/invokespecial/MultipleInvokeSpecialOnSameClassTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/MultipleInvokeSpecialOnSameClassTest.java
new file mode 100644
index 0000000..7c934d8
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/MultipleInvokeSpecialOnSameClassTest.java
@@ -0,0 +1,102 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.graph.invokespecial;
+
+import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.StringUtils;
+import java.io.IOException;
+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 MultipleInvokeSpecialOnSameClassTest extends TestBase {
+
+  private static final String EXPECTED_RESULT =
+      StringUtils.lines("print", "print2", "print", "print2", "print", "print2");
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public MultipleInvokeSpecialOnSameClassTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testRuntime() throws Exception {
+    testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
+        .addProgramClasses(Main.class)
+        .addProgramClassFileData(getClassWithTransformedInvoked())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(Main.class)
+        .addProgramClassFileData(getClassWithTransformedInvoked())
+        .addKeepMainRule(Main.class)
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutput(EXPECTED_RESULT);
+  }
+
+  private byte[] getClassWithTransformedInvoked() throws IOException {
+    return transformer(A.class)
+        .transformMethodInsnInMethod(
+            "bar",
+            (opcode, owner, name, descriptor, isInterface, continuation) -> {
+              continuation.visitMethodInsn(INVOKESPECIAL, owner, name, descriptor, isInterface);
+            })
+        .transformMethodInsnInMethod(
+            "baz",
+            (opcode, owner, name, descriptor, isInterface, continuation) -> {
+              continuation.visitMethodInsn(INVOKESPECIAL, owner, name, descriptor, isInterface);
+            })
+        .transform();
+  }
+
+  public static class A {
+
+    public void print() {
+      System.out.println("print");
+    }
+
+    public void print2() {
+      System.out.println("print2");
+    }
+
+    public void bar() {
+      print(); // Will be rewritten to invoke-special A.print()
+      print2(); // Will be rewritten to invoke-special A.print2()
+      print(); // Will be rewritten to invoke-special A.print()
+      print2(); // Will be rewritten to invoke-special A.print2()
+    }
+
+    public void baz() {
+      print(); // Will be rewritten to invoke-special A.print()
+      print2(); // Will be rewritten to invoke-special A.print2()
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      A a = new A();
+      a.bar();
+      a.baz();
+    }
+  }
+}
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 1d7686c..55fcc74 100644
--- a/src/test/java/com/android/tools/r8/ir/IrInjectionTestBase.java
+++ b/src/test/java/com/android/tools/r8/ir/IrInjectionTestBase.java
@@ -14,7 +14,6 @@
 import com.android.tools.r8.ir.code.InstructionListIterator;
 import com.android.tools.r8.ir.code.NumberGenerator;
 import com.android.tools.r8.ir.conversion.IRConverter;
-import com.android.tools.r8.shaking.MainDexTracingResult;
 import com.android.tools.r8.smali.SmaliBuilder;
 import com.android.tools.r8.smali.SmaliBuilder.MethodSignature;
 import com.android.tools.r8.smali.SmaliTestBase;
@@ -113,7 +112,7 @@
 
     public String run() throws IOException {
       Timing timing = Timing.empty();
-      IRConverter converter = new IRConverter(appView, timing, null, MainDexTracingResult.NONE);
+      IRConverter converter = new IRConverter(appView, timing, null);
       converter.replaceCodeForTesting(method, code);
       AndroidApp app = writeDex();
       return runOnArtRaw(app, DEFAULT_MAIN_CLASS_NAME).stdout;
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java b/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java
index 553a2f4..ac86504 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldBitAccessInfoTest.java
@@ -25,7 +25,7 @@
 import com.android.tools.r8.graph.DirectMappedDexApplication;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.conversion.MethodProcessor;
+import com.android.tools.r8.ir.conversion.MethodProcessorWithWave;
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackIgnore;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.AndroidApp;
@@ -209,7 +209,7 @@
     }
   }
 
-  static class PrimaryMethodProcessorMock extends MethodProcessor {
+  static class PrimaryMethodProcessorMock extends MethodProcessorWithWave {
 
     @Override
     public boolean shouldApplyCodeRewritings(ProgramMethod method) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerCheckCastWithUnknownReturnTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerCheckCastWithUnknownReturnTest.java
new file mode 100644
index 0000000..50a2f54
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerCheckCastWithUnknownReturnTest.java
@@ -0,0 +1,73 @@
+// Copyright (c) 2021, 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.classinliner;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverSingleCallerInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+// This is a reproduction of b/176381203.
+@RunWith(Parameterized.class)
+public class ClassInlinerCheckCastWithUnknownReturnTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public ClassInlinerCheckCastWithUnknownReturnTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test()
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .enableNeverSingleCallerInlineAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatThrows(ClassCastException.class)
+        .inspectFailure(
+            inspector -> {
+              ClassSubject aSubject = inspector.clazz(A.class);
+              assertThat(aSubject, isPresent());
+            });
+  }
+
+  public static class A {
+
+    public int number;
+
+    @NeverSingleCallerInline
+    public Object abs() {
+      if (number == 0) {
+        return new Object();
+      }
+      return this;
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      A a = new A();
+      a.number = args.length;
+      A returnedA = (A) (a.abs());
+      System.out.println("Hello World");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerDirectWithUnknownReturnTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerDirectWithUnknownReturnTest.java
index 99a169d..0da8e12 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerDirectWithUnknownReturnTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerDirectWithUnknownReturnTest.java
@@ -4,19 +4,20 @@
 
 package com.android.tools.r8.ir.optimize.classinliner;
 
-import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
-import static org.hamcrest.CoreMatchers.containsString;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
 
-import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.NeverSingleCallerInline;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 
+// This is a reproduction of b/176381203.
 @RunWith(Parameterized.class)
 public class ClassInlinerDirectWithUnknownReturnTest extends TestBase {
 
@@ -31,19 +32,19 @@
     this.parameters = parameters;
   }
 
-  @Test(expected = CompilationFailedException.class)
+  @Test()
   public void testR8() throws Exception {
     testForR8(parameters.getBackend())
         .addInnerClasses(getClass())
         .addKeepMainRule(Main.class)
         .enableNeverSingleCallerInlineAnnotations()
         .setMinApi(parameters.getApiLevel())
-        .compileWithExpectedDiagnostics(
-            diagnostics -> {
-              diagnostics.assertErrorsMatch(
-                  diagnosticMessage(
-                      containsString(
-                          "Unexpected non-trivial phi in method eligible for class inlining")));
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("Hello World 0")
+        .inspect(
+            inspector -> {
+              ClassSubject aSubject = inspector.clazz(A.class);
+              assertThat(aSubject, isPresent());
             });
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
index 0abfe16..0fb02d7 100644
--- a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
+++ b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
@@ -14,19 +14,17 @@
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
 import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.ThrowableConsumer;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.graph.Code;
 import com.android.tools.r8.graph.DexCode;
 import com.android.tools.r8.jasmin.JasminBuilder;
 import com.android.tools.r8.jasmin.JasminBuilder.ClassBuilder;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
-import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -52,16 +50,13 @@
   private final List<Path> extraClasspath = new ArrayList<>();
 
   // Some tests defined in subclasses, e.g., Metadata tests, don't care about access relaxation.
-  protected AbstractR8KotlinTestBase(
-      KotlinTargetVersion kotlinTargetVersion, KotlinCompiler kotlinc) {
-    this(kotlinTargetVersion, kotlinc, false);
+  protected AbstractR8KotlinTestBase(KotlinTestParameters kotlinParameters) {
+    this(kotlinParameters, false);
   }
 
   protected AbstractR8KotlinTestBase(
-      KotlinTargetVersion kotlinTargetVersion,
-      KotlinCompiler kotlinc,
-      boolean allowAccessModification) {
-    super(kotlinTargetVersion, kotlinc);
+      KotlinTestParameters kotlinParameters, boolean allowAccessModification) {
+    super(kotlinParameters);
     this.allowAccessModification = allowAccessModification;
   }
 
@@ -142,15 +137,6 @@
     return fieldSubject;
   }
 
-  protected void checkFieldIsRemoved(
-      ClassSubject classSubject, String fieldType, String fieldName) {
-    // Field must exist in the input.
-    checkFieldPresenceInInput(classSubject.getOriginalName(), fieldType, fieldName, true);
-    FieldSubject fieldSubject = classSubject.field(fieldType, fieldName);
-    assertNotNull(fieldSubject);
-    assertThat(fieldSubject, not(isPresent()));
-  }
-
   protected void checkFieldIsAbsent(ClassSubject classSubject, String fieldType, String fieldName) {
     // Field must NOT exist in the input.
     checkFieldPresenceInInput(classSubject.getOriginalName(), fieldType, fieldName, false);
@@ -159,12 +145,6 @@
     assertFalse(fieldSubject.isPresent());
   }
 
-  protected FieldSubject checkFieldIsAbsent(ClassSubject classSubject, String fieldName) {
-    FieldSubject fieldSubject = classSubject.uniqueFieldWithName(fieldName);
-    assertThat(fieldSubject, not(isPresent()));
-    return fieldSubject;
-  }
-
   protected void checkMethodIsAbsent(ClassSubject classSubject, MethodSignature methodSignature) {
     checkMethodPresenceInInput(classSubject.getOriginalName(), methodSignature, false);
     checkMethodPresenceInOutput(classSubject, methodSignature, false);
@@ -187,11 +167,6 @@
     checkMethodIsKeptOrRemoved(classSubject, methodSignature, false);
   }
 
-  protected void checkMethodIsRemoved(ClassSubject classSubject, String methodName) {
-    MethodSubject methodSubject = classSubject.uniqueMethodWithName(methodName);
-    assertThat(methodSubject, not(isPresent()));
-  }
-
   protected MethodSubject checkMethodIsKeptOrRemoved(
       ClassSubject classSubject, MethodSignature methodSignature, boolean isPresent) {
     checkMethodPresenceInInput(classSubject.getOriginalName(), methodSignature, true);
@@ -266,14 +241,13 @@
         .addProgramFiles(classpath)
         .addKeepMainRule(mainClass)
         .allowAccessModification(allowAccessModification)
-        .allowDiagnosticMessages()
+        .allowDiagnosticWarningMessages()
         .enableProguardTestOptions()
         .noMinification()
         .apply(configuration)
         .compile()
         .assertAllWarningMessagesMatch(
             containsString("Resource 'META-INF/MANIFEST.MF' already exists."))
-        .assertAllInfoMessagesMatch(containsString("Unrecognized Kotlin lambda "))
         .run(mainClass)
         .assertSuccessWithOutput(javaResult.stdout);
   }
@@ -308,12 +282,6 @@
     }
   }
 
-  @FunctionalInterface
-  public interface AndroidAppInspector {
-
-    void inspectApp(AndroidApp androidApp) throws Exception;
-  }
-
   /**
    * Generates a "main" class which invokes the given static method (which has no argument and
    * return void type). This new class is then added to the test classpath.
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
index e4622be..608b92b 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
@@ -4,28 +4,20 @@
 
 package com.android.tools.r8.kotlin;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
-import com.android.tools.r8.R8FullTestBuilder;
-import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.KotlinTestParameters;
+import com.android.tools.r8.KotlinTestParametersCollection;
 import com.android.tools.r8.TestShrinkerBuilder;
-import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.code.NewInstance;
 import com.android.tools.r8.code.SgetObject;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexCode;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
-import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
@@ -33,7 +25,6 @@
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import com.google.common.collect.Streams;
-import java.util.Collection;
 import java.util.List;
 import java.util.Set;
 import java.util.function.Predicate;
@@ -46,29 +37,27 @@
 @RunWith(Parameterized.class)
 public class KotlinClassInlinerTest extends AbstractR8KotlinTestBase {
 
-  @Parameterized.Parameters(name = "target: {0}, kotlinc: {1}, allowAccessModification: {2}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        KotlinTargetVersion.values(), getKotlinCompilers(), BooleanUtils.values());
+  @Parameterized.Parameters(name = "{0}")
+  public static KotlinTestParametersCollection data() {
+    return getKotlinTestParameters().withAllCompilersAndTargetVersions().build();
   }
 
-  public KotlinClassInlinerTest(
-      KotlinTargetVersion targetVersion, KotlinCompiler kotlinc, boolean allowAccessModification) {
-    super(targetVersion, kotlinc, allowAccessModification);
+  public KotlinClassInlinerTest(KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters, true);
   }
 
   private static boolean isLambda(DexClass clazz) {
-    return !clazz.type.getPackageDescriptor().startsWith("kotlin") &&
-        (isKStyleLambdaOrGroup(clazz) || isJStyleLambdaOrGroup(clazz));
+    return !clazz.getType().getPackageDescriptor().startsWith("kotlin")
+        && (isKStyleLambda(clazz) || isJStyleLambda(clazz));
   }
 
-  private static boolean isKStyleLambdaOrGroup(DexClass clazz) {
-    return clazz.superType.descriptor.toString().equals("Lkotlin/jvm/internal/Lambda;");
+  private static boolean isKStyleLambda(DexClass clazz) {
+    return clazz.getSuperType().getTypeName().equals("kotlin.jvm.internal.Lambda");
   }
 
-  private static boolean isJStyleLambdaOrGroup(DexClass clazz) {
-    return clazz.superType.descriptor.toString().equals("Ljava/lang/Object;") &&
-        clazz.interfaces.size() == 1;
+  private static boolean isJStyleLambda(DexClass clazz) {
+    return clazz.getSuperType().getTypeName().equals(Object.class.getTypeName())
+        && clazz.getInterfaces().size() == 1;
   }
 
   private static Predicate<DexType> createLambdaCheck(CodeInspector inspector) {
@@ -82,9 +71,8 @@
 
   @Test
   public void testJStyleLambdas() throws Exception {
-    assumeTrue("Only work with -allowaccessmodification", allowAccessModification);
-    final String mainClassName = "class_inliner_lambda_j_style.MainKt";
-    runTestWithDefaults(
+    String mainClassName = "class_inliner_lambda_j_style.MainKt";
+    runTest(
             "class_inliner_lambda_j_style",
             mainClassName,
             testBuilder ->
@@ -92,21 +80,32 @@
                     // TODO(jsjeon): Introduce @NeverInline to kotlinR8TestResources
                     .addKeepRules("-neverinline class * { void test*State*(...); }")
                     .addDontWarnJetBrainsNotNullAnnotation()
+                    .addHorizontallyMergedClassesInspector(
+                        inspector ->
+                            inspector
+                                .assertIsCompleteMergeGroup(
+                                    "class_inliner_lambda_j_style.MainKt$testStateless$1",
+                                    "class_inliner_lambda_j_style.MainKt$testStateless$2",
+                                    "class_inliner_lambda_j_style.MainKt$testStateless$3")
+                                .assertIsCompleteMergeGroup(
+                                    "class_inliner_lambda_j_style.MainKt$testStateful$1",
+                                    "class_inliner_lambda_j_style.MainKt$testStateful$2",
+                                    "class_inliner_lambda_j_style.MainKt$testStateful$2$1",
+                                    "class_inliner_lambda_j_style.MainKt$testStateful$3",
+                                    "class_inliner_lambda_j_style.MainKt$testStateful2$1",
+                                    "class_inliner_lambda_j_style.MainKt$testStateful3$1"))
                     .noClassInlining())
         .inspect(
             inspector -> {
               assertThat(
+                  inspector.clazz("class_inliner_lambda_j_style.MainKt$testStateless$1"),
+                  isPresent());
+              assertThat(
                   inspector.clazz("class_inliner_lambda_j_style.MainKt$testStateful$1"),
                   isPresent());
-              assertThat(
-                  inspector.clazz("class_inliner_lambda_j_style.MainKt$testStateful2$1"),
-                  isPresent());
-              assertThat(
-                  inspector.clazz("class_inliner_lambda_j_style.MainKt$testStateful3$1"),
-                  isPresent());
             });
 
-    runTestWithDefaults(
+    runTest(
             "class_inliner_lambda_j_style",
             mainClassName,
             testBuilder ->
@@ -116,40 +115,22 @@
                     .addDontWarnJetBrainsNotNullAnnotation())
         .inspect(
             inspector -> {
-              Predicate<DexType> lambdaCheck = createLambdaCheck(inspector);
-              ClassSubject clazz = inspector.clazz(mainClassName);
+              // TODO(b/173337498): MainKt$testStateless$1 should be class inlined.
+              assertThat(
+                  inspector.clazz("class_inliner_lambda_j_style.MainKt$testStateless$1"),
+                  isPresent());
 
-              assertEquals(
-                  Sets.newHashSet(), collectAccessedTypes(lambdaCheck, clazz, "testStateless"));
-
-              assertEquals(
-                  Sets.newHashSet(), collectAccessedTypes(lambdaCheck, clazz, "testStateful"));
-
+              // TODO(b/173337498): MainKt$testStateful$1 should be class inlined.
               assertThat(
                   inspector.clazz("class_inliner_lambda_j_style.MainKt$testStateful$1"),
-                  not(isPresent()));
-
-              assertEquals(
-                  Sets.newHashSet(), collectAccessedTypes(lambdaCheck, clazz, "testStateful2"));
-
-              assertThat(
-                  inspector.clazz("class_inliner_lambda_j_style.MainKt$testStateful2$1"),
-                  not(isPresent()));
-
-              assertEquals(
-                  Sets.newHashSet(), collectAccessedTypes(lambdaCheck, clazz, "testStateful3"));
-
-              assertThat(
-                  inspector.clazz("class_inliner_lambda_j_style.MainKt$testStateful3$1"),
-                  not(isPresent()));
+                  isPresent());
             });
   }
 
   @Test
   public void testKStyleLambdas() throws Exception {
-    assumeTrue("Only work with -allowaccessmodification", allowAccessModification);
-    final String mainClassName = "class_inliner_lambda_k_style.MainKt";
-    runTestWithDefaults(
+    String mainClassName = "class_inliner_lambda_k_style.MainKt";
+    runTest(
             "class_inliner_lambda_k_style",
             mainClassName,
             testBuilder ->
@@ -160,6 +141,15 @@
                         "-neverinline class * { void testBigExtraMethod(...); }",
                         "-neverinline class * { void testBigExtraMethodReturningLambda(...); }")
                     .addDontWarnJetBrainsAnnotations()
+                    .addHorizontallyMergedClassesInspector(
+                        inspector ->
+                            inspector.assertIsCompleteMergeGroup(
+                                "class_inliner_lambda_k_style.MainKt$testBigExtraMethod$1",
+                                "class_inliner_lambda_k_style.MainKt$testBigExtraMethod2$1",
+                                "class_inliner_lambda_k_style.MainKt$testBigExtraMethod3$1",
+                                "class_inliner_lambda_k_style.MainKt$testBigExtraMethodReturningLambda$1",
+                                "class_inliner_lambda_k_style.MainKt$testBigExtraMethodReturningLambda2$1",
+                                "class_inliner_lambda_k_style.MainKt$testBigExtraMethodReturningLambda3$1"))
                     .noClassInlining())
         .inspect(
             inspector -> {
@@ -174,27 +164,9 @@
               assertThat(
                   inspector.clazz("class_inliner_lambda_k_style.MainKt$testBigExtraMethod$1"),
                   isPresent());
-              assertThat(
-                  inspector.clazz("class_inliner_lambda_k_style.MainKt$testBigExtraMethod2$1"),
-                  isPresent());
-              assertThat(
-                  inspector.clazz("class_inliner_lambda_k_style.MainKt$testBigExtraMethod3$1"),
-                  isPresent());
-              assertThat(
-                  inspector.clazz(
-                      "class_inliner_lambda_k_style.MainKt$testBigExtraMethodReturningLambda$1"),
-                  isPresent());
-              assertThat(
-                  inspector.clazz(
-                      "class_inliner_lambda_k_style.MainKt$testBigExtraMethodReturningLambda2$1"),
-                  isPresent());
-              assertThat(
-                  inspector.clazz(
-                      "class_inliner_lambda_k_style.MainKt$testBigExtraMethodReturningLambda3$1"),
-                  isPresent());
             });
 
-    runTestWithDefaults(
+    runTest(
             "class_inliner_lambda_k_style",
             mainClassName,
             testBuilder ->
@@ -207,20 +179,6 @@
                     .addDontWarnJetBrainsAnnotations())
         .inspect(
             inspector -> {
-              Predicate<DexType> lambdaCheck = createLambdaCheck(inspector);
-              ClassSubject clazz = inspector.clazz(mainClassName);
-
-              // TODO(b/173337498): Should be empty, but horizontal class merging interferes with
-              //  class inlining.
-              assertEquals(
-                  Sets.newHashSet(
-                      "class_inliner_lambda_k_style.MainKt$testKotlinSequencesStateless$1"),
-                  collectAccessedTypes(
-                      lambdaCheck,
-                      clazz,
-                      "testKotlinSequencesStateless",
-                      "kotlin.sequences.Sequence"));
-
               // TODO(b/173337498): Should be absent, but horizontal class merging interferes with
               //  class inlining.
               assertThat(
@@ -228,19 +186,6 @@
                       "class_inliner_lambda_k_style.MainKt$testKotlinSequencesStateless$1"),
                   isPresent());
 
-              // TODO(b/173337498): Should be empty, but horizontal class merging interferes with
-              //  class inlining.
-              assertEquals(
-                  Sets.newHashSet(
-                      "class_inliner_lambda_k_style.MainKt$testKotlinSequencesStateful$1"),
-                  collectAccessedTypes(
-                      lambdaCheck,
-                      clazz,
-                      "testKotlinSequencesStateful",
-                      "int",
-                      "int",
-                      "kotlin.sequences.Sequence"));
-
               // TODO(b/173337498): Should be absent, but horizontal class merging interferes with
               //  class inlining.
               assertThat(
@@ -248,57 +193,33 @@
                       "class_inliner_lambda_k_style.MainKt$testKotlinSequencesStateful$1"),
                   isPresent());
 
-              assertEquals(
-                  Sets.newHashSet(),
-                  collectAccessedTypes(lambdaCheck, clazz, "testBigExtraMethod"));
-
+              // TODO(b/173337498): Should be absent, but horizontal class merging interferes with
+              //  class inlining.
               assertThat(
                   inspector.clazz("class_inliner_lambda_k_style.MainKt$testBigExtraMethod$1"),
-                  not(isPresent()));
-              assertThat(
-                  inspector.clazz("class_inliner_lambda_k_style.MainKt$testBigExtraMethod2$1"),
-                  not(isPresent()));
-              assertThat(
-                  inspector.clazz("class_inliner_lambda_k_style.MainKt$testBigExtraMethod3$1"),
-                  not(isPresent()));
-
-              assertEquals(
-                  Sets.newHashSet(),
-                  collectAccessedTypes(lambdaCheck, clazz, "testBigExtraMethodReturningLambda"));
-
-              assertThat(
-                  inspector.clazz(
-                      "class_inliner_lambda_k_style.MainKt$testBigExtraMethodReturningLambda$1"),
-                  not(isPresent()));
-              assertThat(
-                  inspector.clazz(
-                      "class_inliner_lambda_k_style.MainKt$testBigExtraMethodReturningLambda2$1"),
-                  not(isPresent()));
-              assertThat(
-                  inspector.clazz(
-                      "class_inliner_lambda_k_style.MainKt$testBigExtraMethodReturningLambda3$1"),
-                  not(isPresent()));
+                  isPresent());
             });
   }
 
   @Test
   public void testDataClass() throws Exception {
-    assumeTrue("Only work with -allowaccessmodification", allowAccessModification);
-    final String mainClassName = "class_inliner_data_class.MainKt";
-    runTestWithDefaults(
+    String mainClassName = "class_inliner_data_class.MainKt";
+    runTest(
             "class_inliner_data_class",
             mainClassName,
             TestShrinkerBuilder::addDontWarnJetBrainsAnnotations)
         .inspect(
             inspector -> {
               ClassSubject clazz = inspector.clazz(mainClassName);
-              assertTrue(
+
+              // TODO(b/141719453): Data class should maybe be class inlined.
+              assertEquals(
+                  Sets.newHashSet("class_inliner_data_class.Alpha"),
                   collectAccessedTypes(
-                          type -> !type.toSourceString().startsWith("java."),
-                          clazz,
-                          "main",
-                          String[].class.getCanonicalName())
-                      .isEmpty());
+                      type -> !type.toSourceString().startsWith("java."),
+                      clazz,
+                      "main",
+                      String[].class.getCanonicalName()));
               assertEquals(
                   Lists.newArrayList(
                       "void kotlin.jvm.internal.Intrinsics.throwParameterIsNullException(java.lang.String)"),
@@ -325,39 +246,6 @@
         .collect(Collectors.toSet());
   }
 
-  private R8TestRunResult runTestWithDefaults(String folder, String mainClass) throws Exception {
-    return runTestWithDefaults(folder, mainClass, null);
-  }
-
-  private R8TestRunResult runTestWithDefaults(
-      String folder, String mainClass, ThrowableConsumer<R8FullTestBuilder> configuration)
-      throws Exception {
-    return runTest(
-        folder,
-        mainClass,
-        testBuilder ->
-            testBuilder
-                .addOptionsModification(
-                    options -> {
-                      options.enableInlining = true;
-                      options.enableLambdaMerging = false;
-
-                      // TODO(b/141719453): These limits should be removed if a possible or the test
-                      //  refactored. Tests check if specific lambdas are inlined or not, where some
-                      //  of target lambdas have at least 4 instructions.
-                      options.inliningInstructionLimit = 4;
-                      options.classInliningInstructionLimit = 40;
-
-                      // Class inlining depends on the processing order. We therefore insert all
-                      // call graph edges and verify that we can class inline everything under this
-                      // condition.
-                      options.testing.addCallEdgesForLibraryInvokes = true;
-
-                      options.horizontalClassMergerOptions().disableKotlinLambdaMerging();
-                    })
-                .apply(configuration));
-  }
-
   private List<String> collectStaticCalls(ClassSubject clazz, String methodName, String... params) {
     assertNotNull(clazz);
     MethodSignature signature = new MethodSignature(methodName, "void", params);
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java
index e5d0d09..1598bb8 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java
@@ -4,16 +4,14 @@
 
 package com.android.tools.r8.kotlin;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assume.assumeTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.R8TestRunResult;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
@@ -26,15 +24,16 @@
 @RunWith(Parameterized.class)
 public class KotlinClassStaticizerTest extends AbstractR8KotlinTestBase {
 
-  @Parameterized.Parameters(name = "target: {0}, kotlinc: {1}, allowAccessModification: {2}")
+  @Parameterized.Parameters(name = "{0}, allowAccessModification: {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
-        KotlinTargetVersion.values(), getKotlinCompilers(), BooleanUtils.values());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values());
   }
 
   public KotlinClassStaticizerTest(
-      KotlinTargetVersion targetVersion, KotlinCompiler kotlinc, boolean allowAccessModification) {
-    super(targetVersion, kotlinc, allowAccessModification);
+      KotlinTestParameters kotlinParameters, boolean allowAccessModification) {
+    super(kotlinParameters, allowAccessModification);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinDuplicateAnnotationTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinDuplicateAnnotationTest.java
index 7407d46..e74d082 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinDuplicateAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinDuplicateAnnotationTest.java
@@ -3,16 +3,14 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.fail;
 import static org.junit.Assume.assumeTrue;
 
 import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.StringUtils;
@@ -36,12 +34,11 @@
       o.enableInlining = false;
     };
 
-  @Parameterized.Parameters(name = "{0} target: {1}, kotlinc: {2}, allowAccessModification: {3}")
+  @Parameterized.Parameters(name = "{0}, {1}, allowAccessModification: {2}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withAllRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers(),
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
         BooleanUtils.values());
   }
 
@@ -49,10 +46,9 @@
 
   public KotlinDuplicateAnnotationTest(
       TestParameters parameters,
-      KotlinTargetVersion targetVersion,
-      KotlinCompiler kotlinc,
+      KotlinTestParameters kotlinParameters,
       boolean allowAccessModification) {
-    super(targetVersion, kotlinc, allowAccessModification);
+    super(kotlinParameters, allowAccessModification);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
index eb1ca57..dae8a7d 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
@@ -3,15 +3,13 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assume.assumeTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -26,12 +24,11 @@
   private static final String FOLDER = "intrinsics";
   private static final String MAIN = FOLDER + ".InlineKt";
 
-  @Parameterized.Parameters(name = "{0} target: {1}, kotlinc: {2}, allowAccessModification: {3}")
+  @Parameterized.Parameters(name = "{0}, {1}, allowAccessModification: {2}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withAllRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers(),
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
         BooleanUtils.values());
   }
 
@@ -39,10 +36,9 @@
 
   public KotlinIntrinsicsInlineTest(
       TestParameters parameters,
-      KotlinTargetVersion targetVersion,
-      KotlinCompiler kotlinc,
+      KotlinTestParameters kotlinParameters,
       boolean allowAccessModification) {
-    super(targetVersion, kotlinc, allowAccessModification);
+    super(kotlinParameters, allowAccessModification);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
index 5e25b92..fa3b505 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
@@ -3,15 +3,13 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestShrinkerBuilder;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
 import com.google.common.collect.ImmutableList;
@@ -23,15 +21,16 @@
 @RunWith(Parameterized.class)
 public class KotlinUnusedArgumentsInLambdasTest extends AbstractR8KotlinTestBase {
 
-  @Parameterized.Parameters(name = "target: {0}, kotlinc: {1}, allowAccessModification: {2}")
+  @Parameterized.Parameters(name = "{0}, allowAccessModification: {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
-        KotlinTargetVersion.values(), getKotlinCompilers(), BooleanUtils.values());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values());
   }
 
   public KotlinUnusedArgumentsInLambdasTest(
-      KotlinTargetVersion targetVersion, KotlinCompiler kotlinc, boolean allowAccessModification) {
-    super(targetVersion, kotlinc, allowAccessModification);
+      KotlinTestParameters kotlinParameters, boolean allowAccessModification) {
+    super(kotlinParameters, allowAccessModification);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
index 6a8e196..226fb8b 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
@@ -3,16 +3,14 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestShrinkerBuilder;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.FieldSubject;
@@ -28,18 +26,19 @@
 @RunWith(Parameterized.class)
 public class KotlinUnusedSingletonTest extends AbstractR8KotlinTestBase {
 
-  @Parameterized.Parameters(name = "target: {0}, kotlinc: {1}, allowAccessModification: {1}")
+  @Parameterized.Parameters(name = "{0}, allowAccessModification: {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
-        KotlinTargetVersion.values(), getKotlinCompilers(), BooleanUtils.values());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values());
   }
 
   private static final String printlnSignature =
       "void java.io.PrintStream.println(java.lang.Object)";
 
   public KotlinUnusedSingletonTest(
-      KotlinTargetVersion targetVersion, KotlinCompiler kotlinc, boolean allowAccessModification) {
-    super(targetVersion, kotlinc, allowAccessModification);
+      KotlinTestParameters kotlinParameters, boolean allowAccessModification) {
+    super(kotlinParameters, allowAccessModification);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinReflectionLibTest.java b/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinReflectionLibTest.java
index 3137d61..9f92a95 100644
--- a/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinReflectionLibTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinReflectionLibTest.java
@@ -3,16 +3,14 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
 import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestShrinkerBuilder;
 import com.android.tools.r8.ThrowableConsumer;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import java.util.Collection;
 import org.junit.Test;
@@ -24,17 +22,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0} target: {1}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withAllRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public ProcessKotlinReflectionLibTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinStdlibTest.java b/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinStdlibTest.java
index 7166aed..c2c68e4 100644
--- a/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinStdlibTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinStdlibTest.java
@@ -3,16 +3,14 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
 import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestShrinkerBuilder;
 import com.android.tools.r8.ThrowableConsumer;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.google.common.collect.ImmutableList;
 import java.util.Collection;
@@ -24,17 +22,15 @@
 public class ProcessKotlinStdlibTest extends KotlinTestBase {
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0} target: {1}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withAllRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
-  public ProcessKotlinStdlibTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+  public ProcessKotlinStdlibTest(TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
@@ -71,22 +67,6 @@
   }
 
   @Test
-  public void testDontShrinkAndDontOptimizeDifferently() throws Exception {
-    test(
-        ImmutableList.of("-keep,allowobfuscation class **.*Exception*"),
-        tb ->
-            tb.addDontWarnJetBrainsAnnotations()
-                .noTreeShaking()
-                .addOptionsModification(
-                    o -> {
-                      // Randomly choose a couple of optimizations.
-                      o.enableClassInlining = false;
-                      o.enableLambdaMerging = false;
-                      o.enableValuePropagation = false;
-                    }));
-  }
-
-  @Test
   public void testDontShrinkAndDontObfuscate() throws Exception {
     test(
         ImmutableList.of("-dontshrink", "-dontobfuscate"),
@@ -99,13 +79,6 @@
   }
 
   @Test
-  public void testDontShrinkDifferently() throws Exception {
-    test(
-        ImmutableList.of("-keep,allowobfuscation class **.*Exception*"),
-        tb -> tb.addDontWarnJetBrainsAnnotations().noTreeShaking());
-  }
-
-  @Test
   public void testDontOptimize() throws Exception {
     test(ImmutableList.of("-dontoptimize"));
   }
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
index 882bc22..a405400 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
@@ -4,16 +4,14 @@
 
 package com.android.tools.r8.kotlin;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.R8TestBuilder;
 import com.android.tools.r8.TestShrinkerBuilder;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.jasmin.JasminBuilder;
 import com.android.tools.r8.jasmin.JasminBuilder.ClassBuilder;
@@ -68,15 +66,16 @@
           .addProperty("property", JAVA_LANG_STRING, Visibility.PRIVATE)
           .addProperty("indirectPropertyGetter", JAVA_LANG_STRING, Visibility.PRIVATE);
 
-  @Parameterized.Parameters(name = "target: {0}, kotlinc: {1}, allowAccessModification: {2}")
+  @Parameterized.Parameters(name = "{0}, allowAccessModification: {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
-        KotlinTargetVersion.values(), getKotlinCompilers(), BooleanUtils.values());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values());
   }
 
   public R8KotlinAccessorTest(
-      KotlinTargetVersion targetVersion, KotlinCompiler kotlinc, boolean allowAccessModification) {
-    super(targetVersion, kotlinc, allowAccessModification);
+      KotlinTestParameters kotlinParameters, boolean allowAccessModification) {
+    super(kotlinParameters, allowAccessModification);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
index 3faf486..b2f0927 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
@@ -4,10 +4,7 @@
 
 package com.android.tools.r8.kotlin;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
-
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.graph.DexCode;
 import com.android.tools.r8.kotlin.TestKotlinClass.Visibility;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
@@ -45,15 +42,16 @@
 
   private Consumer<InternalOptions> disableClassInliner = o -> o.enableClassInlining = false;
 
-  @Parameterized.Parameters(name = "target: {0}, kotlinc: {2}, allowAccessModification: {1}")
+  @Parameterized.Parameters(name = "{0}, allowAccessModification: {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
-        KotlinTargetVersion.values(), getKotlinCompilers(), BooleanUtils.values());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values());
   }
 
   public R8KotlinDataClassTest(
-      KotlinTargetVersion targetVersion, KotlinCompiler kotlinc, boolean allowAccessModification) {
-    super(targetVersion, kotlinc, allowAccessModification);
+      KotlinTestParameters kotlinParameters, boolean allowAccessModification) {
+    super(kotlinParameters, allowAccessModification);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java
index 934ee16..11d1ea2 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java
@@ -4,10 +4,7 @@
 
 package com.android.tools.r8.kotlin;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
-
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -26,15 +23,16 @@
   private static final TestKotlinDataClass KOTLIN_INTRINSICS_CLASS =
       new TestKotlinDataClass("kotlin.jvm.internal.Intrinsics");
 
-  @Parameterized.Parameters(name = "target: {0}, kotlinc: {1}, allowAccessModification: {2}")
+  @Parameterized.Parameters(name = "{0}, allowAccessModification: {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
-        KotlinTargetVersion.values(), getKotlinCompilers(), BooleanUtils.values());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values());
   }
 
   public R8KotlinIntrinsicsTest(
-      KotlinTargetVersion targetVersion, KotlinCompiler kotlinc, boolean allowAccessModification) {
-    super(targetVersion, kotlinc, allowAccessModification);
+      KotlinTestParameters kotlinParameters, boolean allowAccessModification) {
+    super(kotlinParameters, allowAccessModification);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
index b9fefbaf4..edd2c8f 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
@@ -4,11 +4,9 @@
 
 package com.android.tools.r8.kotlin;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.kotlin.TestKotlinClass.Visibility;
 import com.android.tools.r8.naming.MemberNaming;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
@@ -95,15 +93,16 @@
         o.enableClassStaticizer = false;
       };
 
-  @Parameterized.Parameters(name = "target: {0}, kotlinc: {1}, allowAccessModification: {1}")
+  @Parameterized.Parameters(name = "{0}, allowAccessModification: {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
-        KotlinTargetVersion.values(), getKotlinCompilers(), BooleanUtils.values());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values());
   }
 
   public R8KotlinPropertiesTest(
-      KotlinTargetVersion targetVersion, KotlinCompiler kotlinc, boolean allowAccessModification) {
-    super(targetVersion, kotlinc, allowAccessModification);
+      KotlinTestParameters kotlinParameters, boolean allowAccessModification) {
+    super(kotlinParameters, allowAccessModification);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java b/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
index 64e3a80..c9fd417 100644
--- a/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
@@ -3,11 +3,9 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static org.junit.Assert.assertEquals;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -23,15 +21,16 @@
   private static final String FOLDER = "non_null";
   private static final String STRING = "java.lang.String";
 
-  @Parameterized.Parameters(name = "target: {0}, kotlinc: {1}, allowAccessModification: {2}")
+  @Parameterized.Parameters(name = "{0}, allowAccessModification: {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
-        KotlinTargetVersion.values(), getKotlinCompilers(), BooleanUtils.values());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values());
   }
 
   public SimplifyIfNotNullKotlinTest(
-      KotlinTargetVersion targetVersion, KotlinCompiler kotlinc, boolean allowAccessModification) {
-    super(targetVersion, kotlinc, allowAccessModification);
+      KotlinTestParameters kotlinParameters, boolean allowAccessModification) {
+    super(kotlinParameters, allowAccessModification);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/kotlin/coroutines/KotlinxCoroutinesTestRunner.java b/src/test/java/com/android/tools/r8/kotlin/coroutines/KotlinxCoroutinesTestRunner.java
index 4a05b76..1241446 100644
--- a/src/test/java/com/android/tools/r8/kotlin/coroutines/KotlinxCoroutinesTestRunner.java
+++ b/src/test/java/com/android/tools/r8/kotlin/coroutines/KotlinxCoroutinesTestRunner.java
@@ -4,13 +4,11 @@
 
 package com.android.tools.r8.kotlin.coroutines;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static org.junit.Assert.assertEquals;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.kotlin.metadata.KotlinMetadataTestBase;
 import com.android.tools.r8.utils.ZipUtils;
@@ -50,19 +48,18 @@
   private Set<String> notWorkingTests =
       Sets.newHashSet("kotlinx.coroutines.test.TestDispatchersTest");
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   private final TestParameters parameters;
 
   public KotlinxCoroutinesTestRunner(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/JStyleKotlinLambdaMergingWithEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/JStyleKotlinLambdaMergingWithEnumUnboxingTest.java
index 7103667..787ae1f 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/JStyleKotlinLambdaMergingWithEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/JStyleKotlinLambdaMergingWithEnumUnboxingTest.java
@@ -9,13 +9,9 @@
 import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NoHorizontalClassMerging;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.ir.optimize.lambda.kotlin.JStyleLambdaGroupIdFactory;
-import com.android.tools.r8.ir.optimize.lambda.kotlin.KotlinLambdaGroupIdFactory;
 import com.android.tools.r8.kotlin.lambda.JStyleKotlinLambdaMergingWithEnumUnboxingTest.Main.EnumUnboxingCandidate;
 import java.util.List;
 import org.junit.Test;
@@ -49,31 +45,17 @@
         .addDefaultRuntimeLibrary(parameters)
         .addLibraryFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
         .addKeepMainRule(Main.class)
-        .addOptionsModification(
-            options ->
-                options.testing.kotlinLambdaMergerFactoryForClass =
-                    this::getKotlinLambdaMergerFactoryForClass)
-        .addHorizontallyMergedLambdaClassesInspector(
-            inspector -> inspector.assertMerged(Lambda1.class, Lambda2.class))
+        .addHorizontallyMergedClassesInspector(
+            inspector -> inspector.assertMergedInto(Lambda2.class, Lambda1.class))
         .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(EnumUnboxingCandidate.class))
         .enableInliningAnnotations()
         .enableNeverClassInliningAnnotations()
-        .enableNoHorizontalClassMergingAnnotations()
         .setMinApi(parameters.getApiLevel())
         .compile()
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("Lambda1.method()", "Lambda2.method()");
   }
 
-  private KotlinLambdaGroupIdFactory getKotlinLambdaMergerFactoryForClass(DexProgramClass clazz) {
-    String typeName = clazz.getType().toSourceString();
-    if (typeName.equals(Lambda1.class.getTypeName())
-        || typeName.equals(Lambda2.class.getTypeName())) {
-      return JStyleLambdaGroupIdFactory.getInstance();
-    }
-    return null;
-  }
-
   static class Main {
 
     @NeverClassInline
@@ -121,7 +103,6 @@
   }
 
   @NeverClassInline
-  @NoHorizontalClassMerging
   public static final class Lambda2 implements I {
 
     @NeverInline
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KStyleKotlinLambdaMergingWithEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KStyleKotlinLambdaMergingWithEnumUnboxingTest.java
index aea188c..fe0ef77 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KStyleKotlinLambdaMergingWithEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KStyleKotlinLambdaMergingWithEnumUnboxingTest.java
@@ -9,13 +9,9 @@
 import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NoHorizontalClassMerging;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.ir.optimize.lambda.kotlin.KStyleLambdaGroupIdFactory;
-import com.android.tools.r8.ir.optimize.lambda.kotlin.KotlinLambdaGroupIdFactory;
 import com.android.tools.r8.kotlin.lambda.KStyleKotlinLambdaMergingWithEnumUnboxingTest.Main.EnumUnboxingCandidate;
 import java.util.List;
 import org.junit.Test;
@@ -48,17 +44,12 @@
         .addInnerClasses(getClass())
         .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
         .addKeepMainRule(Main.class)
-        .addOptionsModification(
-            options ->
-                options.testing.kotlinLambdaMergerFactoryForClass =
-                    this::getKotlinLambdaMergerFactoryForClass)
-        .addHorizontallyMergedLambdaClassesInspector(
-            inspector -> inspector.assertMerged(Lambda1.class, Lambda2.class))
+        .addHorizontallyMergedClassesInspector(
+            inspector -> inspector.assertMergedInto(Lambda2.class, Lambda1.class))
         .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(EnumUnboxingCandidate.class))
         .addDontWarnJetBrainsNotNullAnnotation()
         .enableInliningAnnotations()
         .enableNeverClassInliningAnnotations()
-        .enableNoHorizontalClassMergingAnnotations()
         .noMinification()
         .setMinApi(parameters.getApiLevel())
         .compile()
@@ -66,15 +57,6 @@
         .assertSuccessWithOutputLines("Lambda1.method()", "Lambda2.method()");
   }
 
-  private KotlinLambdaGroupIdFactory getKotlinLambdaMergerFactoryForClass(DexProgramClass clazz) {
-    String typeName = clazz.getType().toSourceString();
-    if (typeName.equals(Lambda1.class.getTypeName())
-        || typeName.equals(Lambda2.class.getTypeName())) {
-      return KStyleLambdaGroupIdFactory.getInstance();
-    }
-    return null;
-  }
-
   static class Main {
 
     @NeverClassInline
@@ -123,7 +105,6 @@
   }
 
   @NeverClassInline
-  @NoHorizontalClassMerging
   public static final class Lambda2 extends kotlin.jvm.internal.Lambda<kotlin.Unit>
       implements kotlin.jvm.functions.Function0<kotlin.Unit> {
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java
index 4f78df2..655ddb5 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java
@@ -3,16 +3,14 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.lambda;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assume.assumeTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestRuntime;
 import com.android.tools.r8.TestRuntime.CfRuntime;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.kotlin.AbstractR8KotlinTestBase;
 import com.android.tools.r8.utils.DescriptorUtils;
 import java.nio.file.Path;
@@ -26,17 +24,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withAllRuntimesAndApiLevels().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public KotlinLambdaMergerValidationTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc, false);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters, false);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingCapturesKotlinStyleTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingCapturesKotlinStyleTest.java
new file mode 100644
index 0000000..0a49461
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingCapturesKotlinStyleTest.java
@@ -0,0 +1,161 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin.lambda;
+
+import static com.android.tools.r8.utils.PredicateUtils.not;
+import static junit.framework.TestCase.assertEquals;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assume.assumeFalse;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+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 KotlinLambdaMergingCapturesKotlinStyleTest extends KotlinTestBase {
+
+  private final boolean allowAccessModification;
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}, {1}, allow access modification: {2}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters()
+            .withCfRuntime(CfVm.last())
+            .withDexRuntime(Version.last())
+            .withAllApiLevels()
+            .build(),
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values());
+  }
+
+  public KotlinLambdaMergingCapturesKotlinStyleTest(
+      TestParameters parameters,
+      KotlinTestParameters kotlinParameters,
+      boolean allowAccessModification) {
+    super(kotlinParameters);
+    this.allowAccessModification = allowAccessModification;
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testJVM() throws Exception {
+    assumeFalse(allowAccessModification);
+    assumeTrue(parameters.isCfRuntime());
+    assumeTrue(kotlinParameters.isFirst());
+    testForJvm()
+        .addProgramFiles(getProgramFiles())
+        .run(parameters.getRuntime(), getMainClassName())
+        .assertSuccessWithOutput(getExpectedOutput());
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramFiles(getProgramFiles())
+        .addKeepMainRule(getMainClassName())
+        .addDontWarnJetBrainsAnnotations()
+        .addHorizontallyMergedClassesInspector(this::inspect)
+        .allowAccessModification(allowAccessModification)
+        .allowDiagnosticWarningMessages()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .assertAllWarningMessagesMatch(
+            containsString("Resource 'META-INF/MANIFEST.MF' already exists."))
+        .run(parameters.getRuntime(), getMainClassName())
+        .assertSuccessWithOutput(getExpectedOutput());
+  }
+
+  private void inspect(HorizontallyMergedClassesInspector inspector) throws IOException {
+    // Get the Kotlin lambdas in the input.
+    KotlinLambdasInInput lambdasInInput =
+        KotlinLambdasInInput.create(getProgramFiles(), getTestName());
+    assertEquals(0, lambdasInInput.getNumberOfJStyleLambdas());
+    assertEquals(26, lambdasInInput.getNumberOfKStyleLambdas());
+
+    // Only a subset of all K-style Kotlin lambdas are merged.
+    Set<ClassReference> unmergedLambdas =
+        ImmutableSet.of(
+            lambdasInInput.getKStyleLambdaReferenceFromTypeName(getTestName(), "MainKt$test1$15"),
+            lambdasInInput.getKStyleLambdaReferenceFromTypeName(getTestName(), "MainKt$test2$9"),
+            lambdasInInput.getKStyleLambdaReferenceFromTypeName(getTestName(), "MainKt$test2$10"),
+            lambdasInInput.getKStyleLambdaReferenceFromTypeName(getTestName(), "MainKt$test2$11"));
+    inspector
+        .assertClassReferencesMerged(
+            lambdasInInput.getKStyleLambdas().stream()
+                .filter(not(unmergedLambdas::contains))
+                .collect(Collectors.toList()))
+        .assertClassReferencesNotMerged(unmergedLambdas);
+  }
+
+  private String getExpectedOutput() {
+    return StringUtils.lines(
+        "a: 1 2 3",
+        "b: 2 3 1",
+        "c: 3 1 2",
+        "d: 1 A D(d=x)",
+        "e: 2 D(d=y) B",
+        "f: 3 D(d=z) D(d=x)",
+        "g: 7 D(d=z) 3",
+        "h: 8 9 1",
+        "i: A B C",
+        "j: D(d=x) D(d=y) D(d=z)",
+        "k: 7 8 9",
+        "l: A D(d=y) 9",
+        "n: 7 B D(d=z)",
+        "o: D(d=x) 8 C",
+        "p: 1 2 C",
+        "a: true 10 * 20 30 40 50.0 60.0 D(d=D) S null 70",
+        "a: true 10 D(d=D) S * 20 30 40 50.0 60.0 null 70",
+        "a: true * 20 40 50.0 60.0 S null 70 10 30 D(d=D)",
+        "a: D(d=D) S null 70 true 10 * 20 30 40 50.0 60.0",
+        "a: true 10 * 20 30 40 50.0 60.0 D(d=D) S $o3 $o4",
+        "a: true 10 * 20 30 40 50.0 60.0 D(d=D) $o2 $o3 70",
+        "a: true 10 * 20 30 40 50.0 60.0 $o1 $o2 null 70",
+        "a: true 10 * 20 30 40 50.0 60.0 $o1 S null $o4",
+        "x: true 10 * 20 30 40 50.0 60.0 D(d=D) S $o3 70",
+        "y: true 10 * 20 30 40 $f 60.0 D(d=D) S null 70",
+        "z: true 10 * $s 30 40 50.0 60.0 D(d=D) S null 70");
+  }
+
+  private Path getJavaJarFile() {
+    return getJavaJarFile(getTestName());
+  }
+
+  private String getMainClassName() {
+    return getTestName() + ".MainKt";
+  }
+
+  private List<Path> getProgramFiles() {
+    Path kotlinJarFile =
+        getCompileMemoizer(getKotlinFilesInResource(getTestName()), getTestName())
+            .configure(kotlinCompilerTool -> kotlinCompilerTool.includeRuntime().noReflect())
+            .getForConfiguration(kotlinc, targetVersion);
+    return ImmutableList.of(kotlinJarFile, getJavaJarFile());
+  }
+
+  private String getTestName() {
+    return "lambdas_kstyle_captures";
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java
index 9cee958..61f417e 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java
@@ -3,11 +3,10 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.lambda;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static org.hamcrest.CoreMatchers.equalTo;
 
 import com.android.tools.r8.CompilationMode;
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.kotlin.AbstractR8KotlinTestBase;
@@ -24,14 +23,19 @@
   private static final String FOLDER = "reprocess_merged_lambdas_kstyle";
   private static final String MAIN_CLASS = "reprocess_merged_lambdas_kstyle.MainKt";
 
-  @Parameters(name = "{0}")
+  @Parameters(name = "{0}, {1}")
   public static List<Object[]> data() {
     return buildParameters(
-        getTestParameters().withDexRuntimes().withAllApiLevels().build(), getKotlinCompilers());
+        getTestParameters().withDexRuntimes().withAllApiLevels().build(),
+        getKotlinTestParameters()
+            .withAllCompilers()
+            .withTargetVersion(KotlinTargetVersion.JAVA_6)
+            .build());
   }
 
-  public KotlinLambdaMergingDebugTest(TestParameters parameters, KotlinCompiler kotlinc) {
-    super(KotlinTargetVersion.JAVA_6, kotlinc);
+  public KotlinLambdaMergingDebugTest(
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingKeepAttributesKotlinStyleTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingKeepAttributesKotlinStyleTest.java
new file mode 100644
index 0000000..a20a77d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingKeepAttributesKotlinStyleTest.java
@@ -0,0 +1,160 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin.lambda;
+
+import static com.android.tools.r8.shaking.ProguardKeepAttributes.ENCLOSING_METHOD;
+import static com.android.tools.r8.shaking.ProguardKeepAttributes.INNER_CLASSES;
+import static com.android.tools.r8.shaking.ProguardKeepAttributes.SIGNATURE;
+import static junit.framework.TestCase.assertEquals;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assume.assumeFalse;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
+import com.google.common.collect.ImmutableList;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.Collections;
+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 KotlinLambdaMergingKeepAttributesKotlinStyleTest extends KotlinTestBase {
+
+  private final boolean allowAccessModification;
+  private final List<String> attributes;
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}, {1}, allow access modification: {2}, attributes: {3}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters()
+            .withCfRuntime(CfVm.last())
+            .withDexRuntime(Version.last())
+            .withAllApiLevels()
+            .build(),
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values(),
+        ImmutableList.of(
+            Collections.emptyList(),
+            ImmutableList.of(ENCLOSING_METHOD, INNER_CLASSES),
+            ImmutableList.of(ENCLOSING_METHOD, INNER_CLASSES, SIGNATURE)));
+  }
+
+  public KotlinLambdaMergingKeepAttributesKotlinStyleTest(
+      TestParameters parameters,
+      KotlinTestParameters kotlinParameters,
+      boolean allowAccessModification,
+      List<String> attributes) {
+    super(kotlinParameters);
+    this.allowAccessModification = allowAccessModification;
+    this.attributes = attributes;
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testJVM() throws Exception {
+    assumeFalse(allowAccessModification);
+    assumeTrue(parameters.isCfRuntime());
+    assumeTrue(kotlinParameters.isFirst());
+    testForJvm()
+        .addProgramFiles(getProgramFiles())
+        .run(parameters.getRuntime(), getMainClassName())
+        .assertSuccessWithOutput(getExpectedOutput());
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramFiles(getProgramFiles())
+        .addKeepMainRule(getMainClassName())
+        .applyIf(!attributes.isEmpty(), builder -> builder.addKeepAttributes(attributes))
+        .addDontWarnJetBrainsAnnotations()
+        .addHorizontallyMergedClassesInspector(this::inspect)
+        .allowAccessModification(allowAccessModification)
+        .allowDiagnosticWarningMessages()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .assertAllWarningMessagesMatch(
+            containsString("Resource 'META-INF/MANIFEST.MF' already exists."))
+        .run(parameters.getRuntime(), getMainClassName())
+        .assertSuccessWithOutput(getExpectedOutput());
+  }
+
+  private void inspect(HorizontallyMergedClassesInspector inspector) throws IOException {
+    // Get the Kotlin lambdas in the input.
+    KotlinLambdasInInput lambdasInInput =
+        KotlinLambdasInInput.create(getProgramFiles(), getTestName());
+    assertEquals(0, lambdasInInput.getNumberOfJStyleLambdas());
+    assertEquals(24, lambdasInInput.getNumberOfKStyleLambdas());
+
+    // All K-style Kotlin lambdas are merged if no attributes are kept.
+    if (attributes.isEmpty()) {
+      inspector.assertClassReferencesMerged(lambdasInInput.getKStyleLambdas());
+    } else {
+      // TODO(b/179018501): allow merging classes with inner/outer classes.
+      inspector.assertClassReferencesNotMerged(lambdasInInput.getKStyleLambdas());
+    }
+  }
+
+  private String getExpectedOutput() {
+    return StringUtils.lines(
+        "Alpha(id=11)",
+        "Beta(id=12)",
+        "Gamma(payload={any}, id=13)",
+        "Alpha(id=14)",
+        "First-1-Beta(id=15)",
+        "First-2-Beta(id=16)",
+        "First-3-Beta(id=17)",
+        "First-A-Gamma(payload=18, id=19)-11",
+        "First-B-Gamma(payload=20, id=21)-11",
+        "First-C-Gamma(payload=22, id=23)-11",
+        "First-D-Gamma(payload=24, id=25)-11",
+        "First-E-Gamma(payload=26, id=27)-11",
+        "First-F-Gamma(payload=28, id=29)-11",
+        "Second-1-Beta(id=30)",
+        "Second-2-Beta(id=31)",
+        "Second-3-Beta(id=32)",
+        "Second-A-Gamma(payload=33, id=34)-22",
+        "Second-B-Gamma(payload=35, id=36)-22",
+        "Second-C-Gamma(payload=37, id=38)-22",
+        "Second-D-Gamma(payload=39, id=40)-22",
+        "Second-E-Gamma(payload=41, id=42)-22",
+        "Second-F-Gamma(payload=43, id=44)-22",
+        "4321 45 46 47",
+        "1234 Alpha(id=48) Beta(id=49) Gamma(payload=50, id=51)");
+  }
+
+  private Path getJavaJarFile() {
+    return getJavaJarFile(getTestName());
+  }
+
+  private String getMainClassName() {
+    return getTestName() + ".MainKt";
+  }
+
+  private List<Path> getProgramFiles() {
+    Path kotlinJarFile =
+        getCompileMemoizer(getKotlinFilesInResource(getTestName()), getTestName())
+            .configure(kotlinCompilerTool -> kotlinCompilerTool.includeRuntime().noReflect())
+            .getForConfiguration(kotlinc, targetVersion);
+    return ImmutableList.of(kotlinJarFile, getJavaJarFile());
+  }
+
+  private String getTestName() {
+    return "lambdas_kstyle_generics";
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingSingletonTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingSingletonTest.java
new file mode 100644
index 0000000..72abfe3
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingSingletonTest.java
@@ -0,0 +1,155 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin.lambda;
+
+import static com.android.tools.r8.utils.PredicateUtils.not;
+import static junit.framework.TestCase.assertEquals;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assume.assumeFalse;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Sets;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+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 KotlinLambdaMergingSingletonTest extends KotlinTestBase {
+
+  private final boolean allowAccessModification;
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}, {1}, allow access modification: {2}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters()
+            .withCfRuntime(CfVm.last())
+            .withDexRuntime(Version.last())
+            .withAllApiLevels()
+            .build(),
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values());
+  }
+
+  public KotlinLambdaMergingSingletonTest(
+      TestParameters parameters,
+      KotlinTestParameters kotlinParameters,
+      boolean allowAccessModification) {
+    super(kotlinParameters);
+    this.allowAccessModification = allowAccessModification;
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testJVM() throws Exception {
+    assumeFalse(allowAccessModification);
+    assumeTrue(parameters.isCfRuntime());
+    assumeTrue(kotlinParameters.isFirst());
+    testForJvm()
+        .addProgramFiles(getProgramFiles())
+        .run(parameters.getRuntime(), getMainClassName())
+        .assertSuccessWithOutput(getExpectedOutput());
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramFiles(getProgramFiles())
+        .addKeepMainRule(getMainClassName())
+        .addDontWarnJetBrainsAnnotations()
+        .addHorizontallyMergedClassesInspector(this::inspect)
+        .allowAccessModification(allowAccessModification)
+        .allowDiagnosticWarningMessages()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .assertAllWarningMessagesMatch(
+            containsString("Resource 'META-INF/MANIFEST.MF' already exists."))
+        .run(parameters.getRuntime(), getMainClassName())
+        .assertSuccessWithOutput(getExpectedOutput());
+  }
+
+  private void inspect(HorizontallyMergedClassesInspector inspector) throws IOException {
+    // Get the Kotlin lambdas in the input.
+    KotlinLambdasInInput lambdasInInput =
+        KotlinLambdasInInput.create(getProgramFiles(), getTestName());
+    assertEquals(2, lambdasInInput.getNumberOfJStyleLambdas());
+    assertEquals(7, lambdasInInput.getNumberOfKStyleLambdas());
+
+    // All J-style Kotlin lambdas should be merged into one class.
+    inspector.assertIsCompleteMergeGroup(lambdasInInput.getJStyleLambdas());
+
+    // A subset of the K-style Kotlin lambdas should be merged into one class.
+    Set<ClassReference> kStyleLambdaMergeGroup =
+        Sets.newHashSet(
+            lambdasInInput.getKStyleLambdaReferenceFromTypeName(
+                getTestName(), "MainKt$test2$$inlined$process$1"),
+            lambdasInInput.getKStyleLambdaReferenceFromTypeName(
+                getTestName(), "MainKt$test2$$inlined$process$2"),
+            lambdasInInput.getKStyleLambdaReferenceFromTypeName(
+                getTestName(), "MainKt$test2$$inlined$process$3"),
+            lambdasInInput.getKStyleLambdaReferenceFromTypeName(
+                getTestName(), "MainKt$test2$$inlined$process$4"));
+    if (allowAccessModification) {
+      kStyleLambdaMergeGroup.add(
+          lambdasInInput.getKStyleLambdaReferenceFromTypeName(
+              getTestName(), "MainKt$test2$lambda$1"));
+    }
+    inspector.assertIsCompleteMergeGroup(kStyleLambdaMergeGroup);
+
+    // The remaining lambdas are not merged.
+    inspector.assertClassReferencesNotMerged(
+        lambdasInInput.getAllLambdas().stream()
+            .filter(not(lambdasInInput::isJStyleLambda))
+            .filter(not(kStyleLambdaMergeGroup::contains))
+            .collect(Collectors.toSet()));
+  }
+
+  private String getExpectedOutput() {
+    return StringUtils.lines(
+        "(*000*001*002*003*004*005*006*007*008*009*)",
+        "(*000*001*002*003*004*005*006*007*008*009*)",
+        "(*010*011*)",
+        "(*012*013*014*)",
+        "(*015*016*)",
+        "(*017*018*019*)");
+  }
+
+  private Path getJavaJarFile() {
+    return getJavaJarFile(getTestName());
+  }
+
+  private String getMainClassName() {
+    return getTestName() + ".MainKt";
+  }
+
+  private List<Path> getProgramFiles() {
+    Path kotlinJarFile =
+        getCompileMemoizer(getKotlinFilesInResource(getTestName()), getTestName())
+            .configure(kotlinCompilerTool -> kotlinCompilerTool.includeRuntime().noReflect())
+            .getForConfiguration(kotlinc, targetVersion);
+    return ImmutableList.of(kotlinJarFile, getJavaJarFile());
+  }
+
+  private String getTestName() {
+    return "lambdas_singleton";
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTest.java
deleted file mode 100644
index 4997fe3..0000000
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTest.java
+++ /dev/null
@@ -1,580 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.kotlin.lambda;
-
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
-import static com.google.common.base.Predicates.alwaysTrue;
-import static junit.framework.TestCase.assertEquals;
-import static junit.framework.TestCase.assertTrue;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.fail;
-
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.optimize.lambda.CaptureSignature;
-import com.android.tools.r8.kotlin.AbstractR8KotlinTestBase;
-import com.android.tools.r8.utils.BooleanUtils;
-import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.google.common.collect.Lists;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-@RunWith(Parameterized.class)
-public class KotlinLambdaMergingTest extends AbstractR8KotlinTestBase {
-  private static final String KOTLIN_FUNCTION_IFACE = "Lkotlin/jvm/functions/Function";
-  private static final String KOTLIN_FUNCTION_IFACE_STR = "kotlin.jvm.functions.Function";
-
-  private void configure(InternalOptions options) {
-    options.enableClassInlining = false;
-    // The test checks that the generated lambdas inherit from Function, which is not true if
-    // the unused interface removal is enabled.
-    options.enableUnusedInterfaceRemoval = enableUnusedInterfaceRemoval;
-    // Ensure that enclosing method and inner class attributes are kept even on classes that are
-    // not explicitly mentioned by a keep rule.
-    options.forceProguardCompatibility = true;
-    options.horizontalClassMergerOptions().disableKotlinLambdaMerging();
-  }
-
-  private final boolean enableUnusedInterfaceRemoval;
-
-  @Parameterized.Parameters(
-      name =
-          "target: {0}, kotlinc: {1}, allow access modification: {2}, unused interface removal:"
-              + " {3}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        KotlinTargetVersion.values(),
-        getKotlinCompilers(),
-        BooleanUtils.values(),
-        BooleanUtils.values());
-  }
-
-  public KotlinLambdaMergingTest(
-      KotlinTargetVersion targetVersion,
-      KotlinCompiler kotlinc,
-      boolean allowAccessModification,
-      boolean enableUnusedInterfaceRemoval) {
-    super(targetVersion, kotlinc, allowAccessModification);
-    this.enableUnusedInterfaceRemoval = enableUnusedInterfaceRemoval;
-  }
-
-  abstract static class LambdaOrGroup {
-    abstract boolean match(DexClass clazz);
-  }
-
-  static class Group extends LambdaOrGroup {
-    final String pkg;
-    final String capture;
-    final int arity;
-    final String sam;
-    final int singletons;
-
-    private Group(String pkg, String capture, int arity, String sam, int singletons) {
-      this.pkg = pkg;
-      this.capture = fixCapture(capture);
-      this.arity = arity;
-      this.sam = sam;
-      this.singletons = singletons;
-    }
-
-    private String fixCapture(String capture) {
-      capture += "I";
-      char[] chars = capture.toCharArray();
-      Arrays.sort(chars);
-      return new String(chars);
-    }
-
-    @Override
-    public String toString() {
-      return "group class " +
-          (pkg.length() == 0 ? "" : pkg + "/") +
-          "-$$LambdaGroup$XXXX (arity: " + arity +
-          ", capture: " + capture + ", iface: " + sam + ", sing: " + singletons + ")";
-    }
-
-    @Override
-    boolean match(DexClass clazz) {
-      return clazz.type.getPackageDescriptor().equals(pkg) &&
-          getLambdaOrGroupCapture(clazz).equals(capture) &&
-          getLambdaSam(clazz).equals(sam) &&
-          getLambdaSingletons(clazz) == singletons &&
-          getLambdaOrGroupArity(clazz) == arity;
-    }
-  }
-
-  private static Group kstyleImpl(String pkg, String capture, int arity, int singletons) {
-    return new Group(pkg, capture, arity, KOTLIN_FUNCTION_IFACE_STR + arity, singletons);
-  }
-
-  static Group kstyle(String pkg, int arity) {
-    return kstyleImpl(pkg, "", arity, 0);
-  }
-
-  static Group kstyle(String pkg, int arity, int singletons) {
-    assertTrue(singletons != 0);
-    return kstyleImpl(pkg, "", arity, singletons);
-  }
-
-  private static Group kstyle(String pkg, String capture, int arity) {
-    assertFalse(capture.isEmpty());
-    return kstyleImpl(pkg, capture, arity, 0);
-  }
-
-  private static Group jstyleImpl(
-      String pkg, String capture, int arity, String sam, int singletons) {
-    assertTrue(capture.isEmpty() || singletons == 0);
-    return new Group(pkg, capture, arity, sam, singletons);
-  }
-
-  private static Group jstyle(String pkg, String capture, int arity, String sam) {
-    return jstyleImpl(pkg, capture, arity, sam, 0);
-  }
-
-  private static Group jstyle(String pkg, int arity, String sam, int singletons) {
-    return jstyleImpl(pkg, "", arity, sam, singletons);
-  }
-
-  static class Lambda extends LambdaOrGroup {
-    final String pkg;
-    final String name;
-    final int arity;
-
-    Lambda(String pkg, String name, int arity) {
-      this.pkg = pkg;
-      this.name = name;
-      this.arity = arity;
-    }
-
-    @Override
-    public String toString() {
-      return "lambda class " +
-          (pkg.length() == 0 ? "" : pkg + "/") +
-          name + " (arity: " + arity + ")";
-    }
-
-    @Override
-    boolean match(DexClass clazz) {
-      return clazz.type.getPackageDescriptor().equals(pkg) &&
-          clazz.type.getName().equals(name) &&
-          getLambdaOrGroupArity(clazz) == arity;
-    }
-  }
-
-  static class Verifier {
-    final CodeInspector codeInspector;
-    final List<DexClass> lambdas = new ArrayList<>();
-    final List<DexClass> groups = new ArrayList<>();
-
-    Verifier(CodeInspector codeInspector) {
-      this.codeInspector = codeInspector;
-      initGroupsAndLambdas();
-    }
-
-    private void initGroupsAndLambdas() {
-      codeInspector.forAllClasses(
-          clazz -> {
-            DexClass dexClass = clazz.getDexProgramClass();
-            if (isLambdaOrGroup(dexClass)) {
-              if (isLambdaGroupClass(dexClass)) {
-                groups.add(dexClass);
-              } else {
-                lambdas.add(dexClass);
-              }
-            }
-          });
-    }
-
-    void assertLambdaGroups(Group... groups) {
-      assertLambdasOrGroups("Lambda group", this.groups, groups);
-    }
-
-    void assertLambdas(Lambda... lambdas) {
-      assertLambdasOrGroups("Lambda", this.lambdas, lambdas);
-    }
-
-    @SafeVarargs
-    private static <T extends LambdaOrGroup>
-    void assertLambdasOrGroups(String what, List<DexClass> objects, T... checks) {
-      ArrayList<DexClass> list = Lists.newArrayList(objects);
-      for (int i = 0; i < checks.length; i++) {
-        T check = checks[i];
-        for (DexClass clazz : list) {
-          if (check.match(clazz)) {
-            // Validate static initializer.
-            if (check instanceof Group) {
-              assertEquals(
-                  clazz.getMethodCollection().numberOfDirectMethods(),
-                  ((Group) check).singletons == 0 ? 1 : 2);
-            }
-
-            list.remove(clazz);
-            checks[i] = null;
-            break;
-          }
-        }
-      }
-
-      int notFound = 0;
-      for (T check : checks) {
-        if (check != null) {
-          System.err.println(what + " not found: " + check);
-          notFound++;
-        }
-      }
-
-      for (DexClass dexClass : list) {
-        System.err.println(what + " unexpected: " +
-            dexClass.type.descriptor.toString() +
-            ", arity: " + getLambdaOrGroupArity(dexClass) +
-            ", capture: " + getLambdaOrGroupCapture(dexClass) +
-            ", sam: " + getLambdaSam(dexClass) +
-            ", sing: " + getLambdaSingletons(dexClass));
-        notFound++;
-      }
-
-      assertTrue(what + "s match failed", 0 == notFound && 0 == list.size());
-    }
-  }
-
-  private static int getLambdaOrGroupArity(DexClass clazz) {
-    if (isKStyleLambdaOrGroup(clazz)) {
-      for (DexType iface : clazz.interfaces.values) {
-        String descr = iface.descriptor.toString();
-        if (descr.startsWith(KOTLIN_FUNCTION_IFACE)) {
-          return Integer.parseInt(
-              descr.substring(KOTLIN_FUNCTION_IFACE.length(), descr.length() - 1));
-        }
-      }
-
-    } else {
-      assertTrue(isJStyleLambdaOrGroup(clazz));
-      // Taking the number of any virtual method parameters seems to be good enough.
-      assertTrue(clazz.getMethodCollection().hasVirtualMethods());
-      return clazz.lookupVirtualMethod(alwaysTrue()).method.proto.parameters.size();
-    }
-    fail("Failed to get arity for " + clazz.type.descriptor.toString());
-    throw new AssertionError();
-  }
-
-  private static String getLambdaSam(DexClass clazz) {
-    assertEquals(1, clazz.interfaces.size());
-    return clazz.interfaces.values[0].toSourceString();
-  }
-
-  private static int getLambdaSingletons(DexClass clazz) {
-    assertEquals(1, clazz.interfaces.size());
-    return clazz.staticFields().size();
-  }
-
-  private static boolean isLambdaOrGroup(DexClass clazz) {
-    return !clazz.type.getPackageDescriptor().startsWith("kotlin") &&
-        (isKStyleLambdaOrGroup(clazz) || isJStyleLambdaOrGroup(clazz));
-  }
-
-  private static boolean isKStyleLambdaOrGroup(DexClass clazz) {
-    return clazz.superType.descriptor.toString().equals("Lkotlin/jvm/internal/Lambda;");
-  }
-
-  private static boolean isJStyleLambdaOrGroup(DexClass clazz) {
-    return clazz.superType.descriptor.toString().equals("Ljava/lang/Object;") &&
-        clazz.interfaces.size() == 1;
-  }
-
-  private static boolean isLambdaGroupClass(DexClass clazz) {
-    return clazz.type.getName().startsWith("-$$LambdaGroup$");
-  }
-
-  private static String getLambdaOrGroupCapture(DexClass clazz) {
-    return CaptureSignature.getCaptureSignature(clazz.instanceFields());
-  }
-
-  @Test
-  public void testTrivialKs() throws Exception {
-    final String mainClassName = "lambdas_kstyle_trivial.MainKt";
-    runTest(
-            "lambdas_kstyle_trivial",
-            mainClassName,
-            testBuilder ->
-                testBuilder
-                    .addKeepRules(
-                        "-keepunusedarguments class * extends kotlin.jvm.internal.Lambda {"
-                            + " invoke(int, short); }")
-                    .addDontWarnJetBrainsNotNullAnnotation()
-                    .addOptionsModification(this::configure))
-        .inspect(
-            inspector -> {
-              if (enableUnusedInterfaceRemoval) {
-                // Only test that the code generates the same output as the input code does on the
-                // JVM.
-                return;
-              }
-
-              Verifier verifier = new Verifier(inspector);
-              String pkg = "lambdas_kstyle_trivial";
-
-              verifier.assertLambdaGroups(
-                  allowAccessModification
-                      ? new Group[] {
-                        kstyle("", 0, 4),
-                        kstyle("", 1, 9),
-                        kstyle("", 2, 2), // -\
-                        kstyle("", 2, 5), // - 3 groups different by main method
-                        kstyle("", 2, 4), // -/
-                        kstyle("", 3, 2),
-                        kstyle("", 22, 2)
-                      }
-                      : new Group[] {
-                        kstyle(pkg, 0, 2),
-                        kstyle(pkg, 1, 5),
-                        kstyle(pkg, 2, 5), // - 2 groups different by main method
-                        kstyle(pkg, 2, 4), // -/
-                        kstyle(pkg, 3, 2),
-                        kstyle(pkg, 22, 2),
-                        kstyle(pkg + "/inner", 0, 2),
-                        kstyle(pkg + "/inner", 1, 4)
-                      });
-
-              verifier.assertLambdas(
-                  allowAccessModification
-                      ? new Lambda[] {}
-                      : new Lambda[] {
-                        new Lambda(pkg, "MainKt$testStateless$8", 2),
-                        new Lambda(pkg + "/inner", "InnerKt$testInnerStateless$7", 2)
-                      });
-            });
-  }
-
-  @Test
-  public void testCapturesKs() throws Exception {
-    final String mainClassName = "lambdas_kstyle_captures.MainKt";
-    runTest(
-            "lambdas_kstyle_captures",
-            mainClassName,
-            testBuilder ->
-                testBuilder
-                    .addDontWarnJetBrainsAnnotations()
-                    .addOptionsModification(this::configure))
-        .inspect(
-            inspector -> {
-              if (enableUnusedInterfaceRemoval) {
-                // Only test that the code generates the same output as the input code does on the
-                // JVM.
-                return;
-              }
-
-              Verifier verifier = new Verifier(inspector);
-              String pkg = "lambdas_kstyle_captures";
-              String grpPkg = allowAccessModification ? "" : pkg;
-
-              verifier.assertLambdaGroups(
-                  kstyle(grpPkg, "LLL", 0),
-                  kstyle(grpPkg, "ILL", 0),
-                  kstyle(grpPkg, "III", 0),
-                  kstyle(grpPkg, "BCDFIJLLLLSZ", 0),
-                  kstyle(grpPkg, "BCDFIJLLSZ", 0));
-
-              verifier.assertLambdas(
-                  new Lambda(pkg, "MainKt$test1$15", 0),
-                  new Lambda(pkg, "MainKt$test2$10", 0),
-                  new Lambda(pkg, "MainKt$test2$11", 0),
-                  new Lambda(pkg, "MainKt$test2$9", 0));
-            });
-  }
-
-  @Test
-  public void testGenericsNoSignatureKs() throws Exception {
-    final String mainClassName = "lambdas_kstyle_generics.MainKt";
-    runTest(
-            "lambdas_kstyle_generics",
-            mainClassName,
-            testBuilder ->
-                testBuilder
-                    .addDontWarnJetBrainsAnnotations()
-                    .addOptionsModification(this::configure))
-        .inspect(
-            inspector -> {
-              if (enableUnusedInterfaceRemoval) {
-                // Only test that the code generates the same output as the input code does on the
-                // JVM.
-                return;
-              }
-
-              Verifier verifier = new Verifier(inspector);
-              String pkg = "lambdas_kstyle_generics";
-              String grpPkg = allowAccessModification ? "" : pkg;
-
-              verifier.assertLambdaGroups(
-                  kstyle(grpPkg, 1, 3), // Group for Any
-                  kstyle(grpPkg, "L", 1), // Group for Beta
-                  kstyle(grpPkg, "LS", 1), // Group for Gamma
-                  kstyle(grpPkg, 1, 2) // Group for int
-                  );
-
-              verifier.assertLambdas(new Lambda(pkg, "MainKt$main$4", 1));
-            });
-  }
-
-  @Test
-  public void testInnerClassesAndEnclosingMethodsKs() throws Exception {
-    final String mainClassName = "lambdas_kstyle_generics.MainKt";
-    runTest(
-            "lambdas_kstyle_generics",
-            mainClassName,
-            testBuilder ->
-                testBuilder
-                    .addDontWarnJetBrainsAnnotations()
-                    .addKeepAttributeInnerClassesAndEnclosingMethod()
-                    .addOptionsModification(this::configure))
-        .inspect(
-            inspector -> {
-              if (enableUnusedInterfaceRemoval) {
-                // Only test that the code generates the same output as the input code does on the
-                // JVM.
-                return;
-              }
-
-              Verifier verifier = new Verifier(inspector);
-              String pkg = "lambdas_kstyle_generics";
-              String grpPkg = allowAccessModification ? "" : pkg;
-
-              verifier.assertLambdaGroups(
-                  kstyle(grpPkg, 1, 3), // Group for Any
-                  kstyle(grpPkg, "L", 1), // Group for Beta   // First
-                  kstyle(grpPkg, "L", 1), // Group for Beta   // Second
-                  kstyle(grpPkg, "LS", 1), // Group for Gamma // First
-                  kstyle(grpPkg, "LS", 1), // Group for Gamma // Second
-                  kstyle(grpPkg, 1, 2) // Group for int
-                  );
-
-              verifier.assertLambdas(new Lambda(pkg, "MainKt$main$4", 1));
-            });
-  }
-
-  @Test
-  public void testGenericsSignatureInnerEnclosingKs() throws Exception {
-    final String mainClassName = "lambdas_kstyle_generics.MainKt";
-    runTest(
-            "lambdas_kstyle_generics",
-            mainClassName,
-            // KEEP_SIGNATURE_INNER_ENCLOSING,
-            testBuilder ->
-                testBuilder
-                    .addDontWarnJetBrainsAnnotations()
-                    .addKeepAttributeInnerClassesAndEnclosingMethod()
-                    .addKeepAttributeSignature()
-                    .addOptionsModification(this::configure))
-        .inspect(
-            inspector -> {
-              if (enableUnusedInterfaceRemoval) {
-                // Only test that the code generates the same output as the input code does on the
-                // JVM.
-                return;
-              }
-
-              Verifier verifier = new Verifier(inspector);
-              String pkg = "lambdas_kstyle_generics";
-              String grpPkg = allowAccessModification ? "" : pkg;
-
-              verifier.assertLambdaGroups(
-                  kstyle(grpPkg, 1, 3), // Group for Any
-                  kstyle(grpPkg, "L", 1), // Group for Beta in First
-                  kstyle(grpPkg, "L", 1), // Group for Beta in Second
-                  kstyle(grpPkg, "LS", 1), // Group for Gamma<String> in First
-                  kstyle(grpPkg, "LS", 1), // Group for Gamma<Integer> in First
-                  kstyle(grpPkg, "LS", 1), // Group for Gamma<String> in Second
-                  kstyle(grpPkg, "LS", 1), // Group for Gamma<Integer> in Second
-                  kstyle(grpPkg, 1, 2) // Group for int
-                  );
-
-              verifier.assertLambdas(new Lambda(pkg, "MainKt$main$4", 1));
-            });
-  }
-
-  @Test
-  public void testTrivialJs() throws Exception {
-    final String mainClassName = "lambdas_jstyle_trivial.MainKt";
-    runTest(
-            "lambdas_jstyle_trivial",
-            mainClassName,
-            testBuilder ->
-                testBuilder
-                    .addDontWarnJetBrainsAnnotations()
-                    .addOptionsModification(this::configure))
-        .inspect(
-            inspector -> {
-              Verifier verifier = new Verifier(inspector);
-              String pkg = "lambdas_jstyle_trivial";
-              String grp = allowAccessModification ? "" : pkg;
-
-              String supplier = "lambdas_jstyle_trivial.Lambdas$Supplier";
-              String intSupplier = "lambdas_jstyle_trivial.Lambdas$IntSupplier";
-              String consumer = "lambdas_jstyle_trivial.Lambdas$Consumer";
-              String intConsumer = "lambdas_jstyle_trivial.Lambdas$IntConsumer";
-              String multiFunction = "lambdas_jstyle_trivial.Lambdas$MultiFunction";
-
-              verifier.assertLambdaGroups(
-                  jstyle(grp, 0, intSupplier, 2),
-                  jstyle(grp, "L", 0, supplier),
-                  jstyle(grp, "LL", 0, supplier),
-                  jstyle(grp, "LLL", 0, supplier),
-                  jstyle(grp, 1, intConsumer, allowAccessModification ? 3 : 2),
-                  jstyle(grp, "I", 1, consumer),
-                  jstyle(grp, "II", 1, consumer),
-                  jstyle(grp, "III", 1, consumer),
-                  jstyle(grp, "IIII", 1, consumer),
-                  jstyle(grp, 3, multiFunction, 2),
-                  jstyle(grp, 3, multiFunction, 2),
-                  jstyle(grp, 3, multiFunction, 4),
-                  jstyle(grp, 3, multiFunction, 6));
-
-              verifier.assertLambdas(
-                  allowAccessModification
-                      ? new Lambda[] {
-                        new Lambda(pkg + "/inner", "InnerKt$testInner1$4", 1),
-                        new Lambda(pkg + "/inner", "InnerKt$testInner1$5", 1)
-                      }
-                      : new Lambda[] {
-                        new Lambda(pkg + "/inner", "InnerKt$testInner1$1", 1),
-                        new Lambda(pkg + "/inner", "InnerKt$testInner1$2", 1),
-                        new Lambda(pkg + "/inner", "InnerKt$testInner1$3", 1),
-                        new Lambda(pkg + "/inner", "InnerKt$testInner1$4", 1),
-                        new Lambda(pkg + "/inner", "InnerKt$testInner1$5", 1)
-                      });
-            });
-  }
-
-  @Test
-  public void testSingleton() throws Exception {
-    final String mainClassName = "lambdas_singleton.MainKt";
-    runTest(
-            "lambdas_singleton",
-            mainClassName,
-            testBuilder ->
-                testBuilder
-                    .addDontWarnJetBrainsAnnotations()
-                    .addOptionsModification(this::configure)
-                    .noHorizontalClassMerging())
-        .inspect(
-            inspector -> {
-              Verifier verifier = new Verifier(inspector);
-              String pkg = "lambdas_singleton";
-              String grp = allowAccessModification ? "" : pkg;
-
-              verifier.assertLambdaGroups(
-                  kstyle(grp, 1 /* 1 out of 5 lambdas in the group */),
-                  jstyle(grp, 2, "java.util.Comparator", 0 /* 0 out of 2 lambdas in the group */));
-
-              verifier.assertLambdas(/* None */ );
-            });
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTrivialJavaStyleTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTrivialJavaStyleTest.java
new file mode 100644
index 0000000..1e83c00
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTrivialJavaStyleTest.java
@@ -0,0 +1,210 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin.lambda;
+
+import static com.android.tools.r8.utils.PredicateUtils.not;
+import static junit.framework.TestCase.assertEquals;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assume.assumeFalse;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+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 KotlinLambdaMergingTrivialJavaStyleTest extends KotlinTestBase {
+
+  private final boolean allowAccessModification;
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}, {1}, allow access modification: {2}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters()
+            .withCfRuntime(CfVm.last())
+            .withDexRuntime(Version.last())
+            .withAllApiLevels()
+            .build(),
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values());
+  }
+
+  public KotlinLambdaMergingTrivialJavaStyleTest(
+      TestParameters parameters,
+      KotlinTestParameters kotlinParameters,
+      boolean allowAccessModification) {
+    super(kotlinParameters);
+    this.allowAccessModification = allowAccessModification;
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testJVM() throws Exception {
+    assumeFalse(allowAccessModification);
+    assumeTrue(parameters.isCfRuntime());
+    assumeTrue(kotlinParameters.isFirst());
+    testForJvm()
+        .addProgramFiles(getProgramFiles())
+        .run(parameters.getRuntime(), getMainClassName())
+        .assertSuccessWithOutput(getExpectedOutput());
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramFiles(getProgramFiles())
+        .addKeepMainRule(getMainClassName())
+        .addDontWarnJetBrainsAnnotations()
+        .addHorizontallyMergedClassesInspector(this::inspect)
+        .allowAccessModification(allowAccessModification)
+        .allowDiagnosticWarningMessages()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .assertAllWarningMessagesMatch(
+            containsString("Resource 'META-INF/MANIFEST.MF' already exists."))
+        .run(parameters.getRuntime(), getMainClassName())
+        .assertSuccessWithOutput(getExpectedOutput());
+  }
+
+  private void inspect(HorizontallyMergedClassesInspector inspector) throws IOException {
+    // Get the Kotlin lambdas in the input.
+    KotlinLambdasInInput lambdasInInput =
+        KotlinLambdasInInput.create(getProgramFiles(), getTestName());
+    assertEquals(39, lambdasInInput.getNumberOfJStyleLambdas());
+    assertEquals(0, lambdasInInput.getNumberOfKStyleLambdas());
+
+    if (!allowAccessModification) {
+      // Only a subset of all J-style Kotlin lambdas are merged without -allowaccessmodification.
+      Set<ClassReference> unmergedLambdas =
+          ImmutableSet.of(
+              lambdasInInput.getJStyleLambdaReferenceFromTypeName(
+                  getTestName(), "inner.InnerKt$testInner1$1"),
+              lambdasInInput.getJStyleLambdaReferenceFromTypeName(
+                  getTestName(), "inner.InnerKt$testInner1$2"),
+              lambdasInInput.getJStyleLambdaReferenceFromTypeName(
+                  getTestName(), "inner.InnerKt$testInner1$3"),
+              lambdasInInput.getJStyleLambdaReferenceFromTypeName(
+                  getTestName(), "inner.InnerKt$testInner1$4"),
+              lambdasInInput.getJStyleLambdaReferenceFromTypeName(
+                  getTestName(), "inner.InnerKt$testInner1$5"));
+      inspector
+          .assertClassReferencesMerged(
+              lambdasInInput.getJStyleLambdas().stream()
+                  .filter(not(unmergedLambdas::contains))
+                  .collect(Collectors.toList()))
+          .assertClassReferencesNotMerged(unmergedLambdas);
+      return;
+    }
+
+    // All J-style Kotlin lambdas are merged with -allowaccessmodification.
+    inspector.assertClassReferencesMerged(lambdasInInput.getJStyleLambdas());
+  }
+
+  private String getExpectedOutput() {
+    return StringUtils.lines(
+        "{005:4}",
+        "{007:6}",
+        "009:{008}:{0}",
+        "011:{010}:{0}",
+        "013:{012}:{0}:{1}",
+        "015:{014}:{0}:{1}",
+        "017:{Local(id=016)}:{0}:{1}:{2}",
+        "019:{Local(id=018)}:{0}:{1}:{2}",
+        "021:{Local(id=Local(id=020))}:{0}:{1}:{2}:{3}",
+        "023:{Local(id=Local(id=022))}:{0}:{1}:{2}:{3}",
+        "27",
+        "kotlin.Unit",
+        "28",
+        "kotlin.Unit",
+        "029:024",
+        "kotlin.Unit",
+        "030:024",
+        "kotlin.Unit",
+        "031:024",
+        "kotlin.Unit",
+        "032:024",
+        "kotlin.Unit",
+        "Local(id=033):024:025",
+        "kotlin.Unit",
+        "Local(id=034):024:025",
+        "kotlin.Unit",
+        "Local(id=Local(id=035)):024:025:026",
+        "kotlin.Unit",
+        "Local(id=Local(id=036)):024:025:026",
+        "kotlin.Unit",
+        "037:038:039",
+        "039:037:038",
+        "038:039:037",
+        "Local(id=037):038:039",
+        "Local(id=038):037:039",
+        "037:Local(id=038):039",
+        "037:Local(id=039):038",
+        "Local(id=Local(id=037)):Local(id=Local(id=038)):Local(id=Local(id=039))",
+        "Local(id=Local(id=039)):Local(id=Local(id=037)):Local(id=Local(id=038))",
+        "040:Local(id=041):Local(id=Local(id=042))",
+        "Local(id=Local(id=042)):040:Local(id=041)",
+        "Local(id=041):Local(id=Local(id=042)):040",
+        "Local(id=040):Local(id=041):Local(id=Local(id=042))",
+        "Local(id=Local(id=041)):040:Local(id=Local(id=042))",
+        "040:Local(id=Local(id=041)):Local(id=Local(id=042))",
+        "040:Local(id=Local(id=Local(id=042))):Local(id=041)",
+        "Local(id=Local(id=040)):Local(id=Local(id=Local(id=041))):Local(id=Local(id=Local(id=Local(id=042))))",
+        "Local(id=Local(id=Local(id=Local(id=042)))):Local(id=Local(id=040)):Local(id=Local(id=Local(id=041)))",
+        "043:044:045",
+        "045:043:044",
+        "044:045:043",
+        "Local(id=043):044:045",
+        "Local(id=044):043:045",
+        "046:Local(id=047):Local(id=048)",
+        "Local(id=048):046:Local(id=047)",
+        "Local(id=047):Local(id=048):046",
+        "Local(id=046):Local(id=047):Local(id=048)",
+        "Local(id=Local(id=047)):046:Local(id=048)",
+        "{053:100}",
+        "055:{054}:{49}",
+        "057:{056}:{49}:{50}",
+        "059:{InnerLocal(id=058)}:{49}:{50}:{51}",
+        "061:{InnerLocal(id=InnerLocal(id=060))}:{49}:{50}:{51}:{52");
+  }
+
+  private Path getJavaJarFile() {
+    return getJavaJarFile(getTestName());
+  }
+
+  private String getMainClassName() {
+    return getTestName() + ".MainKt";
+  }
+
+  private List<Path> getProgramFiles() {
+    Path kotlinJarFile =
+        getCompileMemoizer(getKotlinFilesInResource(getTestName()), getTestName())
+            .configure(kotlinCompilerTool -> kotlinCompilerTool.includeRuntime().noReflect())
+            .getForConfiguration(kotlinc, targetVersion);
+    return ImmutableList.of(kotlinJarFile, getJavaJarFile());
+  }
+
+  private String getTestName() {
+    return "lambdas_jstyle_trivial";
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTrivialKotlinStyleTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTrivialKotlinStyleTest.java
new file mode 100644
index 0000000..3515109
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTrivialKotlinStyleTest.java
@@ -0,0 +1,171 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin.lambda;
+
+import static com.android.tools.r8.utils.PredicateUtils.not;
+import static junit.framework.TestCase.assertEquals;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assume.assumeFalse;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+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 KotlinLambdaMergingTrivialKotlinStyleTest extends KotlinTestBase {
+
+  private final boolean allowAccessModification;
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}, {1}, allow access modification: {2}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters()
+            .withCfRuntime(CfVm.last())
+            .withDexRuntime(Version.last())
+            .withAllApiLevels()
+            .build(),
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values());
+  }
+
+  public KotlinLambdaMergingTrivialKotlinStyleTest(
+      TestParameters parameters,
+      KotlinTestParameters kotlinParameters,
+      boolean allowAccessModification) {
+    super(kotlinParameters);
+    this.allowAccessModification = allowAccessModification;
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testJVM() throws Exception {
+    assumeFalse(allowAccessModification);
+    assumeTrue(parameters.isCfRuntime());
+    assumeTrue(kotlinParameters.isFirst());
+    testForJvm()
+        .addProgramFiles(getProgramFiles())
+        .run(parameters.getRuntime(), getMainClassName())
+        .assertSuccessWithOutput(getExpectedOutput());
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramFiles(getProgramFiles())
+        .addKeepMainRule(getMainClassName())
+        .addDontWarnJetBrainsNotNullAnnotation()
+        .addHorizontallyMergedClassesInspector(this::inspect)
+        .allowAccessModification(allowAccessModification)
+        .allowDiagnosticWarningMessages()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .assertAllWarningMessagesMatch(
+            containsString("Resource 'META-INF/MANIFEST.MF' already exists."))
+        .run(parameters.getRuntime(), getMainClassName())
+        .assertSuccessWithOutput(getExpectedOutput());
+  }
+
+  private void inspect(HorizontallyMergedClassesInspector inspector) throws IOException {
+    // Get the Kotlin lambdas in the input.
+    KotlinLambdasInInput lambdasInInput =
+        KotlinLambdasInInput.create(getProgramFiles(), getTestName());
+    assertEquals(0, lambdasInInput.getNumberOfJStyleLambdas());
+    assertEquals(28, lambdasInInput.getNumberOfKStyleLambdas());
+
+    if (!allowAccessModification) {
+      // Only a subset of all K-style Kotlin lambdas are merged without -allowaccessmodification.
+      Set<ClassReference> unmergedLambdas =
+          ImmutableSet.of(
+              lambdasInInput.getKStyleLambdaReferenceFromTypeName(
+                  getTestName(), "inner.InnerKt$testInnerStateless$7"));
+      inspector
+          .assertClassReferencesMerged(
+              lambdasInInput.getKStyleLambdas().stream()
+                  .filter(not(unmergedLambdas::contains))
+                  .collect(Collectors.toList()))
+          .assertClassReferencesNotMerged(unmergedLambdas);
+      return;
+    }
+
+    // All K-style Kotlin lambdas are merged with -allowaccessmodification.
+    inspector.assertClassReferencesMerged(lambdasInInput.getKStyleLambdas());
+  }
+
+  private String getExpectedOutput() {
+    return StringUtils.lines(
+        "first empty",
+        "second empty",
+        "first single",
+        "second single",
+        "third single",
+        "caught: exception#14",
+        "15",
+        "16-17",
+        "181920",
+        "one-two-three",
+        "one-two-...-twentythree",
+        "46474849505152535455565758596061626364656667",
+        "first empty",
+        "second empty",
+        "first single",
+        "second single",
+        "third single",
+        "71",
+        "72-73",
+        "1",
+        "5",
+        "8",
+        "20",
+        "5",
+        "",
+        "kotlin.Unit",
+        "10",
+        "kotlin.Unit",
+        "13",
+        "kotlin.Unit",
+        "14 -- 10",
+        "kotlin.Unit");
+  }
+
+  private Path getJavaJarFile() {
+    return getJavaJarFile(getTestName());
+  }
+
+  private String getMainClassName() {
+    return getTestName() + ".MainKt";
+  }
+
+  private List<Path> getProgramFiles() {
+    Path kotlinJarFile =
+        getCompileMemoizer(getKotlinFilesInResource(getTestName()), getTestName())
+            .configure(kotlinCompilerTool -> kotlinCompilerTool.includeRuntime().noReflect())
+            .getForConfiguration(kotlinc, targetVersion);
+    return ImmutableList.of(kotlinJarFile, getJavaJarFile());
+  }
+
+  private String getTestName() {
+    return "lambdas_kstyle_trivial";
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithReprocessingTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithReprocessingTest.java
index b8fb366..8258582 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithReprocessingTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithReprocessingTest.java
@@ -3,10 +3,8 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.lambda;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
-
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.KotlinTestParameters;
+import com.android.tools.r8.TestShrinkerBuilder;
 import com.android.tools.r8.kotlin.AbstractR8KotlinTestBase;
 import com.android.tools.r8.utils.BooleanUtils;
 import java.util.Collection;
@@ -17,15 +15,16 @@
 @RunWith(Parameterized.class)
 public class KotlinLambdaMergingWithReprocessingTest extends AbstractR8KotlinTestBase {
 
-  @Parameterized.Parameters(name = "target: {0}, kotlinc: {1}, allowAccessModification: {2}")
+  @Parameterized.Parameters(name = "{0}, allowAccessModification: {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
-        KotlinTargetVersion.values(), getKotlinCompilers(), BooleanUtils.values());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values());
   }
 
   public KotlinLambdaMergingWithReprocessingTest(
-      KotlinTargetVersion targetVersion, KotlinCompiler kotlinc, boolean allowAccessModification) {
-    super(targetVersion, kotlinc, allowAccessModification);
+      KotlinTestParameters kotlinParameters, boolean allowAccessModification) {
+    super(kotlinParameters, allowAccessModification);
   }
 
   @Test
@@ -34,14 +33,6 @@
     runTest(
         "reprocess_merged_lambdas_kstyle",
         mainClassName,
-        testBuilder ->
-            testBuilder
-                .addDontWarnJetBrainsNotNullAnnotation()
-                .addOptionsModification(
-                    options -> {
-                      options.enableInlining = true;
-                      options.enableClassInlining = true;
-                      options.enableLambdaMerging = true;
-                    }));
+        TestShrinkerBuilder::addDontWarnJetBrainsNotNullAnnotation);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithSmallInliningBudgetTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithSmallInliningBudgetTest.java
index 5032ea2..087a81b 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithSmallInliningBudgetTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithSmallInliningBudgetTest.java
@@ -3,10 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.lambda;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
-
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.kotlin.AbstractR8KotlinTestBase;
 import com.android.tools.r8.utils.BooleanUtils;
 import java.util.Collection;
@@ -17,15 +14,16 @@
 @RunWith(Parameterized.class)
 public class KotlinLambdaMergingWithSmallInliningBudgetTest extends AbstractR8KotlinTestBase {
 
-  @Parameterized.Parameters(name = "target: {0}, kotlinc: {1}, allowAccessModification: {2}")
+  @Parameterized.Parameters(name = "{0}, allowAccessModification: {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
-        KotlinTargetVersion.values(), getKotlinCompilers(), BooleanUtils.values());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
+        BooleanUtils.values());
   }
 
   public KotlinLambdaMergingWithSmallInliningBudgetTest(
-      KotlinTargetVersion targetVersion, KotlinCompiler kotlinc, boolean allowAccessModification) {
-    super(targetVersion, kotlinc, allowAccessModification);
+      KotlinTestParameters kotlinParameters, boolean allowAccessModification) {
+    super(kotlinParameters, allowAccessModification);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdasInInput.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdasInInput.java
new file mode 100644
index 0000000..3517ff3
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdasInInput.java
@@ -0,0 +1,125 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin.lambda;
+
+import static junit.framework.TestCase.assertTrue;
+
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.SetUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class KotlinLambdasInInput {
+
+  private final Set<ClassReference> jStyleLambdas;
+  private final Set<ClassReference> kStyleLambdas;
+
+  private KotlinLambdasInInput(
+      Set<ClassReference> jStyleLambdas, Set<ClassReference> kStyleLambdas) {
+    this.jStyleLambdas = jStyleLambdas;
+    this.kStyleLambdas = kStyleLambdas;
+  }
+
+  public static KotlinLambdasInInput create(List<Path> programFiles, String testName)
+      throws IOException {
+    CodeInspector inputInspector = new CodeInspector(programFiles);
+    Set<ClassReference> jStyleLambdas = new HashSet<>();
+    Set<ClassReference> kStyleLambdas = new HashSet<>();
+    for (FoundClassSubject classSubject : inputInspector.allClasses()) {
+      DexProgramClass clazz = classSubject.getDexProgramClass();
+      if (!clazz.getType().getPackageName().startsWith(testName)) {
+        continue;
+      }
+      if (internalIsJStyleLambda(clazz)) {
+        jStyleLambdas.add(Reference.classFromTypeName(clazz.getTypeName()));
+      } else if (internalIsKStyleLambda(clazz)) {
+        kStyleLambdas.add(Reference.classFromTypeName(clazz.getTypeName()));
+      }
+    }
+    return new KotlinLambdasInInput(jStyleLambdas, kStyleLambdas);
+  }
+
+  private static boolean internalIsKStyleLambda(DexProgramClass clazz) {
+    return clazz.getSuperType().getTypeName().equals("kotlin.jvm.internal.Lambda");
+  }
+
+  private static boolean internalIsJStyleLambda(DexProgramClass clazz) {
+    if (!clazz.getSuperType().getTypeName().equals(Object.class.getTypeName())
+        || clazz.getInterfaces().size() != 1
+        || clazz.getMethodCollection().numberOfVirtualMethods() == 0) {
+      return false;
+    }
+    if (clazz
+        .getMethodCollection()
+        .hasDirectMethods(method -> method.isStatic() && !method.isClassInitializer())) {
+      return false;
+    }
+    int numberOfFinalNonBridgeNonSyntheticMethods = 0;
+    for (DexEncodedMethod method : clazz.virtualMethods()) {
+      if (method.isFinal() && !method.isBridge() && !method.isSyntheticMethod()) {
+        numberOfFinalNonBridgeNonSyntheticMethods++;
+      }
+    }
+    return numberOfFinalNonBridgeNonSyntheticMethods == 1;
+  }
+
+  public Set<ClassReference> getAllLambdas() {
+    return SetUtils.newIdentityHashSet(jStyleLambdas, kStyleLambdas);
+  }
+
+  public Set<ClassReference> getJStyleLambdas() {
+    return jStyleLambdas;
+  }
+
+  public ClassReference getJStyleLambdaReferenceFromTypeName(String testName, String simpleName) {
+    ClassReference classReference = Reference.classFromTypeName(testName + "." + simpleName);
+    assertTrue(jStyleLambdas.contains(classReference));
+    return classReference;
+  }
+
+  public Set<ClassReference> getKStyleLambdas() {
+    return kStyleLambdas;
+  }
+
+  public ClassReference getKStyleLambdaReferenceFromTypeName(String testName, String simpleName) {
+    ClassReference classReference = Reference.classFromTypeName(testName + "." + simpleName);
+    assertTrue(
+        "Class is not a Kotlin-style lambda: " + classReference.getTypeName(),
+        kStyleLambdas.contains(classReference));
+    return classReference;
+  }
+
+  public int getNumberOfJStyleLambdas() {
+    return jStyleLambdas.size();
+  }
+
+  public int getNumberOfKStyleLambdas() {
+    return kStyleLambdas.size();
+  }
+
+  public boolean isJStyleLambda(ClassReference classReference) {
+    return jStyleLambdas.contains(classReference);
+  }
+
+  public boolean isKStyleLambda(ClassReference classReference) {
+    return kStyleLambdas.contains(classReference);
+  }
+
+  public void print() {
+    System.out.println("Java-style Kotlin lambdas:");
+    jStyleLambdas.forEach(lambda -> System.out.println(lambda.getTypeName()));
+    System.out.println();
+    System.out.println("Kotlin-style Kotlin lambdas:");
+    kStyleLambdas.forEach(lambda -> System.out.println(lambda.getTypeName()));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinxMetadataExtensionsServiceTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinxMetadataExtensionsServiceTest.java
deleted file mode 100644
index 26cc829..0000000
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinxMetadataExtensionsServiceTest.java
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.kotlin.lambda;
-
-import static com.android.tools.r8.ToolHelper.EXAMPLES_KOTLIN_RESOURCE_DIR;
-import static com.android.tools.r8.kotlin.lambda.KotlinLambdaMergingTest.kstyle;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.kotlin.lambda.KotlinLambdaMergingTest.Group;
-import com.android.tools.r8.kotlin.lambda.KotlinLambdaMergingTest.Lambda;
-import com.android.tools.r8.kotlin.lambda.KotlinLambdaMergingTest.Verifier;
-import com.android.tools.r8.utils.AndroidApiLevel;
-import com.android.tools.r8.utils.FileUtils;
-import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.google.common.collect.ImmutableList;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.List;
-import org.junit.Test;
-
-public class KotlinxMetadataExtensionsServiceTest extends TestBase {
-
-  private void forkR8_kstyle_trivial(boolean allowAccessModification) throws Exception {
-    if (!isRunR8Jar()) {
-      return;
-    }
-    Path working = temp.getRoot().toPath();
-    Path kotlinJar =
-        Paths.get(EXAMPLES_KOTLIN_RESOURCE_DIR, "JAVA_8", "lambdas_kstyle_trivial.jar")
-            .toAbsolutePath();
-    Path output = working.resolve("classes.dex");
-    assertFalse(Files.exists(output));
-    Path proguardConfiguration = temp.newFile("test.conf").toPath();
-    List<String> lines = ImmutableList.of(
-        "-keepattributes Signature,InnerClasses,EnclosingMethod",
-        "-keep class **MainKt {",
-        "  public static void main(...);",
-        "}",
-        "-printmapping",
-        "-dontobfuscate",
-        allowAccessModification ? "-allowaccessmodification" : ""
-    );
-    FileUtils.writeTextFile(proguardConfiguration, lines);
-    ProcessResult result = ToolHelper.forkR8Jar(working,
-        "--pg-conf", proguardConfiguration.toString(),
-        "--lib", ToolHelper.getAndroidJar(AndroidApiLevel.O).toAbsolutePath().toString(),
-        kotlinJar.toString());
-    assertEquals(0, result.exitCode);
-    assertThat(result.stderr, not(containsString(
-        "No MetadataExtensions instances found in the classpath")));
-    assertTrue(Files.exists(output));
-
-    CodeInspector inspector = new CodeInspector(output);
-    Verifier verifier = new Verifier(inspector);
-    String pkg = "lambdas_kstyle_trivial";
-    verifier.assertLambdaGroups(
-        allowAccessModification
-            ? new Group[] {
-              kstyle("", 0, 4),
-              kstyle("", 1, 9),
-              kstyle("", 2, 2), // -\
-              kstyle("", 2, 5), // - 3 groups different by main method
-              kstyle("", 2, 4), // -/
-              kstyle("", 3, 2),
-              kstyle("", 22, 2)
-            }
-            : new Group[] {
-              kstyle(pkg, 0, 2),
-              kstyle(pkg, 1, 5),
-              kstyle(pkg, 2, 5), // - 2 groups different by main method
-              kstyle(pkg, 2, 4), // -/
-              kstyle(pkg, 3, 2),
-              kstyle(pkg, 22, 2),
-              kstyle(pkg + "/inner", 0, 2),
-              kstyle(pkg + "/inner", 1, 4)
-            });
-
-    verifier.assertLambdas(
-        allowAccessModification
-            ? new Lambda[] {}
-            : new Lambda[] {
-              new Lambda(pkg, "MainKt$testStateless$8", 2),
-              new Lambda(pkg + "/inner", "InnerKt$testInnerStateless$7", 2)
-            });
-  }
-
-  @Test
-  public void testTrivialKs_allowAccessModification() throws Exception {
-    forkR8_kstyle_trivial(true);
-  }
-
-  @Test
-  public void testTrivialKs_notAllowAccessModification() throws Exception {
-    forkR8_kstyle_trivial(false);
-  }
-
-}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b148525512/B148525512.java b/src/test/java/com/android/tools/r8/kotlin/lambda/b148525512/B148525512.java
index e9f4e46..ac22198 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/b148525512/B148525512.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b148525512/B148525512.java
@@ -4,31 +4,19 @@
 
 package com.android.tools.r8.kotlin.lambda.b148525512;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static junit.framework.TestCase.assertEquals;
-import static junit.framework.TestCase.assertTrue;
 import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 import com.android.tools.r8.DexIndexedConsumer.ArchiveConsumer;
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
 import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.utils.ArchiveResourceProvider;
-import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
-import com.android.tools.r8.utils.codeinspector.InstructionSubject;
-import com.android.tools.r8.utils.codeinspector.MethodSubject;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Collection;
-import java.util.List;
-import java.util.stream.Collectors;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -57,17 +45,15 @@
               });
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withDexRuntimes().withAllApiLevels().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
-  public B148525512(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+  public B148525512(TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
@@ -84,35 +70,6 @@
     }
   }
 
-  private void checkLambdaGroups(CodeInspector inspector) {
-    List<FoundClassSubject> lambdaGroups =
-        inspector.allClasses().stream()
-            .filter(clazz -> clazz.getOriginalName().contains("LambdaGroup"))
-            .collect(Collectors.toList());
-    assertEquals(1, lambdaGroups.size());
-    MethodSubject invokeMethod = lambdaGroups.get(0).uniqueMethodWithName("invoke");
-    assertThat(invokeMethod, isPresent());
-    // The lambda group has 2 captures which capture "Base".
-    assertEquals(
-        2,
-        invokeMethod
-            .streamInstructions()
-            .filter(InstructionSubject::isCheckCast)
-            .filter(
-                instruction ->
-                    instruction.asCheckCast().getType().toSourceString().contains("Base"))
-            .count());
-    // The lambda group has no captures which capture "Feature" (lambdas in the feature are not
-    // in this lambda group).
-    assertTrue(
-        invokeMethod
-            .streamInstructions()
-            .filter(InstructionSubject::isCheckCast)
-            .noneMatch(
-                instruction ->
-                    instruction.asCheckCast().getType().toSourceString().contains("Feature")));
-  }
-
   @Test
   public void test() throws Exception {
     Path featureCode = temp.newFile("feature.zip").toPath();
@@ -125,10 +82,16 @@
             .addKeepClassAndMembersRules(baseClassName)
             .addKeepClassAndMembersRules(featureKtClassNamet)
             .addKeepClassAndMembersRules(FeatureAPI.class)
-            .addOptionsModification(
-                options -> options.horizontalClassMergerOptions().disableKotlinLambdaMerging())
+            .addHorizontallyMergedClassesInspector(
+                inspector ->
+                    inspector
+                        .assertIsCompleteMergeGroup(
+                            "com.android.tools.r8.kotlin.lambda.b148525512.BaseKt$main$1",
+                            "com.android.tools.r8.kotlin.lambda.b148525512.BaseKt$main$2")
+                        .assertIsCompleteMergeGroup(
+                            "com.android.tools.r8.kotlin.lambda.b148525512.FeatureKt$feature$1",
+                            "com.android.tools.r8.kotlin.lambda.b148525512.FeatureKt$feature$2"))
             .setMinApi(parameters.getApiLevel())
-            .noMinification() // The check cast inspection above relies on original names.
             .addFeatureSplit(
                 builder ->
                     builder
@@ -142,10 +105,9 @@
             .addDontWarnJetBrainsNotNullAnnotation()
             .compile()
             .assertAllWarningMessagesMatch(
-                equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
-            .inspect(this::checkLambdaGroups);
+                equalTo("Resource 'META-INF/MANIFEST.MF' already exists."));
 
-    // Run the code without the feature code present.
+    // Run the code without the feature code.
     compileResult
         .run(parameters.getRuntime(), baseKtClassName)
         .assertSuccessWithOutputLines("1", "2");
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java
index c33d03b..8d476be 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java
@@ -11,21 +11,19 @@
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.InternalOptions.HorizontalClassMergerOptions;
-import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
+import com.google.common.collect.ImmutableList;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
-import java.util.stream.Collectors;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -34,36 +32,61 @@
 @RunWith(Parameterized.class)
 public class LambdaGroupGCLimitTest extends TestBase {
 
-  private final boolean enableHorizontalClassMergingOfKotlinLambdas;
-  private final TestParameters parameters;
-  private final int LAMBDA_HOLDER_LIMIT = 50;
-  private final int LAMBDAS_PER_CLASS_LIMIT = 100;
+  private static final int LAMBDA_HOLDER_LIMIT = 50;
+  private static final int LAMBDAS_PER_CLASS_LIMIT = 100;
 
-  @Parameters(name = "{1}, horizontal class merging: {0}")
-  public static List<Object[]> data() {
-    return buildParameters(
-        BooleanUtils.values(), getTestParameters().withDexRuntimes().withAllApiLevels().build());
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDexRuntimes().withAllApiLevels().build();
   }
 
-  public LambdaGroupGCLimitTest(
-      boolean enableHorizontalClassMergingOfKotlinLambdas, TestParameters parameters) {
-    this.enableHorizontalClassMergingOfKotlinLambdas = enableHorizontalClassMergingOfKotlinLambdas;
+  public LambdaGroupGCLimitTest(TestParameters parameters) {
     this.parameters = parameters;
   }
 
   @Test
   public void testR8() throws ExecutionException, CompilationFailedException, IOException {
     String PKG_NAME = LambdaGroupGCLimitTest.class.getPackage().getName();
-    R8FullTestBuilder testBuilder =
+    R8TestCompileResult compileResult =
         testForR8(parameters.getBackend())
-            .addProgramFiles(ToolHelper.getKotlinStdlibJar(ToolHelper.getKotlinC_1_3_72()))
-            .addOptionsModification(
-                options ->
-                    options
-                        .horizontalClassMergerOptions()
-                        .enableKotlinLambdaMergingIf(enableHorizontalClassMergingOfKotlinLambdas))
+            .addProgramFiles(getProgramFiles())
             .setMinApi(parameters.getApiLevel())
-            .noMinification();
+            .apply(
+                builder -> {
+                  for (int mainId = 0; mainId < LAMBDA_HOLDER_LIMIT; mainId++) {
+                    builder.addKeepClassAndMembersRules(PKG_NAME + ".MainKt" + mainId);
+                  }
+                })
+            .addDontWarnJetBrainsNotNullAnnotation()
+            .addHorizontallyMergedClassesInspector(
+                inspector -> {
+                  HorizontalClassMergerOptions defaultHorizontalClassMergerOptions =
+                      new HorizontalClassMergerOptions();
+                  assertEquals(4833, inspector.getSources().size());
+                  assertEquals(167, inspector.getTargets().size());
+                  assertTrue(
+                      inspector.getMergeGroups().stream()
+                          .allMatch(
+                              mergeGroup ->
+                                  mergeGroup.size()
+                                      <= defaultHorizontalClassMergerOptions.getMaxGroupSize()));
+                })
+            .compile();
+    Path path = compileResult.writeToZip();
+    compileResult
+        .run(parameters.getRuntime(), PKG_NAME + ".MainKt0")
+        .assertSuccessWithOutputLines("3");
+    Path oatFile = temp.newFile("out.oat").toPath();
+    ProcessResult processResult =
+        ToolHelper.runDex2OatRaw(path, oatFile, parameters.getRuntime().asDex().getVm());
+    assertEquals(0, processResult.exitCode);
+    assertThat(
+        processResult.stderr, not(containsString("Method exceeds compiler instruction limit")));
+  }
+
+  private List<Path> getProgramFiles() throws IOException {
     Path classFiles = temp.newFile("classes.jar").toPath();
     List<byte[]> classFileData = new ArrayList<>();
     for (int mainId = 0; mainId < LAMBDA_HOLDER_LIMIT; mainId++) {
@@ -71,50 +94,9 @@
       for (int lambdaId = 0; lambdaId < LAMBDAS_PER_CLASS_LIMIT; lambdaId++) {
         classFileData.add(MainKt$main$1Dump.dump(mainId, lambdaId));
       }
-      testBuilder.addKeepClassAndMembersRules(PKG_NAME + ".MainKt" + mainId);
     }
     writeClassFileDataToJar(classFiles, classFileData);
-    R8TestCompileResult compileResult =
-        testBuilder
-            .addProgramFiles(classFiles)
-            .addHorizontallyMergedClassesInspector(
-                inspector -> {
-                  if (enableHorizontalClassMergingOfKotlinLambdas) {
-                    HorizontalClassMergerOptions defaultHorizontalClassMergerOptions =
-                        new HorizontalClassMergerOptions();
-                    assertEquals(4833, inspector.getSources().size());
-                    assertEquals(167, inspector.getTargets().size());
-                    assertTrue(
-                        inspector.getMergeGroups().stream()
-                            .allMatch(
-                                mergeGroup ->
-                                    mergeGroup.size()
-                                        <= defaultHorizontalClassMergerOptions.getMaxGroupSize()));
-                  } else {
-                    inspector.assertNoClassesMerged();
-                  }
-                })
-            .addDontWarnJetBrainsNotNullAnnotation()
-            .compile();
-    Path path = compileResult.writeToZip();
-    compileResult
-        .run(parameters.getRuntime(), PKG_NAME + ".MainKt0")
-        .assertSuccessWithOutputLines("3")
-        .inspect(
-            codeInspector -> {
-              List<FoundClassSubject> lambdaGroups =
-                  codeInspector.allClasses().stream()
-                      .filter(c -> c.getFinalName().contains("LambdaGroup"))
-                      .collect(Collectors.toList());
-              assertEquals(
-                  1 - BooleanUtils.intValue(enableHorizontalClassMergingOfKotlinLambdas),
-                  lambdaGroups.size());
-            });
-    Path oatFile = temp.newFile("out.oat").toPath();
-    ProcessResult processResult =
-        ToolHelper.runDex2OatRaw(path, oatFile, parameters.getRuntime().asDex().getVm());
-    assertEquals(0, processResult.exitCode);
-    assertThat(
-        processResult.stderr, not(containsString("Method exceeds compiler instruction limit")));
+    return ImmutableList.of(
+        classFiles, ToolHelper.getKotlinStdlibJar(ToolHelper.getKotlinC_1_3_72()));
   }
 }
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaSplitByCodeCorrectnessTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaSplitByCodeCorrectnessTest.java
index 663c081..79cef64 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaSplitByCodeCorrectnessTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaSplitByCodeCorrectnessTest.java
@@ -4,24 +4,25 @@
 
 package com.android.tools.r8.kotlin.lambda.b159688129;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestRuntime;
 import com.android.tools.r8.TestRuntime.CfRuntime;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.kotlin.AbstractR8KotlinTestBase;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.DescriptorUtils;
-import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
 import java.nio.file.Path;
 import java.util.List;
-import java.util.stream.Collectors;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -31,26 +32,20 @@
 public class LambdaSplitByCodeCorrectnessTest extends AbstractR8KotlinTestBase {
 
   private final TestParameters parameters;
-  private final KotlinTargetVersion targetVersion;
   private final boolean splitGroup;
 
-  @Parameters(name = "{0}, kotlinc: {2} targetVersion: {1}, splitGroup: {3}")
+  @Parameters(name = "{0}, {1}, splitGroup: {2}")
   public static List<Object[]> data() {
     return buildParameters(
         getTestParameters().withDexRuntimes().withAllApiLevels().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers(),
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
         BooleanUtils.values());
   }
 
   public LambdaSplitByCodeCorrectnessTest(
-      TestParameters parameters,
-      KotlinTargetVersion targetVersion,
-      KotlinCompiler kotlinc,
-      boolean splitGroup) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters, boolean splitGroup) {
+    super(kotlinParameters);
     this.parameters = parameters;
-    this.targetVersion = targetVersion;
     this.splitGroup = splitGroup;
   }
 
@@ -67,8 +62,6 @@
     testForR8(parameters.getBackend())
         .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
         .addProgramFiles(ktClasses)
-        .addOptionsModification(
-            options -> options.horizontalClassMergerOptions().disableKotlinLambdaMerging())
         .setMinApi(parameters.getApiLevel())
         .addKeepMainRule(PKG_NAME + ".SimpleKt")
         .addDontWarnJetBrainsNotNullAnnotation()
@@ -77,25 +70,40 @@
             b ->
                 b.addOptionsModification(
                     internalOptions ->
-                        // Setting verificationSizeLimitInBytesOverride = 1 will force a a chain
-                        // having only a single implementation method in each.
-                        internalOptions.testing.verificationSizeLimitInBytesOverride =
-                            splitGroup ? 1 : -1))
-        .noMinification()
+                        // Setting inliningInstructionAllowance = 1 will force each switch branch to
+                        // contain an invoke instruction to a private method.
+                        internalOptions.inliningInstructionAllowance = 1))
+        .addHorizontallyMergedClassesInspector(
+            inspector ->
+                inspector.assertIsCompleteMergeGroup(
+                    "com.android.tools.r8.kotlin.lambda.b159688129.SimpleKt$main$1",
+                    "com.android.tools.r8.kotlin.lambda.b159688129.SimpleKt$main$2",
+                    "com.android.tools.r8.kotlin.lambda.b159688129.SimpleKt$main$3",
+                    "com.android.tools.r8.kotlin.lambda.b159688129.SimpleKt$main$4",
+                    "com.android.tools.r8.kotlin.lambda.b159688129.SimpleKt$main$5",
+                    "com.android.tools.r8.kotlin.lambda.b159688129.SimpleKt$main$6"))
         .allowDiagnosticWarningMessages()
         .compile()
         .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
         .inspect(
             codeInspector -> {
-              List<FoundClassSubject> lambdaGroups =
-                  codeInspector.allClasses().stream()
-                      .filter(c -> c.getFinalName().contains("LambdaGroup"))
-                      .collect(Collectors.toList());
-              assertEquals(1, lambdaGroups.size());
-              FoundClassSubject lambdaGroup = lambdaGroups.get(0);
-              List<FoundMethodSubject> invokeChain =
-                  lambdaGroup.allMethods(method -> method.getFinalName().contains("invoke$"));
-              assertEquals(splitGroup ? 5 : 0, invokeChain.size());
+              ClassSubject mergeTarget =
+                  codeInspector.clazz(
+                      "com.android.tools.r8.kotlin.lambda.b159688129.SimpleKt$main$1");
+              assertThat(mergeTarget, isPresent());
+
+              MethodSubject virtualMethodSubject =
+                  mergeTarget.uniqueMethodThatMatches(
+                      method -> method.isVirtual() && !method.isSynthetic());
+              assertThat(virtualMethodSubject, isPresent());
+
+              int found = 0;
+              for (FoundMethodSubject directMethodSubject :
+                  mergeTarget.allMethods(x -> x.isPrivate() && !x.isSynthetic())) {
+                assertThat(virtualMethodSubject, invokesMethod(directMethodSubject));
+                found++;
+              }
+              assertEquals(splitGroup ? 6 : 0, found);
             })
         .run(parameters.getRuntime(), PKG_NAME + ".SimpleKt")
         .assertSuccessWithOutputLines("Hello1", "Hello2", "Hello3", "Hello4", "Hello5", "Hello6");
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java b/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java
index e158fc7..3765187 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java
@@ -8,8 +8,7 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertNull;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.kotlin.AbstractR8KotlinTestBase;
 import com.android.tools.r8.kotlin.KotlinMetadataWriter;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -22,8 +21,8 @@
 
 public abstract class KotlinMetadataTestBase extends AbstractR8KotlinTestBase {
 
-  public KotlinMetadataTestBase(KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+  public KotlinMetadataTestBase(KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
   }
 
   static final String PKG = KotlinMetadataTestBase.class.getPackage().getName();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java
index b4fd614..b0a30d7 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java
@@ -4,17 +4,15 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
 
 import com.android.tools.r8.JvmTestRunResult;
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -32,17 +30,16 @@
   private static final String PKG_LIB = PKG + ".primitive_type_rewrite_lib";
   private static final String PKG_APP = PKG + ".primitive_type_rewrite_app";
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, compiler: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataPrimitiveTypeRewriteTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrunedFieldsTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrunedFieldsTest.java
index a048351..09c2a9d 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrunedFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrunedFieldsTest.java
@@ -4,16 +4,14 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.kotlin.metadata.metadata_pruned_fields.Main;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -28,17 +26,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withAllRuntimesAndApiLevels().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataPrunedFieldsTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java
index b6d7701..71bd275 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java
@@ -4,16 +4,14 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static junit.framework.TestCase.assertEquals;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.StringContains.containsString;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringUtils;
@@ -52,17 +50,16 @@
           "staticPrivate",
           "staticInternal");
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteAllowAccessModificationTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java
index a285149..ebe0dac 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java
@@ -4,17 +4,15 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringUtils;
@@ -58,17 +56,16 @@
   private static final String FOO_ORIGINAL_NAME = PKG_LIB + ".Foo";
   private static final String FOO_FINAL_NAME = "a.b.c";
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteAnnotationTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java
index 8db1944..374c3fd 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java
@@ -4,14 +4,12 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
 import static org.hamcrest.MatcherAssert.assertThat;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.kotlin.KotlinMetadataWriter;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -27,17 +25,16 @@
 
   private final String EXPECTED = "foo";
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteAnonymousTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteBoxedTypesTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteBoxedTypesTest.java
index 4e7d224..16d3765 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteBoxedTypesTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteBoxedTypesTest.java
@@ -4,17 +4,15 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static junit.framework.TestCase.assertEquals;
 import static junit.framework.TestCase.assertNotNull;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertNull;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.kotlin.KotlinMetadataWriter;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
@@ -37,17 +35,16 @@
   private final String EXPECTED =
       StringUtils.lines("false", "0", "a", "0.042", "0.42", "42", "442", "1", "2", "42", "42");
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteBoxedTypesTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineAnonFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineAnonFunctionTest.java
index 065d63f..989512b 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineAnonFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineAnonFunctionTest.java
@@ -4,12 +4,9 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
-
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringUtils;
 import java.nio.file.Path;
@@ -25,17 +22,16 @@
   private static final String PKG_LIB = PKG + ".crossinline_anon_lib";
   private static final String PKG_APP = PKG + ".crossinline_anon_app";
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteCrossinlineAnonFunctionTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineConcreteFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineConcreteFunctionTest.java
index 15f68ea..d969f34 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineConcreteFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineConcreteFunctionTest.java
@@ -4,12 +4,9 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
-
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringUtils;
 import java.nio.file.Path;
@@ -25,17 +22,16 @@
   private static final String PKG_LIB = PKG + ".crossinline_concrete_lib";
   private static final String PKG_APP = PKG + ".crossinline_concrete_app";
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteCrossinlineConcreteFunctionTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java
index b43f846..bc8051d 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java
@@ -4,12 +4,9 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
-
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringUtils;
@@ -33,17 +30,16 @@
           "null",
           "New value has been read in CustomDelegate from 'x'");
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteDelegatedPropertyTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDependentKeep.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDependentKeep.java
index 2ccbb3a..3f42968 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDependentKeep.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDependentKeep.java
@@ -4,15 +4,13 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 
 import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -27,19 +25,18 @@
 @RunWith(Parameterized.class)
 public class MetadataRewriteDependentKeep extends KotlinMetadataTestBase {
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   private final TestParameters parameters;
 
   public MetadataRewriteDependentKeep(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDoNotEmitValuesIfEmpty.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDoNotEmitValuesIfEmpty.java
index feca0f8..1caec7d 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDoNotEmitValuesIfEmpty.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDoNotEmitValuesIfEmpty.java
@@ -4,14 +4,12 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.graph.DexAnnotationElement;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.codeinspector.AnnotationSubject;
@@ -29,19 +27,18 @@
 
   private final Set<String> nullableFieldKeys = Sets.newHashSet("pn", "xs", "xi");
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   private final TestParameters parameters;
 
   public MetadataRewriteDoNotEmitValuesIfEmpty(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java
index fbfc10f..91ede26 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java
@@ -4,7 +4,6 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
@@ -12,10 +11,9 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -39,17 +37,16 @@
   private final String EXPECTED = StringUtils.lines("B.foo(): 42");
   private final String PKG_LIB = PKG + ".flexible_upper_bound_lib";
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteFlexibleUpperBoundTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java
index c7b9ea6..eebb77f 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -11,10 +10,9 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -35,17 +33,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInClasspathTypeTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
index bdcb905..9106a3b 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
@@ -12,10 +11,9 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -44,17 +42,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInCompanionTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
index f9124bd..f46402b 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -13,10 +12,9 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -41,17 +39,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInExtensionFunctionTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java
index c78cea1..c2a923f 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionProperty;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
@@ -14,10 +13,9 @@
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -40,17 +38,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInExtensionPropertyTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
index 5c8468d..48044e2 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -13,10 +12,9 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -39,17 +37,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0} target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInFunctionTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java
index db348d0..746c690 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -12,10 +11,9 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -39,17 +37,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInFunctionWithDefaultValueTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java
index 65207dd..262d8a2 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -13,10 +12,9 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -40,17 +38,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInFunctionWithVarargTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInLibraryTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInLibraryTypeTest.java
index f3c59d9..d583ea7 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInLibraryTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInLibraryTypeTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
 import static org.hamcrest.CoreMatchers.anyOf;
@@ -11,10 +10,9 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -32,17 +30,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInLibraryTypeTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java
index 3949d6e..6411cfc 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -16,10 +15,9 @@
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -44,17 +42,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInMultifileClassTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInNestedClassTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInNestedClassTest.java
index 8bb4603..f2aa77d 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInNestedClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInNestedClassTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.DescriptorUtils.descriptorToJavaType;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -12,10 +11,9 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -34,17 +32,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInNestedClassTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java
index f84fa48..abce684 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java
@@ -3,17 +3,15 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -32,17 +30,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInParameterTypeTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
index af4c9b6..693c7fc 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionProperty;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -14,10 +13,9 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -38,17 +36,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInPropertyTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java
index 0113f19..cb18acb 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java
@@ -3,17 +3,15 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -32,17 +30,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInPropertyTypeTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInRenamedTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInRenamedTypeTest.java
index a4a3a68..7badf74 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInRenamedTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInRenamedTypeTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.DescriptorUtils.getDescriptorFromKotlinClassifier;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -12,10 +11,9 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.codeinspector.AnnotationSubject;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -33,17 +31,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withAllRuntimesAndApiLevels().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInRenamedTypeTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java
index c8144f4..dbaf933 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java
@@ -3,17 +3,15 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -32,17 +30,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInReturnTypeTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassNestedTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassNestedTest.java
index db927a8..e479bba 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassNestedTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassNestedTest.java
@@ -3,12 +3,9 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
-
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringUtils;
@@ -31,17 +28,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInSealedClassNestedTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassTest.java
index ef43f6e..5156b72 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.DescriptorUtils.descriptorToJavaType;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
@@ -15,10 +14,9 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
@@ -39,17 +37,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInSealedClassTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSuperTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSuperTypeTest.java
index 9b0da43..ccc94e5 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSuperTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSuperTypeTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
@@ -11,10 +10,9 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -33,17 +31,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInSuperTypeTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
index e680d6e..98102c5 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isDexClass;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -13,10 +12,9 @@
 import static junit.framework.TestCase.assertTrue;
 import static org.hamcrest.MatcherAssert.assertThat;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.kotlin.Kotlin.ClassClassifiers;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -61,17 +59,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInTypeAliasTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java
index acdda5b..097c832 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isDexClass;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
@@ -12,10 +11,9 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -77,17 +75,16 @@
 
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInTypeArgumentsTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlinePropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlinePropertyTest.java
index ac232d7..d5e9e1a 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlinePropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlinePropertyTest.java
@@ -4,15 +4,13 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertNull;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.kotlin.KotlinMetadataWriter;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.StringUtils;
@@ -34,17 +32,16 @@
 
   private final String EXPECTED = StringUtils.lines("true", "false", "false", "true");
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewriteInlinePropertyTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java
index 0558ebc..e03a72c 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java
@@ -3,12 +3,11 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
@@ -40,12 +39,18 @@
 
   @Parameterized.Parameters(name = "{0}, kotlinc: {1}")
   public static List<Object[]> data() {
-    return buildParameters(getTestParameters().withCfRuntimes().build(), getKotlinCompilers());
+    // We are testing static methods on interfaces which requires java 8.
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(),
+        getKotlinTestParameters()
+            .withAllCompilers()
+            .withTargetVersion(KotlinTargetVersion.JAVA_8)
+            .build());
   }
 
-  public MetadataRewriteJvmStaticTest(TestParameters parameters, KotlinCompiler kotlinc) {
-    // We are testing static methods on interfaces which requires java 8.
-    super(KotlinTargetVersion.JAVA_8, kotlinc);
+  public MetadataRewriteJvmStaticTest(
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepPathTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepPathTest.java
index 056b18b..569d2b7 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepPathTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepPathTest.java
@@ -4,17 +4,15 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestShrinkerBuilder;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -26,12 +24,11 @@
 @RunWith(Parameterized.class)
 public class MetadataRewriteKeepPathTest extends KotlinMetadataTestBase {
 
-  @Parameterized.Parameters(name = "{0} target: {1}, kotlinc: {2}, keep: {3}")
+  @Parameterized.Parameters(name = "{0}, {1}, keep: {2}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers(),
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
         BooleanUtils.values());
   }
 
@@ -42,11 +39,8 @@
   private final boolean keepMetadata;
 
   public MetadataRewriteKeepPathTest(
-      TestParameters parameters,
-      KotlinTargetVersion targetVersion,
-      KotlinCompiler kotlinc,
-      boolean keepMetadata) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters, boolean keepMetadata) {
+    super(kotlinParameters);
     this.parameters = parameters;
     this.keepMetadata = keepMetadata;
   }
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepTest.java
index 74159a6..c8dd873 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepTest.java
@@ -4,14 +4,12 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
@@ -23,19 +21,17 @@
 @RunWith(Parameterized.class)
 public class MetadataRewriteKeepTest extends KotlinMetadataTestBase {
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   private final TestParameters parameters;
 
-  public MetadataRewriteKeepTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+  public MetadataRewriteKeepTest(TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java
index 0b65ec3..99586b1 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java
@@ -4,12 +4,9 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
-
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import java.util.Collection;
@@ -20,19 +17,18 @@
 @RunWith(Parameterized.class)
 public class MetadataRewritePassThroughTest extends KotlinMetadataTestBase {
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   private final TestParameters parameters;
 
   public MetadataRewritePassThroughTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePrunedObjectsTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePrunedObjectsTest.java
index 3d3386c..6d4391f 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePrunedObjectsTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePrunedObjectsTest.java
@@ -4,16 +4,14 @@
 
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static junit.framework.TestCase.assertEquals;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -37,17 +35,16 @@
           getKotlinFileInTest(DescriptorUtils.getBinaryNameFromJavaType(PKG_LIB), "lib"));
   private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withCfRuntimes().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public MetadataRewritePrunedObjectsTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
index 1a2cd73..8111567 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.kotlin.metadata;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
@@ -11,11 +10,10 @@
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.codeinspector.AnnotationSubject;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -31,17 +29,15 @@
   private final TestParameters parameters;
   private static final String FOLDER = "lambdas_jstyle_runnable";
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameterized.Parameters(name = "{0}, {1}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withAllRuntimesAndApiLevels().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
-  public MetadataStripTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+  public MetadataStripTest(TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataVersionNumberBumpTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataVersionNumberBumpTest.java
index e23ac8f..a7886b2 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataVersionNumberBumpTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataVersionNumberBumpTest.java
@@ -9,9 +9,9 @@
 import static org.junit.Assert.fail;
 import static org.objectweb.asm.Opcodes.ASM7;
 
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.graph.DexAnnotationElement;
@@ -25,6 +25,7 @@
 import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
 import java.io.IOException;
 import java.util.Arrays;
+import java.util.List;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import org.junit.Test;
@@ -39,12 +40,18 @@
   private final TestParameters parameters;
 
   @Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withAllRuntimesAndApiLevels().build(),
+        getKotlinTestParameters()
+            .withCompiler(getKotlinC_1_3_72())
+            .withTargetVersion(KotlinTargetVersion.JAVA_8)
+            .build());
   }
 
-  public MetadataVersionNumberBumpTest(TestParameters parameters) {
-    super(KotlinTargetVersion.JAVA_8, getKotlinC_1_3_72());
+  public MetadataVersionNumberBumpTest(
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/reflection/KotlinReflectTest.java b/src/test/java/com/android/tools/r8/kotlin/reflection/KotlinReflectTest.java
index ac7eb23..ae80118 100644
--- a/src/test/java/com/android/tools/r8/kotlin/reflection/KotlinReflectTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/reflection/KotlinReflectTest.java
@@ -4,16 +4,14 @@
 
 package com.android.tools.r8.kotlin.reflection;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assume.assumeTrue;
 
 import com.android.tools.r8.DexIndexedConsumer.ArchiveConsumer;
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
 import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.FileUtils;
@@ -29,7 +27,6 @@
 public class KotlinReflectTest extends KotlinTestBase {
 
   private final TestParameters parameters;
-  private final KotlinTargetVersion targetVersion;
   private static final String EXPECTED_OUTPUT = "Hello World!";
   private static final String PKG = KotlinReflectTest.class.getPackage().getName();
   private static final KotlinCompileMemoizer compiledJars =
@@ -40,19 +37,16 @@
               DescriptorUtils.getBinaryNameFromJavaType(PKG),
               "SimpleReflect" + FileUtils.KT_EXTENSION));
 
-  @Parameters(name = "{0}, target: {1}, kotlinc: {2}")
+  @Parameters(name = "{0}, {1}")
   public static List<Object[]> data() {
     return buildParameters(
         getTestParameters().withAllRuntimesAndApiLevels().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
-  public KotlinReflectTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+  public KotlinReflectTest(TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
-    this.targetVersion = targetVersion;
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/kotlin/sealed/SealedClassTest.java b/src/test/java/com/android/tools/r8/kotlin/sealed/SealedClassTest.java
index 92b6b97..47f9463 100644
--- a/src/test/java/com/android/tools/r8/kotlin/sealed/SealedClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/sealed/SealedClassTest.java
@@ -6,15 +6,13 @@
 
 import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
 import static com.android.tools.r8.ToolHelper.getFilesInTestFolderRelativeToClass;
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static org.hamcrest.CoreMatchers.containsString;
 
 import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
 import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.Collection;
@@ -33,17 +31,15 @@
 
   private final TestParameters parameters;
 
-  @Parameters(name = "{0}")
+  @Parameters(name = "{0}, {1}")
   public static List<Object[]> data() {
     return buildParameters(
         getTestParameters().withAllRuntimesAndApiLevels().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
-  public SealedClassTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+  public SealedClassTest(TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningSpuriousRootTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningSpuriousRootTest.java
new file mode 100644
index 0000000..5f21fee
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningSpuriousRootTest.java
@@ -0,0 +1,152 @@
+// Copyright (c) 2021, 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.maindexlist;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.ImmutableSet;
+import java.util.List;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class MainDexListFromGenerateMainDexInliningSpuriousRootTest extends TestBase {
+
+  private static List<ClassReference> mainDexList;
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters()
+        .withDexRuntimes()
+        .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
+        .build();
+  }
+
+  @BeforeClass
+  public static void setup() throws Exception {
+    mainDexList =
+        testForMainDexListGenerator(getStaticTemp())
+            .addInnerClasses(MainDexListFromGenerateMainDexInliningSpuriousRootTest.class)
+            .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
+            .addMainDexRules(
+                "-keep class " + Main.class.getTypeName() + " {",
+                "  public static void main(java.lang.String[]);",
+                "}")
+            .run()
+            .getMainDexList();
+  }
+
+  public MainDexListFromGenerateMainDexInliningSpuriousRootTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    // The generated main dex list should contain Main (which is a root) and A (which is a direct
+    // dependency of Main).
+    assertEquals(2, mainDexList.size());
+    assertEquals(A.class.getTypeName(), mainDexList.get(0).getTypeName());
+    assertEquals(Main.class.getTypeName(), mainDexList.get(1).getTypeName());
+    R8TestCompileResult compileResult =
+        testForR8(parameters.getBackend())
+            .addInnerClasses(getClass())
+            .addInliningAnnotations()
+            .addKeepClassAndMembersRules(Main.class)
+            .addKeepMainRule(Main2.class)
+            .addMainDexListClassReferences(mainDexList)
+            .addMainDexRules(
+                "-keep class " + Main2.class.getTypeName() + " {",
+                "  public static void main(java.lang.String[]);",
+                "}")
+            .collectMainDexClasses()
+            .enableInliningAnnotations()
+            .enableNoHorizontalClassMergingAnnotations()
+            .setMinApi(parameters.getApiLevel())
+            .noMinification()
+            .compile();
+    CodeInspector inspector = compileResult.inspector();
+    ClassSubject mainClassSubject = inspector.clazz(Main.class);
+    assertThat(mainClassSubject, isPresent());
+    MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithName("foo");
+    assertThat(fooMethodSubject, isPresent());
+    ClassSubject main2ClassSubject = inspector.clazz(Main2.class);
+    assertThat(main2ClassSubject, isPresent());
+    ClassSubject aClassSubject = inspector.clazz(A.class);
+    assertThat(aClassSubject, isPresent());
+    MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithName("bar");
+    assertThat(barMethodSubject, isPresent());
+    ClassSubject bClassSubject = inspector.clazz(B.class);
+    assertThat(bClassSubject, isPresent());
+    MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithName("baz");
+    assertThat(bazMethodSubject, isPresent());
+    assertThat(fooMethodSubject, invokesMethod(barMethodSubject));
+    assertThat(barMethodSubject, invokesMethod(bazMethodSubject));
+    assertEquals(
+        ImmutableSet.of(
+            mainClassSubject.getFinalName(),
+            main2ClassSubject.getFinalName(),
+            aClassSubject.getFinalName()),
+        compileResult.getMainDexClasses());
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      System.out.println("Main.main()");
+    }
+
+    static void foo() {
+      A.bar();
+    }
+  }
+
+  static class Main2 {
+
+    public static void main(String[] args) {
+      if (getFalse()) {
+        A.bar();
+      }
+    }
+
+    static boolean getFalse() {
+      return false;
+    }
+  }
+
+  @NoHorizontalClassMerging
+  static class A {
+    // Must not be inlined into Main.foo(), since that would cause B to become direct dependence of
+    // Main without ending up in the main dex.
+    static void bar() {
+      B.baz();
+    }
+  }
+
+  @NoHorizontalClassMerging
+  static class B {
+
+    @NeverInline
+    static void baz() {
+      System.out.println("B.baz");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java
index a76d8cc..98ec426 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningTest.java
@@ -5,7 +5,6 @@
 package com.android.tools.r8.maindexlist;
 
 import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
@@ -21,6 +20,7 @@
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.ImmutableSet;
 import java.util.List;
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -90,12 +90,10 @@
     assertThat(fooMethodSubject, isPresent());
 
     ClassSubject aClassSubject = inspector.clazz(A.class);
-    // TODO(b/178353726): Should be present, but was inlined.
-    assertThat(aClassSubject, isAbsent());
+    assertThat(aClassSubject, isPresent());
 
     MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithName("bar");
-    // TODO(b/178353726): Should be present, but was inlined.
-    assertThat(barMethodSubject, isAbsent());
+    assertThat(barMethodSubject, isPresent());
 
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
@@ -103,16 +101,13 @@
     MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithName("baz");
     assertThat(bazMethodSubject, isPresent());
 
-    // TODO(b/178353726): foo() should invoke bar() and bar() should invoke baz().
-    assertThat(fooMethodSubject, invokesMethod(bazMethodSubject));
+    assertThat(fooMethodSubject, invokesMethod(barMethodSubject));
+    assertThat(barMethodSubject, invokesMethod(bazMethodSubject));
 
-    // TODO(b/178353726): Main is the only class guaranteed to be in the main dex, but it has a
-    //  direct reference to B.
-    compileResult.inspectMainDexClasses(
-        mainDexClasses -> {
-          assertEquals(1, mainDexClasses.size());
-          assertEquals(mainClassSubject.getFinalName(), mainDexClasses.iterator().next());
-        });
+    // The main dex classes should be the same as the input main dex list.
+    assertEquals(
+        ImmutableSet.of(mainClassSubject.getFinalName(), aClassSubject.getFinalName()),
+        compileResult.getMainDexClasses());
   }
 
   static class Main {
@@ -122,8 +117,8 @@
     }
 
     static void foo() {
-      // TODO(b/178353726): Should not allow inlining bar into foo(), since that adds B as a direct
-      //  dependence, and we don't include the direct dependencies of main dex list classes.
+      // Should not allow inlining bar into foo(), since that adds B as a direct
+      // dependence, and we don't include the direct dependencies of main dex list classes.
       A.bar();
     }
   }
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningWithTracingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningWithTracingTest.java
new file mode 100644
index 0000000..f5971f9
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainDexInliningWithTracingTest.java
@@ -0,0 +1,158 @@
+// Copyright (c) 2021, 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.maindexlist;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.ImmutableSet;
+import java.util.List;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class MainDexListFromGenerateMainDexInliningWithTracingTest extends TestBase {
+
+  private static List<ClassReference> mainDexList;
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters()
+        .withDexRuntimes()
+        .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
+        .build();
+  }
+
+  @BeforeClass
+  public static void setup() throws Exception {
+    mainDexList =
+        testForMainDexListGenerator(getStaticTemp())
+            .addInnerClasses(MainDexListFromGenerateMainDexInliningWithTracingTest.class)
+            .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
+            .addMainDexRules(
+                "-keep class " + Main.class.getTypeName() + " {",
+                "  public static void main(java.lang.String[]);",
+                "}")
+            .run()
+            .getMainDexList();
+  }
+
+  public MainDexListFromGenerateMainDexInliningWithTracingTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    // The generated main dex list should contain Main (which is a root) and A (which is a direct
+    // dependency of Main).
+    assertEquals(2, mainDexList.size());
+    assertEquals(A.class.getTypeName(), mainDexList.get(0).getTypeName());
+    assertEquals(Main.class.getTypeName(), mainDexList.get(1).getTypeName());
+
+    R8TestCompileResult compileResult =
+        testForR8(parameters.getBackend())
+            .addInnerClasses(getClass())
+            .addInliningAnnotations()
+            .addKeepClassAndMembersRules(Main.class)
+            .addMainDexListClassReferences(mainDexList)
+            .addMainDexRules(
+                "-keep class " + Main.class.getTypeName() + " {",
+                "  public static void foo(java.lang.String[]);",
+                "}")
+            .collectMainDexClasses()
+            .enableInliningAnnotations()
+            .enableNoHorizontalClassMergingAnnotations()
+            .noMinification()
+            .setMinApi(parameters.getApiLevel())
+            .compile();
+
+    CodeInspector inspector = compileResult.inspector();
+    ClassSubject mainClassSubject = inspector.clazz(Main.class);
+    assertThat(mainClassSubject, isPresent());
+
+    MethodSubject fooMethodSubject = mainClassSubject.uniqueMethodWithName("foo");
+    assertThat(fooMethodSubject, isPresent());
+
+    MethodSubject notCalledAtStartupMethodSubject =
+        mainClassSubject.uniqueMethodWithName("notCalledAtStartup");
+    assertThat(notCalledAtStartupMethodSubject, isPresent());
+
+    ClassSubject aClassSubject = inspector.clazz(A.class);
+    assertThat(aClassSubject, isPresent());
+
+    MethodSubject barMethodSubject = aClassSubject.uniqueMethodWithName("bar");
+    assertThat(barMethodSubject, isPresent());
+
+    ClassSubject bClassSubject = inspector.clazz(B.class);
+    assertThat(bClassSubject, isPresent());
+
+    MethodSubject bazMethodSubject = bClassSubject.uniqueMethodWithName("baz");
+    assertThat(bazMethodSubject, isPresent());
+
+    assertThat(notCalledAtStartupMethodSubject, invokesMethod(barMethodSubject));
+    assertThat(barMethodSubject, invokesMethod(bazMethodSubject));
+
+    // The main dex classes should be the same as the input main dex list.
+    assertEquals(
+        ImmutableSet.of(mainClassSubject.getFinalName(), aClassSubject.getFinalName()),
+        compileResult.getMainDexClasses());
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      System.out.println("Main.main()");
+    }
+
+    public static void notCalledAtStartup() {
+      // Should not allow inlining bar into notCalledAtStartup(), since that adds B as a direct
+      // dependence, and we don't include the direct dependencies of main dex list classes.
+      new A().bar();
+    }
+
+    // This method is traced for main dex when running with R8, to add A as a dependency.
+    static A foo(A a) {
+      if (a != null) {
+        System.out.println("Hello World");
+      }
+      return a;
+    }
+  }
+
+  @NoHorizontalClassMerging
+  static class A {
+
+    static void bar() {
+      B.baz();
+    }
+  }
+
+  @NoHorizontalClassMerging
+  static class B {
+
+    @NeverInline
+    static void baz() {
+      System.out.println("B.baz");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainHorizontalMergingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainHorizontalMergingTest.java
index 867b1ec..c2c96ec 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainHorizontalMergingTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainHorizontalMergingTest.java
@@ -5,7 +5,6 @@
 package com.android.tools.r8.maindexlist;
 
 import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -14,10 +13,12 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ThrowableConsumer;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.TypeReference;
@@ -38,7 +39,6 @@
 public class MainDexListFromGenerateMainHorizontalMergingTest extends TestBase {
 
   private static List<ClassReference> mainDexList;
-
   private final TestParameters parameters;
 
   @Parameters(name = "{0}")
@@ -66,30 +66,45 @@
   }
 
   @Test
-  public void test() throws Exception {
+  public void testMainDexList() throws Exception {
     assertEquals(3, mainDexList.size());
     Set<String> mainDexReferences =
         mainDexList.stream().map(TypeReference::getTypeName).collect(Collectors.toSet());
     assertTrue(mainDexReferences.contains(A.class.getTypeName()));
     assertTrue(mainDexReferences.contains(B.class.getTypeName()));
     assertTrue(mainDexReferences.contains(Main.class.getTypeName()));
+    runTest(builder -> builder.addMainDexListClassReferences(mainDexList));
+  }
 
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(getClass())
-            .addInliningAnnotations()
-            .addKeepClassAndMembersRules(Main.class, Outside.class)
-            .addMainDexListClassReferences(mainDexList)
-            .collectMainDexClasses()
-            .enableInliningAnnotations()
-            .enableNeverClassInliningAnnotations()
-            .setMinApi(parameters.getApiLevel())
-            .addHorizontallyMergedClassesInspector(
-                horizontallyMergedClassesInspector -> {
-                  horizontallyMergedClassesInspector.assertMergedInto(B.class, A.class);
-                })
-            .compile();
+  @Test
+  public void testMainDexTracing() throws Exception {
+    runTest(
+        builder ->
+            builder.addMainDexRules(
+                "-keep class " + Main.class.getTypeName() + " { public static void foo(); }"));
+  }
 
+  private void runTest(ThrowableConsumer<R8FullTestBuilder> testBuilder) throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addInliningAnnotations()
+        .addKeepClassAndMembersRules(Main.class, Outside.class)
+        .collectMainDexClasses()
+        .enableInliningAnnotations()
+        .enableNeverClassInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .addHorizontallyMergedClassesInspector(
+            horizontallyMergedClassesInspector -> {
+              horizontallyMergedClassesInspector.assertClassesNotMerged(B.class, A.class);
+            })
+        .apply(testBuilder)
+        .compile()
+        .apply(this::inspectCompileResult)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputThatMatches(containsString(Outside.class.getTypeName()));
+  }
+
+  private void inspectCompileResult(R8TestCompileResult compileResult) throws Exception {
     CodeInspector inspector = compileResult.inspector();
     ClassSubject mainClassSubject = inspector.clazz(Main.class);
     assertThat(mainClassSubject, isPresent());
@@ -100,9 +115,8 @@
     ClassSubject aClassSubject = inspector.clazz(A.class);
     assertThat(aClassSubject, isPresent());
 
-    // TODO(b/178460068): Should be present, but was merged with A.
     ClassSubject bClassSubject = inspector.clazz(B.class);
-    assertThat(bClassSubject, isAbsent());
+    assertThat(bClassSubject, isPresent());
 
     MethodSubject fooASubject = aClassSubject.uniqueMethodWithName("foo");
     assertThat(fooASubject, isPresent());
@@ -112,19 +126,16 @@
     compileResult.inspectMainDexClasses(
         mainDexClasses -> {
           assertEquals(
-              ImmutableSet.of(mainClassSubject.getFinalName(), aClassSubject.getFinalName()),
+              ImmutableSet.of(
+                  mainClassSubject.getFinalName(),
+                  aClassSubject.getFinalName(),
+                  bClassSubject.getFinalName()),
               mainDexClasses);
         });
-
-    compileResult
-        .run(parameters.getRuntime(), Main.class)
-        .assertSuccessWithOutputThatMatches(containsString(Outside.class.getTypeName()));
   }
 
   static class Main {
 
-    // public static B b;
-
     public static void main(String[] args) {
       B.print();
     }
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainVerticalMergingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainVerticalMergingTest.java
index e3d49f5..ec50d1e 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainVerticalMergingTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListFromGenerateMainVerticalMergingTest.java
@@ -5,7 +5,6 @@
 package com.android.tools.r8.maindexlist;
 
 import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
@@ -13,16 +12,17 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ThrowableConsumer;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.TypeReference;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.android.tools.r8.utils.codeinspector.FieldSubject;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
 import com.google.common.collect.ImmutableSet;
 import java.util.List;
@@ -66,23 +66,34 @@
   }
 
   @Test
-  public void test() throws Exception {
+  public void testMainDexList() throws Exception {
     assertEquals(3, mainDexList.size());
     Set<String> mainDexReferences =
         mainDexList.stream().map(TypeReference::getTypeName).collect(Collectors.toSet());
     assertTrue(mainDexReferences.contains(A.class.getTypeName()));
     assertTrue(mainDexReferences.contains(B.class.getTypeName()));
     assertTrue(mainDexReferences.contains(Main.class.getTypeName()));
+    runTest(builder -> builder.addMainDexListClassReferences(mainDexList));
+  }
 
+  @Test
+  public void testMainTracing() throws Exception {
+    runTest(
+        builder ->
+            builder.addMainDexRules(
+                "-keep class " + Main.class.getTypeName() + " { public static void foo(); }"));
+  }
+
+  private void runTest(ThrowableConsumer<R8FullTestBuilder> testBuilder) throws Exception {
     R8TestCompileResult compileResult =
         testForR8(parameters.getBackend())
             .addInnerClasses(getClass())
             .addInliningAnnotations()
             .addKeepClassAndMembersRules(Main.class, Outside.class)
-            .addMainDexListClassReferences(mainDexList)
             .collectMainDexClasses()
             .enableInliningAnnotations()
             .enableNeverClassInliningAnnotations()
+            .apply(testBuilder)
             .setMinApi(parameters.getApiLevel())
             .compile();
 
@@ -94,25 +105,23 @@
     assertThat(fooMethodSubject, isPresent());
 
     ClassSubject aClassSubject = inspector.clazz(A.class);
-    // TODO(b/178460068): Should be present, but was merged with B.
-    assertThat(aClassSubject, isAbsent());
+    assertThat(aClassSubject, isPresent());
+
+    MethodSubject fooAMethodSubject = aClassSubject.uniqueMethodWithName("foo");
+    assertThat(fooAMethodSubject, isPresent());
 
     ClassSubject bClassSubject = inspector.clazz(B.class);
     assertThat(bClassSubject, isPresent());
 
-    FieldSubject outsideFieldSubject = bClassSubject.uniqueFieldWithName("outsideField");
-    assertThat(outsideFieldSubject, isPresent());
+    assertThat(fooMethodSubject, invokesMethod(fooAMethodSubject));
 
-    MethodSubject fooBMethodSubject = bClassSubject.uniqueMethodWithName("foo");
-    assertThat(fooBMethodSubject, isPresent());
-
-    assertThat(fooMethodSubject, invokesMethod(fooBMethodSubject));
-
-    // TODO(b/178460068): B should not be in main dex.
     compileResult.inspectMainDexClasses(
         mainDexClasses -> {
           assertEquals(
-              ImmutableSet.of(mainClassSubject.getFinalName(), bClassSubject.getFinalName()),
+              ImmutableSet.of(
+                  mainClassSubject.getFinalName(),
+                  aClassSubject.getFinalName(),
+                  bClassSubject.getFinalName()),
               mainDexClasses);
         });
 
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListInliningTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListInliningTest.java
index 82f5e7d..09df9d4 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListInliningTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListInliningTest.java
@@ -4,7 +4,6 @@
 
 package com.android.tools.r8.maindexlist;
 
-import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertFalse;
@@ -55,10 +54,9 @@
     ClassSubject mainClassSubject = inspector.clazz(Main.class);
     assertThat(mainClassSubject, isPresent());
 
-    // A is absent due to inlining.
-    // TODO(b/178353726): Inlining should be prohibited.
+    // A is not allowed to be inlined and is therefore present.
     ClassSubject aClassSubject = inspector.clazz(A.class);
-    assertThat(aClassSubject, isAbsent());
+    assertThat(aClassSubject, isPresent());
 
     // B should be referenced from Main.main.
     ClassSubject bClassSubject = inspector.clazz(B.class);
@@ -67,6 +65,9 @@
     compileResult.inspectMainDexClasses(
         mainDexClasses -> {
           assertTrue(mainDexClasses.contains(mainClassSubject.getFinalName()));
+          // Since we passed a main-dex list the traced references A and B are not automagically
+          // included.
+          assertFalse(mainDexClasses.contains(aClassSubject.getFinalName()));
           assertFalse(mainDexClasses.contains(bClassSubject.getFinalName()));
         });
   }
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListMergeInRootTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListMergeInRootTest.java
index 7041c75..9451f9a 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListMergeInRootTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListMergeInRootTest.java
@@ -4,17 +4,13 @@
 
 package com.android.tools.r8.maindexlist;
 
-import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
-import static com.android.tools.r8.utils.codeinspector.AssertUtils.assertFailsCompilation;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.junit.Assume.assumeTrue;
-
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.NoHorizontalClassMerging;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -27,7 +23,10 @@
 
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
-    return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+    return getTestParameters()
+        .withDexRuntimes()
+        .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
+        .build();
   }
 
   public MainDexListMergeInRootTest(TestParameters parameters) {
@@ -35,35 +34,26 @@
   }
 
   @Test
-  public void testMainDexTracing() {
-    assumeTrue(parameters.getDexRuntimeVersion().isDalvik());
-    assertFailsCompilation(
-        () ->
-            testForR8(parameters.getBackend())
-                .addProgramClasses(OutsideMainDex.class, InsideA.class, InsideB.class, Main.class)
-                .addKeepClassAndMembersRules(Main.class)
-                .setMinApi(parameters.getApiLevel())
-                .enableNeverClassInliningAnnotations()
-                .enableNoHorizontalClassMergingAnnotations()
-                .enableInliningAnnotations()
-                .noMinification()
-                .addMainDexRules(
-                    "-keep class "
-                        + Main.class.getTypeName()
-                        + " { public static void main(***); }")
-                .addOptionsModification(
-                    options -> {
-                      options.testing.checkForNotExpandingMainDexTracingResult = true;
-                    })
-                .compileWithExpectedDiagnostics(
-                    diagnostics -> {
-                      diagnostics.assertErrorsMatch(
-                          diagnosticMessage(
-                              containsString(
-                                  "Class com.android.tools.r8.maindexlist"
-                                      + ".MainDexListMergeInRootTest$OutsideMainDex"
-                                      + " was not a main dex root in the first round")));
-                    }));
+  public void testMainDexTracing() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(OutsideMainDex.class, InsideA.class, InsideB.class, Main.class)
+        .addKeepClassAndMembersRules(Main.class)
+        .setMinApi(parameters.getApiLevel())
+        .enableNeverClassInliningAnnotations()
+        .enableNoHorizontalClassMergingAnnotations()
+        .enableInliningAnnotations()
+        .noMinification()
+        .addMainDexRules(
+            "-keep class " + Main.class.getTypeName() + " { public static void main(***); }")
+        .addOptionsModification(
+            options -> {
+              options.testing.checkForNotExpandingMainDexTracingResult = true;
+            })
+        // TODO(b/178151906): See if we can merge the classes.
+        .addHorizontallyMergedClassesInspector(
+            HorizontallyMergedClassesInspector::assertNoClassesMerged)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("InsideB::live0", "InsideA::live");
   }
 
   @NoHorizontalClassMerging
@@ -80,7 +70,7 @@
   public static class InsideA {
 
     public void bar() {
-      System.out.println("A::live");
+      System.out.println("InsideA::live");
     }
 
     /* Not a traced root */
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexPrunedReferenceTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexPrunedReferenceTest.java
index 65bf904..e2d7dd2 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexPrunedReferenceTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexPrunedReferenceTest.java
@@ -6,8 +6,7 @@
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assume.assumeFalse;
 import static org.junit.Assume.assumeTrue;
 
@@ -20,6 +19,7 @@
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.ThrowableConsumer;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.google.common.collect.ImmutableSet;
 import java.util.Set;
 import java.util.function.Consumer;
 import org.junit.Assert;
@@ -53,10 +53,7 @@
     assumeTrue(parameters.getDexRuntimeVersion().isDalvik());
     testMainDex(
         builder -> builder.addMainDexListClasses(Main.class),
-        mainDexClasses -> {
-          assertTrue(mainDexClasses.contains(Main.class.getTypeName()));
-          assertFalse(mainDexClasses.contains(Outside.class.getTypeName()));
-        });
+        mainDexClasses -> assertEquals(ImmutableSet.of(Main.class.getTypeName()), mainDexClasses));
   }
 
   @Test
@@ -66,11 +63,7 @@
         builder ->
             builder.addMainDexRules(
                 "-keep class " + Main.class.getTypeName() + " { public static void notMain(); }"),
-        mainDexClasses -> {
-          assertTrue(mainDexClasses.contains(Main.class.getTypeName()));
-          // TODO(b/178362682): This should be false.
-          assertTrue(mainDexClasses.contains(Outside.class.getTypeName()));
-        });
+        mainDexClasses -> assertEquals(ImmutableSet.of(Main.class.getTypeName()), mainDexClasses));
   }
 
   private void testMainDex(
@@ -89,7 +82,7 @@
             parameters.getDexRuntimeVersion().isDalvik(),
             TestCompilerBuilder::collectMainDexClasses)
         .compile()
-        .apply(compileResult -> compileResult.inspectMainDexClasses(mainDexListConsumer))
+        .inspectMainDexClasses(mainDexListConsumer)
         .run(parameters.getRuntime(), Main.class)
         .inspect(
             inspector -> {
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexRootIfRuleTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexRootIfRuleTest.java
new file mode 100644
index 0000000..4520900
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexRootIfRuleTest.java
@@ -0,0 +1,81 @@
+// Copyright (c) 2021, 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.maindexlist;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.google.common.collect.ImmutableSet;
+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 MainDexRootIfRuleTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters()
+        .withDexRuntimes()
+        .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
+        .build();
+  }
+
+  public MainDexRootIfRuleTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .addKeepClassRules(R.class)
+        .addMainDexRules(
+            "-keep class " + Main.class.getTypeName() + " { void main(java.lang.String[]); }")
+        .addMainDexRules(
+            "-if class " + MainDexRoot.class.getTypeName() + " { void methodWithSingleCaller(); }",
+            "-keep class " + R.class.getTypeName())
+        .collectMainDexClasses()
+        .compile()
+        .inspectMainDexClasses(
+            mainDexClasses -> {
+              // TODO(b/164019179): Fix if-rules
+              // MainDexRoot will be traced during first round of main dex tracing and result in the
+              // R class being kept due to the if-rule. When tracing in the second round, the
+              // class MainDexRoot is gone and the method inlined, resulting in R not being added to
+              // Main Dex.
+              assertEquals(ImmutableSet.of(Main.class.getTypeName()), mainDexClasses);
+            })
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(R.class.getName());
+  }
+
+  public static class R {}
+
+  public static class MainDexRoot {
+
+    public static void methodWithSingleCaller() throws Exception {
+      // Reflectively access class R
+      String[] strings =
+          new String[] {"com", "android", "tools", "r8", "maindexlist", "MainDexRootIfRuleTest$R"};
+      Class<?> clazz = Class.forName(String.join(".", strings));
+      System.out.println(clazz.getName());
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) throws Exception {
+      MainDexRoot.methodWithSingleCaller();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
index ccaa66a..bcea2fe 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
@@ -22,7 +22,6 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestCompilerBuilder;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestShrinkerBuilder;
 import com.android.tools.r8.ThrowableConsumer;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.references.Reference;
@@ -212,11 +211,7 @@
         Paths.get(EXAMPLE_O_SRC_DIR, "multidex004", "ref-list-1.txt"),
         Paths.get(EXAMPLE_O_SRC_DIR, "multidex004", "ref-list-1.txt"),
         AndroidApiLevel.I,
-        builder ->
-            builder
-                .applyIf(
-                    backend.isDex(), TestShrinkerBuilder::addDontWarnCompilerSynthesizedAnnotations)
-                .addOptionsModification(options -> options.enableInlining = false));
+        builder -> builder.addOptionsModification(options -> options.enableInlining = false));
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexUnusedArgumentRewriteWithLensTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexUnusedArgumentRewriteWithLensTest.java
new file mode 100644
index 0000000..fea8bfa
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexUnusedArgumentRewriteWithLensTest.java
@@ -0,0 +1,115 @@
+// Copyright (c) 2021, 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.maindexlist;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+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.TestParametersCollection;
+import com.android.tools.r8.utils.Box;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.ImmutableSet;
+import java.util.Set;
+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 MainDexUnusedArgumentRewriteWithLensTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters()
+        .withDexRuntimes()
+        .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
+        .build();
+  }
+
+  public MainDexUnusedArgumentRewriteWithLensTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    Box<Set<String>> mainDex = new Box<>();
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .enableInliningAnnotations()
+        .enableNeverClassInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .addKeepClassRules(Dependency.class)
+        .addMainDexRules(
+            "-keep class " + A.class.getTypeName() + " { void foo(java.lang.Object,int); }")
+        .addKeepMainRule(Main.class)
+        .collectMainDexClasses()
+        .compile()
+        .inspectMainDexClasses(mainDex::set)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("A::foo")
+        .inspect(
+            inspector -> {
+              ClassSubject aSubject = inspector.clazz(A.class);
+              assertThat(aSubject, isPresent());
+              ClassSubject bSubject = inspector.clazz(B.class);
+              assertThat(bSubject, isPresent());
+              ClassSubject mainSubject = inspector.clazz(Main.class);
+              assertThat(mainSubject, isPresentAndNotRenamed());
+              MethodSubject mainMethodSubject = mainSubject.uniqueMethodWithName("main");
+              assertThat(mainMethodSubject, isPresentAndNotRenamed());
+              assertTrue(
+                  mainMethodSubject
+                      .streamInstructions()
+                      .anyMatch(
+                          instructionSubject ->
+                              instructionSubject.isNewInstance(Dependency.class.getTypeName())));
+              assertEquals(
+                  mainDex.get(),
+                  ImmutableSet.of(
+                      aSubject.getFinalName(),
+                      bSubject.getFinalName(),
+                      Dependency.class.getTypeName()));
+            });
+  }
+
+  public static class Dependency {}
+
+  public static class B {
+
+    @NeverInline
+    public static void foo(Object obj) {
+      if (!(obj instanceof Dependency)) {
+        System.out.println("A::foo");
+      }
+    }
+  }
+
+  @NeverClassInline
+  public static class A {
+
+    // Will be rewritten because it has an unused argument
+    @NeverInline
+    public void foo(Object obj, int argumentUnused) {
+      B.foo(obj);
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      new A().foo(args.length > 0 ? new Dependency() : new Object(), 42);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCatchHandlerTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCatchHandlerTest.java
new file mode 100644
index 0000000..e9bc43b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCatchHandlerTest.java
@@ -0,0 +1,61 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import org.junit.Test;
+
+public class MissingClassReferencedFromCatchHandlerTest extends MissingClassesTestBase {
+
+  private static final MethodReference referencedFrom =
+      MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+
+  public MissingClassReferencedFromCatchHandlerTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(Main.class));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(MissingClass.class));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings());
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      try {
+        nop();
+      } catch (MissingClass ignore) {
+      }
+    }
+
+    private static void nop() {}
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCheckCastTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCheckCastTest.java
new file mode 100644
index 0000000..b10a231
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCheckCastTest.java
@@ -0,0 +1,56 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import org.junit.Test;
+
+public class MissingClassReferencedFromCheckCastTest extends MissingClassesTestBase {
+
+  private static final MethodReference referencedFrom =
+      MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+
+  public MissingClassReferencedFromCheckCastTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(Main.class));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(MissingClass.class));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings());
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      MissingClass ignore = (MissingClass) null;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromConstClassTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromConstClassTest.java
new file mode 100644
index 0000000..cb6287c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromConstClassTest.java
@@ -0,0 +1,56 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import org.junit.Test;
+
+public class MissingClassReferencedFromConstClassTest extends MissingClassesTestBase {
+
+  private static final MethodReference referencedFrom =
+      MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+
+  public MissingClassReferencedFromConstClassTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(Main.class));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(MissingClass.class));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings());
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      Class<?> ignore = MissingClass.class;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromEnclosingMethodAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromEnclosingMethodAttributeTest.java
new file mode 100644
index 0000000..74f00d4
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromEnclosingMethodAttributeTest.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.missingclasses;
+
+import static com.android.tools.r8.utils.codeinspector.AssertUtils.assertFailsCompilationIf;
+import static org.junit.Assert.assertFalse;
+
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.R8TestBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.BooleanUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runners.Parameterized.Parameters;
+
+public class MissingClassReferencedFromEnclosingMethodAttributeTest extends MissingClassesTestBase {
+
+  private static final ClassReference referencedFrom = Reference.classFromClass(getMainClass());
+
+  @Parameters(name = "{1}, report: {0}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
+  }
+
+  private final boolean reportMissingClassesInEnclosingMethodAttribute;
+
+  public MissingClassReferencedFromEnclosingMethodAttributeTest(
+      boolean reportMissingClassesInEnclosingMethodAttribute, TestParameters parameters) {
+    super(parameters);
+    this.reportMissingClassesInEnclosingMethodAttribute =
+        reportMissingClassesInEnclosingMethodAttribute;
+  }
+
+  @Test
+  public void testNoRules() throws Exception {
+    assertFailsCompilationIf(
+        reportMissingClassesInEnclosingMethodAttribute,
+        () ->
+            compileWithExpectedDiagnostics(
+                getMainClass(),
+                reportMissingClassesInEnclosingMethodAttribute
+                    ? diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom)
+                    : TestDiagnosticMessages::assertNoMessages,
+                this::configure));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        getMainClass(),
+        TestDiagnosticMessages::assertNoMessages,
+        addDontWarn(getMainClass()).andThen(this::configure));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        getMainClass(),
+        TestDiagnosticMessages::assertNoMessages,
+        addDontWarn(MissingClass.class).andThen(this::configure));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        getMainClass(),
+        reportMissingClassesInEnclosingMethodAttribute
+            ? diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom)
+            : TestDiagnosticMessages::assertNoMessages,
+        addIgnoreWarnings(reportMissingClassesInEnclosingMethodAttribute).andThen(this::configure));
+  }
+
+  void configure(R8FullTestBuilder builder) {
+    builder
+        .addKeepAttributeInnerClassesAndEnclosingMethod()
+        .addOptionsModification(
+            options -> {
+              // We do not report missing classes from inner class attributes by default.
+              assertFalse(options.reportMissingClassesInEnclosingMethodAttribute);
+              options.reportMissingClassesInEnclosingMethodAttribute =
+                  reportMissingClassesInEnclosingMethodAttribute;
+            })
+        .applyIf(
+            !reportMissingClassesInEnclosingMethodAttribute,
+            // The -dontwarn Main and -dontwarn MissingClass tests will have unused -dontwarn rules.
+            R8TestBuilder::allowUnusedDontWarnPatterns);
+  }
+
+  static Class<?> getMainClass() {
+    return MissingClass.getMainClass();
+  }
+
+  @Override
+  ClassReference getMissingClassReference() {
+    return Reference.classFromClass(MissingClass.class);
+  }
+
+  static class MissingClass {
+
+    static Class<?> getMainClass() {
+      class Main {}
+      return Main.class;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromImplementsClauseTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromImplementsClauseTest.java
new file mode 100644
index 0000000..490efdc
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromImplementsClauseTest.java
@@ -0,0 +1,67 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestCompilerBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import org.junit.Test;
+
+public class MissingClassReferencedFromImplementsClauseTest extends MissingClassesTestBase {
+
+  private static final ClassReference referencedFrom = Reference.classFromClass(Main.class);
+
+  public MissingClassReferencedFromImplementsClauseTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Override
+  ClassReference getMissingClassReference() {
+    return Reference.classFromClass(MissingInterface.class);
+  }
+
+  // The tests explicitly disable desugaring to prevent desugaring warnings.
+  // TODO(b/179341237): Consider if desugaring warnings should be D8 only, since in a way they are
+  //  all duplicates of the MissingClassesDiagnostic.
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom),
+        TestCompilerBuilder::disableDesugaring);
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        TestDiagnosticMessages::assertNoMessages,
+        addDontWarn(Main.class).andThen(TestCompilerBuilder::disableDesugaring));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        TestDiagnosticMessages::assertNoMessages,
+        addDontWarn(MissingInterface.class).andThen(TestCompilerBuilder::disableDesugaring));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings().andThen(TestCompilerBuilder::disableDesugaring));
+  }
+
+  static class Main implements MissingInterface {
+
+    public static void main(String[] args) {}
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInnerClassAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInnerClassAttributeTest.java
new file mode 100644
index 0000000..aa64ab8
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInnerClassAttributeTest.java
@@ -0,0 +1,107 @@
+// 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.missingclasses;
+
+import static com.android.tools.r8.utils.codeinspector.AssertUtils.assertFailsCompilationIf;
+import static org.junit.Assert.assertFalse;
+
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.R8TestBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.BooleanUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runners.Parameterized.Parameters;
+
+public class MissingClassReferencedFromInnerClassAttributeTest extends MissingClassesTestBase {
+
+  private static final ClassReference referencedFrom = Reference.classFromClass(Main.class);
+
+  @Parameters(name = "{1}, report: {0}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
+  }
+
+  private final boolean reportMissingClassesInInnerClassAttributes;
+
+  public MissingClassReferencedFromInnerClassAttributeTest(
+      boolean reportMissingClassesInInnerClassAttributes, TestParameters parameters) {
+    super(parameters);
+    this.reportMissingClassesInInnerClassAttributes = reportMissingClassesInInnerClassAttributes;
+  }
+
+  @Test
+  public void testNoRules() throws Exception {
+    assertFailsCompilationIf(
+        reportMissingClassesInInnerClassAttributes,
+        () ->
+            compileWithExpectedDiagnostics(
+                Main.class,
+                reportMissingClassesInInnerClassAttributes
+                    ? diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom)
+                    : TestDiagnosticMessages::assertNoMessages,
+                this::configure));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        TestDiagnosticMessages::assertNoMessages,
+        addDontWarn(Main.class).andThen(this::configure));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        TestDiagnosticMessages::assertNoMessages,
+        addDontWarn(Main.MissingClass.class).andThen(this::configure));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        reportMissingClassesInInnerClassAttributes
+            ? diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom)
+            : TestDiagnosticMessages::assertNoMessages,
+        addIgnoreWarnings(reportMissingClassesInInnerClassAttributes).andThen(this::configure));
+  }
+
+  void configure(R8FullTestBuilder builder) {
+    builder
+        .addKeepAttributeInnerClassesAndEnclosingMethod()
+        .addOptionsModification(
+            options -> {
+              // We do not report missing classes from inner class attributes by default.
+              assertFalse(options.reportMissingClassesInInnerClassAttributes);
+              options.reportMissingClassesInInnerClassAttributes =
+                  reportMissingClassesInInnerClassAttributes;
+            })
+        .applyIf(
+            reportMissingClassesInInnerClassAttributes,
+            // We need to ignore the inner class attribute for the test class.
+            addDontWarn(MissingClassReferencedFromInnerClassAttributeTest.class),
+            // The -dontwarn Main and -dontwarn MissingClass tests will have unused -dontwarn rules.
+            R8TestBuilder::allowUnusedDontWarnPatterns);
+  }
+
+  @Override
+  ClassReference getMissingClassReference() {
+    return Reference.classFromClass(Main.MissingClass.class);
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {}
+
+    static class MissingClass {}
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToExistingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToExistingFieldTest.java
new file mode 100644
index 0000000..6c7f620
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToExistingFieldTest.java
@@ -0,0 +1,65 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.Reference;
+import org.junit.Test;
+
+/**
+ * If a field reference that refers to a missing class resolves to a definition, then the field
+ * definition is to be blamed.
+ */
+public class MissingClassReferencedFromInstanceGetToExistingFieldTest
+    extends MissingClassesTestBase {
+
+  private static final FieldReference referencedFrom =
+      Reference.field(
+          Reference.classFromClass(Main.class),
+          "field",
+          Reference.classFromClass(MissingClass.class));
+
+  public MissingClassReferencedFromInstanceGetToExistingFieldTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(Main.class));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(MissingClass.class));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings());
+  }
+
+  static class Main {
+
+    public MissingClass field;
+
+    public static void main(String[] args) {
+      MissingClass ignore = new Main().field;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToMissingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToMissingFieldTest.java
new file mode 100644
index 0000000..851d65d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToMissingFieldTest.java
@@ -0,0 +1,61 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import org.junit.Test;
+
+/**
+ * If a field reference that refers to a missing class does not resolve, then the enclosing method
+ * is to be blamed.
+ */
+public class MissingClassReferencedFromInstanceGetToMissingFieldTest
+    extends MissingClassesTestBase {
+
+  private static final MethodReference referencedFrom =
+      MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+
+  public MissingClassReferencedFromInstanceGetToMissingFieldTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(Main.class));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(MissingClass.class));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings());
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      int ignore = new MissingClass().field;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceOfTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceOfTest.java
new file mode 100644
index 0000000..2d05aac
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceOfTest.java
@@ -0,0 +1,56 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import org.junit.Test;
+
+public class MissingClassReferencedFromInstanceOfTest extends MissingClassesTestBase {
+
+  private static final MethodReference referencedFrom =
+      MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+
+  public MissingClassReferencedFromInstanceOfTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(Main.class));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(MissingClass.class));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings());
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      boolean ignore = null instanceof MissingClass;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToExistingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToExistingFieldTest.java
new file mode 100644
index 0000000..b69625e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToExistingFieldTest.java
@@ -0,0 +1,65 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.Reference;
+import org.junit.Test;
+
+/**
+ * If a field reference that refers to a missing class resolves to a definition, then the field
+ * definition is to be blamed.
+ */
+public class MissingClassReferencedFromInstancePutToExistingFieldTest
+    extends MissingClassesTestBase {
+
+  private static final FieldReference referencedFrom =
+      Reference.field(
+          Reference.classFromClass(Main.class),
+          "field",
+          Reference.classFromClass(MissingClass.class));
+
+  public MissingClassReferencedFromInstancePutToExistingFieldTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(Main.class));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(MissingClass.class));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings());
+  }
+
+  static class Main {
+
+    MissingClass field;
+
+    public static void main(String[] args) {
+      new Main().field = null;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToMissingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToMissingFieldTest.java
new file mode 100644
index 0000000..ec615f1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToMissingFieldTest.java
@@ -0,0 +1,61 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import org.junit.Test;
+
+/**
+ * If a field reference that refers to a missing class does not resolve, then the enclosing method
+ * is to be blamed.
+ */
+public class MissingClassReferencedFromInstancePutToMissingFieldTest
+    extends MissingClassesTestBase {
+
+  private static final MethodReference referencedFrom =
+      MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+
+  public MissingClassReferencedFromInstancePutToMissingFieldTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(Main.class));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(MissingClass.class));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings());
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      new MissingClass().field = 42;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptFieldTest.java
new file mode 100644
index 0000000..19dfdea
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptFieldTest.java
@@ -0,0 +1,73 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.Reference;
+import org.junit.Test;
+
+/** If a field definition refers to a missing class, then the field definition is to be blamed. */
+public class MissingClassReferencedFromKeptFieldTest extends MissingClassesTestBase {
+
+  private static final FieldReference referencedFrom =
+      Reference.field(
+          Reference.classFromClass(Main.class),
+          "FIELD",
+          Reference.classFromClass(MissingClass.class));
+
+  public MissingClassReferencedFromKeptFieldTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom),
+        this::addKeepFieldRule);
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        TestDiagnosticMessages::assertNoMessages,
+        addDontWarn(Main.class).andThen(this::addKeepFieldRule));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        TestDiagnosticMessages::assertNoMessages,
+        addDontWarn(MissingClass.class).andThen(this::addKeepFieldRule));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings().andThen(this::addKeepFieldRule));
+  }
+
+  private void addKeepFieldRule(R8FullTestBuilder builder) {
+    builder.addKeepRules(
+        "-keep class " + Main.class.getTypeName() + " {",
+        "  public static " + MissingClass.class.getTypeName() + " FIELD;",
+        "}");
+  }
+
+  static class Main {
+
+    public static MissingClass FIELD;
+
+    public static void main(String[] args) {}
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestHostAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestHostAttributeTest.java
new file mode 100644
index 0000000..fc1ac99
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestHostAttributeTest.java
@@ -0,0 +1,76 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.missingclasses.MissingClassReferencedFromNestHostAttributeTest.MissingClass.Main;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import com.google.common.collect.ImmutableList;
+import java.io.IOException;
+import java.util.Collection;
+import org.junit.Test;
+
+public class MissingClassReferencedFromNestHostAttributeTest extends MissingClassesTestBase {
+
+  private static final ClassReference referencedFrom = Reference.classFromClass(Main.class);
+
+  public MissingClassReferencedFromNestHostAttributeTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        addMain(), diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        addMain().andThen(addDontWarn(Main.class)), TestDiagnosticMessages::assertNoMessages);
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        addMain().andThen(addDontWarn(MissingClass.class)),
+        TestDiagnosticMessages::assertNoMessages);
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        addMain().andThen(addIgnoreWarnings()),
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom));
+  }
+
+  private ThrowableConsumer<R8FullTestBuilder> addMain() {
+    return builder ->
+        builder.addProgramClassFileData(getProgramClassFileData()).addKeepMainRule(Main.class);
+  }
+
+  @Override
+  ClassReference getMissingClassReference() {
+    return Reference.classFromClass(MissingClass.class);
+  }
+
+  static Collection<byte[]> getProgramClassFileData() throws IOException {
+    return ImmutableList.of(
+        transformer(Main.class).setNest(MissingClass.class, Main.class).transform());
+  }
+
+  static /*host*/ class MissingClass {
+
+    static /*member*/ class Main {
+
+      public static void main(String[] args) {}
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestMemberAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestMemberAttributeTest.java
new file mode 100644
index 0000000..a151dce
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestMemberAttributeTest.java
@@ -0,0 +1,74 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import com.google.common.collect.ImmutableList;
+import java.io.IOException;
+import java.util.Collection;
+import org.junit.Test;
+
+public class MissingClassReferencedFromNestMemberAttributeTest extends MissingClassesTestBase {
+
+  private static final ClassReference referencedFrom = Reference.classFromClass(Main.class);
+
+  public MissingClassReferencedFromNestMemberAttributeTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        addMain(), diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        addMain().andThen(addDontWarn(Main.class)), TestDiagnosticMessages::assertNoMessages);
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        addMain().andThen(addDontWarn(Main.MissingClass.class)),
+        TestDiagnosticMessages::assertNoMessages);
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        addMain().andThen(addIgnoreWarnings()),
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom));
+  }
+
+  private ThrowableConsumer<R8FullTestBuilder> addMain() {
+    return builder ->
+        builder.addProgramClassFileData(getProgramClassFileData()).addKeepMainRule(Main.class);
+  }
+
+  @Override
+  ClassReference getMissingClassReference() {
+    return Reference.classFromClass(Main.MissingClass.class);
+  }
+
+  static Collection<byte[]> getProgramClassFileData() throws IOException {
+    return ImmutableList.of(
+        transformer(Main.class).setNest(Main.class, Main.MissingClass.class).transform());
+  }
+
+  static /*host*/ class Main {
+
+    static /*member*/ class MissingClass {}
+
+    public static void main(String[] args) {}
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewArrayTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewArrayTest.java
new file mode 100644
index 0000000..66242bf
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewArrayTest.java
@@ -0,0 +1,56 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import org.junit.Test;
+
+public class MissingClassReferencedFromNewArrayTest extends MissingClassesTestBase {
+
+  private static final MethodReference referencedFrom =
+      MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+
+  public MissingClassReferencedFromNewArrayTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(Main.class));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(MissingClass.class));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings());
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      MissingClass[] ignore = new MissingClass[0];
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewInstanceTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewInstanceTest.java
index 8f43ab8..2af5045 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewInstanceTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewInstanceTest.java
@@ -4,51 +4,47 @@
 
 package com.android.tools.r8.missingclasses;
 
-import static com.android.tools.r8.DiagnosticsMatcher.diagnosticType;
-import static org.junit.Assert.assertEquals;
-
+import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.TypeReference;
-import com.android.tools.r8.shaking.MissingClassesDiagnostic;
-import com.android.tools.r8.utils.codeinspector.AssertUtils;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
 public class MissingClassReferencedFromNewInstanceTest extends MissingClassesTestBase {
 
-  public MissingClassReferencedFromNewInstanceTest(
-      DontWarnConfiguration dontWarnConfiguration, TestParameters parameters) {
-    super(dontWarnConfiguration, parameters);
+  private static final MethodReference referencedFrom =
+      MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+
+  public MissingClassReferencedFromNewInstanceTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
   }
 
   @Test
-  public void test() throws Exception {
-    AssertUtils.assertFailsCompilationIf(
-        // TODO(b/175542052): Should not fail compilation with -dontwarn Main.
-        !getDontWarnConfiguration().isDontWarnMissingClass(),
-        () ->
-            compileWithExpectedDiagnostics(
-                Main.class, MissingClass.class, this::inspectDiagnostics));
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(Main.class));
   }
 
-  private void inspectDiagnostics(TestDiagnosticMessages diagnostics) {
-    // TODO(b/175542052): Should also not have any diagnostics with -dontwarn Main.
-    if (getDontWarnConfiguration().isDontWarnMissingClass()) {
-      diagnostics.assertNoMessages();
-      return;
-    }
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(MissingClass.class));
+  }
 
-    diagnostics
-        .assertOnlyErrors()
-        .assertErrorsCount(1)
-        .assertAllErrorsMatch(diagnosticType(MissingClassesDiagnostic.class));
-
-    MissingClassesDiagnostic diagnostic = (MissingClassesDiagnostic) diagnostics.getErrors().get(0);
-    assertEquals(
-        !getDontWarnConfiguration().isDontWarnMissingClass(),
-        diagnostic.getMissingClasses().stream()
-            .map(TypeReference::getTypeName)
-            .anyMatch(MissingClass.class.getTypeName()::equals));
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings());
   }
 
   static class Main {
@@ -57,6 +53,4 @@
       new MissingClass();
     }
   }
-
-  static class MissingClass {}
 }
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromOuterClassAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromOuterClassAttributeTest.java
new file mode 100644
index 0000000..d707f74
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromOuterClassAttributeTest.java
@@ -0,0 +1,109 @@
+// 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.missingclasses;
+
+import static com.android.tools.r8.utils.codeinspector.AssertUtils.assertFailsCompilationIf;
+import static org.junit.Assert.assertFalse;
+
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.R8TestBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.missingclasses.MissingClassReferencedFromOuterClassAttributeTest.MissingClass.Main;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.BooleanUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runners.Parameterized.Parameters;
+
+public class MissingClassReferencedFromOuterClassAttributeTest extends MissingClassesTestBase {
+
+  private static final ClassReference referencedFrom = Reference.classFromClass(Main.class);
+
+  @Parameters(name = "{1}, report: {0}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
+  }
+
+  private final boolean reportMissingClassesInInnerClassAttributes;
+
+  public MissingClassReferencedFromOuterClassAttributeTest(
+      boolean reportMissingClassesInInnerClassAttributes, TestParameters parameters) {
+    super(parameters);
+    this.reportMissingClassesInInnerClassAttributes = reportMissingClassesInInnerClassAttributes;
+  }
+
+  @Test
+  public void testNoRules() throws Exception {
+    assertFailsCompilationIf(
+        reportMissingClassesInInnerClassAttributes,
+        () ->
+            compileWithExpectedDiagnostics(
+                Main.class,
+                reportMissingClassesInInnerClassAttributes
+                    ? diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom)
+                    : TestDiagnosticMessages::assertNoMessages,
+                this::configure));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        TestDiagnosticMessages::assertNoMessages,
+        addDontWarn(Main.class).andThen(this::configure));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        TestDiagnosticMessages::assertNoMessages,
+        addDontWarn(MissingClass.class).andThen(this::configure));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        reportMissingClassesInInnerClassAttributes
+            ? diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom)
+            : TestDiagnosticMessages::assertNoMessages,
+        addIgnoreWarnings(reportMissingClassesInInnerClassAttributes).andThen(this::configure));
+  }
+
+  void configure(R8FullTestBuilder builder) {
+    builder
+        .addKeepAttributeInnerClassesAndEnclosingMethod()
+        .addOptionsModification(
+            options -> {
+              // We do not report missing classes from inner class attributes by default.
+              assertFalse(options.reportMissingClassesInInnerClassAttributes);
+              options.reportMissingClassesInInnerClassAttributes =
+                  reportMissingClassesInInnerClassAttributes;
+            })
+        .applyIf(
+            reportMissingClassesInInnerClassAttributes,
+            // We need to ignore the inner class attribute for the test class.
+            addDontWarn(MissingClassReferencedFromOuterClassAttributeTest.class),
+            // The -dontwarn Main and -dontwarn MissingClass tests will have unused -dontwarn rules.
+            R8TestBuilder::allowUnusedDontWarnPatterns);
+  }
+
+  @Override
+  ClassReference getMissingClassReference() {
+    return Reference.classFromClass(MissingClass.class);
+  }
+
+  static class MissingClass {
+
+    static class Main {
+
+      public static void main(String[] args) {}
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToExistingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToExistingFieldTest.java
new file mode 100644
index 0000000..e76c4c9
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToExistingFieldTest.java
@@ -0,0 +1,64 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.Reference;
+import org.junit.Test;
+
+/**
+ * If a field reference that refers to a missing class resolves to a definition, then the field
+ * definition is to be blamed.
+ */
+public class MissingClassReferencedFromStaticGetToExistingFieldTest extends MissingClassesTestBase {
+
+  private static final FieldReference referencedFrom =
+      Reference.field(
+          Reference.classFromClass(Main.class),
+          "FIELD",
+          Reference.classFromClass(MissingClass.class));
+
+  public MissingClassReferencedFromStaticGetToExistingFieldTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(Main.class));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(MissingClass.class));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings());
+  }
+
+  static class Main {
+
+    public static MissingClass FIELD;
+
+    public static void main(String[] args) {
+      MissingClass ignore = FIELD;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToMissingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToMissingFieldTest.java
new file mode 100644
index 0000000..36f8a29
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToMissingFieldTest.java
@@ -0,0 +1,60 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import org.junit.Test;
+
+/**
+ * If a field reference that refers to a missing class does not resolve, then the enclosing method
+ * is to be blamed.
+ */
+public class MissingClassReferencedFromStaticGetToMissingFieldTest extends MissingClassesTestBase {
+
+  private static final MethodReference referencedFrom =
+      MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+
+  public MissingClassReferencedFromStaticGetToMissingFieldTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(Main.class));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(MissingClass.class));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings());
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      int ignore = MissingClass.FIELD;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToExistingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToExistingFieldTest.java
new file mode 100644
index 0000000..542c928
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToExistingFieldTest.java
@@ -0,0 +1,64 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.Reference;
+import org.junit.Test;
+
+/**
+ * If a field reference that refers to a missing class resolves to a definition, then the field
+ * definition is to be blamed.
+ */
+public class MissingClassReferencedFromStaticPutToExistingFieldTest extends MissingClassesTestBase {
+
+  private static final FieldReference referencedFrom =
+      Reference.field(
+          Reference.classFromClass(Main.class),
+          "FIELD",
+          Reference.classFromClass(MissingClass.class));
+
+  public MissingClassReferencedFromStaticPutToExistingFieldTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(Main.class));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(MissingClass.class));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings());
+  }
+
+  static class Main {
+
+    public static MissingClass FIELD;
+
+    public static void main(String[] args) {
+      FIELD = null;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToMissingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToMissingFieldTest.java
new file mode 100644
index 0000000..542d509
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToMissingFieldTest.java
@@ -0,0 +1,60 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import org.junit.Test;
+
+/**
+ * If a field reference that refers to a missing class does not resolve, then the enclosing method
+ * is to be blamed.
+ */
+public class MissingClassReferencedFromStaticPutToMissingFieldTest extends MissingClassesTestBase {
+
+  private static final MethodReference referencedFrom =
+      MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+
+  public MissingClassReferencedFromStaticPutToMissingFieldTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom));
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(Main.class));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class, TestDiagnosticMessages::assertNoMessages, addDontWarn(MissingClass.class));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings());
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      MissingClass.FIELD = 42;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromSuperClassTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromSuperClassTest.java
new file mode 100644
index 0000000..7aeb068
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromSuperClassTest.java
@@ -0,0 +1,62 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestCompilerBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import org.junit.Test;
+
+public class MissingClassReferencedFromSuperClassTest extends MissingClassesTestBase {
+
+  private static final ClassReference referencedFrom = Reference.classFromClass(Main.class);
+
+  public MissingClassReferencedFromSuperClassTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  // The tests explicitly disable desugaring to prevent desugaring warnings.
+  // TODO(b/179341237): Consider if desugaring warnings should be D8 only, since in a way they are
+  //  all duplicates of the MissingClassesDiagnostic.
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom),
+        TestCompilerBuilder::disableDesugaring);
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        TestDiagnosticMessages::assertNoMessages,
+        addDontWarn(Main.class).andThen(TestCompilerBuilder::disableDesugaring));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        TestDiagnosticMessages::assertNoMessages,
+        addDontWarn(MissingClass.class).andThen(TestCompilerBuilder::disableDesugaring));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings().andThen(TestCompilerBuilder::disableDesugaring));
+  }
+
+  static class Main extends MissingClass {
+
+    public static void main(String[] args) {}
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseTest.java
new file mode 100644
index 0000000..1708330
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseTest.java
@@ -0,0 +1,61 @@
+// 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.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestShrinkerBuilder;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import org.junit.Test;
+
+public class MissingClassReferencedFromThrowsClauseTest extends MissingClassesTestBase {
+
+  private static final MethodReference referencedFrom =
+      MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+
+  public MissingClassReferencedFromThrowsClauseTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test(expected = CompilationFailedException.class)
+  public void testNoRules() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom),
+        TestShrinkerBuilder::addKeepAttributeExceptions);
+  }
+
+  @Test
+  public void testDontWarnMainClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        TestDiagnosticMessages::assertNoMessages,
+        addDontWarn(Main.class).andThen(TestShrinkerBuilder::addKeepAttributeExceptions));
+  }
+
+  @Test
+  public void testDontWarnMissingClass() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        TestDiagnosticMessages::assertNoMessages,
+        addDontWarn(MissingClass.class).andThen(TestShrinkerBuilder::addKeepAttributeExceptions));
+  }
+
+  @Test
+  public void testIgnoreWarnings() throws Exception {
+    compileWithExpectedDiagnostics(
+        Main.class,
+        diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+        addIgnoreWarnings().andThen(TestShrinkerBuilder::addKeepAttributeExceptions));
+  }
+
+  static class Main {
+
+    public static void main(String[] args) throws MissingClass {}
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java
index 7c72273..dafb7b4 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java
@@ -4,13 +4,27 @@
 
 package com.android.tools.r8.missingclasses;
 
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticType;
+import static org.junit.Assert.assertEquals;
+
 import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestCompilerBuilder.DiagnosticsConsumer;
+import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.shaking.MissingClassesDiagnostic;
+import com.android.tools.r8.utils.FieldReferenceUtils;
 import com.android.tools.r8.utils.InternalOptions.TestingOptions;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import com.google.common.collect.ImmutableSet;
 import java.util.List;
+import java.util.function.Function;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
@@ -18,53 +32,164 @@
 @RunWith(Parameterized.class)
 public abstract class MissingClassesTestBase extends TestBase {
 
-  enum DontWarnConfiguration {
-    DONT_WARN_MAIN_CLASS,
-    DONT_WARN_MISSING_CLASS,
-    NONE;
+  static class MissingClass extends RuntimeException {
 
-    public boolean isDontWarnMainClass() {
-      return this == DONT_WARN_MAIN_CLASS;
-    }
+    static int FIELD;
 
-    public boolean isDontWarnMissingClass() {
-      return this == DONT_WARN_MISSING_CLASS;
-    }
+    int field;
   }
 
-  private final DontWarnConfiguration dontWarnConfiguration;
+  interface MissingInterface {}
+
   private final TestParameters parameters;
 
-  @Parameters(name = "{1}, {0}")
+  @Parameters(name = "{0}")
   public static List<Object[]> data() {
-    return buildParameters(
-        DontWarnConfiguration.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
+    return buildParameters(getTestParameters().withAllRuntimesAndApiLevels().build());
   }
 
-  public MissingClassesTestBase(
-      DontWarnConfiguration dontWarnConfiguration, TestParameters parameters) {
-    this.dontWarnConfiguration = dontWarnConfiguration;
+  public MissingClassesTestBase(TestParameters parameters) {
     this.parameters = parameters;
   }
 
-  public R8TestCompileResult compileWithExpectedDiagnostics(
-      Class<?> mainClass, Class<?> missingClass, DiagnosticsConsumer diagnosticsConsumer)
+  public ThrowableConsumer<R8FullTestBuilder> addDontWarn(Class<?> clazz) {
+    return builder -> builder.addDontWarn(clazz);
+  }
+
+  public ThrowableConsumer<R8FullTestBuilder> addIgnoreWarnings() {
+    return addIgnoreWarnings(true);
+  }
+
+  public ThrowableConsumer<R8FullTestBuilder> addIgnoreWarnings(
+      boolean allowDiagnosticWarningMessages) {
+    return builder ->
+        builder.addIgnoreWarnings().allowDiagnosticWarningMessages(allowDiagnosticWarningMessages);
+  }
+
+  public void compileWithExpectedDiagnostics(
+      Class<?> mainClass, DiagnosticsConsumer diagnosticsConsumer)
       throws CompilationFailedException {
-    return testForR8(parameters.getBackend())
-        .addProgramClasses(mainClass)
-        .addKeepMainRule(mainClass)
-        .applyIf(
-            dontWarnConfiguration.isDontWarnMainClass(),
-            testBuilder -> testBuilder.addDontWarn(mainClass))
-        .applyIf(
-            dontWarnConfiguration.isDontWarnMissingClass(),
-            testBuilder -> testBuilder.addDontWarn(missingClass))
+    compileWithExpectedDiagnostics(mainClass, diagnosticsConsumer, null);
+  }
+
+  public void compileWithExpectedDiagnostics(
+      Class<?> mainClass,
+      DiagnosticsConsumer diagnosticsConsumer,
+      ThrowableConsumer<R8FullTestBuilder> configuration)
+      throws CompilationFailedException {
+    internalCompileWithExpectedDiagnostics(
+        diagnosticsConsumer,
+        builder ->
+            builder.addProgramClasses(mainClass).addKeepMainRule(mainClass).apply(configuration));
+  }
+
+  public void compileWithExpectedDiagnostics(
+      ThrowableConsumer<R8FullTestBuilder> configuration, DiagnosticsConsumer diagnosticsConsumer)
+      throws CompilationFailedException {
+    internalCompileWithExpectedDiagnostics(diagnosticsConsumer, configuration);
+  }
+
+  private void internalCompileWithExpectedDiagnostics(
+      DiagnosticsConsumer diagnosticsConsumer, ThrowableConsumer<R8FullTestBuilder> configuration)
+      throws CompilationFailedException {
+    testForR8(parameters.getBackend())
+        .apply(configuration)
         .addOptionsModification(TestingOptions::enableExperimentalMissingClassesReporting)
         .setMinApi(parameters.getApiLevel())
         .compileWithExpectedDiagnostics(diagnosticsConsumer);
   }
 
-  public DontWarnConfiguration getDontWarnConfiguration() {
-    return dontWarnConfiguration;
+  ClassReference getMissingClassReference() {
+    return Reference.classFromClass(MissingClass.class);
+  }
+
+  void inspectDiagnosticsWithIgnoreWarnings(
+      TestDiagnosticMessages diagnostics, ClassReference referencedFrom) {
+    inspectDiagnosticsWithIgnoreWarnings(
+        diagnostics,
+        getExpectedDiagnosticMessageWithIgnoreWarnings(
+            referencedFrom, ClassReference::getTypeName));
+  }
+
+  void inspectDiagnosticsWithIgnoreWarnings(
+      TestDiagnosticMessages diagnostics, FieldReference referencedFrom) {
+    inspectDiagnosticsWithIgnoreWarnings(
+        diagnostics,
+        getExpectedDiagnosticMessageWithIgnoreWarnings(
+            referencedFrom, FieldReferenceUtils::toSourceString));
+  }
+
+  void inspectDiagnosticsWithIgnoreWarnings(
+      TestDiagnosticMessages diagnostics, MethodReference referencedFrom) {
+    inspectDiagnosticsWithIgnoreWarnings(
+        diagnostics,
+        getExpectedDiagnosticMessageWithIgnoreWarnings(
+            referencedFrom, MethodReferenceUtils::toSourceString));
+  }
+
+  void inspectDiagnosticsWithIgnoreWarnings(
+      TestDiagnosticMessages diagnostics, String expectedDiagnosticMessage) {
+    MissingClassesDiagnostic diagnostic =
+        diagnostics
+            .assertOnlyWarnings()
+            .assertWarningsCount(1)
+            .assertAllWarningsMatch(diagnosticType(MissingClassesDiagnostic.class))
+            .getWarning(0);
+    assertEquals(ImmutableSet.of(getMissingClassReference()), diagnostic.getMissingClasses());
+    assertEquals(expectedDiagnosticMessage, diagnostic.getDiagnosticMessage());
+  }
+
+  private <T> String getExpectedDiagnosticMessageWithIgnoreWarnings(
+      T referencedFrom, Function<T, String> toSourceStringFunction) {
+    return "Missing class "
+        + getMissingClassReference().getTypeName()
+        + " (referenced from: "
+        + toSourceStringFunction.apply(referencedFrom)
+        + ")";
+  }
+
+  void inspectDiagnosticsWithNoRules(
+      TestDiagnosticMessages diagnostics, ClassReference referencedFrom) {
+    inspectDiagnosticsWithNoRules(
+        diagnostics,
+        getExpectedDiagnosticMessageWithNoRules(referencedFrom, ClassReference::getTypeName));
+  }
+
+  void inspectDiagnosticsWithNoRules(
+      TestDiagnosticMessages diagnostics, FieldReference referencedFrom) {
+    inspectDiagnosticsWithNoRules(
+        diagnostics,
+        getExpectedDiagnosticMessageWithNoRules(
+            referencedFrom, FieldReferenceUtils::toSourceString));
+  }
+
+  void inspectDiagnosticsWithNoRules(
+      TestDiagnosticMessages diagnostics, MethodReference referencedFrom) {
+    inspectDiagnosticsWithNoRules(
+        diagnostics,
+        getExpectedDiagnosticMessageWithNoRules(
+            referencedFrom, MethodReferenceUtils::toSourceString));
+  }
+
+  void inspectDiagnosticsWithNoRules(
+      TestDiagnosticMessages diagnostics, String expectedDiagnosticMessage) {
+    MissingClassesDiagnostic diagnostic =
+        diagnostics
+            .assertOnlyErrors()
+            .assertErrorsCount(1)
+            .assertAllErrorsMatch(diagnosticType(MissingClassesDiagnostic.class))
+            .getError(0);
+    assertEquals(ImmutableSet.of(getMissingClassReference()), diagnostic.getMissingClasses());
+    assertEquals(expectedDiagnosticMessage, diagnostic.getDiagnosticMessage());
+  }
+
+  private <T> String getExpectedDiagnosticMessageWithNoRules(
+      T referencedFrom, Function<T, String> toSourceStringFunction) {
+    return "Compilation can't be completed because the following class is missing: "
+        + getMissingClassReference().getTypeName()
+        + " (referenced from: "
+        + toSourceStringFunction.apply(referencedFrom)
+        + ")"
+        + ".";
   }
 }
diff --git a/src/test/java/com/android/tools/r8/naming/AbstractR8KotlinNamingTestBase.java b/src/test/java/com/android/tools/r8/naming/AbstractR8KotlinNamingTestBase.java
index ddc2da6..2c3f2bb 100644
--- a/src/test/java/com/android/tools/r8/naming/AbstractR8KotlinNamingTestBase.java
+++ b/src/test/java/com/android/tools/r8/naming/AbstractR8KotlinNamingTestBase.java
@@ -7,10 +7,8 @@
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
 import static org.hamcrest.MatcherAssert.assertThat;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.kotlin.AbstractR8KotlinTestBase;
-import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.FieldSubject;
@@ -21,11 +19,10 @@
   protected final boolean minification;
 
   AbstractR8KotlinNamingTestBase(
-      KotlinTargetVersion kotlinTargetVersion,
-      KotlinCompiler kotlinc,
+      KotlinTestParameters kotlinParameters,
       boolean allowAccessModification,
       boolean minification) {
-    super(kotlinTargetVersion, kotlinc, allowAccessModification);
+    super(kotlinParameters, allowAccessModification);
     this.minification = minification;
   }
 
@@ -41,56 +38,27 @@
     return classSubject;
   }
 
-  protected FieldSubject checkFieldIsRenamed(
-      ClassSubject classSubject, String fieldType, String fieldName) {
-    FieldSubject fieldSubject = checkFieldIsKept(classSubject, fieldType, fieldName);
-    assertThat(fieldSubject, isPresentAndRenamed());
-    return fieldSubject;
-  }
-
   protected FieldSubject checkFieldIsRenamed(ClassSubject classSubject, String fieldName) {
     FieldSubject fieldSubject = checkFieldIsKept(classSubject, fieldName);
     assertThat(fieldSubject, isPresentAndRenamed());
     return fieldSubject;
   }
 
-  protected FieldSubject checkFieldIsNotRenamed(
-      ClassSubject classSubject, String fieldType, String fieldName) {
-    FieldSubject fieldSubject = checkFieldIsKept(classSubject, fieldType, fieldName);
-    assertThat(fieldSubject, isPresentAndNotRenamed());
-    return fieldSubject;
-  }
-
   protected FieldSubject checkFieldIsNotRenamed(ClassSubject classSubject, String fieldName) {
     FieldSubject fieldSubject = checkFieldIsKept(classSubject, fieldName);
     assertThat(fieldSubject, isPresentAndNotRenamed());
     return fieldSubject;
   }
 
-  protected MethodSubject checkMethodIsRenamed(
-      ClassSubject classSubject, MethodSignature methodSignature) {
-    MethodSubject methodSubject = checkMethodIsKept(classSubject, methodSignature);
-    assertThat(methodSubject, isPresentAndRenamed());
-    return methodSubject;
-  }
-
   protected MethodSubject checkMethodIsRenamed(ClassSubject classSubject, String methodName) {
     MethodSubject methodSubject = checkMethodIsKept(classSubject, methodName);
     assertThat(methodSubject, isPresentAndRenamed());
     return methodSubject;
   }
 
-  protected MethodSubject checkMethodIsNotRenamed(
-      ClassSubject classSubject, MethodSignature methodSignature) {
-    MethodSubject methodSubject = checkMethodIsKept(classSubject, methodSignature);
-    assertThat(methodSubject, isPresentAndNotRenamed());
-    return methodSubject;
-  }
-
   protected MethodSubject checkMethodIsNotRenamed(ClassSubject classSubject, String methodName) {
     MethodSubject methodSubject = checkMethodIsKept(classSubject, methodName);
     assertThat(methodSubject, isPresentAndNotRenamed());
     return methodSubject;
   }
-
 }
diff --git a/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java b/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
index b96ff51..f911ce6 100644
--- a/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
@@ -3,17 +3,15 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.naming;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
 import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -31,21 +29,17 @@
   private final TestParameters parameters;
   private final boolean minify;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}, minify: {3}")
+  @Parameterized.Parameters(name = "{0}, {1}, minify: {2}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withAllRuntimesAndApiLevels().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers(),
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
         BooleanUtils.values());
   }
 
   public EnumMinificationKotlinTest(
-      TestParameters parameters,
-      KotlinTargetVersion targetVersion,
-      KotlinCompiler kotlinc,
-      boolean minify) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters, boolean minify) {
+    super(kotlinParameters);
     this.parameters = parameters;
     this.minify = minify;
   }
diff --git a/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java b/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
index 7a1b6e4..5d9e78b 100644
--- a/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
+++ b/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
@@ -3,17 +3,15 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.naming;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.SingleTestRunResult;
 import com.android.tools.r8.TestCompileResult;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.kotlin.TestKotlinClass;
@@ -39,21 +37,19 @@
 public class KotlinIntrinsicsIdentifierTest extends AbstractR8KotlinNamingTestBase {
   private static final String FOLDER = "intrinsics_identifiers";
 
-  @Parameters(name = "target: {0}, kotlinc: {1}, allowAccessModification: {2}, minification: {3}")
+  @Parameters(name = "{0}, allowAccessModification: {1}, minification: {2}")
   public static Collection<Object[]> data() {
     return buildParameters(
-        KotlinTargetVersion.values(),
-        getKotlinCompilers(),
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
         BooleanUtils.values(),
         BooleanUtils.values());
   }
 
   public KotlinIntrinsicsIdentifierTest(
-      KotlinTargetVersion targetVersion,
-      KotlinCompiler kotlinc,
+      KotlinTestParameters kotlinParameters,
       boolean allowAccessModification,
       boolean minification) {
-    super(targetVersion, kotlinc, allowAccessModification, minification);
+    super(kotlinParameters, allowAccessModification, minification);
   }
 
   private static final KotlinCompileMemoizer compiledJars =
diff --git a/src/test/java/com/android/tools/r8/naming/b139991218/TestRunner.java b/src/test/java/com/android/tools/r8/naming/b139991218/TestRunner.java
index 69f0148..665e410 100644
--- a/src/test/java/com/android/tools/r8/naming/b139991218/TestRunner.java
+++ b/src/test/java/com/android/tools/r8/naming/b139991218/TestRunner.java
@@ -4,8 +4,8 @@
 
 package com.android.tools.r8.naming.b139991218;
 
-import static junit.framework.TestCase.assertTrue;
-import static org.junit.Assert.assertFalse;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestBase;
@@ -14,8 +14,6 @@
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ir.optimize.Inliner.Reason;
 import com.android.tools.r8.utils.FileUtils;
-import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
 import com.google.common.collect.ImmutableSet;
 import java.io.IOException;
 import java.nio.file.Paths;
@@ -63,21 +61,25 @@
             options -> {
               options.testing.validInliningReasons = ImmutableSet.of(Reason.FORCE);
               options.enableClassInlining = false;
+
+              // TODO(b/179019716): Add support for merging in presence of annotations.
+              options.horizontalClassMergerOptions()
+                      .skipNoClassesOrMembersWithAnnotationsPolicyForTesting =
+                  true;
             })
         .addDontWarnJetBrainsAnnotations()
+        .addHorizontallyMergedClassesInspector(
+            inspector ->
+                inspector.assertIsCompleteMergeGroup(
+                    "com.android.tools.r8.naming.b139991218.Lambda1",
+                    "com.android.tools.r8.naming.b139991218.Lambda2"))
         .setMinApi(parameters.getApiLevel())
         .run(parameters.getRuntime(), Main.class)
-        .assertSuccessWithOutput(StringUtils.lines("11", "12"))
+        .assertSuccessWithOutputLines("11", "12")
         .inspect(
-            inspector -> {
-              // Ensure that we have created a lambda group and that the lambda classes are now
-              // gone.
-              boolean foundLambdaGroup = false;
-              for (FoundClassSubject allClass : inspector.allClasses()) {
-                foundLambdaGroup |= allClass.getOriginalName().contains("LambdaGroup");
-                assertFalse(allClass.getOriginalName().contains("b139991218.Lambda"));
-              }
-              assertTrue(foundLambdaGroup);
-            });
+            inspector ->
+                assertThat(
+                    inspector.clazz("com.android.tools.r8.naming.b139991218.Lambda1"),
+                    isPresent()));
   }
 }
diff --git a/src/test/java/com/android/tools/r8/regress/b113347830/B113347830.java b/src/test/java/com/android/tools/r8/regress/b113347830/B113347830.java
index 397f703..942ae66 100644
--- a/src/test/java/com/android/tools/r8/regress/b113347830/B113347830.java
+++ b/src/test/java/com/android/tools/r8/regress/b113347830/B113347830.java
@@ -48,7 +48,7 @@
 
     testForD8(Backend.DEX)
         .addProgramClassFileData(bytes)
-        .setDisableDesugaring(true)
+        .disableDesugaring()
         .setProgramConsumer(DexIndexedConsumer.emptyConsumer())
         .addOptionsModification(options -> options.testing.disableStackMapVerification = true)
         .compile();
diff --git a/src/test/java/com/android/tools/r8/regress/b149890887/MissingLibraryTargetTest.java b/src/test/java/com/android/tools/r8/regress/b149890887/MissingLibraryTargetTest.java
index 927decb..d01d917 100644
--- a/src/test/java/com/android/tools/r8/regress/b149890887/MissingLibraryTargetTest.java
+++ b/src/test/java/com/android/tools/r8/regress/b149890887/MissingLibraryTargetTest.java
@@ -46,10 +46,6 @@
                 .build()));
   }
 
-  private boolean isDesugaring() {
-    return parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.N);
-  }
-
   @Test
   public void testReference() throws Exception {
     testForRuntime(parameters)
diff --git a/src/test/java/com/android/tools/r8/regress/b77842465/Regress77842465.java b/src/test/java/com/android/tools/r8/regress/b77842465/Regress77842465.java
index 196ca52..cd3743f 100644
--- a/src/test/java/com/android/tools/r8/regress/b77842465/Regress77842465.java
+++ b/src/test/java/com/android/tools/r8/regress/b77842465/Regress77842465.java
@@ -17,7 +17,7 @@
   public void test() throws CompilationFailedException, IOException {
     testForD8()
         .addProgramClassFileData(Regress77842465Dump.dump())
-        .noDesugaring()
+        .disableDesugaring()
         .setMinApi(AndroidApiLevel.M)
         .compile()
         .runDex2Oat(new DexRuntime(ToolHelper.getDexVm()))
diff --git a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
index 94e1e1a..2479dce 100644
--- a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
@@ -5,7 +5,6 @@
 
 import static com.android.tools.r8.Collectors.toSingle;
 import static com.android.tools.r8.ToolHelper.getFilesInTestFolderRelativeToClass;
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.containsLinePositions;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isInlineFrame;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isInlineStack;
@@ -16,11 +15,10 @@
 
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.CompilationMode;
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
 import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.naming.retrace.StackTrace;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
@@ -44,18 +42,17 @@
 
   private final TestParameters parameters;
 
-  @Parameters(name = "{0}")
+  @Parameters(name = "{0}, {1}")
   public static List<Object[]> data() {
     // TODO(b/141817471): Extend with compilation modes.
     return buildParameters(
         getTestParameters().withAllRuntimesAndApiLevels().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public KotlinInlineFunctionInSameFileRetraceTests(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
index 3827c26..945b732 100644
--- a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
@@ -6,7 +6,6 @@
 
 import static com.android.tools.r8.Collectors.toSingle;
 import static com.android.tools.r8.ToolHelper.getFilesInTestFolderRelativeToClass;
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.containsLinePositions;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isInlineFrame;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isInlineStack;
@@ -17,11 +16,10 @@
 
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.CompilationMode;
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
 import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.naming.retrace.StackTrace;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
@@ -45,18 +43,17 @@
   private static final String FILENAME_INLINE_STATIC = "InlineFunction.kt";
   private static final String FILENAME_INLINE_INSTANCE = "InlineFunction.kt";
 
-  @Parameters(name = "{0}")
+  @Parameters(name = "{0}, {1}")
   public static List<Object[]> data() {
     // TODO(b/141817471): Extend with compilation modes.
     return buildParameters(
         getTestParameters().withAllRuntimesAndApiLevels().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers());
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build());
   }
 
   public KotlinInlineFunctionRetraceTest(
-      TestParameters parameters, KotlinTargetVersion targetVersion, KotlinCompiler kotlinc) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters) {
+    super(kotlinParameters);
     this.parameters = parameters;
   }
 
diff --git a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java
index 64ea164..2cc7c96 100644
--- a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java
@@ -4,7 +4,6 @@
 
 package com.android.tools.r8.rewrite.assertions;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.not;
@@ -15,8 +14,8 @@
 
 import com.android.tools.r8.AssertionsConfiguration;
 import com.android.tools.r8.D8TestBuilder;
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
 import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
@@ -63,24 +62,21 @@
   private final boolean useJvmAssertions;
   private final KotlinCompileMemoizer compiledForAssertions;
 
-  @Parameterized.Parameters(
-      name = "{0}, target: {1}, kotlinc: {2}, kotlin-stdlib as library: {3}, -Xassertions=jvm: {4}")
+  @Parameterized.Parameters(name = "{0}, {1}, kotlin-stdlib as library: {2}, -Xassertions=jvm: {3}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withAllRuntimesAndApiLevels().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers(),
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
         BooleanUtils.values(),
         BooleanUtils.values());
   }
 
   public AssertionConfigurationKotlinTest(
       TestParameters parameters,
-      KotlinTargetVersion targetVersion,
-      KotlinCompiler kotlinc,
+      KotlinTestParameters kotlinParameters,
       boolean kotlinStdlibAsClasspath,
       boolean useJvmAssertions) {
-    super(targetVersion, kotlinc);
+    super(kotlinParameters);
     this.parameters = parameters;
     this.kotlinStdlibAsLibrary = kotlinStdlibAsClasspath;
     this.useJvmAssertions = useJvmAssertions;
diff --git a/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java b/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java
index 5ad87de..7ba46d2 100644
--- a/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java
@@ -5,6 +5,7 @@
 
 import static com.android.tools.r8.ToolHelper.EXAMPLES_BUILD_DIR;
 import static com.android.tools.r8.ToolHelper.EXAMPLES_DIR;
+import static org.junit.Assert.assertEquals;
 
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.Diagnostic;
@@ -26,7 +27,6 @@
 import java.util.Collection;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
-import org.junit.Assert;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
@@ -92,12 +92,10 @@
         new DiagnosticsHandler() {
           @Override
           public void error(Diagnostic error) {
-            String expectedErrorMessage =
-                "Compilation can't be completed because the class java.lang.Object is missing.";
-            if (error.getDiagnosticMessage().equals(expectedErrorMessage)) {
-              return;
-            }
-            throw new RuntimeException("Unexpected compilation error");
+            assertEquals(
+                "Compilation can't be completed because the following class is missing: "
+                    + "java.lang.Object.",
+                error.getDiagnosticMessage());
           }
         };
     R8Command.Builder builder = R8Command.builder(handler)
@@ -146,7 +144,7 @@
                     "shaking1",
                     "print-mapping-" + backend.name().toLowerCase() + ".ref")),
             StandardCharsets.UTF_8);
-    Assert.assertEquals(sorted(refMapping), sorted(actualMapping));
+    assertEquals(sorted(refMapping), sorted(actualMapping));
   }
 
   private static String sorted(String str) {
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
index bc55c55..8eaee28 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.shaking.annotations;
 
-import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
 import static org.hamcrest.CoreMatchers.containsString;
@@ -13,10 +12,9 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assume.assumeTrue;
 
-import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
 import com.android.tools.r8.KotlinTestBase;
+import com.android.tools.r8.KotlinTestParameters;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.graph.DexAnnotationElement;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.BooleanUtils;
@@ -62,21 +60,17 @@
   private final TestParameters parameters;
   private final boolean minify;
 
-  @Parameterized.Parameters(name = "{0}, target: {1}, kotlinc: {2}, minify: {3}")
+  @Parameterized.Parameters(name = "{0}, {1}, minify: {2}")
   public static Collection<Object[]> data() {
     return buildParameters(
         getTestParameters().withAllRuntimesAndApiLevels().build(),
-        KotlinTargetVersion.values(),
-        getKotlinCompilers(),
+        getKotlinTestParameters().withAllCompilersAndTargetVersions().build(),
         BooleanUtils.values());
   }
 
   public ReflectiveAnnotationUseTest(
-      TestParameters parameters,
-      KotlinTargetVersion targetVersion,
-      KotlinCompiler kotlinc,
-      boolean minify) {
-    super(targetVersion, kotlinc);
+      TestParameters parameters, KotlinTestParameters kotlinParameters, boolean minify) {
+    super(kotlinParameters);
     this.parameters = parameters;
     this.minify = minify;
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisherTest.java b/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisherTest.java
index 6f9c298..5d5a4b9 100644
--- a/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisherTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/b134858535/EventPublisherTest.java
@@ -51,8 +51,8 @@
         .addKeepClassRules(Interface.class)
         .addKeepMainRule(Main.class)
         .setMinApi(parameters.getApiLevel())
-        .addHorizontallyMergedLambdaClassesInspector(
-            inspector -> inspector.assertClassNotMerged(EventPublisher$b.class))
+        .addHorizontallyMergedClassesInspector(
+            inspector -> inspector.assertClassesNotMerged(EventPublisher$b.class))
         .compile();
   }
 
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptSingletonIsNotCyclicTest.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptSingletonIsNotCyclicTest.java
index 1a61008..a14683a 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptSingletonIsNotCyclicTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptSingletonIsNotCyclicTest.java
@@ -18,6 +18,7 @@
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.shaking.WhyAreYouKeepingConsumer;
@@ -75,6 +76,7 @@
     MethodReference fooClInitRef = Reference.classConstructor(fooClassRef);
     MethodReference fooInitRef = Reference.methodFromMethod(fooClass.getDeclaredConstructor());
 
+    FieldReference testFooFieldRef = Reference.fieldFromField(testClass.getDeclaredField("foo"));
     MethodReference testInitRef =
         Reference.methodFromMethod(testClass.getDeclaredConstructor());
 
@@ -96,8 +98,16 @@
     QueryNode mainMethod = inspector.method(mainMethodRef).assertNotRenamed().assertKeptBy(root);
     // TestClass.<init> is kept by TestClass.main.
     QueryNode testInit = inspector.method(testInitRef).assertPresent().assertKeptBy(mainMethod);
-    // The type Foo is kept by TestClass.<init>
-    QueryNode fooClassNode = inspector.clazz(fooClassRef).assertRenamed().assertKeptBy(testInit);
+    // TestClass.foo is kept by TestClass.<init>.
+    QueryNode testFooFieldNode =
+        inspector.field(testFooFieldRef).assertPresent().assertKeptBy(testInit);
+    // The type Foo is not kept by TestClass.<init>, but TestClass.foo.
+    QueryNode fooClassNode =
+        inspector
+            .clazz(fooClassRef)
+            .assertRenamed()
+            .assertKeptBy(testFooFieldNode)
+            .assertNotKeptBy(testInit);
     // Foo.<clinit> is kept by Foo
     QueryNode fooClInit = inspector.method(fooClInitRef).assertPresent().assertKeptBy(fooClassNode);
     // The type Foo is also kept by Foo.<clinit>
diff --git a/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java b/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
index 3f9c6af..6f3a6cc 100644
--- a/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
+++ b/src/test/java/com/android/tools/r8/synthesis/SyntheticItemsTestUtils.java
@@ -86,6 +86,10 @@
     return SyntheticNaming.isSynthetic(reference, Phase.EXTERNAL, SyntheticKind.OUTLINE);
   }
 
+  public static boolean isInitializerTypeArgument(ClassReference reference) {
+    return SyntheticNaming.isSynthetic(reference, null, SyntheticKind.INIT_TYPE_ARGUMENT);
+  }
+
   public static Matcher<String> containsInternalSyntheticReference() {
     return containsString(SyntheticNaming.getPhaseSeparator(Phase.INTERNAL));
   }
diff --git a/src/test/java/com/android/tools/r8/tracereferences/TraceReferenceStaticFieldIndirectionTest.java b/src/test/java/com/android/tools/r8/tracereferences/TraceReferenceStaticFieldIndirectionTest.java
new file mode 100644
index 0000000..b0e6069
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/tracereferences/TraceReferenceStaticFieldIndirectionTest.java
@@ -0,0 +1,110 @@
+// Copyright (c) 2021, 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.tracereferences;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.DiagnosticsChecker;
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.ZipUtils.ZipBuilder;
+import com.google.common.collect.ImmutableSet;
+import java.nio.file.Path;
+import java.util.HashSet;
+import java.util.Set;
+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 TraceReferenceStaticFieldIndirectionTest extends TestBase {
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withNoneRuntime().build();
+  }
+
+  public TraceReferenceStaticFieldIndirectionTest(TestParameters parameters) {}
+
+  static class MissingReferencesConsumer implements TraceReferencesConsumer {
+
+    private Set<FieldReference> seenFields = new HashSet<>();
+
+    @Override
+    public void acceptType(TracedClass tracedClass, DiagnosticsHandler handler) {}
+
+    @Override
+    public void acceptField(TracedField tracedField, DiagnosticsHandler handler) {
+      seenFields.add(tracedField.getReference());
+    }
+
+    @Override
+    public void acceptMethod(TracedMethod tracedMethod, DiagnosticsHandler handler) {}
+  }
+
+  @Test
+  public void traceStaticFields() throws Throwable {
+    Path dir = temp.newFolder().toPath();
+    Path targetJar =
+        ZipBuilder.builder(dir.resolve("target.jar"))
+            .addFilesRelative(
+                ToolHelper.getClassPathForTests(),
+                ToolHelper.getClassFileForTestClass(SuperClass.class),
+                ToolHelper.getClassFileForTestClass(SubClass.class))
+            .build();
+    Path sourceJar =
+        ZipBuilder.builder(dir.resolve("source.jar"))
+            .addFilesRelative(
+                ToolHelper.getClassPathForTests(), ToolHelper.getClassFileForTestClass(Main.class))
+            .build();
+    DiagnosticsChecker diagnosticsChecker = new DiagnosticsChecker();
+    MissingReferencesConsumer consumer = new MissingReferencesConsumer();
+
+    TraceReferences.run(
+        TraceReferencesCommand.builder(diagnosticsChecker)
+            .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P))
+            .addSourceFiles(sourceJar)
+            .addTargetFiles(targetJar)
+            .setConsumer(consumer)
+            .build());
+
+    ImmutableSet<FieldReference> expectedSet =
+        ImmutableSet.of(
+            Reference.field(
+                Reference.classFromClass(SuperClass.class),
+                "field1",
+                Reference.typeFromTypeName("int")),
+            Reference.field(
+                Reference.classFromClass(SubClass.class),
+                "field2",
+                Reference.typeFromTypeName("int")));
+    assertEquals(expectedSet, consumer.seenFields);
+  }
+
+  static class SuperClass {
+
+    static int field1 = 1;
+  }
+
+  static class SubClass extends SuperClass {
+
+    static int field2 = 2;
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      System.out.println(SubClass.field1);
+      System.out.println(SubClass.field2);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/tracereferences/TraceReferenceStaticMethodIndirectionTest.java b/src/test/java/com/android/tools/r8/tracereferences/TraceReferenceStaticMethodIndirectionTest.java
new file mode 100644
index 0000000..3c35e76
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/tracereferences/TraceReferenceStaticMethodIndirectionTest.java
@@ -0,0 +1,117 @@
+// Copyright (c) 2021, 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.tracereferences;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.DiagnosticsChecker;
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.ZipUtils.ZipBuilder;
+import com.google.common.collect.ImmutableSet;
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+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 TraceReferenceStaticMethodIndirectionTest extends TestBase {
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withNoneRuntime().build();
+  }
+
+  public TraceReferenceStaticMethodIndirectionTest(TestParameters parameters) {}
+
+  static class MissingReferencesConsumer implements TraceReferencesConsumer {
+
+    private Set<MethodReference> seenMethods = new HashSet<>();
+
+    @Override
+    public void acceptType(TracedClass tracedClass, DiagnosticsHandler handler) {}
+
+    @Override
+    public void acceptField(TracedField tracedField, DiagnosticsHandler handler) {}
+
+    @Override
+    public void acceptMethod(TracedMethod tracedMethod, DiagnosticsHandler handler) {
+      seenMethods.add(tracedMethod.getReference());
+    }
+  }
+
+  @Test
+  public void traceStaticMethods() throws Throwable {
+    Path dir = temp.newFolder().toPath();
+    Path targetJar =
+        ZipBuilder.builder(dir.resolve("target.jar"))
+            .addFilesRelative(
+                ToolHelper.getClassPathForTests(),
+                ToolHelper.getClassFileForTestClass(SuperClass.class),
+                ToolHelper.getClassFileForTestClass(SubClass.class))
+            .build();
+    Path sourceJar =
+        ZipBuilder.builder(dir.resolve("source.jar"))
+            .addFilesRelative(
+                ToolHelper.getClassPathForTests(), ToolHelper.getClassFileForTestClass(Main.class))
+            .build();
+    DiagnosticsChecker diagnosticsChecker = new DiagnosticsChecker();
+    MissingReferencesConsumer consumer = new MissingReferencesConsumer();
+
+    TraceReferences.run(
+        TraceReferencesCommand.builder(diagnosticsChecker)
+            .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P))
+            .addSourceFiles(sourceJar)
+            .addTargetFiles(targetJar)
+            .setConsumer(consumer)
+            .build());
+
+    ImmutableSet<MethodReference> expectedSet =
+        ImmutableSet.of(
+            Reference.method(
+                Reference.classFromClass(SuperClass.class),
+                "method1",
+                Collections.emptyList(),
+                null),
+            Reference.method(
+                Reference.classFromClass(SubClass.class),
+                "method2",
+                Collections.emptyList(),
+                null));
+    assertEquals(expectedSet, consumer.seenMethods);
+  }
+
+  static class SuperClass {
+
+    static void method1() {
+      System.out.println("SuperClass::method1");
+    }
+  }
+
+  static class SubClass extends SuperClass {
+
+    static void method2() {
+      System.out.println("SuperClass::method2");
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      SuperClass.method1();
+      SubClass.method2();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java
index cb09a17..491bf9d 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java
@@ -12,6 +12,7 @@
 import com.android.tools.r8.references.ClassReference;
 import java.util.List;
 import java.util.function.Consumer;
+import java.util.function.Predicate;
 import kotlinx.metadata.jvm.KotlinClassMetadata;
 import org.junit.rules.TemporaryFolder;
 
@@ -38,7 +39,7 @@
   }
 
   @Override
-  public MethodSubject uniqueInstanceInitializer() {
+  public MethodSubject uniqueMethodThatMatches(Predicate<FoundMethodSubject> predicate) {
     return new AbsentMethodSubject();
   }
 
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/AssertUtils.java b/src/test/java/com/android/tools/r8/utils/codeinspector/AssertUtils.java
index e9634a5..174e734 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/AssertUtils.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/AssertUtils.java
@@ -9,6 +9,8 @@
 
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.utils.ThrowingAction;
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
 import java.util.function.Consumer;
 
 public class AssertUtils {
@@ -54,7 +56,7 @@
         action.execute();
         fail("Expected action to fail with an exception, but succeeded");
       } catch (Throwable e) {
-        assertEquals(clazz, e.getClass());
+        assertEquals(printStackTraceToString(e), clazz, e.getClass());
         if (consumer != null) {
           consumer.accept(e);
         }
@@ -63,4 +65,12 @@
       action.execute();
     }
   }
+
+  private static String printStackTraceToString(Throwable e) {
+    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+    try (PrintStream ps = new PrintStream(baos)) {
+      e.printStackTrace(ps);
+    }
+    return baos.toString();
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
index cec4e2b..ee96d6b 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
@@ -96,7 +96,11 @@
 
   public abstract MethodSubject method(String returnType, String name, List<String> parameters);
 
-  public abstract MethodSubject uniqueInstanceInitializer();
+  public final MethodSubject uniqueInstanceInitializer() {
+    return uniqueMethodThatMatches(FoundMethodSubject::isInstanceInitializer);
+  }
+
+  public abstract MethodSubject uniqueMethodThatMatches(Predicate<FoundMethodSubject> predicate);
 
   public abstract MethodSubject uniqueMethodWithName(String name);
 
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
index 0bfe560..ed04f35 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
@@ -46,6 +46,7 @@
 import java.util.List;
 import java.util.Set;
 import java.util.function.Consumer;
+import java.util.function.Predicate;
 import kotlinx.metadata.jvm.KotlinClassMetadata;
 import org.junit.rules.TemporaryFolder;
 
@@ -128,9 +129,9 @@
   }
 
   @Override
-  public MethodSubject uniqueInstanceInitializer() {
+  public MethodSubject uniqueMethodThatMatches(Predicate<FoundMethodSubject> predicate) {
     MethodSubject methodSubject = null;
-    for (FoundMethodSubject candidate : allMethods(FoundMethodSubject::isInstanceInitializer)) {
+    for (FoundMethodSubject candidate : allMethods(predicate)) {
       assert methodSubject == null;
       methodSubject = candidate;
     }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/HorizontallyMergedClassesInspector.java b/src/test/java/com/android/tools/r8/utils/codeinspector/HorizontallyMergedClassesInspector.java
index e90df17..a5c623c 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/HorizontallyMergedClassesInspector.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/HorizontallyMergedClassesInspector.java
@@ -8,16 +8,25 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
+import com.android.tools.r8.TestBase;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.horizontalclassmerging.HorizontallyMergedClasses;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.SetUtils;
+import com.android.tools.r8.utils.StringUtils;
 import com.google.common.collect.Sets;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.List;
 import java.util.Set;
 import java.util.function.BiConsumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class HorizontallyMergedClassesInspector {
 
@@ -59,8 +68,32 @@
 
   public HorizontallyMergedClassesInspector assertMergedInto(Class<?> from, Class<?> target) {
     assertEquals(
-        horizontallyMergedClasses.getMergeTargetOrDefault(toDexType(from, dexItemFactory)),
-        toDexType(target, dexItemFactory));
+        horizontallyMergedClasses.getMergeTargetOrDefault(toDexType(from)), toDexType(target));
+    return this;
+  }
+
+  public HorizontallyMergedClassesInspector assertClassesMerged(Collection<Class<?>> classes) {
+    return assertTypesMerged(classes.stream().map(this::toDexType).collect(Collectors.toList()));
+  }
+
+  public HorizontallyMergedClassesInspector assertClassReferencesMerged(
+      Collection<ClassReference> classReferences) {
+    return assertTypesMerged(
+        classReferences.stream().map(this::toDexType).collect(Collectors.toList()));
+  }
+
+  public HorizontallyMergedClassesInspector assertTypesMerged(Collection<DexType> types) {
+    List<DexType> unmerged = new ArrayList<>();
+    for (DexType type : types) {
+      if (!horizontallyMergedClasses.hasBeenMergedOrIsMergeTarget(type)) {
+        unmerged.add(type);
+      }
+    }
+    assertEquals(
+        "Expected the following classes to be merged: "
+            + StringUtils.join(", ", unmerged, DexType::getTypeName),
+        0,
+        unmerged.size());
     return this;
   }
 
@@ -69,52 +102,91 @@
     return this;
   }
 
-  public HorizontallyMergedClassesInspector assertClassNotMerged(Class<?> clazz) {
-    assertFalse(
-        horizontallyMergedClasses.hasBeenMergedIntoDifferentType(toDexType(clazz, dexItemFactory)));
-    return this;
-  }
-
-  public HorizontallyMergedClassesInspector assertClassesNotMerged(Collection<Class<?>> classes) {
-    for (Class<?> clazz : classes) {
-      assertClassNotMerged(clazz);
-    }
-    return this;
-  }
-
   public HorizontallyMergedClassesInspector assertClassesNotMerged(Class<?>... classes) {
     return assertClassesNotMerged(Arrays.asList(classes));
   }
 
-  public HorizontallyMergedClassesInspector assertClassNotMergedIntoDifferentType(Class<?> clazz) {
-    assertFalse(
-        horizontallyMergedClasses.hasBeenMergedIntoDifferentType(toDexType(clazz, dexItemFactory)));
-    return this;
+  public HorizontallyMergedClassesInspector assertClassesNotMerged(Collection<Class<?>> classes) {
+    return assertTypesNotMerged(classes.stream().map(this::toDexType).collect(Collectors.toList()));
   }
 
-  public HorizontallyMergedClassesInspector assertMerged(Class<?> clazz) {
-    assertTrue(
-        horizontallyMergedClasses.hasBeenMergedOrIsMergeTarget(toDexType(clazz, dexItemFactory)));
-    return this;
+  public HorizontallyMergedClassesInspector assertClassReferencesNotMerged(
+      ClassReference... classReferences) {
+    return assertClassReferencesNotMerged(Arrays.asList(classReferences));
   }
 
-  public HorizontallyMergedClassesInspector assertMerged(Class<?>... classes) {
-    for (Class<?> clazz : classes) {
-      assertMerged(clazz);
+  public HorizontallyMergedClassesInspector assertClassReferencesNotMerged(
+      Collection<ClassReference> classReferences) {
+    return assertTypesNotMerged(
+        classReferences.stream().map(this::toDexType).collect(Collectors.toList()));
+  }
+
+  public HorizontallyMergedClassesInspector assertTypesNotMerged(DexType... types) {
+    return assertTypesNotMerged(Arrays.asList(types));
+  }
+
+  public HorizontallyMergedClassesInspector assertTypesNotMerged(Collection<DexType> types) {
+    for (DexType type : types) {
+      assertTrue(type.isClassType());
+      assertFalse(horizontallyMergedClasses.hasBeenMergedOrIsMergeTarget(type));
     }
     return this;
   }
 
-  public HorizontallyMergedClassesInspector assertMergedIntoDifferentType(Class<?> clazz) {
-    assertTrue(
-        horizontallyMergedClasses.hasBeenMergedIntoDifferentType(toDexType(clazz, dexItemFactory)));
+  public HorizontallyMergedClassesInspector assertIsCompleteMergeGroup(String... typeNames) {
+    return assertIsCompleteMergeGroup(
+        Stream.of(typeNames).map(Reference::classFromTypeName).collect(Collectors.toList()));
+  }
+
+  public HorizontallyMergedClassesInspector assertIsCompleteMergeGroup(
+      Collection<ClassReference> classReferences) {
+    assertFalse(classReferences.isEmpty());
+    List<DexType> types =
+        classReferences.stream().map(this::toDexType).collect(Collectors.toList());
+    DexType uniqueTarget = null;
+    for (DexType type : types) {
+      if (horizontallyMergedClasses.isMergeTarget(type)) {
+        if (uniqueTarget == null) {
+          uniqueTarget = type;
+        } else {
+          fail(
+              "Expected a single merge target, but found "
+                  + type.getTypeName()
+                  + " and "
+                  + uniqueTarget.getTypeName());
+        }
+      }
+    }
+    if (uniqueTarget == null) {
+      for (DexType type : types) {
+        if (horizontallyMergedClasses.hasBeenMergedIntoDifferentType(type)) {
+          fail(
+              "Expected merge target "
+                  + horizontallyMergedClasses.getMergeTargetOrDefault(type).getTypeName()
+                  + " to be in merge group");
+        }
+      }
+      fail("Expected to find a merge target, but none found");
+    }
+    Set<DexType> sources = horizontallyMergedClasses.getSourcesFor(uniqueTarget);
+    assertEquals(
+        "Expected to find "
+            + (classReferences.size() - 1)
+            + " source(s) for merge target "
+            + uniqueTarget.getTypeName()
+            + ", but only found: "
+            + StringUtils.join(", ", sources, DexType::getTypeName),
+        classReferences.size() - 1,
+        sources.size());
+    assertTrue(types.containsAll(sources));
     return this;
   }
 
-  public HorizontallyMergedClassesInspector assertMergedIntoDifferentType(Class<?>... classes) {
-    for (Class<?> clazz : classes) {
-      assertMergedIntoDifferentType(clazz);
-    }
-    return this;
+  private DexType toDexType(Class<?> clazz) {
+    return TestBase.toDexType(clazz, dexItemFactory);
+  }
+
+  private DexType toDexType(ClassReference classReference) {
+    return TestBase.toDexType(classReference, dexItemFactory);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/HorizontallyMergedLambdaClassesInspector.java b/src/test/java/com/android/tools/r8/utils/codeinspector/HorizontallyMergedLambdaClassesInspector.java
deleted file mode 100644
index 619b415..0000000
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/HorizontallyMergedLambdaClassesInspector.java
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.utils.codeinspector;
-
-import static com.android.tools.r8.TestBase.toDexType;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.classmerging.HorizontallyMergedLambdaClasses;
-import java.util.Set;
-import java.util.function.BiConsumer;
-
-public class HorizontallyMergedLambdaClassesInspector {
-
-  private final DexItemFactory dexItemFactory;
-  private final HorizontallyMergedLambdaClasses horizontallyMergedLambdaClasses;
-
-  public HorizontallyMergedLambdaClassesInspector(
-      DexItemFactory dexItemFactory,
-      HorizontallyMergedLambdaClasses horizontallyMergedLambdaClasses) {
-    this.dexItemFactory = dexItemFactory;
-    this.horizontallyMergedLambdaClasses = horizontallyMergedLambdaClasses;
-  }
-
-  public HorizontallyMergedLambdaClassesInspector assertMerged(Class<?> clazz) {
-    assertTrue(
-        horizontallyMergedLambdaClasses.hasBeenMergedIntoDifferentType(
-            toDexType(clazz, dexItemFactory)));
-    return this;
-  }
-
-  public HorizontallyMergedLambdaClassesInspector assertMerged(Class<?>... classes) {
-    for (Class<?> clazz : classes) {
-      assertMerged(clazz);
-    }
-    return this;
-  }
-
-  public HorizontallyMergedLambdaClassesInspector assertClassNotMerged(Class<?> clazz) {
-    assertFalse(
-        horizontallyMergedLambdaClasses.hasBeenMergedIntoDifferentType(
-            toDexType(clazz, dexItemFactory)));
-    return this;
-  }
-
-  public void forEachMergeGroup(BiConsumer<Set<DexType>, DexType> consumer) {
-    horizontallyMergedLambdaClasses.forEachMergeGroup(consumer);
-  }
-}