diff --git a/LIBRARY-LICENSE b/LIBRARY-LICENSE
index aa4218c..9808c03 100644
--- a/LIBRARY-LICENSE
+++ b/LIBRARY-LICENSE
@@ -200,18 +200,24 @@
   license: The Apache License, Version 2.0
   licenseUrl: http://www.apache.org/licenses/LICENSE-2.0.txt
   url: http://code.google.com/p/atinject/source/checkout
-- artifact: org.bouncycastle:bcpkix-jdk15on
+- artifact: org.bouncycastle:bcpkix-jdk18on
   name: Bouncy Castle PKIX, CMS, EAC, TSP, PKCS, OCSP, CMP, and CRMF APIs
   copyrightHolder: The Legion of the Bouncy Castle Inc.
   license: The MIT License
   licenseUrl: http://opensource.org/licenses/MIT
   url: http://www.bouncycastle.org/java.html
-- artifact: org.bouncycastle:bcprov-jdk15on
+- artifact: org.bouncycastle:bcprov-jdk18on
   name: Bouncy Castle Provider
   copyrightHolder: The Legion of the Bouncy Castle Inc.
   license: The MIT License
   licenseUrl: http://opensource.org/licenses/MIT
   url: http://www.bouncycastle.org/java.html
+- artifact: org.bouncycastle:bcutil-jdk18on
+  name: Bouncy Castle ASN.1 Extension and Utility APIs
+  copyrightHolder: The Legion of the Bouncy Castle Inc.
+  license: The MIT License
+  licenseUrl: http://opensource.org/licenses/MIT
+  url: http://www.bouncycastle.org/java.html
 - artifact: org.glassfish.jaxb:jaxb-runtime
   name: JAXB Runtime
   copyrightHolder: Oracle and/or its affiliates
diff --git a/d8_r8/commonBuildSrc/src/main/kotlin/DependenciesPlugin.kt b/d8_r8/commonBuildSrc/src/main/kotlin/DependenciesPlugin.kt
index 121a668..99f829f 100644
--- a/d8_r8/commonBuildSrc/src/main/kotlin/DependenciesPlugin.kt
+++ b/d8_r8/commonBuildSrc/src/main/kotlin/DependenciesPlugin.kt
@@ -13,12 +13,18 @@
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.Directory
 import org.gradle.api.file.DuplicatesStrategy
+import org.gradle.api.file.RegularFile
 import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.api.tasks.JavaExec
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.testing.Test
 import org.gradle.jvm.tasks.Jar
+import org.gradle.jvm.toolchain.JavaInstallationMetadata
+import org.gradle.jvm.toolchain.JavaLanguageVersion
+import org.gradle.jvm.toolchain.JavaLauncher
+import org.gradle.jvm.toolchain.internal.DefaultJavaLanguageVersion
 import org.gradle.kotlin.dsl.register
 import org.gradle.nativeplatform.platform.OperatingSystem
 import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform
@@ -43,12 +49,12 @@
   }
 }
 
-enum class Jdk(val folder : String) {
-  JDK_8("jdk8"),
-  JDK_9("openjdk-9.0.4"),
-  JDK_11("jdk-11"),
-  JDK_17("jdk-17"),
-  JDK_21("jdk-21");
+enum class Jdk(val folder : String, val version: Int) {
+  JDK_8("jdk8", 8),
+  JDK_9("openjdk-9.0.4", 9),
+  JDK_11("jdk-11", 11),
+  JDK_17("jdk-17", 17),
+  JDK_21("jdk-21", 21);
 
   fun isJdk8() : Boolean {
     return this == JDK_8
@@ -268,6 +274,42 @@
   return getJavaHome(jdk).resolveAll("bin", binary).toString()
 }
 
+fun Project.getJavaLauncher(jdk : Jdk) : JavaLauncher {
+  return object : JavaLauncher {
+    override fun getMetadata(): JavaInstallationMetadata {
+      return object : JavaInstallationMetadata {
+        override fun getLanguageVersion(): JavaLanguageVersion {
+          return DefaultJavaLanguageVersion.of(jdk.version)
+        }
+
+        override fun getJavaRuntimeVersion(): String {
+          return jdk.name
+        }
+
+        override fun getJvmVersion(): String {
+          return jdk.name
+        }
+
+        override fun getVendor(): String {
+          return "vendor"
+        }
+
+        override fun getInstallationPath(): Directory {
+          return project.layout.projectDirectory.dir(getJavaHome(jdk).toString())
+        }
+
+        override fun isCurrentJvm(): Boolean {
+          return false
+        }
+      }
+    }
+
+    override fun getExecutablePath(): RegularFile {
+      return project.layout.projectDirectory.file(getJavaPath(jdk))
+    }
+  }
+}
+
 fun Project.getClasspath(vararg paths: File) : String {
   val os: OperatingSystem = DefaultNativePlatform.getCurrentOperatingSystem()
   assert (!paths.isEmpty())
diff --git a/d8_r8/resourceshrinker/build.gradle.kts b/d8_r8/resourceshrinker/build.gradle.kts
index c716378..183d1ed 100644
--- a/d8_r8/resourceshrinker/build.gradle.kts
+++ b/d8_r8/resourceshrinker/build.gradle.kts
@@ -36,9 +36,9 @@
   compileOnly(files(resolve(ThirdPartyDeps.r8, "r8lib_8.2.20-dev.jar")))
   implementation("com.android.tools.build:aapt2-proto:8.2.0-alpha10-10154469")
   implementation("com.google.protobuf:protobuf-java:3.19.3")
-  implementation("com.android.tools.layoutlib:layoutlib-api:31.2.0-rc01")
-  implementation("com.android.tools:common:31.2.0-rc01")
-  implementation("com.android.tools:sdk-common:31.2.0-rc01")
+  implementation("com.android.tools.layoutlib:layoutlib-api:31.5.0-alpha04")
+  implementation("com.android.tools:common:31.5.0-alpha04")
+  implementation("com.android.tools:sdk-common:31.5.0-alpha04")
 }
 
 tasks {
diff --git a/d8_r8/test/build.gradle.kts b/d8_r8/test/build.gradle.kts
index 2bd2638..52b3748 100644
--- a/d8_r8/test/build.gradle.kts
+++ b/d8_r8/test/build.gradle.kts
@@ -459,6 +459,7 @@
       dependsOn(testR8LibNoDeps)
     } else {
       dependsOn(gradle.includedBuild("tests_java_8").task(":test"))
+      dependsOn(gradle.includedBuild("tests_java_17").task(":test"))
       dependsOn(gradle.includedBuild("tests_bootstrap").task(":test"))
     }
   }
diff --git a/d8_r8/test/settings.gradle.kts b/d8_r8/test/settings.gradle.kts
index d114948..52121d0 100644
--- a/d8_r8/test/settings.gradle.kts
+++ b/d8_r8/test/settings.gradle.kts
@@ -36,4 +36,3 @@
 includeBuild(root.resolve("test_modules").resolve("tests_java_11"))
 includeBuild(root.resolve("test_modules").resolve("tests_java_17"))
 includeBuild(root.resolve("test_modules").resolve("tests_java_21"))
-
diff --git a/d8_r8/test_modules/tests_java_17/build.gradle.kts b/d8_r8/test_modules/tests_java_17/build.gradle.kts
index 92f1dcd..f3c9100 100644
--- a/d8_r8/test_modules/tests_java_17/build.gradle.kts
+++ b/d8_r8/test_modules/tests_java_17/build.gradle.kts
@@ -14,6 +14,9 @@
 val root = getRoot()
 
 java {
+  // Can be moved into src/test/java17 when all examples have been converted
+  // to tests. Currently both the Test target below and buildExampleJars depend
+  // on this.
   sourceSets.test.configure {
     java.srcDir(root.resolveAll("src", "test", "examplesJava17"))
   }
@@ -21,7 +24,16 @@
   targetCompatibility = JavaVersion.VERSION_17
 }
 
-dependencies { }
+val testbaseJavaCompileTask = projectTask("testbase", "compileJava")
+val testbaseDepsJarTask = projectTask("testbase", "depsJar")
+val mainCompileTask = projectTask("main", "compileJava")
+
+
+dependencies {
+  implementation(files(testbaseDepsJarTask.outputs.files.getSingleFile()))
+  implementation(testbaseJavaCompileTask.outputs.files)
+  implementation(mainCompileTask.outputs.files)
+}
 
 // We just need to register the examples jars for it to be referenced by other modules.
 val buildExampleJars = buildExampleJars("examplesJava17")
@@ -33,5 +45,17 @@
     options.forkOptions.memoryMaximumSize = "3g"
     options.forkOptions.executable = getCompilerPath(Jdk.JDK_17)
   }
+
+  withType<Test> {
+    TestingState.setUpTestingState(this)
+    javaLauncher = getJavaLauncher(Jdk.JDK_17)
+    systemProperty("TEST_DATA_LOCATION",
+                   // This should be
+                   //   layout.buildDirectory.dir("classes/java/test").get().toString()
+                   // once the use of 'buildExampleJars' above is removed.
+                   getRoot().resolveAll("build", "test", "examplesJava17", "classes"))
+    systemProperty("TESTBASE_DATA_LOCATION",
+                   testbaseJavaCompileTask.outputs.files.getAsPath().split(File.pathSeparator)[0])
+  }
 }
 
diff --git a/d8_r8/test_modules/tests_java_17/settings.gradle.kts b/d8_r8/test_modules/tests_java_17/settings.gradle.kts
index c01f377..ce5980a 100644
--- a/d8_r8/test_modules/tests_java_17/settings.gradle.kts
+++ b/d8_r8/test_modules/tests_java_17/settings.gradle.kts
@@ -23,4 +23,7 @@
 
 rootProject.name = "tests_java_17"
 val root = rootProject.projectDir.parentFile.parentFile
+
 includeBuild(root.resolve("shared"))
+includeBuild(root.resolve("main"))
+includeBuild(root.resolve("test_modules").resolve("testbase"))
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdge.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdge.java
index 05ee81c..9932654 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdge.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdge.java
@@ -215,6 +215,12 @@
 
   @Override
   public String toString() {
-    return "KeepEdge{" + "preconditions=" + preconditions + ", consequences=" + consequences + '}';
+    return "KeepEdge{metainfo="
+        + getMetaInfo()
+        + ", preconditions="
+        + preconditions
+        + ", consequences="
+        + consequences
+        + '}';
   }
 }
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdgeMetaInfo.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdgeMetaInfo.java
index 6d4705a..9cf3305 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdgeMetaInfo.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdgeMetaInfo.java
@@ -3,6 +3,9 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.keepanno.ast;
 
+import com.android.tools.r8.keepanno.keeprules.RulePrintingUtils;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Objects;
 
 public class KeepEdgeMetaInfo {
@@ -62,6 +65,21 @@
     return version;
   }
 
+  public String toString() {
+    List<String> props = new ArrayList<>(3);
+    if (hasVersion()) {
+      props.add("version=" + version);
+    }
+    if (hasContext()) {
+      props.add("context=" + context.getDescriptorString());
+    }
+    if (hasDescription()) {
+      props.add(
+          "description=\"" + RulePrintingUtils.escapeLineBreaks(description.description) + "\"");
+    }
+    return "MetaInfo{" + String.join(", ", props) + "}";
+  }
+
   public static class Builder {
     private KeepEdgeContext context = KeepEdgeContext.none();
     private KeepEdgeDescription description = KeepEdgeDescription.empty();
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index fe43d5c..7cabfb6 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -33,7 +33,6 @@
 import com.android.tools.r8.graph.PrunedItems;
 import com.android.tools.r8.graph.SubtypingInfo;
 import com.android.tools.r8.graph.analysis.ClassInitializerAssertionEnablingAnalysis;
-import com.android.tools.r8.graph.analysis.InitializedClassesInInstanceMethodsAnalysis;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMerger;
 import com.android.tools.r8.inspector.internal.InspectorImpl;
 import com.android.tools.r8.ir.conversion.IRConverter;
@@ -503,6 +502,9 @@
 
       assert ArtProfileCompletenessChecker.verify(appView);
 
+      LirConverter.rewriteLirWithLens(appView, timing, executorService);
+      appView.clearCodeRewritings(executorService, timing);
+
       VerticalClassMerger.createForInitialClassMerging(appViewWithLiveness, timing)
           .runIfNecessary(executorService, timing);
 
@@ -868,6 +870,7 @@
       assert appView.dexItemFactory().verifyNoCachedTypeElements();
 
       // Generate the resulting application resources.
+      writeKeepDeclarationsToConfigurationConsumer(keepDeclarations);
       writeApplication(appView, inputApp, executorService);
 
       if (options.androidResourceProvider != null && options.androidResourceConsumer != null) {
@@ -888,6 +891,27 @@
     }
   }
 
+  private void writeKeepDeclarationsToConfigurationConsumer(
+      List<KeepDeclaration> keepDeclarations) {
+    if (options.configurationConsumer == null) {
+      return;
+    }
+    if (keepDeclarations.isEmpty()) {
+      return;
+    }
+    for (KeepDeclaration declaration : keepDeclarations) {
+      List<String> lines = StringUtils.splitLines(declaration.toString());
+      StringBuilder builder = new StringBuilder();
+      builder.append("# Start of content from keep annotations\n");
+      for (String line : lines) {
+        builder.append("# ").append(line).append("\n");
+      }
+      builder.append("# End of content from keep annotations\n");
+      ExceptionUtils.withConsumeResourceHandler(
+          options.reporter, options.configurationConsumer, builder.toString());
+    }
+  }
+
   private static ForwardingConsumer wrapConsumerStoreBytesInList(
       Map<String, byte[]> dexFileContent,
       DexIndexedConsumer programConsumer,
@@ -1116,9 +1140,6 @@
             appView, profileCollectionAdditions, executorService, subtypingInfo);
     enqueuer.setKeepDeclarations(keepDeclarations);
     enqueuer.setAnnotationRemoverBuilder(annotationRemoverBuilder);
-    if (appView.options().enableInitializedClassesInInstanceMethodsAnalysis) {
-      enqueuer.registerAnalysis(new InitializedClassesInInstanceMethodsAnalysis(appView));
-    }
     if (AssertionsRewriter.isEnabled(appView.options())) {
       ClassInitializerAssertionEnablingAnalysis analysis =
           new ClassInitializerAssertionEnablingAnalysis(
diff --git a/src/main/java/com/android/tools/r8/dex/DexParser.java b/src/main/java/com/android/tools/r8/dex/DexParser.java
index cb80f3d..5ddb8c1 100644
--- a/src/main/java/com/android/tools/r8/dex/DexParser.java
+++ b/src/main/java/com/android/tools/r8/dex/DexParser.java
@@ -1027,6 +1027,9 @@
     int saved = dexReader.position();
     DexDebugInfo debugInfo = debugInfoAt(debugInfoOff, instructions);
     dexReader.position(saved);
+    if (options.testing.nullOutDebugInfo) {
+      debugInfo = null;
+    }
 
     return new DexCode(registerSize, insSize, outsSize, instructions, tries, handlers, debugInfo);
   }
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 42e9f77..3ea094d 100644
--- a/src/main/java/com/android/tools/r8/graph/AppView.java
+++ b/src/main/java/com/android/tools/r8/graph/AppView.java
@@ -52,6 +52,7 @@
 import com.android.tools.r8.shaking.KeepFieldInfo;
 import com.android.tools.r8.shaking.KeepInfo;
 import com.android.tools.r8.shaking.KeepInfoCollection;
+import com.android.tools.r8.shaking.KeepMemberInfo;
 import com.android.tools.r8.shaking.KeepMethodInfo;
 import com.android.tools.r8.shaking.LibraryModeledPredicate;
 import com.android.tools.r8.shaking.MainDexInfo;
@@ -715,6 +716,14 @@
     this.kotlinMetadataLens = kotlinMetadataLens;
   }
 
+  public boolean hasInitializedClassesInInstanceMethods() {
+    return initializedClassesInInstanceMethods != null;
+  }
+
+  public InitializedClassesInInstanceMethods getInitializedClassesInInstanceMethods() {
+    return initializedClassesInInstanceMethods;
+  }
+
   public void setInitializedClassesInInstanceMethods(
       InitializedClassesInInstanceMethods initializedClassesInInstanceMethods) {
     this.initializedClassesInInstanceMethods = initializedClassesInInstanceMethods;
@@ -800,6 +809,12 @@
     return getKeepInfo().getFieldInfo(field);
   }
 
+  public KeepMemberInfo<?, ?> getKeepInfo(ProgramMember<?, ?> member) {
+    return member.isField()
+        ? getKeepInfo(member.asProgramField())
+        : getKeepInfo(member.asProgramMethod());
+  }
+
   public KeepMethodInfo getKeepInfo(ProgramMethod method) {
     return getKeepInfo().getMethodInfo(method);
   }
@@ -1239,6 +1254,20 @@
                 public boolean shouldRun() {
                   return !appView.cfByteCodePassThrough.isEmpty();
                 }
+              },
+              new ThreadTask() {
+                @Override
+                public void run(Timing timing) {
+                  appView.setInitializedClassesInInstanceMethods(
+                      appView
+                          .getInitializedClassesInInstanceMethods()
+                          .rewrittenWithLens(lens, appliedLens));
+                }
+
+                @Override
+                public boolean shouldRun() {
+                  return appView.hasInitializedClassesInInstanceMethods();
+                }
               });
         });
 
diff --git a/src/main/java/com/android/tools/r8/graph/Code.java b/src/main/java/com/android/tools/r8/graph/Code.java
index b4913b1..3e23b32 100644
--- a/src/main/java/com/android/tools/r8/graph/Code.java
+++ b/src/main/java/com/android/tools/r8/graph/Code.java
@@ -13,10 +13,12 @@
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.NumberGenerator;
 import com.android.tools.r8.ir.code.Position;
+import com.android.tools.r8.ir.code.Position.OutlineCallerPosition;
 import com.android.tools.r8.ir.code.Position.PositionBuilder;
 import com.android.tools.r8.ir.conversion.MethodConversionOptions;
 import com.android.tools.r8.ir.conversion.MethodConversionOptions.MutableMethodConversionOptions;
 import com.android.tools.r8.lightir.LirCode;
+import com.android.tools.r8.utils.Int2StructuralItemArrayMap;
 import com.android.tools.r8.utils.RetracerForCodePrinting;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
 import java.util.function.Consumer;
@@ -219,16 +221,48 @@
     if (!outermostCallee.isOutline() && !outermostCallee.isRemoveInnerFramesIfThrowingNpe()) {
       return calleePosition.replacePosition(outermostCallee, callerPosition);
     }
+    // If the position is inlining an outline then both frames are to be replaced by the
+    // translation of the line positions.
+    if (callerPosition.isOutlineCaller() && outermostCallee.isOutline()) {
+      OutlineCallerPosition outlineCaller = callerPosition.asOutlineCaller();
+      Int2StructuralItemArrayMap<Position> translation = outlineCaller.getOutlinePositions();
+      // Map the synthetic line found in the outline to the actual position as encoded in the
+      // outline-caller position table. Note that the outline may have more lines than the table
+      // if multiple outline instructions translate to the same original caller positions.
+      int outlineLine = outermostCallee.getLine();
+      Position translatedPosition = null;
+      for (int i = 0; i <= outlineLine; i++) {
+        Position result = translation.lookup(i);
+        if (result != null) {
+          translatedPosition = result;
+        }
+      }
+      assert translatedPosition != null;
+      // If the caller has outer frames compose them with the translated position.
+      if (callerPosition.hasCallerPosition()) {
+        translatedPosition =
+            translatedPosition.withOutermostCallerPosition(callerPosition.getCallerPosition());
+      }
+      // If the outline has additional inner frames append them as inner frames on the translation.
+      if (calleePosition.hasCallerPosition()) {
+        translatedPosition = calleePosition.replacePosition(outermostCallee, translatedPosition);
+      }
+      return translatedPosition;
+    }
 
     assert !callerPosition.isOutline();
-    assert !callerPosition.hasCallerPosition();
     // Copy the callee frame to ensure transfer of the outline key if present.
     PositionBuilder<?, ?> newCallerBuilder =
         outermostCallee.builderWithCopy().setMethod(callerPosition.getMethod());
+    // Transfer the callers outer frames if any.
+    if (callerPosition.hasCallerPosition()) {
+      newCallerBuilder.setCallerPosition(callerPosition.getCallerPosition());
+    }
     // If the callee is an outline, the line must be that of the outline to maintain the positions.
     if (outermostCallee.isOutline()) {
       // This does not implement inlining an outline. The cases this hits should always be a full
       // "move as inlining" to be correct.
+      assert !callerPosition.isOutlineCaller();
       assert callerPosition.isD8R8Synthesized();
       assert callerPosition.getLine() == 0;
     } else {
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 f597df0..108877b 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -394,6 +394,12 @@
     return definitionSupplier.definitionFor(this).isInterface();
   }
 
+  public boolean isInterfaceOrDefault(
+      DexDefinitionSupplier definitionSupplier, boolean defaultValue) {
+    DexClass clazz = definitionSupplier.definitionFor(this);
+    return clazz != null ? clazz.isInterface() : defaultValue;
+  }
+
   public DexProgramClass asProgramClass(DexDefinitionSupplier definitions) {
     return asProgramClassOrNull(definitions.definitionFor(this));
   }
diff --git a/src/main/java/com/android/tools/r8/graph/DexTypeUtils.java b/src/main/java/com/android/tools/r8/graph/DexTypeUtils.java
index 30e2f54..bdc9c67 100644
--- a/src/main/java/com/android/tools/r8/graph/DexTypeUtils.java
+++ b/src/main/java/com/android/tools/r8/graph/DexTypeUtils.java
@@ -61,20 +61,22 @@
   public static DexType findApiSafeUpperBound(
       AppView<? extends AppInfoWithClassHierarchy> appView, DexType type) {
     DexItemFactory factory = appView.dexItemFactory();
-    if (type.toBaseType(factory).isPrimitiveType()) {
+    DexType baseType = type.toBaseType(factory);
+    if (baseType.isPrimitiveType()) {
       return type;
     }
-    DexClass clazz = appView.definitionFor(type.isArrayType() ? type.toBaseType(factory) : type);
+    DexClass clazz = appView.definitionFor(baseType);
     if (clazz == null) {
       assert false : "We should not have found an upper bound if the hierarchy is missing";
       return type;
     }
     if (!clazz.isLibraryClass()
-        || AndroidApiLevelUtils.isApiSafeForReference(clazz.asLibraryClass(), appView)) {
+        || AndroidApiLevelUtils.isApiSafeForReference(clazz.asLibraryClass(), appView)
+        || !clazz.hasSuperType()) {
       return type;
     }
-    // Always just return the object type since this is safe for all api versions.
-    return factory.objectType;
+    // Return the nearest API safe supertype.
+    return findApiSafeUpperBound(appView, clazz.getSuperType());
   }
 
   public static boolean isTypeAccessibleInMethodContext(
diff --git a/src/main/java/com/android/tools/r8/graph/analysis/InitializedClassesInInstanceMethodsAnalysis.java b/src/main/java/com/android/tools/r8/graph/analysis/InitializedClassesInInstanceMethodsAnalysis.java
index d849002..ddb64d7 100644
--- a/src/main/java/com/android/tools/r8/graph/analysis/InitializedClassesInInstanceMethodsAnalysis.java
+++ b/src/main/java/com/android/tools/r8/graph/analysis/InitializedClassesInInstanceMethodsAnalysis.java
@@ -9,9 +9,11 @@
 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.lens.GraphLens;
 import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
 import com.android.tools.r8.shaking.Enqueuer;
 import com.android.tools.r8.shaking.EnqueuerWorklist;
+import com.android.tools.r8.utils.MapUtils;
 import java.util.IdentityHashMap;
 import java.util.Map;
 
@@ -50,6 +52,26 @@
       // transitively.
       return !subject.isInterface();
     }
+
+    public InitializedClassesInInstanceMethods rewrittenWithLens(
+        GraphLens lens, GraphLens appliedLens) {
+      return new InitializedClassesInInstanceMethods(
+          appView,
+          MapUtils.transform(
+              mapping,
+              IdentityHashMap::new,
+              key -> {
+                DexType rewrittenKey = lens.lookupType(key, appliedLens);
+                return rewrittenKey.isPrimitiveType() ? null : rewrittenKey;
+              },
+              value -> {
+                DexType rewrittenValue = lens.lookupType(value, appliedLens);
+                return rewrittenValue.isPrimitiveType() ? null : rewrittenValue;
+              },
+              (key, value, otherValue) ->
+                  ClassTypeElement.computeLeastUpperBoundOfClasses(
+                      appView.appInfo(), value, otherValue)));
+    }
   }
 
   private final AppView<? extends AppInfoWithClassHierarchy> appView;
@@ -63,6 +85,16 @@
     this.appView = appView;
   }
 
+  public static void register(
+      AppView<? extends AppInfoWithClassHierarchy> appView, Enqueuer enqueuer) {
+    if (appView.options().enableInitializedClassesInInstanceMethodsAnalysis
+        && enqueuer.getMode().isInitialTreeShaking()) {
+      enqueuer.registerAnalysis(new InitializedClassesInInstanceMethodsAnalysis(appView));
+    } else {
+      appView.setInitializedClassesInInstanceMethods(null);
+    }
+  }
+
   @Override
   public void processNewlyInstantiatedClass(
       DexProgramClass clazz, ProgramMethod context, EnqueuerWorklist worklist) {
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/UndoConstructorInlining.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/UndoConstructorInlining.java
index e507b4f..564b7e1 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/UndoConstructorInlining.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/UndoConstructorInlining.java
@@ -12,6 +12,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.DexClassAndMember;
+import com.android.tools.r8.graph.DexEncodedMember;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
@@ -42,7 +44,9 @@
 import com.android.tools.r8.optimize.argumentpropagation.utils.ProgramClassesBidirectedGraph;
 import com.android.tools.r8.profile.rewriting.ProfileCollectionAdditions;
 import com.android.tools.r8.utils.ArrayUtils;
+import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.ObjectUtils;
+import com.android.tools.r8.utils.SetUtils;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
 import com.android.tools.r8.utils.WorkList;
@@ -52,6 +56,7 @@
 import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Comparator;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
@@ -179,6 +184,7 @@
           this::processClass,
           appView.options().getThreadingModule(),
           executorService);
+      commitPendingConstructors();
       profileCollectionAdditions.commit(appView);
     }
 
@@ -429,6 +435,13 @@
     private StronglyConnectedComponent getStronglyConnectedComponent(DexProgramClass clazz) {
       return stronglyConnectedComponents.get(clazz);
     }
+
+    private void commitPendingConstructors() {
+      Set<StronglyConnectedComponent> uniqueStronglyConnectedComponents =
+          SetUtils.newIdentityHashSet(stronglyConnectedComponents.values());
+      uniqueStronglyConnectedComponents.forEach(
+          StronglyConnectedComponent::commitPendingConstructors);
+    }
   }
 
   private static class InvokeDirectInfo {
@@ -525,7 +538,6 @@
               .setApiLevelForDefinition(
                   appView.apiLevelCompute().computeInitialMinApiLevel(appView.options()))
               .build();
-      clazz.addDirectMethod(method);
       ProgramMethod programMethod = method.asProgramMethod(clazz);
       creationConsumer.accept(programMethod);
       return programMethod;
@@ -579,5 +591,16 @@
 
       return lirBuilder.build();
     }
+
+    public void commitPendingConstructors() {
+      constructorCache.forEach(
+          (clazz, constructors) -> {
+            List<DexEncodedMethod> methods =
+                ListUtils.sort(
+                    ListUtils.map(constructors.values(), DexClassAndMember::getDefinition),
+                    Comparator.comparing(DexEncodedMember::getReference));
+            clazz.addDirectMethods(methods);
+          });
+    }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java
index 2c917645..8cd6e37 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java
@@ -42,7 +42,6 @@
 import com.android.tools.r8.optimize.argumentpropagation.codescanner.ValueState;
 import com.android.tools.r8.optimize.argumentpropagation.utils.WideningUtils;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.shaking.KeepFieldInfo;
 import com.android.tools.r8.utils.TraversalContinuation;
 import com.android.tools.r8.utils.collections.ProgramFieldMap;
 import com.android.tools.r8.utils.collections.ProgramMethodSet;
@@ -138,8 +137,7 @@
       clazz.forEachProgramField(
           field -> {
             FieldAccessInfo accessInfo = fieldAccessInfos.get(field.getReference());
-            KeepFieldInfo keepInfo = appView.getKeepInfo(field);
-            if (keepInfo.isPinned(appView.options())
+            if (!appView.getKeepInfo(field).isValuePropagationAllowed(appView, field)
                 || (accessInfo != null && accessInfo.isWrittenFromMethodHandle())) {
               fieldStates.put(field.getDefinition(), ValueState.unknown());
             }
@@ -314,7 +312,6 @@
     }
   }
 
-  @SuppressWarnings("ReferenceEquality")
   private void recordAllFieldPutsProcessed(
       ProgramField field, OptimizationFeedbackDelayed feedback) {
     ValueState fieldState =
@@ -324,7 +321,7 @@
             ? appView.abstractValueFactory().createDefaultValue(field.getType())
             : fieldState.getAbstractValue(appView);
     if (abstractValue.isNonTrivial()) {
-      feedback.recordFieldHasAbstractValue(field.getDefinition(), appView, abstractValue);
+      feedback.recordFieldHasAbstractValue(field, appView, abstractValue);
     }
 
     if (fieldState.isClassState() && field.getOptimizationInfo().getDynamicType().isUnknown()) {
@@ -332,7 +329,7 @@
       DynamicType dynamicType = classFieldState.getDynamicType();
       if (!dynamicType.isUnknown()) {
         assert WideningUtils.widenDynamicNonReceiverType(appView, dynamicType, field.getType())
-            == dynamicType;
+            .equals(dynamicType);
         if (dynamicType.isNotNullType()) {
           feedback.markFieldHasDynamicType(field, dynamicType);
         } else {
@@ -393,7 +390,7 @@
     assert !abstractValue.isBottom();
 
     if (!abstractValue.isUnknown()) {
-      feedback.recordFieldHasAbstractValue(field.getDefinition(), appView, abstractValue);
+      feedback.recordFieldHasAbstractValue(field, appView, abstractValue);
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/TrivialFieldAccessReprocessor.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/TrivialFieldAccessReprocessor.java
index 916b595..23bebb5 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/TrivialFieldAccessReprocessor.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/TrivialFieldAccessReprocessor.java
@@ -36,6 +36,7 @@
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackDelayed;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.threading.ThreadingModule;
+import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.SetUtils;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
@@ -279,7 +280,7 @@
       DexEncodedField field,
       boolean isWrite,
       FieldAccessInfoCollection<?> fieldAccessInfoCollection) {
-    assert !appView.appInfo().isPinned(field) || field.getType().isAlwaysNull(appView);
+    assert verifyValuePropagationIsAllowed(field);
 
     FieldAccessInfo fieldAccessInfo = fieldAccessInfoCollection.get(field.getReference());
     if (fieldAccessInfo == null) {
@@ -309,6 +310,13 @@
     return true;
   }
 
+  private boolean verifyValuePropagationIsAllowed(DexEncodedField definition) {
+    ProgramField field = definition.asProgramField(appView);
+    assert field != null;
+    assert appView.getKeepInfo(field).isValuePropagationAllowed(appView, field);
+    return true;
+  }
+
   private static boolean verifyNoConstantFieldsOnSynthesizedClasses(
       AppView<AppInfoWithLiveness> appView) {
     for (DexProgramClass clazz :
@@ -340,11 +348,13 @@
       ProgramField field = resolutionResult.getProgramField();
       DexEncodedField definition = field.getDefinition();
 
+      InternalOptions options = appView.options();
+      ProgramMethod context = getContext();
       if (definition.isStatic() != isStatic
-          || appView.isCfByteCodePassThrough(getContext().getDefinition())
+          || appView.isCfByteCodePassThrough(context.getDefinition())
           || !resolutionResult.isSingleProgramFieldResolutionResult()
-          || resolutionResult.isAccessibleFrom(getContext(), appView()).isPossiblyFalse()
-          || appView().appInfo().isNeverReprocessMethod(getContext())) {
+          || resolutionResult.isAccessibleFrom(context, appView()).isPossiblyFalse()
+          || !appView().getKeepInfo(context).isReprocessingAllowed(options, context)) {
         recordAccessThatCannotBeOptimized(field, definition);
         return;
       }
@@ -366,7 +376,7 @@
       }
 
       // Record access.
-      if (field.isProgramField() && appView().appInfo().mayPropagateValueFor(appView(), field)) {
+      if (appView.getKeepInfo(field).isValuePropagationAllowed(appView(), field)) {
         if (field.getAccessFlags().isStatic() == isStatic) {
           if (isWrite) {
             recordFieldAccessContext(definition, writtenFields, readFields);
@@ -408,10 +418,9 @@
       return true;
     }
 
-    private void recordAccessThatCannotBeOptimized(
-        DexClassAndField field, DexEncodedField definition) {
+    private void recordAccessThatCannotBeOptimized(ProgramField field, DexEncodedField definition) {
       constantFields.remove(definition);
-      if (field.isProgramField() && appView().appInfo().mayPropagateValueFor(appView(), field)) {
+      if (appView.getKeepInfo(field).isValuePropagationAllowed(appView(), field)) {
         destroyFieldAccessContexts(definition);
       }
     }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/FieldValueAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/FieldValueAnalysis.java
index ab97348..69fe17c 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/FieldValueAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/FieldValueAnalysis.java
@@ -102,7 +102,7 @@
 
   abstract boolean isSubjectToOptimization(DexClassAndField field);
 
-  void recordFieldPut(DexClassAndField field, Instruction instruction) {
+  void recordFieldPut(ProgramField field, Instruction instruction) {
     recordFieldPut(field, instruction, UnknownInstanceFieldInitializationInfo.getInstance());
   }
 
@@ -175,7 +175,8 @@
               // after a null/0 check can take advantage of the optimization.
               DexValue valueBeforePut = classInitializerDefaultsResult.getStaticValue(field);
               asStaticFieldValueAnalysis()
-                  .updateFieldOptimizationInfoWith2Values(field, fieldPut.value(), valueBeforePut);
+                  .updateFieldOptimizationInfoWith2Values(
+                      field.asProgramField(), fieldPut.value(), valueBeforePut);
             }
             return;
           }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/InstanceFieldValueAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/InstanceFieldValueAnalysis.java
index a2ef2fa..c60e298 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/InstanceFieldValueAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/InstanceFieldValueAnalysis.java
@@ -11,6 +11,7 @@
 import com.android.tools.r8.graph.DexClassAndField;
 import com.android.tools.r8.graph.DexClassAndMethod;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
@@ -33,6 +34,7 @@
 import com.android.tools.r8.ir.optimize.info.field.InstanceFieldInitializationInfoFactory;
 import com.android.tools.r8.ir.optimize.info.field.UnknownInstanceFieldInitializationInfo;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.KeepFieldInfo;
 import com.android.tools.r8.utils.Timing;
 
 public class InstanceFieldValueAnalysis extends FieldValueAnalysis {
@@ -221,10 +223,17 @@
 
   void recordInstanceFieldIsInitializedWithInfo(
       DexClassAndField field, InstanceFieldInitializationInfo info) {
-    if (!info.isUnknown()
-        && appView.appInfo().mayPropagateValueFor(appView, field.getReference())) {
-      builder.recordInitializationInfo(field, info);
+    if (info.isUnknown()) {
+      return;
     }
+    if (field.isProgramField()) {
+      ProgramField programField = field.asProgramField();
+      KeepFieldInfo keepInfo = appView.getKeepInfo(programField);
+      if (!keepInfo.isValuePropagationAllowed(appView, programField)) {
+        return;
+      }
+    }
+    builder.recordInitializationInfo(field, info);
   }
 
   void recordInstanceFieldIsInitializedWithValue(DexClassAndField field, Value value) {
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
index 1a64882..7b78190 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/StaticFieldValueAnalysis.java
@@ -15,7 +15,7 @@
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.DexValue;
-import com.android.tools.r8.graph.DexValue.DexValueNull;
+import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.ir.analysis.fieldvalueanalysis.StaticFieldValues.EmptyStaticValues;
 import com.android.tools.r8.ir.analysis.type.DynamicTypeWithUpperBound;
 import com.android.tools.r8.ir.analysis.type.Nullability;
@@ -98,7 +98,8 @@
     classInitializerDefaultsResult.forEachOptimizedField(
         (field, value) -> {
           if (putsPerField.containsKey(field)
-              || !appView.appInfo().isFieldOnlyWrittenInMethod(field, context.getDefinition())) {
+              || !appView.appInfo().isFieldOnlyWrittenInMethod(field, context.getDefinition())
+              || !appView.getKeepInfo(field).isValuePropagationAllowed(appView, field)) {
             return;
           }
 
@@ -134,16 +135,17 @@
 
   @Override
   void updateFieldOptimizationInfo(DexClassAndField field, FieldInstruction fieldPut, Value value) {
+    assert field.isProgramField();
     AbstractValue abstractValue = getOrComputeAbstractValue(value, field);
-    updateFieldOptimizationInfo(field, value, abstractValue, false);
+    updateFieldOptimizationInfo(field.asProgramField(), value, abstractValue, false);
   }
 
   void updateFieldOptimizationInfo(
-      DexClassAndField field, Value value, AbstractValue abstractValue, boolean maybeNull) {
+      ProgramField field, Value value, AbstractValue abstractValue, boolean maybeNull) {
     builder.recordStaticField(field, abstractValue, appView.dexItemFactory());
 
     // We cannot modify FieldOptimizationInfo of pinned fields.
-    if (appView.appInfo().isPinned(field)) {
+    if (!appView.getKeepInfo(field).isValuePropagationAllowed(appView, field)) {
       return;
     }
 
@@ -164,12 +166,11 @@
     }
   }
 
-  @SuppressWarnings("ReferenceEquality")
   public void updateFieldOptimizationInfoWith2Values(
-      DexClassAndField field, Value valuePut, DexValue valueBeforePut) {
+      ProgramField field, Value valuePut, DexValue valueBeforePut) {
     // We are interested in the AbstractValue only if it's null or a value, so we can use the value
     // if the code is protected by a null check.
-    if (valueBeforePut != DexValueNull.NULL) {
+    if (!valueBeforePut.isDexValueNull()) {
       return;
     }
 
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraintAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraintAnalysis.java
index 63a2886..ecc3720 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraintAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/inlining/SimpleInliningConstraintAnalysis.java
@@ -103,7 +103,7 @@
       SimpleInliningConstraint instructionConstraint =
           computeConstraintForInstructionNotToMaterialize(instruction);
       if (instructionConstraint.isAlways()) {
-        assert instruction.isAssume();
+        assert instruction.isAssume() || instruction.isConstInstruction();
       } else if (instructionConstraint.isNever()) {
         instructionDepth++;
       } else {
@@ -128,6 +128,13 @@
     if (instruction.isAssume()) {
       return AlwaysSimpleInliningConstraint.getInstance();
     }
+    // We treat const instructions as non-materializing, although they may actually materialize.
+    // In practice, since we limit the number of materializing instructions to one, only few
+    // constants should remain after inlining (e.g., if the materializing instruction is an invoke
+    // that uses constants as in-values).
+    if (instruction.isConstInstruction()) {
+      return AlwaysSimpleInliningConstraint.getInstance();
+    }
     if (instruction.isInvokeVirtual()) {
       InvokeVirtual invoke = instruction.asInvokeVirtual();
       if (invoke.getInvokedMethod().isIdenticalTo(dexItemFactory.objectMembers.getClass)
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/FieldOptimizationFeedback.java b/src/main/java/com/android/tools/r8/ir/conversion/FieldOptimizationFeedback.java
index 4eb2020..f667e31 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/FieldOptimizationFeedback.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/FieldOptimizationFeedback.java
@@ -7,6 +7,7 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClassAndField;
 import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.ir.analysis.type.DynamicType;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
@@ -28,7 +29,7 @@
   void markFieldBitsRead(DexEncodedField field, int bitsRead);
 
   default void recordFieldHasAbstractValue(
-      DexClassAndField field, AppView<AppInfoWithLiveness> appView, AbstractValue abstractValue) {
+      ProgramField field, AppView<AppInfoWithLiveness> appView, AbstractValue abstractValue) {
     recordFieldHasAbstractValue(field.getDefinition(), appView, abstractValue);
   }
 
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 82f47fe..27e3289 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
@@ -521,7 +521,7 @@
             + ExceptionUtils.getMainStackTrace();
     assert !method.isProcessed()
             || !appView.enableWholeProgramOptimizations()
-            || !appView.appInfo().withLiveness().isNeverReprocessMethod(context)
+            || appView.getKeepInfo(context).isReprocessingAllowed(options, context)
         : "Unexpected reprocessing of method: " + context.toSourceString();
 
     if (typeChecker != null && !typeChecker.check(code)) {
@@ -787,11 +787,6 @@
     previous =
         printMethod(code, "IR after idempotent function call canonicalization (SSA)", previous);
 
-    // Insert code to log arguments if requested.
-    if (options.methodMatchesLogArgumentsFilter(method) && !method.isProcessed()) {
-      codeRewriter.logArgumentTypes(method, code);
-    }
-
     previous = printMethod(code, "IR after argument type logging (SSA)", previous);
 
     assert code.verifyTypes(appView);
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
index b4dbe9f..13ce76b 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
@@ -87,7 +87,6 @@
 import com.android.tools.r8.ir.code.InstructionListIterator;
 import com.android.tools.r8.ir.code.Invoke;
 import com.android.tools.r8.ir.code.InvokeCustom;
-import com.android.tools.r8.ir.code.InvokeDirect;
 import com.android.tools.r8.ir.code.InvokeMethod;
 import com.android.tools.r8.ir.code.InvokeMultiNewArray;
 import com.android.tools.r8.ir.code.InvokePolymorphic;
@@ -116,7 +115,6 @@
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.LazyBox;
 import com.android.tools.r8.verticalclassmerging.InterfaceTypeToClassTypeLensCodeRewriterHelper;
-import com.android.tools.r8.verticalclassmerging.VerticallyMergedClasses;
 import com.google.common.collect.Sets;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
@@ -397,9 +395,6 @@
                 assert false;
                 continue;
               }
-              if (invoke.isInvokeDirect()) {
-                checkInvokeDirect(method.getReference(), invoke.asInvokeDirect());
-              }
               MethodLookupResult lensLookup =
                   graphLens.lookupMethod(
                       invokedMethod, method.getReference(), invoke.getType(), codeLens);
@@ -1313,54 +1308,6 @@
     return TypeElement.getNull();
   }
 
-  @SuppressWarnings("ReferenceEquality")
-  // If the given invoke is on the form "invoke-direct A.<init>, v0, ..." and the definition of
-  // value v0 is "new-instance v0, B", where B is a subtype of A (see the Art800 and B116282409
-  // tests), then fail with a compilation error if A has previously been merged into B.
-  //
-  // The motivation for this is that the vertical class merger cannot easily recognize the above
-  // code pattern, since it runs prior to IR construction. Therefore, we currently allow merging
-  // A and B although this will lead to invalid code, because this code pattern does generally
-  // not occur in practice (it leads to a verification error on the JVM, but not on Art).
-  private void checkInvokeDirect(DexMethod method, InvokeDirect invoke) {
-    VerticallyMergedClasses verticallyMergedClasses = appView.getVerticallyMergedClasses();
-    if (verticallyMergedClasses == null) {
-      // No need to check the invocation.
-      return;
-    }
-    DexMethod invokedMethod = invoke.getInvokedMethod();
-    if (invokedMethod.name != factory.constructorMethodName) {
-      // Not a constructor call.
-      return;
-    }
-    if (invoke.arguments().isEmpty()) {
-      // The new instance should always be passed to the constructor call, but continue gracefully.
-      return;
-    }
-    Value receiver = invoke.arguments().get(0);
-    if (!receiver.isPhi() && receiver.definition.isNewInstance()) {
-      NewInstance newInstance = receiver.definition.asNewInstance();
-      if (newInstance.clazz != invokedMethod.holder
-          && verticallyMergedClasses.hasBeenMergedIntoSubtype(invokedMethod.holder)) {
-        // Generated code will not work. Fail with a compilation error.
-        throw appView
-            .options()
-            .reporter
-            .fatalError(
-                String.format(
-                    "Unable to rewrite `invoke-direct %s.<init>(new %s, ...)` in method `%s` after "
-                        + "type `%s` was merged into `%s`. Please add the following rule to your "
-                        + "Proguard configuration file: `-keep,allowobfuscation class %s`.",
-                    invokedMethod.holder.toSourceString(),
-                    newInstance.clazz,
-                    method.toSourceString(),
-                    invokedMethod.holder,
-                    verticallyMergedClasses.getTargetFor(invokedMethod.holder),
-                    invokedMethod.holder.toSourceString()));
-      }
-    }
-  }
-
   /**
    * Due to class merging, it is possible that two exception classes have been merged into one. This
    * function removes catch handlers where the guards ended up being the same as a previous one.
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/LirConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/LirConverter.java
index 25df747..8810391 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/LirConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/LirConverter.java
@@ -84,7 +84,9 @@
 
     GraphLens graphLens = appView.graphLens();
     assert graphLens.isNonIdentityLens();
-    assert appView.codeLens().isAppliedLens() || appView.codeLens().isClearCodeRewritingLens();
+    assert appView.codeLens().isAppliedLens()
+        || appView.codeLens().isClearCodeRewritingLens()
+        || appView.codeLens().isIdentityLens();
 
     MemberRebindingIdentityLens memberRebindingIdentityLens =
         graphLens.asNonIdentityLens().find(GraphLens::isMemberRebindingIdentityLens);
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 a4b8cc3..9175986 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
@@ -147,6 +147,8 @@
         return null;
       }
       ProgramMethodSet methodsToReprocess = methodsToReprocessBuilder.build(appView);
+      // TODO(b/333677610): Check this assert when bridges synthesized by member rebinding is
+      //  always removed
       assert !appView.options().debug
           || methodsToReprocess.stream()
               .allMatch(methodToReprocess -> methodToReprocess.getDefinition().isD8R8Synthesized());
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/callgraph/CallSiteInformation.java b/src/main/java/com/android/tools/r8/ir/conversion/callgraph/CallSiteInformation.java
index e92ea14..300487b 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/callgraph/CallSiteInformation.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/callgraph/CallSiteInformation.java
@@ -111,7 +111,7 @@
 
         int numberOfCallSites = node.getNumberOfCallSites();
         if (numberOfCallSites == 1) {
-          if (appView.appInfo().isNeverInlineDueToSingleCallerMethod(method)) {
+          if (!appView.getKeepInfo(method).isSingleCallerInliningAllowed(options)) {
             continue;
           }
           Set<Node> callersWithDeterministicOrder = node.getCallersWithDeterministicOrder();
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java
index 0c3d095..06fc75f 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java
@@ -610,7 +610,7 @@
     public void acceptInvokeStaticInterfaceOutliningMethod(
         ProgramMethod method, ProgramMethod context) {
       // Intentionally empty. The method will be hit by tracing if required.
-      additions.addMinimumKeepInfo(method, Joiner::disallowInlining);
+      additions.addMinimumSyntheticKeepInfo(method, Joiner::disallowInlining);
     }
 
     @Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java b/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java
index f10854f..afaf0c7 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ClassInitializerDefaultsOptimization.java
@@ -31,6 +31,7 @@
 import com.android.tools.r8.graph.DexValue.DexValueShort;
 import com.android.tools.r8.graph.DexValue.DexValueString;
 import com.android.tools.r8.graph.FieldResolutionResult;
+import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.code.ArrayPut;
@@ -86,8 +87,9 @@
     }
 
     public void forEachOptimizedField(
-        BiConsumer<DexClassAndField, DexValue> consumer, AppView<?> appView) {
-      forEachOptimizedField((field, value) -> consumer.accept(field.asClassField(appView), value));
+        BiConsumer<ProgramField, DexValue> consumer, AppView<?> appView) {
+      forEachOptimizedField(
+          (field, value) -> consumer.accept(field.asProgramField(appView), value));
     }
 
     public boolean hasStaticValue(DexClassAndField field) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
index 7cf20c7..aa4bafe 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
@@ -4,38 +4,22 @@
 
 package com.android.tools.r8.ir.optimize;
 
-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.errors.Unreachable;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DebugLocalInfo;
-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.DexProto;
 import com.android.tools.r8.graph.DexString;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.code.Assume;
 import com.android.tools.r8.ir.code.BasicBlock;
-import com.android.tools.r8.ir.code.ConstString;
 import com.android.tools.r8.ir.code.DebugLocalWrite;
 import com.android.tools.r8.ir.code.DebugLocalsChange;
 import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.code.If;
-import com.android.tools.r8.ir.code.IfType;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InstructionIterator;
 import com.android.tools.r8.ir.code.InstructionListIterator;
-import com.android.tools.r8.ir.code.InvokeVirtual;
 import com.android.tools.r8.ir.code.Move;
 import com.android.tools.r8.ir.code.Position;
-import com.android.tools.r8.ir.code.Position.SyntheticPosition;
-import com.android.tools.r8.ir.code.StaticGet;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.regalloc.LinearScanRegisterAllocator;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Sets;
 import com.google.common.collect.Streams;
 import it.unimi.dsi.fastutil.ints.Int2IntMap;
@@ -45,17 +29,14 @@
 import it.unimi.dsi.fastutil.ints.Int2ReferenceOpenHashMap;
 import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
 import it.unimi.dsi.fastutil.ints.IntSet;
-import java.util.List;
 import java.util.Set;
 
 public class CodeRewriter {
 
   private final AppView<?> appView;
-  private final DexItemFactory dexItemFactory;
 
   public CodeRewriter(AppView<?> appView) {
     this.appView = appView;
-    this.dexItemFactory = appView.dexItemFactory();
   }
 
   public static void removeAssumeInstructions(AppView<?> appView, IRCode code) {
@@ -328,127 +309,4 @@
       locals.put(newRegister, entry.getValue());
     }
   }
-
-  private Value addConstString(IRCode code, InstructionListIterator iterator, String s) {
-    TypeElement typeLattice = TypeElement.stringClassType(appView, definitelyNotNull());
-    Value value = code.createValue(typeLattice);
-    iterator.add(new ConstString(value, dexItemFactory.createString(s)));
-    return value;
-  }
-
-  /**
-   * Insert code into <code>method</code> to log the argument types to System.out.
-   *
-   * The type is determined by calling getClass() on the argument.
-   */
-  public void logArgumentTypes(DexEncodedMethod method, IRCode code) {
-    List<Value> arguments = code.collectArguments();
-    BasicBlock block = code.entryBlock();
-    InstructionListIterator iterator = block.listIterator(code);
-
-    // Attach some synthetic position to all inserted code.
-    Position position =
-        SyntheticPosition.builder().setLine(1).setMethod(method.getReference()).build();
-    iterator.setInsertionPosition(position);
-
-    // Split arguments into their own block.
-    iterator.nextUntil(instruction -> !instruction.isArgument());
-    iterator.previous();
-    iterator.split(code);
-    iterator.previous();
-
-    // Now that the block is split there should not be any catch handlers in the block.
-    assert !block.hasCatchHandlers();
-    DexType javaLangSystemType = dexItemFactory.javaLangSystemType;
-    DexType javaIoPrintStreamType = dexItemFactory.javaIoPrintStreamType;
-    Value out =
-        code.createValue(TypeElement.fromDexType(javaIoPrintStreamType, maybeNull(), appView));
-
-    DexProto proto = dexItemFactory.createProto(dexItemFactory.voidType, dexItemFactory.objectType);
-    DexMethod print = dexItemFactory.createMethod(javaIoPrintStreamType, proto, "print");
-    DexMethod printLn = dexItemFactory.createMethod(javaIoPrintStreamType, proto, "println");
-
-    iterator.add(
-        new StaticGet(
-            out, dexItemFactory.createField(javaLangSystemType, javaIoPrintStreamType, "out")));
-
-    Value value = addConstString(code, iterator, "INVOKE ");
-    iterator.add(new InvokeVirtual(print, null, ImmutableList.of(out, value)));
-
-    value = addConstString(code, iterator, method.getReference().qualifiedName());
-    iterator.add(new InvokeVirtual(print, null, ImmutableList.of(out, value)));
-
-    Value openParenthesis = addConstString(code, iterator, "(");
-    Value comma = addConstString(code, iterator, ",");
-    Value closeParenthesis = addConstString(code, iterator, ")");
-    Value indent = addConstString(code, iterator, "  ");
-    Value nul = addConstString(code, iterator, "(null)");
-    Value primitive = addConstString(code, iterator, "(primitive)");
-    Value empty = addConstString(code, iterator, "");
-
-    iterator.add(new InvokeVirtual(printLn, null, ImmutableList.of(out, openParenthesis)));
-    for (int i = 0; i < arguments.size(); i++) {
-      iterator.add(new InvokeVirtual(print, null, ImmutableList.of(out, indent)));
-
-      // Add a block for end-of-line printing.
-      BasicBlock eol =
-          BasicBlock.createGotoBlock(code.getNextBlockNumber(), position, code.metadata());
-      code.blocks.add(eol);
-
-      BasicBlock successor = block.unlinkSingleSuccessor();
-      block.link(eol);
-      eol.link(successor);
-
-      Value argument = arguments.get(i);
-      if (!argument.getType().isReferenceType()) {
-        iterator.add(new InvokeVirtual(print, null, ImmutableList.of(out, primitive)));
-      } else {
-        // Insert "if (argument != null) ...".
-        successor = block.unlinkSingleSuccessor();
-        If theIf = new If(IfType.NE, argument);
-        theIf.setPosition(position);
-        BasicBlock ifBlock =
-            BasicBlock.createIfBlock(code.getNextBlockNumber(), theIf, code.metadata());
-        code.blocks.add(ifBlock);
-        // Fallthrough block must be added right after the if.
-        BasicBlock isNullBlock =
-            BasicBlock.createGotoBlock(code.getNextBlockNumber(), position, code.metadata());
-        code.blocks.add(isNullBlock);
-        BasicBlock isNotNullBlock =
-            BasicBlock.createGotoBlock(code.getNextBlockNumber(), position, code.metadata());
-        code.blocks.add(isNotNullBlock);
-
-        // Link the added blocks together.
-        block.link(ifBlock);
-        ifBlock.link(isNotNullBlock);
-        ifBlock.link(isNullBlock);
-        isNotNullBlock.link(successor);
-        isNullBlock.link(successor);
-
-        // Fill code into the blocks.
-        iterator = isNullBlock.listIterator(code);
-        iterator.setInsertionPosition(position);
-        iterator.add(new InvokeVirtual(print, null, ImmutableList.of(out, nul)));
-        iterator = isNotNullBlock.listIterator(code);
-        iterator.setInsertionPosition(position);
-        value = code.createValue(TypeElement.classClassType(appView, maybeNull()));
-        iterator.add(
-            new InvokeVirtual(
-                dexItemFactory.objectMembers.getClass, value, ImmutableList.of(arguments.get(i))));
-        iterator.add(new InvokeVirtual(print, null, ImmutableList.of(out, value)));
-      }
-
-      iterator = eol.listIterator(code);
-      iterator.setInsertionPosition(position);
-      if (i == arguments.size() - 1) {
-        iterator.add(new InvokeVirtual(printLn, null, ImmutableList.of(out, closeParenthesis)));
-      } else {
-        iterator.add(new InvokeVirtual(printLn, null, ImmutableList.of(out, comma)));
-      }
-      block = eol;
-    }
-    // When we fall out of the loop the iterator is in the last eol block.
-    iterator.add(new InvokeVirtual(printLn, null, ImmutableList.of(out, empty)));
-    assert code.isConsistentSSA(appView);
-  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java b/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java
index 4797a00..537b313 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.ir.optimize;
 
+import static com.android.tools.r8.graph.ProgramField.asProgramFieldOrNull;
 import static com.android.tools.r8.utils.ConsumerUtils.emptyConsumer;
 import static com.android.tools.r8.utils.MapUtils.ignoreKey;
 import static com.android.tools.r8.utils.PredicateUtils.not;
@@ -18,6 +19,7 @@
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.FieldResolutionResult.SingleFieldResolutionResult;
+import com.android.tools.r8.graph.ProgramField;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
@@ -535,10 +537,13 @@
       fieldInitializationInfos.forEachWithDeterministicOrder(
           appView,
           (field, info) -> {
-            if (!appViewWithLiveness
-                .appInfo()
-                .mayPropagateValueFor(appViewWithLiveness, field.getReference())) {
-              return;
+            if (field.isProgramField()) {
+              ProgramField programField = field.asProgramField();
+              if (!appView
+                  .getKeepInfo(programField)
+                  .isValuePropagationAllowed(appViewWithLiveness, programField)) {
+                return;
+              }
             }
             if (info.isArgumentInitializationInfo()) {
               Value value =
@@ -848,14 +853,22 @@
       AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
       objectState.forEachAbstractFieldValue(
           (field, fieldValue) -> {
-            if (appViewWithLiveness.appInfo().mayPropagateValueFor(appViewWithLiveness, field)
-                && fieldValue.isSingleValue()) {
-              SingleValue singleFieldValue = fieldValue.asSingleValue();
-              if (singleFieldValue.hasSingleMaterializingInstruction()
-                  && singleFieldValue.isMaterializableInContext(appViewWithLiveness, method)) {
-                activeState.putFinalOrEffectivelyFinalInstanceField(
-                    new FieldAndObject(field, value), new MaterializableValue(singleFieldValue));
-              }
+            if (!fieldValue.isSingleValue()) {
+              return;
+            }
+            ProgramField programField =
+                asProgramFieldOrNull(appViewWithLiveness.definitionFor(field));
+            if (programField != null
+                && !appView
+                    .getKeepInfo(programField)
+                    .isValuePropagationAllowed(appViewWithLiveness, programField)) {
+              return;
+            }
+            SingleValue singleFieldValue = fieldValue.asSingleValue();
+            if (singleFieldValue.hasSingleMaterializingInstruction()
+                && singleFieldValue.isMaterializableInContext(appViewWithLiveness, method)) {
+              activeState.putFinalOrEffectivelyFinalInstanceField(
+                  new FieldAndObject(field, value), new MaterializableValue(singleFieldValue));
             }
           });
     }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
index 76616ba..bdb5ede 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
@@ -184,6 +184,9 @@
   private void analyzeReturns(
       IRCode code, OptimizationFeedback feedback, MethodProcessor methodProcessor) {
     ProgramMethod context = code.context();
+    if (!appView.getKeepInfo(context).isValuePropagationAllowed(appView, context)) {
+      return;
+    }
     DexEncodedMethod method = context.getDefinition();
     List<BasicBlock> normalExits = code.computeNormalExitBlocks();
     if (normalExits.isEmpty()) {
@@ -855,10 +858,9 @@
       OptimizationFeedback feedback,
       ProgramMethod method,
       IRCode code) {
-    if (dynamicTypeOptimization == null) {
-      return;
-    }
-    if (!method.getReturnType().isReferenceType()) {
+    if (dynamicTypeOptimization == null
+        || !method.getReturnType().isReferenceType()
+        || !appView.getKeepInfo(method).isValuePropagationAllowed(appView, method)) {
       return;
     }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodResolutionOptimizationInfoReprocessingEnqueuer.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodResolutionOptimizationInfoReprocessingEnqueuer.java
index be20d5b..5902999 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodResolutionOptimizationInfoReprocessingEnqueuer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodResolutionOptimizationInfoReprocessingEnqueuer.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.graph.lens.GraphLens;
 import com.android.tools.r8.ir.conversion.PostMethodProcessor;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.ThreadUtils;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -44,6 +45,7 @@
       PostMethodProcessor.Builder postMethodProcessorBuilder, ExecutorService executorService)
       throws ExecutionException {
     GraphLens currentGraphLens = appView.graphLens();
+    InternalOptions options = appView.options();
     Collection<List<ProgramMethod>> methodsToReprocess =
         ThreadUtils.processItemsWithResults(
             appView.appInfo().classes(),
@@ -53,7 +55,7 @@
                   DexEncodedMethod::hasCode,
                   method -> {
                     if (!postMethodProcessorBuilder.contains(method, currentGraphLens)
-                        && !appView.appInfo().isNeverReprocessMethod(method)) {
+                        && appView.getKeepInfo(method).isReprocessingAllowed(options, method)) {
                       AffectedMethodUseRegistry registry =
                           new AffectedMethodUseRegistry(appView, method);
                       if (method.registerCodeReferencesWithResult(registry)) {
@@ -63,7 +65,7 @@
                   });
               return methodsToReprocessInClass;
             },
-            appView.options().getThreadingModule(),
+            options.getThreadingModule(),
             executorService);
     methodsToReprocess.forEach(
         methodsToReprocessInClass ->
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedback.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedback.java
index be0dd9b..fba1f27 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedback.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedback.java
@@ -9,8 +9,10 @@
 import com.android.tools.r8.graph.DexEncodedMember;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.ProgramMember;
 import com.android.tools.r8.ir.conversion.FieldOptimizationFeedback;
 import com.android.tools.r8.ir.conversion.MethodOptimizationFeedback;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.shaking.AppInfoWithLivenessModifier;
 import com.android.tools.r8.threading.ThreadingModule;
 import com.android.tools.r8.utils.ThreadUtils;
@@ -72,4 +74,11 @@
   public void modifyAppInfoWithLiveness(Consumer<AppInfoWithLivenessModifier> consumer) {
     // Intentionally empty.
   }
+
+  protected boolean verifyValuePropagationIsAllowed(
+      DexEncodedMember<?, ?> definition, AppView<AppInfoWithLiveness> appView) {
+    ProgramMember<?, ?> member = definition.asProgramMember(appView);
+    assert appView.getKeepInfo(member).isValuePropagationAllowed(appView, member);
+    return true;
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
index 54a0fc0..6b0b6eb 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
@@ -155,9 +155,8 @@
         .getFieldAccessInfoCollection()
         .get(field.getReference())
         .hasReflectiveAccess();
-    if (appView.appInfo().mayPropagateValueFor(appView, field.getReference())) {
-      getFieldOptimizationInfoForUpdating(field).setAbstractValue(abstractValue, field);
-    }
+    assert verifyValuePropagationIsAllowed(field, appView);
+    getFieldOptimizationInfoForUpdating(field).setAbstractValue(abstractValue, field);
   }
 
   // METHOD OPTIMIZATION INFO:
@@ -186,10 +185,9 @@
 
   @Override
   public synchronized void methodReturnsAbstractValue(
-      DexEncodedMethod method, AppView<AppInfoWithLiveness> appView, AbstractValue value) {
-    if (appView.appInfo().mayPropagateValueFor(appView, method.getReference())) {
-      getMethodOptimizationInfoForUpdating(method).setAbstractReturnValue(value, method);
-    }
+      DexEncodedMethod definition, AppView<AppInfoWithLiveness> appView, AbstractValue value) {
+    assert verifyValuePropagationIsAllowed(definition, appView);
+    getMethodOptimizationInfoForUpdating(definition).setAbstractReturnValue(value, definition);
   }
 
   @Override
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 c015121..95c8b9a 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
@@ -27,7 +27,7 @@
 
 public class OptimizationFeedbackSimple extends OptimizationFeedback {
 
-  private static OptimizationFeedbackSimple INSTANCE = new OptimizationFeedbackSimple();
+  private static final OptimizationFeedbackSimple INSTANCE = new OptimizationFeedbackSimple();
 
   OptimizationFeedbackSimple() {}
 
@@ -65,9 +65,8 @@
   @Override
   public void recordFieldHasAbstractValue(
       DexEncodedField field, AppView<AppInfoWithLiveness> appView, AbstractValue abstractValue) {
-    if (appView.appInfo().mayPropagateValueFor(appView, field.getReference())) {
-      field.getMutableOptimizationInfo().setAbstractValue(abstractValue, field);
-    }
+    assert verifyValuePropagationIsAllowed(field, appView);
+    field.getMutableOptimizationInfo().setAbstractValue(abstractValue, field);
   }
 
   public void setMultiCallerMethod(ProgramMethod method) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/membervaluepropagation/R8MemberValuePropagation.java b/src/main/java/com/android/tools/r8/ir/optimize/membervaluepropagation/R8MemberValuePropagation.java
index dbd0025..1ad1f33 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/membervaluepropagation/R8MemberValuePropagation.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/membervaluepropagation/R8MemberValuePropagation.java
@@ -5,6 +5,7 @@
 
 import com.android.tools.r8.graph.AppView;
 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.DexField;
@@ -12,6 +13,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.FieldResolutionResult.SingleFieldResolutionResult;
 import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult;
+import com.android.tools.r8.graph.ProgramMember;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
@@ -37,6 +39,7 @@
 import com.android.tools.r8.ir.optimize.membervaluepropagation.assume.AssumeInfo;
 import com.android.tools.r8.ir.optimize.membervaluepropagation.assume.AssumeInfoLookup;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.KeepMemberInfo;
 import com.android.tools.r8.utils.ArrayUtils;
 import java.util.Set;
 
@@ -103,18 +106,13 @@
     }
   }
 
-  private boolean mayPropagateValueFor(DexClassAndField field) {
-    if (field.isProgramField()) {
-      return appView.appInfo().mayPropagateValueFor(appView, field.getReference());
+  private boolean mayPropagateValueFor(DexClassAndMember<?, ?> member) {
+    if (member.isProgramMember()) {
+      ProgramMember<?, ?> programMember = member.asProgramMember();
+      KeepMemberInfo<?, ?> keepInfo = appView.getKeepInfo(programMember);
+      return keepInfo.isValuePropagationAllowed(appView, programMember);
     }
-    return appView.getAssumeInfoCollection().contains(field);
-  }
-
-  private boolean mayPropagateValueFor(DexClassAndMethod method) {
-    if (method.isProgramMethod()) {
-      return appView.appInfo().mayPropagateValueFor(appView, method.getReference());
-    }
-    return appView.getAssumeInfoCollection().contains(method);
+    return appView.getAssumeInfoCollection().contains(member);
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/numberunboxer/NumberUnboxerMethodReprocessingEnqueuer.java b/src/main/java/com/android/tools/r8/ir/optimize/numberunboxer/NumberUnboxerMethodReprocessingEnqueuer.java
index a48a77f..7dd1836 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/numberunboxer/NumberUnboxerMethodReprocessingEnqueuer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/numberunboxer/NumberUnboxerMethodReprocessingEnqueuer.java
@@ -60,7 +60,7 @@
               return;
             }
             if (shouldReprocess(method.getReference())) {
-              assert !appView.appInfo().isNeverReprocessMethod(method);
+              assert appView.getKeepInfo(method).isReprocessingAllowed(appView.options(), method);
               postMethodProcessorBuilder.add(method, numberUnboxerLens);
             }
           });
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/outliner/OutlinerImpl.java b/src/main/java/com/android/tools/r8/ir/optimize/outliner/OutlinerImpl.java
index 20f7598..55a301c 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/outliner/OutlinerImpl.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/outliner/OutlinerImpl.java
@@ -72,6 +72,7 @@
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackDelayed;
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackIgnore;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.KeepMethodInfo.Joiner;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.InternalOptions.OutlineOptions;
 import com.android.tools.r8.utils.ListUtils;
@@ -1402,6 +1403,7 @@
           },
           executorService);
       List<ProgramMethod> outlineMethods = buildOutlineMethods(eventConsumer);
+      disallowInlining(outlineMethods);
       MethodProcessorEventConsumer methodProcessorEventConsumer =
           MethodProcessorEventConsumer.empty();
       converter.optimizeSynthesizedMethods(
@@ -1431,6 +1433,21 @@
     timing.end();
   }
 
+  private void disallowInlining(List<ProgramMethod> outlineMethods) {
+    if (appView.testing().allowInliningOfOutlines) {
+      return;
+    }
+    appView
+        .getKeepInfo()
+        .mutate(
+            keepInfo -> {
+              for (ProgramMethod outlineMethod : outlineMethods) {
+                keepInfo.registerCompilerSynthesizedMethod(outlineMethod);
+                keepInfo.joinMethod(outlineMethod, Joiner::disallowInlining);
+              }
+            });
+  }
+
   private void forEachSelectedOutliningMethod(
       IRConverter converter,
       ProgramMethodSet methodsSelectedForOutlining,
diff --git a/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java b/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java
index de48365..b5ab4d1 100644
--- a/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java
@@ -10,7 +10,6 @@
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexCallSite;
-import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexMethodHandle;
@@ -34,7 +33,6 @@
 import com.android.tools.r8.ir.optimize.AffectedValues;
 import com.android.tools.r8.ir.optimize.DeadCodeRemover;
 import com.android.tools.r8.lightir.LirBuilder.NameComputationPayload;
-import com.android.tools.r8.lightir.LirBuilder.RecordFieldValuesPayload;
 import com.android.tools.r8.lightir.LirCode.TryCatchTable;
 import com.android.tools.r8.naming.dexitembasedstring.NameComputationInfo;
 import com.android.tools.r8.utils.ArrayUtils;
@@ -125,9 +123,10 @@
     assert newMethod.getArity() == method.getArity();
     if (newOpcode != opcode) {
       assert type == newType
-              || (type.isVirtual() && newType.isInterface())
+              || (type.isDirect() && (newType.isInterface() || newType.isVirtual()))
               || (type.isInterface() && newType.isVirtual())
               || (type.isSuper() && newType.isVirtual())
+              || (type.isVirtual() && newType.isInterface())
           : type + " -> " + newType;
       numberOfInvokeOpcodeChanges++;
     } else {
@@ -273,6 +272,9 @@
   }
 
   private InvokeType getInvokeTypeThatMayChange(int opcode) {
+    if (codeLens.isIdentityLens() && LirOpcodeUtils.isInvokeMethod(opcode)) {
+      return LirOpcodeUtils.getInvokeType(opcode);
+    }
     if (opcode == LirOpcodes.INVOKEVIRTUAL) {
       return InvokeType.VIRTUAL;
     }
@@ -400,8 +402,6 @@
     boolean hasFieldReference = false;
     boolean hasPotentialRewrittenMethod = false;
     for (LirConstant constant : code.getConstantPool()) {
-      // RecordFieldValuesPayload is lowered to NewArrayEmpty before lens code rewriting any LIR.
-      assert !(constant instanceof RecordFieldValuesPayload);
       if (constant instanceof DexType) {
         onTypeReference((DexType) constant);
       } else if (constant instanceof DexField) {
@@ -521,15 +521,18 @@
 
   // TODO(b/157111832): This should be part of the graph lens lookup result.
   private boolean lookupIsInterface(DexMethod method, int opcode, MethodLookupResult result) {
+    boolean wasInterface = LirOpcodeUtils.getInterfaceBitFromInvokeOpcode(opcode);
+    // Update interface bit after member rebinding.
+    if (codeLens.isIdentityLens() && method.isNotIdenticalTo(result.getReference())) {
+      return result.getReference().getHolderType().isInterfaceOrDefault(appView, wasInterface);
+    }
+    // Update interface bit after vertical class merging.
     VerticalClassMergerGraphLens verticalClassMergerLens = graphLens.asVerticalClassMergerLens();
     if (verticalClassMergerLens != null
         && verticalClassMergerLens.hasInterfaceBeenMergedIntoClass(method.getHolderType())) {
-      DexClass clazz = appView.definitionFor(result.getReference().getHolderType());
-      if (clazz != null) {
-        return clazz.isInterface();
-      }
+      return result.getReference().getHolderType().isInterfaceOrDefault(appView, wasInterface);
     }
-    return LirOpcodeUtils.getInterfaceBitFromInvokeOpcode(opcode);
+    return wasInterface;
   }
 
   private LirCode<EV> rewriteTryCatchTable(LirCode<EV> code) {
diff --git a/src/main/java/com/android/tools/r8/lightir/LirOpcodeUtils.java b/src/main/java/com/android/tools/r8/lightir/LirOpcodeUtils.java
index 944bfce..7b110eb 100644
--- a/src/main/java/com/android/tools/r8/lightir/LirOpcodeUtils.java
+++ b/src/main/java/com/android/tools/r8/lightir/LirOpcodeUtils.java
@@ -12,6 +12,9 @@
 import static com.android.tools.r8.lightir.LirOpcodes.INVOKESUPER_ITF;
 import static com.android.tools.r8.lightir.LirOpcodes.INVOKEVIRTUAL;
 
+import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.ir.code.InvokeType;
+
 public class LirOpcodeUtils {
 
   public static boolean getInterfaceBitFromInvokeOpcode(int opcode) {
@@ -29,4 +32,41 @@
         return false;
     }
   }
+
+  public static InvokeType getInvokeType(int opcode) {
+    assert isInvokeMethod(opcode);
+    switch (opcode) {
+      case INVOKEDIRECT:
+      case INVOKEDIRECT_ITF:
+        return InvokeType.DIRECT;
+      case INVOKEINTERFACE:
+        return InvokeType.INTERFACE;
+      case INVOKESTATIC:
+      case INVOKESTATIC_ITF:
+        return InvokeType.STATIC;
+      case INVOKESUPER:
+      case INVOKESUPER_ITF:
+        return InvokeType.SUPER;
+      case INVOKEVIRTUAL:
+        return InvokeType.VIRTUAL;
+      default:
+        throw new Unreachable();
+    }
+  }
+
+  public static boolean isInvokeMethod(int opcode) {
+    switch (opcode) {
+      case INVOKEDIRECT:
+      case INVOKEDIRECT_ITF:
+      case INVOKEINTERFACE:
+      case INVOKESTATIC:
+      case INVOKESTATIC_ITF:
+      case INVOKESUPER:
+      case INVOKESUPER_ITF:
+      case INVOKEVIRTUAL:
+        return true;
+      default:
+        return false;
+    }
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/optimize/MemberRebindingAnalysis.java b/src/main/java/com/android/tools/r8/optimize/MemberRebindingAnalysis.java
index efc5ecb..2f02791 100644
--- a/src/main/java/com/android/tools/r8/optimize/MemberRebindingAnalysis.java
+++ b/src/main/java/com/android/tools/r8/optimize/MemberRebindingAnalysis.java
@@ -417,9 +417,9 @@
           for (Pair<DexMethod, DexClassAndMethod> pair : targets) {
             DexMethod method = pair.getFirst();
             DexClassAndMethod target = pair.getSecond();
-            DexMethod bridgeMethod =
+            DexMethod bridgeMethodReference =
                 method.withHolder(bridgeHolder.getType(), appView.dexItemFactory());
-            if (bridgeHolder.getMethodCollection().getMethod(bridgeMethod) == null) {
+            if (bridgeHolder.getMethodCollection().getMethod(bridgeMethodReference) == null) {
               DexEncodedMethod targetDefinition = target.getDefinition();
               DexEncodedMethod bridgeMethodDefinition =
                   targetDefinition.toForwardingMethod(
@@ -445,15 +445,19 @@
               assert !bridgeMethodDefinition.belongsToVirtualPool()
                   || !bridgeMethodDefinition.isLibraryMethodOverride().isUnknown();
               bridgeHolder.addMethod(bridgeMethodDefinition);
-              eventConsumer.acceptMemberRebindingBridgeMethod(
-                  bridgeMethodDefinition.asProgramMethod(bridgeHolder), target);
+              ProgramMethod bridgeMethod = bridgeMethodDefinition.asProgramMethod(bridgeHolder);
+              if (!appView.options().debug) {
+                // TODO(b/333677610): Register these methods in debug mode as well.
+                appView.getKeepInfo().registerCompilerSynthesizedMethod(bridgeMethod);
+              }
+              eventConsumer.acceptMemberRebindingBridgeMethod(bridgeMethod, target);
             }
             assert appView
                 .appInfo()
                 .unsafeResolveMethodDueToDexFormat(method)
                 .getResolvedMethod()
                 .getReference()
-                .isIdenticalTo(bridgeMethod);
+                .isIdenticalTo(bridgeMethodReference);
           }
         });
   }
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorCodeScanner.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorCodeScanner.java
index aa82269..1f95169 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorCodeScanner.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorCodeScanner.java
@@ -66,6 +66,7 @@
 import com.android.tools.r8.utils.Timing;
 import com.google.common.collect.Sets;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
@@ -128,7 +129,7 @@
     this.reprocessingCriteriaCollection = reprocessingCriteriaCollection;
   }
 
-  public synchronized void addMonomorphicVirtualMethods(Set<DexMethod> extension) {
+  public synchronized void addMonomorphicVirtualMethods(Collection<DexMethod> extension) {
     monomorphicVirtualMethods.addAll(extension);
   }
 
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorMethodReprocessingEnqueuer.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorMethodReprocessingEnqueuer.java
index 5056ee3..957cdad 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorMethodReprocessingEnqueuer.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorMethodReprocessingEnqueuer.java
@@ -32,6 +32,7 @@
 import com.android.tools.r8.optimize.argumentpropagation.reprocessingcriteria.ArgumentPropagatorReprocessingCriteriaCollection;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.ArrayUtils;
+import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.ObjectUtils;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
@@ -95,6 +96,7 @@
       ArgumentPropagatorGraphLens graphLens,
       PostMethodProcessor.Builder postMethodProcessorBuilder) {
     GraphLens currentGraphLens = appView.graphLens();
+    InternalOptions options = appView.options();
     for (DexProgramClass clazz : appView.appInfo().classes()) {
       clazz.forEachProgramMethodMatching(
           DexEncodedMethod::hasCode,
@@ -107,7 +109,7 @@
               DexMethod rewrittenMethodSignature =
                   graphLens.getNextMethodSignature(method.getReference());
               if (graphLens.hasPrototypeChanges(rewrittenMethodSignature)) {
-                assert !appView.appInfo().isNeverReprocessMethod(method);
+                assert appView.getKeepInfo(method).isReprocessingAllowed(options, method);
                 postMethodProcessorBuilder.add(method, currentGraphLens);
                 appView.testing().callSiteOptimizationInfoInspector.accept(method);
                 return;
@@ -119,7 +121,7 @@
             if (reprocessingCriteriaCollection
                     .getReprocessingCriteria(method)
                     .shouldReprocess(appView, method, callSiteOptimizationInfo)
-                && !appView.appInfo().isNeverReprocessMethod(method)) {
+                && appView.getKeepInfo(method).isReprocessingAllowed(options, method)) {
               postMethodProcessorBuilder.add(method, currentGraphLens);
               appView.testing().callSiteOptimizationInfoInspector.accept(method);
             }
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorOptimizationInfoPopulator.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorOptimizationInfoPopulator.java
index 2b14cf3..99249e3 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorOptimizationInfoPopulator.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorOptimizationInfoPopulator.java
@@ -108,8 +108,7 @@
     ValueState state = fieldStates.remove(field);
     // TODO(b/296030319): Also publish non-bottom field states.
     if (state.isBottom()) {
-      getSimpleFeedback()
-          .recordFieldHasAbstractValue(field.getDefinition(), appView, AbstractValue.bottom());
+      getSimpleFeedback().recordFieldHasAbstractValue(field, appView, AbstractValue.bottom());
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorProgramOptimizer.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorProgramOptimizer.java
index 181f551..5b5b80c 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorProgramOptimizer.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/ArgumentPropagatorProgramOptimizer.java
@@ -454,7 +454,7 @@
           // OK, this can be rewritten to have void return type.
           continue;
         }
-        if (!appView.appInfo().mayPropagateValueFor(appView, method)) {
+        if (!appView.getKeepInfo(method).isValuePropagationAllowed(appView, method)) {
           return null;
         }
         AbstractValue returnValueForMethod =
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/VirtualRootMethodsAnalysis.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/VirtualRootMethodsAnalysis.java
index dd7eac12..3a9e9c6 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/VirtualRootMethodsAnalysis.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/VirtualRootMethodsAnalysis.java
@@ -4,7 +4,6 @@
 
 package com.android.tools.r8.optimize.argumentpropagation.codescanner;
 
-import static com.android.tools.r8.utils.MapUtils.ignoreKey;
 
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexMethod;
@@ -12,16 +11,11 @@
 import com.android.tools.r8.graph.ImmediateProgramSubtypingInfo;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.optimize.argumentpropagation.ArgumentPropagatorCodeScanner;
-import com.android.tools.r8.optimize.argumentpropagation.utils.DepthFirstTopDownClassHierarchyTraversal;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.collections.DexMethodSignatureMap;
-import com.android.tools.r8.utils.collections.ProgramMethodSet;
-import com.google.common.collect.Sets;
+import com.google.common.collect.Iterables;
+import java.util.ArrayList;
 import java.util.Collection;
-import java.util.IdentityHashMap;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.function.Consumer;
 
 /**
@@ -31,83 +25,7 @@
  * <p>The analysis can be used to easily mark effectively final classes and methods as final, and
  * therefore does this as a side effect.
  */
-public class VirtualRootMethodsAnalysis extends DepthFirstTopDownClassHierarchyTraversal {
-
-  static class VirtualRootMethod {
-
-    private final VirtualRootMethod parent;
-    private final ProgramMethod root;
-    private final ProgramMethodSet overrides = ProgramMethodSet.create();
-
-    VirtualRootMethod(ProgramMethod root) {
-      this(root, null);
-    }
-
-    VirtualRootMethod(ProgramMethod root, VirtualRootMethod parent) {
-      assert root != null;
-      this.parent = parent;
-      this.root = root;
-    }
-
-    void addOverride(ProgramMethod override) {
-      assert override.getDefinition() != root.getDefinition();
-      assert override.getMethodSignature().equals(root.getMethodSignature());
-      overrides.add(override);
-      if (hasParent()) {
-        getParent().addOverride(override);
-      }
-    }
-
-    boolean hasParent() {
-      return parent != null;
-    }
-
-    VirtualRootMethod getParent() {
-      return parent;
-    }
-
-    ProgramMethod getRoot() {
-      return root;
-    }
-
-    ProgramMethod getSingleNonAbstractMethod() {
-      ProgramMethod singleNonAbstractMethod = root.getAccessFlags().isAbstract() ? null : root;
-      for (ProgramMethod override : overrides) {
-        if (!override.getAccessFlags().isAbstract()) {
-          if (singleNonAbstractMethod != null) {
-            // Not a single non-abstract method.
-            return null;
-          }
-          singleNonAbstractMethod = override;
-        }
-      }
-      assert singleNonAbstractMethod == null
-          || !singleNonAbstractMethod.getAccessFlags().isAbstract();
-      return singleNonAbstractMethod;
-    }
-
-    void forEach(Consumer<ProgramMethod> consumer) {
-      consumer.accept(root);
-      overrides.forEach(consumer);
-    }
-
-    boolean hasOverrides() {
-      return !overrides.isEmpty();
-    }
-
-    boolean isInterfaceMethodWithSiblings() {
-      // TODO(b/190154391): Conservatively returns true for all interface methods, but should only
-      //  return true for those with siblings.
-      return root.getHolder().isInterface();
-    }
-  }
-
-  private final Map<DexProgramClass, DexMethodSignatureMap<VirtualRootMethod>>
-      virtualRootMethodsPerClass = new IdentityHashMap<>();
-
-  private final Set<DexMethod> monomorphicVirtualMethods = Sets.newIdentityHashSet();
-
-  private final Map<DexMethod, DexMethod> virtualRootMethods = new IdentityHashMap<>();
+public class VirtualRootMethodsAnalysis extends VirtualRootMethodsAnalysisBase {
 
   public VirtualRootMethodsAnalysis(
       AppView<AppInfoWithLiveness> appView, ImmediateProgramSubtypingInfo immediateSubtypingInfo) {
@@ -121,11 +39,23 @@
     run(stronglyConnectedComponent);
 
     // Commit the result to the code scanner.
-    codeScanner.addMonomorphicVirtualMethods(monomorphicVirtualMethods);
+    List<DexMethod> monomorphicVirtualMethodReferences =
+        new ArrayList<>(
+            monomorphicVirtualRootMethods.size() + monomorphicVirtualNonRootMethods.size());
+    for (ProgramMethod method :
+        Iterables.concat(monomorphicVirtualRootMethods, monomorphicVirtualNonRootMethods)) {
+      monomorphicVirtualMethodReferences.add(method.getReference());
+    }
+    codeScanner.addMonomorphicVirtualMethods(monomorphicVirtualMethodReferences);
     codeScanner.addVirtualRootMethods(virtualRootMethods);
   }
 
   @Override
+  protected void acceptVirtualMethod(ProgramMethod method, VirtualRootMethod virtualRootMethod) {
+    promoteToFinalIfPossible(method, virtualRootMethod);
+  }
+
+  @Override
   public void forEachSubClass(DexProgramClass clazz, Consumer<DexProgramClass> consumer) {
     List<DexProgramClass> subclasses = immediateSubtypingInfo.getSubclasses(clazz);
     if (subclasses.isEmpty()) {
@@ -135,78 +65,6 @@
     }
   }
 
-  @Override
-  public void visit(DexProgramClass clazz) {
-    DexMethodSignatureMap<VirtualRootMethod> state = computeVirtualRootMethodsState(clazz);
-    virtualRootMethodsPerClass.put(clazz, state);
-  }
-
-  private DexMethodSignatureMap<VirtualRootMethod> computeVirtualRootMethodsState(
-      DexProgramClass clazz) {
-    DexMethodSignatureMap<VirtualRootMethod> virtualRootMethodsForClass =
-        DexMethodSignatureMap.create();
-    immediateSubtypingInfo.forEachImmediateProgramSuperClass(
-        clazz,
-        superclass -> {
-          DexMethodSignatureMap<VirtualRootMethod> virtualRootMethodsForSuperclass =
-              virtualRootMethodsPerClass.get(superclass);
-          virtualRootMethodsForSuperclass.forEach(
-              (signature, info) ->
-                  virtualRootMethodsForClass.computeIfAbsent(
-                      signature, ignoreKey(() -> new VirtualRootMethod(info.getRoot(), info))));
-        });
-    clazz.forEachProgramVirtualMethod(
-        method -> {
-          if (virtualRootMethodsForClass.containsKey(method)) {
-            virtualRootMethodsForClass.get(method).getParent().addOverride(method);
-          } else {
-            virtualRootMethodsForClass.put(method, new VirtualRootMethod(method));
-          }
-        });
-    return virtualRootMethodsForClass;
-  }
-
-  @Override
-  public void prune(DexProgramClass clazz) {
-    // Record the overrides for each virtual method that is rooted at this class.
-    DexMethodSignatureMap<VirtualRootMethod> virtualRootMethodsForClass =
-        virtualRootMethodsPerClass.remove(clazz);
-    clazz.forEachProgramVirtualMethod(
-        rootCandidate -> {
-          VirtualRootMethod virtualRootMethod =
-              virtualRootMethodsForClass.remove(rootCandidate.getMethodSignature());
-          promoteToFinalIfPossible(rootCandidate, virtualRootMethod);
-          if (!rootCandidate.isStructurallyEqualTo(virtualRootMethod.getRoot())) {
-            return;
-          }
-          boolean isMonomorphicVirtualMethod =
-              !clazz.isInterface() && !virtualRootMethod.hasOverrides();
-          if (isMonomorphicVirtualMethod) {
-            monomorphicVirtualMethods.add(rootCandidate.getReference());
-          } else {
-            ProgramMethod singleNonAbstractMethod = virtualRootMethod.getSingleNonAbstractMethod();
-            if (singleNonAbstractMethod != null
-                && !virtualRootMethod.isInterfaceMethodWithSiblings()) {
-              virtualRootMethod.forEach(
-                  method -> {
-                    // Interface methods can have siblings and can therefore not be mapped to their
-                    // unique non-abstract implementation, unless the interface method does not have
-                    // any siblings.
-                    virtualRootMethods.put(
-                        method.getReference(), singleNonAbstractMethod.getReference());
-                  });
-              if (!singleNonAbstractMethod.getHolder().isInterface()) {
-                monomorphicVirtualMethods.add(singleNonAbstractMethod.getReference());
-              }
-            } else {
-              virtualRootMethod.forEach(
-                  method ->
-                      virtualRootMethods.put(method.getReference(), rootCandidate.getReference()));
-            }
-          }
-        });
-  }
-
   private void promoteToFinalIfPossible(DexProgramClass clazz) {
     if (!appView.testing().disableMarkingClassesFinal
         && !clazz.isAbstract()
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/VirtualRootMethodsAnalysisBase.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/VirtualRootMethodsAnalysisBase.java
new file mode 100644
index 0000000..b5f1374
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/VirtualRootMethodsAnalysisBase.java
@@ -0,0 +1,184 @@
+// Copyright (c) 2024, 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.optimize.argumentpropagation.codescanner;
+
+import static com.android.tools.r8.utils.MapUtils.ignoreKey;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.ImmediateProgramSubtypingInfo;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.optimize.argumentpropagation.utils.DepthFirstTopDownClassHierarchyTraversal;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.collections.DexMethodSignatureMap;
+import com.android.tools.r8.utils.collections.ProgramMethodSet;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.function.Consumer;
+
+/**
+ * Computes the set of virtual methods for which we can use a monomorphic method state as well as
+ * the mapping from virtual methods to their representative root methods.
+ */
+public class VirtualRootMethodsAnalysisBase extends DepthFirstTopDownClassHierarchyTraversal {
+
+  protected static class VirtualRootMethod {
+
+    private final VirtualRootMethod parent;
+    private final ProgramMethod root;
+    private final ProgramMethodSet overrides = ProgramMethodSet.create();
+
+    VirtualRootMethod(ProgramMethod root) {
+      this(root, null);
+    }
+
+    VirtualRootMethod(ProgramMethod root, VirtualRootMethod parent) {
+      assert root != null;
+      this.parent = parent;
+      this.root = root;
+    }
+
+    void addOverride(ProgramMethod override) {
+      assert override.getDefinition() != root.getDefinition();
+      assert override.getMethodSignature().equals(root.getMethodSignature());
+      overrides.add(override);
+      if (hasParent()) {
+        getParent().addOverride(override);
+      }
+    }
+
+    boolean hasParent() {
+      return parent != null;
+    }
+
+    VirtualRootMethod getParent() {
+      return parent;
+    }
+
+    ProgramMethod getRoot() {
+      return root;
+    }
+
+    ProgramMethod getSingleNonAbstractMethod() {
+      ProgramMethod singleNonAbstractMethod = root.getAccessFlags().isAbstract() ? null : root;
+      for (ProgramMethod override : overrides) {
+        if (!override.getAccessFlags().isAbstract()) {
+          if (singleNonAbstractMethod != null) {
+            // Not a single non-abstract method.
+            return null;
+          }
+          singleNonAbstractMethod = override;
+        }
+      }
+      assert singleNonAbstractMethod == null
+          || !singleNonAbstractMethod.getAccessFlags().isAbstract();
+      return singleNonAbstractMethod;
+    }
+
+    void forEach(Consumer<ProgramMethod> consumer) {
+      consumer.accept(root);
+      overrides.forEach(consumer);
+    }
+
+    boolean hasOverrides() {
+      return !overrides.isEmpty();
+    }
+
+    boolean isInterfaceMethodWithSiblings() {
+      // TODO(b/190154391): Conservatively returns true for all interface methods, but should only
+      //  return true for those with siblings.
+      return root.getHolder().isInterface();
+    }
+  }
+
+  private final Map<DexProgramClass, DexMethodSignatureMap<VirtualRootMethod>>
+      virtualRootMethodsPerClass = new IdentityHashMap<>();
+
+  protected final ProgramMethodSet monomorphicVirtualRootMethods = ProgramMethodSet.create();
+  protected final ProgramMethodSet monomorphicVirtualNonRootMethods = ProgramMethodSet.create();
+
+  protected final Map<DexMethod, DexMethod> virtualRootMethods = new IdentityHashMap<>();
+
+  protected VirtualRootMethodsAnalysisBase(
+      AppView<AppInfoWithLiveness> appView, ImmediateProgramSubtypingInfo immediateSubtypingInfo) {
+    super(appView, immediateSubtypingInfo);
+  }
+
+  @Override
+  public void visit(DexProgramClass clazz) {
+    DexMethodSignatureMap<VirtualRootMethod> state = computeVirtualRootMethodsState(clazz);
+    virtualRootMethodsPerClass.put(clazz, state);
+  }
+
+  private DexMethodSignatureMap<VirtualRootMethod> computeVirtualRootMethodsState(
+      DexProgramClass clazz) {
+    DexMethodSignatureMap<VirtualRootMethod> virtualRootMethodsForClass =
+        DexMethodSignatureMap.create();
+    immediateSubtypingInfo.forEachImmediateProgramSuperClass(
+        clazz,
+        superclass -> {
+          DexMethodSignatureMap<VirtualRootMethod> virtualRootMethodsForSuperclass =
+              virtualRootMethodsPerClass.get(superclass);
+          virtualRootMethodsForSuperclass.forEach(
+              (signature, info) ->
+                  virtualRootMethodsForClass.computeIfAbsent(
+                      signature, ignoreKey(() -> new VirtualRootMethod(info.getRoot(), info))));
+        });
+    clazz.forEachProgramVirtualMethod(
+        method -> {
+          if (virtualRootMethodsForClass.containsKey(method)) {
+            virtualRootMethodsForClass.get(method).getParent().addOverride(method);
+          } else {
+            virtualRootMethodsForClass.put(method, new VirtualRootMethod(method));
+          }
+        });
+    return virtualRootMethodsForClass;
+  }
+
+  @Override
+  public void prune(DexProgramClass clazz) {
+    // Record the overrides for each virtual method that is rooted at this class.
+    DexMethodSignatureMap<VirtualRootMethod> virtualRootMethodsForClass =
+        virtualRootMethodsPerClass.remove(clazz);
+    clazz.forEachProgramVirtualMethod(
+        rootCandidate -> {
+          VirtualRootMethod virtualRootMethod =
+              virtualRootMethodsForClass.remove(rootCandidate.getMethodSignature());
+          acceptVirtualMethod(rootCandidate, virtualRootMethod);
+          if (!rootCandidate.isStructurallyEqualTo(virtualRootMethod.getRoot())) {
+            return;
+          }
+          boolean isMonomorphicVirtualMethod =
+              !clazz.isInterface() && !virtualRootMethod.hasOverrides();
+          if (isMonomorphicVirtualMethod) {
+            monomorphicVirtualRootMethods.add(rootCandidate);
+          } else {
+            ProgramMethod singleNonAbstractMethod = virtualRootMethod.getSingleNonAbstractMethod();
+            if (singleNonAbstractMethod != null
+                && !virtualRootMethod.isInterfaceMethodWithSiblings()) {
+              virtualRootMethod.forEach(
+                  method -> {
+                    // Interface methods can have siblings and can therefore not be mapped to their
+                    // unique non-abstract implementation, unless the interface method does not have
+                    // any siblings.
+                    virtualRootMethods.put(
+                        method.getReference(), singleNonAbstractMethod.getReference());
+                  });
+              if (!singleNonAbstractMethod.getHolder().isInterface()) {
+                monomorphicVirtualNonRootMethods.add(singleNonAbstractMethod);
+              }
+            } else {
+              virtualRootMethod.forEach(
+                  method ->
+                      virtualRootMethods.put(method.getReference(), rootCandidate.getReference()));
+            }
+          }
+        });
+  }
+
+  protected void acceptVirtualMethod(ProgramMethod method, VirtualRootMethod virtualRootMethod) {
+    // Intentionally empty.
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/singlecaller/MonomorphicVirtualMethodsAnalysis.java b/src/main/java/com/android/tools/r8/optimize/singlecaller/MonomorphicVirtualMethodsAnalysis.java
new file mode 100644
index 0000000..8d589a8
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/singlecaller/MonomorphicVirtualMethodsAnalysis.java
@@ -0,0 +1,54 @@
+// Copyright (c) 2024, 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.optimize.singlecaller;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.ImmediateProgramSubtypingInfo;
+import com.android.tools.r8.optimize.argumentpropagation.codescanner.VirtualRootMethodsAnalysisBase;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.ThreadUtils;
+import com.android.tools.r8.utils.collections.ProgramMethodSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+
+public class MonomorphicVirtualMethodsAnalysis extends VirtualRootMethodsAnalysisBase {
+
+  public MonomorphicVirtualMethodsAnalysis(
+      AppView<AppInfoWithLiveness> appView, ImmediateProgramSubtypingInfo immediateSubtypingInfo) {
+    super(appView, immediateSubtypingInfo);
+  }
+
+  public static ProgramMethodSet computeMonomorphicVirtualRootMethods(
+      AppView<AppInfoWithLiveness> appView,
+      ImmediateProgramSubtypingInfo immediateSubtypingInfo,
+      List<Set<DexProgramClass>> stronglyConnectedComponents,
+      ExecutorService executorService)
+      throws ExecutionException {
+    ProgramMethodSet monomorphicVirtualMethods = ProgramMethodSet.createConcurrent();
+    ThreadUtils.processItems(
+        stronglyConnectedComponents,
+        stronglyConnectedComponent -> {
+          ProgramMethodSet monomorphicVirtualMethodsInComponent =
+              computeMonomorphicVirtualRootMethodsInComponent(
+                  appView, immediateSubtypingInfo, stronglyConnectedComponent);
+          monomorphicVirtualMethods.addAll(monomorphicVirtualMethodsInComponent);
+        },
+        appView.options().getThreadingModule(),
+        executorService);
+    return monomorphicVirtualMethods;
+  }
+
+  private static ProgramMethodSet computeMonomorphicVirtualRootMethodsInComponent(
+      AppView<AppInfoWithLiveness> appView,
+      ImmediateProgramSubtypingInfo immediateSubtypingInfo,
+      Set<DexProgramClass> stronglyConnectedComponent) {
+    MonomorphicVirtualMethodsAnalysis analysis =
+        new MonomorphicVirtualMethodsAnalysis(appView, immediateSubtypingInfo);
+    analysis.run(stronglyConnectedComponent);
+    return analysis.monomorphicVirtualRootMethods;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/singlecaller/SingleCallerInliner.java b/src/main/java/com/android/tools/r8/optimize/singlecaller/SingleCallerInliner.java
index 10731fb..02b5231 100644
--- a/src/main/java/com/android/tools/r8/optimize/singlecaller/SingleCallerInliner.java
+++ b/src/main/java/com/android/tools/r8/optimize/singlecaller/SingleCallerInliner.java
@@ -7,6 +7,12 @@
 
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClassAndMethod;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.EnclosingMethodAttribute;
+import com.android.tools.r8.graph.ImmediateProgramSubtypingInfo;
+import com.android.tools.r8.graph.InnerClassAttribute;
 import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.PrunedItems;
@@ -28,13 +34,15 @@
 import com.android.tools.r8.ir.optimize.inliner.NopWhyAreYouNotInliningReporter;
 import com.android.tools.r8.ir.optimize.inliner.WhyAreYouNotInliningReporter;
 import com.android.tools.r8.lightir.LirCode;
+import com.android.tools.r8.optimize.argumentpropagation.utils.ProgramClassesBidirectedGraph;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
 import com.android.tools.r8.utils.collections.ProgramMethodMap;
 import com.android.tools.r8.utils.collections.ProgramMethodSet;
 import java.util.Deque;
+import java.util.List;
+import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 
@@ -56,22 +64,40 @@
   }
 
   private boolean shouldRun() {
-    InternalOptions options = appView.options();
-    return !options.debug
-        && !options.intermediate
-        && options.isOptimizing()
-        && options.isShrinking();
+    return appView.options().getSingleCallerInlinerOptions().isEnabled();
   }
 
   public void run(ExecutorService executorService) throws ExecutionException {
+    ProgramMethodSet monomorphicVirtualMethods =
+        computeMonomorphicVirtualRootMethods(executorService);
     ProgramMethodMap<ProgramMethod> singleCallerMethods =
-        new SingleCallerScanner(appView).getSingleCallerMethods(executorService);
+        new SingleCallerScanner(appView, monomorphicVirtualMethods)
+            .getSingleCallerMethods(executorService);
+    if (singleCallerMethods.isEmpty()) {
+      return;
+    }
     Inliner inliner = new SingleCallerInlinerImpl(appView, singleCallerMethods);
     processCallees(inliner, singleCallerMethods, executorService);
     performInlining(inliner, singleCallerMethods, executorService);
+    pruneEnclosingMethodAttributes();
     pruneItems(singleCallerMethods, executorService);
   }
 
+  // We only allow single caller inlining of "direct dispatch virtual methods". We currently only
+  // deal with (rooted) virtual methods that do not override abstract/interface methods. In order to
+  // also deal with virtual methods that override abstract/interface methods we would need to record
+  // calls to the abstract/interface methods as calls to the non-abstract virtual method.
+  private ProgramMethodSet computeMonomorphicVirtualRootMethods(ExecutorService executorService)
+      throws ExecutionException {
+    ImmediateProgramSubtypingInfo immediateSubtypingInfo =
+        ImmediateProgramSubtypingInfo.create(appView);
+    List<Set<DexProgramClass>> stronglyConnectedComponents =
+        new ProgramClassesBidirectedGraph(appView, immediateSubtypingInfo)
+            .computeStronglyConnectedComponents();
+    return MonomorphicVirtualMethodsAnalysis.computeMonomorphicVirtualRootMethods(
+        appView, immediateSubtypingInfo, stronglyConnectedComponents, executorService);
+  }
+
   private void processCallees(
       Inliner inliner,
       ProgramMethodMap<ProgramMethod> singleCallerMethods,
@@ -160,6 +186,42 @@
     };
   }
 
+  // TODO(b/335124741): Determine what to do when single caller inlining the enclosing method
+  //  of a class.
+  private void pruneEnclosingMethodAttributes() {
+    for (DexProgramClass clazz : appView.appInfo().classes()) {
+      if (!clazz.hasEnclosingMethodAttribute()) {
+        continue;
+      }
+      EnclosingMethodAttribute enclosingMethodAttribute = clazz.getEnclosingMethodAttribute();
+      if (!enclosingMethodAttribute.hasEnclosingMethod()) {
+        continue;
+      }
+      DexMethod enclosingMethodReference = enclosingMethodAttribute.getEnclosingMethod();
+      DexClassAndMethod enclosingMethod = appView.definitionFor(enclosingMethodReference);
+      if (enclosingMethod == null
+          || !enclosingMethod.getOptimizationInfo().hasBeenInlinedIntoSingleCallSite()) {
+        continue;
+      }
+
+      // Remove enclosing method attribute and rewrite the inner class attribute.
+      clazz.clearEnclosingMethodAttribute();
+
+      InnerClassAttribute innerClassAttributeForThisClass =
+          clazz.getInnerClassAttributeForThisClass();
+      if (innerClassAttributeForThisClass != null) {
+        assert innerClassAttributeForThisClass.getOuter() == null;
+        InnerClassAttribute replacement =
+            new InnerClassAttribute(
+                innerClassAttributeForThisClass.getAccess(),
+                innerClassAttributeForThisClass.getInner(),
+                enclosingMethod.getHolderType(),
+                innerClassAttributeForThisClass.getInnerName());
+        clazz.replaceInnerClassAttributeForThisClass(replacement);
+      }
+    }
+  }
+
   private void pruneItems(
       ProgramMethodMap<ProgramMethod> singleCallerMethods, ExecutorService executorService)
       throws ExecutionException {
diff --git a/src/main/java/com/android/tools/r8/optimize/singlecaller/SingleCallerInlinerOptions.java b/src/main/java/com/android/tools/r8/optimize/singlecaller/SingleCallerInlinerOptions.java
new file mode 100644
index 0000000..fa8d1f0
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/singlecaller/SingleCallerInlinerOptions.java
@@ -0,0 +1,29 @@
+// Copyright (c) 2024, 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.optimize.singlecaller;
+
+import com.android.tools.r8.utils.InternalOptions;
+
+public class SingleCallerInlinerOptions {
+
+  private final InternalOptions options;
+
+  private boolean enable = true;
+
+  public SingleCallerInlinerOptions(InternalOptions options) {
+    this.options = options;
+  }
+
+  public boolean isEnabled() {
+    return enable
+        && !options.debug
+        && !options.intermediate
+        && options.isOptimizing()
+        && options.isShrinking();
+  }
+
+  public void setEnable(boolean enable) {
+    this.enable = enable;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/singlecaller/SingleCallerScanner.java b/src/main/java/com/android/tools/r8/optimize/singlecaller/SingleCallerScanner.java
index f71e82f..fa0bdfd 100644
--- a/src/main/java/com/android/tools/r8/optimize/singlecaller/SingleCallerScanner.java
+++ b/src/main/java/com/android/tools/r8/optimize/singlecaller/SingleCallerScanner.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.optimize.singlecaller;
 
-import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
 import static com.android.tools.r8.utils.MapUtils.ignoreKey;
 
 import com.android.tools.r8.graph.AppView;
@@ -17,8 +16,9 @@
 import com.android.tools.r8.lightir.LirCode;
 import com.android.tools.r8.lightir.LirConstant;
 import com.android.tools.r8.lightir.LirInstructionView;
-import com.android.tools.r8.lightir.LirOpcodes;
+import com.android.tools.r8.lightir.LirOpcodeUtils;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.ObjectUtils;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.collections.ProgramMethodMap;
@@ -31,15 +31,23 @@
   private static final ProgramMethod MULTIPLE_CALLERS = ProgramMethod.createSentinel();
 
   private final AppView<AppInfoWithLiveness> appView;
+  private final ProgramMethodSet monomorphicVirtualMethods;
 
-  SingleCallerScanner(AppView<AppInfoWithLiveness> appView) {
+  SingleCallerScanner(
+      AppView<AppInfoWithLiveness> appView, ProgramMethodSet monomorphicVirtualMethods) {
     this.appView = appView;
+    this.monomorphicVirtualMethods = monomorphicVirtualMethods;
   }
 
   public ProgramMethodMap<ProgramMethod> getSingleCallerMethods(ExecutorService executorService)
       throws ExecutionException {
+    InternalOptions options = appView.options();
     ProgramMethodMap<ProgramMethod> singleCallerMethodCandidates =
         traceConstantPools(executorService);
+    singleCallerMethodCandidates.removeIf(
+        (callee, caller) ->
+            callee.getDefinition().isLibraryMethodOverride().isPossiblyTrue()
+                || !appView.getKeepInfo(callee).isSingleCallerInliningAllowed(options));
     return traceInstructions(singleCallerMethodCandidates, executorService);
   }
 
@@ -133,28 +141,13 @@
     if (referencedMethod.getHolderType().isArrayType()) {
       return;
     }
-    if (referencedMethod.isInstanceInitializer(appView.dexItemFactory())) {
-      ProgramMethod referencedProgramMethod =
-          appView
-              .appInfo()
-              .unsafeResolveMethodDueToDexFormat(referencedMethod)
-              .getResolvedProgramMethod();
-      if (referencedProgramMethod != null) {
-        recordCallEdge(method, referencedProgramMethod, threadLocalSingleCallerMethods);
-      }
-    } else {
-      DexProgramClass referencedProgramMethodHolder =
-          asProgramClassOrNull(
-              appView
-                  .appInfo()
-                  .definitionForWithoutExistenceAssert(referencedMethod.getHolderType()));
-      ProgramMethod referencedProgramMethod =
-          referencedMethod.lookupOnProgramClass(referencedProgramMethodHolder);
-      if (referencedProgramMethod != null
-          && referencedProgramMethod.getAccessFlags().isPrivate()
-          && !referencedProgramMethod.getAccessFlags().isStatic()) {
-        recordCallEdge(method, referencedProgramMethod, threadLocalSingleCallerMethods);
-      }
+    ProgramMethod resolvedMethod =
+        appView
+            .appInfo()
+            .unsafeResolveMethodDueToDexFormat(referencedMethod)
+            .getResolvedProgramMethod();
+    if (resolvedMethod != null) {
+      recordCallEdge(method, resolvedMethod, threadLocalSingleCallerMethods);
     }
   }
 
@@ -181,10 +174,7 @@
           ProgramMethodMap<Integer> counters = ProgramMethodMap.create();
           for (LirInstructionView view : code) {
             int opcode = view.getOpcode();
-            if (opcode != LirOpcodes.INVOKEDIRECT
-                && opcode != LirOpcodes.INVOKEDIRECT_ITF
-                // JDK 17 generates invokevirtual to private methods.
-                && opcode != LirOpcodes.INVOKEVIRTUAL) {
+            if (!LirOpcodeUtils.isInvokeMethod(opcode)) {
               continue;
             }
             DexMethod invokedMethod =
@@ -192,11 +182,17 @@
             ProgramMethod resolvedMethod =
                 appView
                     .appInfo()
-                    .resolveMethod(invokedMethod, opcode == LirOpcodes.INVOKEDIRECT_ITF)
+                    .resolveMethod(
+                        invokedMethod, LirOpcodeUtils.getInterfaceBitFromInvokeOpcode(opcode))
                     .getResolvedProgramMethod();
-            if (resolvedMethod != null && callees.contains(resolvedMethod)) {
-              counters.put(resolvedMethod, counters.getOrDefault(resolvedMethod, 0) + 1);
+            if (resolvedMethod == null || !callees.contains(resolvedMethod)) {
+              continue;
             }
+            if (resolvedMethod.getAccessFlags().belongsToVirtualPool()
+                && !monomorphicVirtualMethods.contains(resolvedMethod)) {
+              continue;
+            }
+            counters.put(resolvedMethod, counters.getOrDefault(resolvedMethod, 0) + 1);
           }
           callees.forEach(
               (callee) -> {
diff --git a/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentation.java b/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentation.java
index 192178b..521d784 100644
--- a/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentation.java
+++ b/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentation.java
@@ -5,6 +5,7 @@
 package com.android.tools.r8.profile.startup.instrumentation;
 
 import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
+import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
 import static com.android.tools.r8.utils.PredicateUtils.not;
 
 import com.android.tools.r8.androidapi.ComputedApiLevel;
@@ -17,14 +18,16 @@
 import com.android.tools.r8.graph.DexCode;
 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.DexReference;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.DexValue.DexValueBoolean;
 import com.android.tools.r8.graph.DexValue.DexValueString;
 import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.bytecodemetadata.BytecodeMetadataProvider;
+import com.android.tools.r8.ir.code.BasicBlockIterator;
+import com.android.tools.r8.ir.code.ConstString;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InstructionListIterator;
@@ -44,6 +47,7 @@
 import com.android.tools.r8.utils.Timing;
 import com.google.common.collect.ImmutableList;
 import java.util.List;
+import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 
@@ -67,7 +71,8 @@
 
   public static void run(AppView<AppInfo> appView, ExecutorService executorService)
       throws ExecutionException {
-    if (appView.options().getStartupInstrumentationOptions().isStartupInstrumentationEnabled()) {
+    if (appView.options().getStartupInstrumentationOptions().isStartupInstrumentationEnabled()
+        && appView.options().isGeneratingDex()) {
       StartupInstrumentation startupInstrumentation = new StartupInstrumentation(appView);
       startupInstrumentation.instrumentAllClasses(executorService);
       startupInstrumentation.injectStartupRuntimeLibrary(executorService);
@@ -126,6 +131,10 @@
           .lookupUniqueStaticFieldWithName(dexItemFactory.createString("writeToLogcat"))
           .setStaticValue(DexValueBoolean.create(true));
       instrumentationServerImplClass
+          .lookupUniqueStaticFieldWithName(
+              dexItemFactory.createString("writeToLogcatIncludeDuplicates"))
+          .setStaticValue(DexValueBoolean.create(true));
+      instrumentationServerImplClass
           .lookupUniqueStaticFieldWithName(dexItemFactory.createString("logcatTag"))
           .setStaticValue(
               new DexValueString(
@@ -137,11 +146,10 @@
         InstrumentationServerFactory.createClass(dexItemFactory), instrumentationServerImplClass);
   }
 
-  @SuppressWarnings("ReferenceEquality")
   private void instrumentClass(DexProgramClass clazz) {
     // Do not instrument the instrumentation server if it is already in the app.
-    if (clazz.getType() == references.instrumentationServerType
-        || clazz.getType() == references.instrumentationServerImplType) {
+    if (clazz.getType().isIdenticalTo(references.instrumentationServerType)
+        || clazz.getType().isIdenticalTo(references.instrumentationServerImplType)) {
       return;
     }
 
@@ -178,7 +186,8 @@
     // finalizing the code.
     MutableMethodConversionOptions conversionOptions = MethodConversionOptions.forD8(appView);
     IRCode code = method.buildIR(appView, conversionOptions);
-    InstructionListIterator instructionIterator = code.entryBlock().listIterator(code);
+    BasicBlockIterator blocks = code.listIterator();
+    InstructionListIterator instructionIterator = blocks.next().listIterator(code);
     instructionIterator.positionBeforeNextInstructionThatMatches(not(Instruction::isArgument));
 
     // Insert invoke to record that the enclosing class is a startup class.
@@ -197,18 +206,59 @@
 
     // Insert invoke to record the execution of the current method.
     if (!skipMethodLogging) {
-      DexReference referenceToPrint = method.getReference();
       Value descriptorValue =
           instructionIterator.insertConstStringInstruction(
-              appView, code, dexItemFactory.createString(referenceToPrint.toSmaliString()));
+              appView, code, dexItemFactory.createString(method.getReference().toSmaliString()));
       instructionIterator.add(
           InvokeStatic.builder()
               .setMethod(references.addMethod)
               .setSingleArgument(descriptorValue)
               .setPosition(Position.syntheticNone())
               .build());
+
+      Set<DexMethod> callSitesToInstrument =
+          startupInstrumentationOptions.getCallSitesToInstrument();
+      if (!callSitesToInstrument.isEmpty()) {
+        do {
+          while (instructionIterator.hasNext()) {
+            Instruction instruction = instructionIterator.next();
+            if (instruction.isInvokeMethod()) {
+              DexMethod invokedMethod = instruction.asInvokeMethod().getInvokedMethod();
+              if (callSitesToInstrument.contains(invokedMethod)) {
+                instructionIterator.previous();
+                ConstString calleeString =
+                    ConstString.builder()
+                        .setFreshOutValue(
+                            code,
+                            dexItemFactory.stringType.toTypeElement(appView, definitelyNotNull()))
+                        .setPosition(instruction.getPosition())
+                        .setValue(dexItemFactory.createString(invokedMethod.toSmaliString()))
+                        .build();
+                instructionIterator =
+                    instructionIterator.addPossiblyThrowingInstructionsToPossiblyThrowingBlock(
+                        code,
+                        blocks,
+                        ImmutableList.of(
+                            calleeString,
+                            InvokeStatic.builder()
+                                .setMethod(references.addCall)
+                                .setArguments(descriptorValue, calleeString.outValue())
+                                .setPosition(instruction.getPosition())
+                                .build()),
+                        options);
+                Instruction next = instructionIterator.next();
+                assert next == instruction;
+              }
+            }
+          }
+          if (blocks.hasNext()) {
+            instructionIterator = blocks.next().listIterator(code);
+          }
+        } while (instructionIterator.hasNext());
+      }
     }
 
+    code.removeRedundantBlocks();
     converter.deadCodeRemover.run(code, Timing.empty());
 
     DexCode instrumentedCode =
diff --git a/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentationOptions.java b/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentationOptions.java
index ad94406..4a11409 100644
--- a/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentationOptions.java
+++ b/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentationOptions.java
@@ -7,8 +7,15 @@
 import static com.android.tools.r8.utils.SystemPropertyUtils.getSystemPropertyForDevelopment;
 import static com.android.tools.r8.utils.SystemPropertyUtils.parseSystemPropertyForDevelopmentOrDefault;
 
+import com.android.tools.r8.graph.DexMethod;
+import java.util.Collections;
+import java.util.Set;
+
 public class StartupInstrumentationOptions {
 
+  /** Set of method references where all calls to the exact method reference should print. */
+  private Set<DexMethod> callSitesToInstrument = Collections.emptySet();
+
   /**
    * When enabled, each method will be instrumented to notify the startup InstrumentationServer that
    * it has been executed.
@@ -45,6 +52,14 @@
       getSystemPropertyForDevelopment(
           "com.android.tools.r8.startup.instrumentation.instrumentationtag");
 
+  public Set<DexMethod> getCallSitesToInstrument() {
+    return callSitesToInstrument;
+  }
+
+  public void setCallSitesToInstrument(Set<DexMethod> callSitesToInstrument) {
+    this.callSitesToInstrument = callSitesToInstrument;
+  }
+
   public boolean hasStartupInstrumentationServerSyntheticContext() {
     return startupInstrumentationServerSyntheticContext != null;
   }
diff --git a/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentationReferences.java b/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentationReferences.java
index 78d55f0..7b180a8 100644
--- a/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentationReferences.java
+++ b/src/main/java/com/android/tools/r8/profile/startup/instrumentation/StartupInstrumentationReferences.java
@@ -12,6 +12,7 @@
 
   final DexType instrumentationServerType;
   final DexType instrumentationServerImplType;
+  final DexMethod addCall;
   final DexMethod addMethod;
 
   StartupInstrumentationReferences(DexItemFactory dexItemFactory) {
@@ -19,6 +20,12 @@
         dexItemFactory.createType("Lcom/android/tools/r8/startup/InstrumentationServer;");
     instrumentationServerImplType =
         dexItemFactory.createType("Lcom/android/tools/r8/startup/InstrumentationServerImpl;");
+    addCall =
+        dexItemFactory.createMethod(
+            instrumentationServerImplType,
+            dexItemFactory.createProto(
+                dexItemFactory.voidType, dexItemFactory.stringType, dexItemFactory.stringType),
+            "addCall");
     addMethod =
         dexItemFactory.createMethod(
             instrumentationServerImplType,
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 bcaeaa5..022be10 100644
--- a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
+++ b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
@@ -16,7 +16,6 @@
 import com.android.tools.r8.graph.DexCallSite;
 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.DexClasspathClass;
 import com.android.tools.r8.graph.DexDefinition;
@@ -67,12 +66,10 @@
 import com.android.tools.r8.utils.PredicateSet;
 import com.android.tools.r8.utils.Timing;
 import com.android.tools.r8.utils.Visibility;
-import com.android.tools.r8.utils.WorkList;
 import com.android.tools.r8.utils.collections.DexClassAndMethodSet;
 import com.android.tools.r8.utils.collections.ProgramMethodSet;
 import com.android.tools.r8.utils.collections.ThrowingSet;
 import com.android.tools.r8.utils.structural.Ordered;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Sets;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
 import it.unimi.dsi.fastutil.objects.Object2BooleanMap;
@@ -148,17 +145,10 @@
   public final Map<DexReference, ProguardMemberRule> mayHaveSideEffects;
   /** All methods that should be inlined if possible due to a configuration directive. */
   private final Set<DexMethod> alwaysInline;
-  /**
-   * All methods that *must* never be inlined as a result of having a single caller due to a
-   * configuration directive (testing only).
-   */
-  private final Set<DexMethod> neverInlineDueToSingleCaller;
   /** Items for which to print inlining decisions for (testing only). */
   private final Set<DexMethod> whyAreYouNotInlining;
   /** All methods that must be reprocessed (testing only). */
   private final Set<DexMethod> reprocess;
-  /** All methods that must not be reprocessed (testing only). */
-  private final Set<DexMethod> neverReprocess;
   /** All types that should be inlined if possible due to a configuration directive. */
   public final PredicateSet<DexType> alwaysClassInline;
   /**
@@ -175,11 +165,6 @@
    */
   public final Set<DexMethod> recordFieldValuesReferences;
   /**
-   * All methods and fields whose value *must* never be propagated due to a configuration directive.
-   * (testing only).
-   */
-  private final Set<DexMember<?, ?>> neverPropagateValue;
-  /**
    * All items with -identifiernamestring rule. Bound boolean value indicates the rule is explicitly
    * specified by users (<code>true</code>) or not, i.e., implicitly added by R8 (<code>false</code>
    * ).
@@ -214,12 +199,9 @@
       KeepInfoCollection keepInfo,
       Map<DexReference, ProguardMemberRule> mayHaveSideEffects,
       Set<DexMethod> alwaysInline,
-      Set<DexMethod> neverInlineDueToSingleCaller,
       Set<DexMethod> whyAreYouNotInlining,
       Set<DexMethod> reprocess,
-      Set<DexMethod> neverReprocess,
       PredicateSet<DexType> alwaysClassInline,
-      Set<DexMember<?, ?>> neverPropagateValue,
       Object2BooleanMap<DexMember<?, ?>> identifierNameStrings,
       Set<DexType> prunedTypes,
       Map<DexField, Int2ReferenceMap<DexField>> switchMaps,
@@ -242,12 +224,9 @@
     this.mayHaveSideEffects = mayHaveSideEffects;
     this.callSites = callSites;
     this.alwaysInline = alwaysInline;
-    this.neverInlineDueToSingleCaller = neverInlineDueToSingleCaller;
     this.whyAreYouNotInlining = whyAreYouNotInlining;
     this.reprocess = reprocess;
-    this.neverReprocess = neverReprocess;
     this.alwaysClassInline = alwaysClassInline;
-    this.neverPropagateValue = neverPropagateValue;
     this.identifierNameStrings = identifierNameStrings;
     this.prunedTypes = prunedTypes;
     this.switchMaps = switchMaps;
@@ -278,12 +257,9 @@
         previous.keepInfo,
         previous.mayHaveSideEffects,
         previous.alwaysInline,
-        previous.neverInlineDueToSingleCaller,
         previous.whyAreYouNotInlining,
         previous.reprocess,
-        previous.neverReprocess,
         previous.alwaysClassInline,
-        previous.neverPropagateValue,
         previous.identifierNameStrings,
         previous.prunedTypes,
         previous.switchMaps,
@@ -315,12 +291,9 @@
         extendPinnedItems(previous, prunedItems.getAdditionalPinnedItems()),
         previous.mayHaveSideEffects,
         pruneMethods(previous.alwaysInline, prunedItems, tasks),
-        pruneMethods(previous.neverInlineDueToSingleCaller, prunedItems, tasks),
         pruneMethods(previous.whyAreYouNotInlining, prunedItems, tasks),
         pruneMethods(previous.reprocess, prunedItems, tasks),
-        pruneMethods(previous.neverReprocess, prunedItems, tasks),
         previous.alwaysClassInline,
-        pruneMembers(previous.neverPropagateValue, prunedItems, tasks),
         pruneMapFromMembers(previous.identifierNameStrings, prunedItems, tasks),
         prunedItems.hasRemovedClasses()
             ? CollectionUtils.mergeSets(previous.prunedTypes, prunedItems.getRemovedClasses())
@@ -360,29 +333,6 @@
     return pruneItems(fields, prunedItems.getRemovedFields(), tasks);
   }
 
-  private static Set<DexMember<?, ?>> pruneMembers(
-      Set<DexMember<?, ?>> members, PrunedItems prunedItems, TaskCollection<?> tasks)
-      throws ExecutionException {
-    if (prunedItems.hasRemovedMembers()) {
-      tasks.submit(
-          () -> {
-            Set<DexField> removedFields = prunedItems.getRemovedFields();
-            Set<DexMethod> removedMethods = prunedItems.getRemovedMethods();
-            if (members.size() <= removedFields.size() + removedMethods.size()) {
-              members.removeIf(
-                  member ->
-                      member.isDexField()
-                          ? removedFields.contains(member.asDexField())
-                          : removedMethods.contains(member.asDexMethod()));
-            } else {
-              removedFields.forEach(members::remove);
-              removedMethods.forEach(members::remove);
-            }
-          });
-    }
-    return members;
-  }
-
   private static Set<DexMethod> pruneMethods(
       Set<DexMethod> methods, PrunedItems prunedItems, TaskCollection<?> tasks)
       throws ExecutionException {
@@ -483,12 +433,9 @@
         keepInfo,
         mayHaveSideEffects,
         alwaysInline,
-        neverInlineDueToSingleCaller,
         whyAreYouNotInlining,
         reprocess,
-        neverReprocess,
         alwaysClassInline,
-        neverPropagateValue,
         identifierNameStrings,
         prunedTypes,
         switchMaps,
@@ -556,12 +503,9 @@
     this.mayHaveSideEffects = previous.mayHaveSideEffects;
     this.callSites = previous.callSites;
     this.alwaysInline = previous.alwaysInline;
-    this.neverInlineDueToSingleCaller = previous.neverInlineDueToSingleCaller;
     this.whyAreYouNotInlining = previous.whyAreYouNotInlining;
     this.reprocess = previous.reprocess;
-    this.neverReprocess = previous.neverReprocess;
     this.alwaysClassInline = previous.alwaysClassInline;
-    this.neverPropagateValue = previous.neverPropagateValue;
     this.identifierNameStrings = previous.identifierNameStrings;
     this.prunedTypes = previous.prunedTypes;
     this.switchMaps = switchMaps;
@@ -678,10 +622,6 @@
     return alwaysInline.contains(method);
   }
 
-  public boolean isNeverInlineDueToSingleCallerMethod(ProgramMethod method) {
-    return neverInlineDueToSingleCaller.contains(method.getReference());
-  }
-
   public boolean isWhyAreYouNotInliningMethod(DexMethod method) {
     return whyAreYouNotInlining.contains(method);
   }
@@ -690,40 +630,10 @@
     return whyAreYouNotInlining.isEmpty();
   }
 
-  public boolean isNeverReprocessMethod(ProgramMethod method) {
-    return neverReprocess.contains(method.getReference())
-        || method.getOptimizationInfo().hasBeenInlinedIntoSingleCallSite();
-  }
-
   public Set<DexMethod> getReprocessMethods() {
     return reprocess;
   }
 
-  public void forEachReachableInterface(Consumer<DexClass> consumer) {
-    forEachReachableInterface(consumer, ImmutableList.of());
-  }
-
-  public void forEachReachableInterface(
-      Consumer<DexClass> consumer, Iterable<DexType> additionalPaths) {
-    WorkList<DexType> worklist = WorkList.newIdentityWorkList();
-    worklist.addIfNotSeen(additionalPaths);
-    worklist.addIfNotSeen(objectAllocationInfoCollection.getInstantiatedLambdaInterfaces());
-    for (DexProgramClass clazz : classes()) {
-      worklist.addIfNotSeen(clazz.type);
-    }
-    while (worklist.hasNext()) {
-      DexType type = worklist.next();
-      DexClass definition = definitionFor(type);
-      if (definition == null) {
-        continue;
-      }
-      if (definition.isInterface()) {
-        consumer.accept(definition);
-      }
-      definition.forEachImmediateSupertype(worklist::addIfNotSeen);
-    }
-  }
-
   /**
    * Resolve the methods implemented by the lambda expression that created the {@code callSite}.
    *
@@ -925,41 +835,6 @@
     return staticInitializer != null && isFieldOnlyWrittenInMethod(field, staticInitializer);
   }
 
-  public boolean mayPropagateValueFor(
-      AppView<AppInfoWithLiveness> appView, DexClassAndMember<?, ?> member) {
-    assert checkIfObsolete();
-    return member
-        .getReference()
-        .apply(
-            field -> mayPropagateValueFor(appView, field),
-            method -> mayPropagateValueFor(appView, method));
-  }
-
-  public boolean mayPropagateValueFor(AppView<AppInfoWithLiveness> appView, DexField field) {
-    assert checkIfObsolete();
-    if (neverPropagateValue.contains(field)) {
-      return false;
-    }
-    if (isPinnedWithDefinitionLookup(field) && !field.getType().isAlwaysNull(appView)) {
-      return false;
-    }
-    return true;
-  }
-
-  public boolean mayPropagateValueFor(AppView<AppInfoWithLiveness> appView, DexMethod method) {
-    assert checkIfObsolete();
-    if (neverPropagateValue.contains(method)) {
-      return false;
-    }
-    if (!method.getReturnType().isAlwaysNull(appView)
-        && !getKeepInfo()
-            .getMethodInfoWithDefinitionLookup(method, this)
-            .isOptimizationAllowed(options())) {
-      return false;
-    }
-    return true;
-  }
-
   public boolean isInstantiatedInterface(DexProgramClass clazz) {
     assert checkIfObsolete();
     return objectAllocationInfoCollection.isInterfaceWithUnknownSubtypeHierarchy(clazz);
@@ -1107,12 +982,9 @@
         // Take any rule in case of collisions.
         lens.rewriteReferenceKeys(mayHaveSideEffects, (reference, rules) -> ListUtils.first(rules)),
         lens.rewriteReferences(alwaysInline),
-        lens.rewriteReferences(neverInlineDueToSingleCaller),
         lens.rewriteReferences(whyAreYouNotInlining),
         lens.rewriteReferences(reprocess),
-        lens.rewriteReferences(neverReprocess),
         alwaysClassInline.rewriteItems(lens::lookupType),
-        lens.rewriteReferences(neverPropagateValue),
         lens.rewriteReferenceKeys(identifierNameStrings),
         // Don't rewrite pruned types - the removed types are identified by their original name.
         prunedTypes,
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 8102003..629d003 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -98,6 +98,7 @@
 import com.android.tools.r8.graph.analysis.EnqueuerNewInstanceAnalysis;
 import com.android.tools.r8.graph.analysis.EnqueuerTypeAccessAnalysis;
 import com.android.tools.r8.graph.analysis.GetArrayOfMissingTypeVerifyErrorWorkaround;
+import com.android.tools.r8.graph.analysis.InitializedClassesInInstanceMethodsAnalysis;
 import com.android.tools.r8.graph.analysis.InvokeVirtualToInterfaceVerifyErrorWorkaround;
 import com.android.tools.r8.graph.analysis.ResourceAccessAnalysis;
 import com.android.tools.r8.ir.analysis.proto.ProtoEnqueuerUseRegistry;
@@ -518,7 +519,9 @@
       appView.getResourceShrinkerState().setEnqueuerCallback(this::recordReferenceFromResources);
     }
     if (mode.isTreeShaking()) {
+      InitializedClassesInInstanceMethodsAnalysis.register(appView, this);
       GetArrayOfMissingTypeVerifyErrorWorkaround.register(appView, this);
+      InitializedClassesInInstanceMethodsAnalysis.register(appView, this);
       InvokeVirtualToInterfaceVerifyErrorWorkaround.register(appView, this);
       if (options.protoShrinking().enableGeneratedMessageLiteShrinking) {
         registerAnalysis(new ProtoEnqueuerExtension(appView));
@@ -659,13 +662,26 @@
   }
 
   public boolean addLiveMethod(ProgramMethod method, KeepReason reason) {
+    addEffectivelyLiveOriginalMethod(method);
     return liveMethods.add(method, reason);
   }
 
   public boolean addTargetedMethod(ProgramMethod method, KeepReason reason) {
+    addEffectivelyLiveOriginalMethod(method);
     return targetedMethods.add(method, reason);
   }
 
+  private void addEffectivelyLiveOriginalMethod(ProgramMethod method) {
+    if (!options.testing.isKeepAnnotationsEnabled()) {
+      return;
+    }
+    if (method.getDefinition().hasPendingInlineFrame()) {
+      traceMethodPosition(method.getDefinition().getPendingInlineFrameAsPosition(), method);
+    } else if (!method.getDefinition().isD8R8Synthesized()) {
+      markEffectivelyLiveOriginalReference(method.getReference());
+    }
+  }
+
   private void recordCompilerSynthesizedTypeReference(DexType type) {
     DexClass clazz = appInfo().definitionFor(type);
     if (clazz == null) {
@@ -1662,17 +1678,23 @@
     while (position.hasCallerPosition()) {
       // Any inner position should not be non-synthetic user methods.
       assert !position.isD8R8Synthesized();
-      DexMethod method = position.getMethod();
-      // TODO(b/325014359): It might be reasonable to reduce this map size by tracking which methods
-      //  actually are used in preconditions.
-      if (effectivelyLiveOriginalReferences.add(method)) {
-        effectivelyLiveOriginalReferences.add(method.getHolderType());
-      }
+      markEffectivelyLiveOriginalReference(position.getMethod());
       position = position.getCallerPosition();
     }
     // The outer-most position should be equal to the context.
-    // No need to trace this as the method is already traced since it is invoked.
+    // Mark it if it is not synthetic.
     assert context.getReference().isIdenticalTo(position.getMethod());
+    if (!context.getDefinition().isD8R8Synthesized()) {
+      markEffectivelyLiveOriginalReference(context.getReference());
+    }
+  }
+
+  void markEffectivelyLiveOriginalReference(DexReference reference) {
+    // TODO(b/325014359): It might be reasonable to reduce this map size by tracking which items
+    //  actually are used in preconditions.
+    if (effectivelyLiveOriginalReferences.add(reference) && reference.isDexMember()) {
+      effectivelyLiveOriginalReferences.add(reference.getContextType());
+    }
   }
 
   void traceNewInstance(DexType type, ProgramMethod context) {
@@ -2171,6 +2193,7 @@
     if (!liveTypes.add(clazz, witness)) {
       return;
     }
+    markEffectivelyLiveOriginalReference(clazz.getType());
 
     assert !mode.isFinalMainDexTracing()
             || !options.testing.checkForNotExpandingMainDexTracingResult
@@ -2308,7 +2331,6 @@
     analyses.forEach(analysis -> analysis.processNewlyLiveClass(clazz, worklist));
   }
 
-  @SuppressWarnings("ReferenceEquality")
   private void processDeferredAnnotations(
       DexProgramClass clazz,
       Map<DexType, Map<DexAnnotation, List<ProgramDefinition>>> deferredAnnotations,
@@ -2317,7 +2339,7 @@
         deferredAnnotations.remove(clazz.getType());
     if (annotations != null) {
       assert annotations.keySet().stream()
-          .allMatch(annotation -> annotation.getAnnotationType() == clazz.getType());
+          .allMatch(annotation -> clazz.getType().isIdenticalTo(annotation.getAnnotationType()));
       annotations.forEach(
           (annotation, annotatedItems) ->
               annotatedItems.forEach(
@@ -3253,6 +3275,13 @@
     }
   }
 
+  private void addEffectivelyLiveOriginalField(ProgramField field) {
+    if (!options.testing.isKeepAnnotationsEnabled()) {
+      return;
+    }
+    markEffectivelyLiveOriginalReference(field.getReference());
+  }
+
   private void markFieldAsLive(ProgramField field, ProgramMethod context) {
     markFieldAsLive(field, context, KeepReason.fieldReferencedIn(context));
   }
@@ -3265,6 +3294,7 @@
       // Already live.
       return;
     }
+    addEffectivelyLiveOriginalField(field);
 
     // Mark the field as targeted.
     if (field.getAccessFlags().isStatic()) {
@@ -3306,13 +3336,12 @@
       graphReporter.registerField(field.getDefinition(), reason);
       return;
     }
-
+    addEffectivelyLiveOriginalField(field);
     traceFieldDefinition(field);
 
     analyses.forEach(analysis -> analysis.notifyMarkFieldAsReachable(field, worklist));
   }
 
-  @SuppressWarnings("UnusedVariable")
   private void traceFieldDefinition(ProgramField field) {
     markTypeAsLive(field.getHolder(), field);
     markTypeAsLive(field.getType(), field);
@@ -3827,20 +3856,22 @@
       timing.begin("Model library");
       modelLibraryMethodsWithCovariantReturnTypes(appView);
       timing.end();
-    } else if (appView.getKeepInfo() != null) {
-      timing.begin("Retain keep info");
-      applicableRules = appView.getKeepInfo().getApplicableRules();
-      EnqueuerEvent preconditionEvent = UnconditionalKeepInfoEvent.get();
-      appView
-          .getKeepInfo()
-          .forEachRuleInstance(
-              appView,
-              (clazz, minimumKeepInfo) ->
-                  applyMinimumKeepInfoWhenLive(clazz, minimumKeepInfo, preconditionEvent),
-              (field, minimumKeepInfo) ->
-                  applyMinimumKeepInfoWhenLive(field, minimumKeepInfo, preconditionEvent),
-              this::applyMinimumKeepInfoWhenLiveOrTargeted);
-      timing.end();
+    } else {
+      KeepInfoCollection keepInfoCollection = appView.getKeepInfo();
+      if (keepInfoCollection != null) {
+        timing.begin("Retain keep info");
+        applicableRules = keepInfoCollection.getApplicableRules();
+        EnqueuerEvent preconditionEvent = UnconditionalKeepInfoEvent.get();
+        keepInfo.registerCompilerSynthesizedMethods(keepInfoCollection);
+        keepInfoCollection.forEachRuleInstance(
+            appView,
+            (clazz, minimumKeepInfo) ->
+                applyMinimumKeepInfoWhenLive(clazz, minimumKeepInfo, preconditionEvent),
+            (field, minimumKeepInfo) ->
+                applyMinimumKeepInfoWhenLive(field, minimumKeepInfo, preconditionEvent),
+            this::applyMinimumKeepInfoWhenLiveOrTargeted);
+        timing.end();
+      }
     }
     timing.time("Unconditional rules", () -> applicableRules.evaluateUnconditionalRules(this));
     timing.begin("Enqueue all");
@@ -4103,7 +4134,7 @@
 
     private final Map<DexMethod, ProgramMethod> liveMethods = new ConcurrentHashMap<>();
 
-    private final ProgramMethodMap<KeepMethodInfo.Joiner> minimumKeepInfo =
+    private final ProgramMethodMap<KeepMethodInfo.Joiner> minimumSyntheticKeepInfo =
         ProgramMethodMap.createConcurrent();
 
     private final Map<DexType, DexClasspathClass> syntheticClasspathClasses =
@@ -4160,9 +4191,11 @@
       newInterfaces.add(newInterface);
     }
 
-    public void addMinimumKeepInfo(ProgramMethod method, Consumer<KeepMethodInfo.Joiner> consumer) {
+    public void addMinimumSyntheticKeepInfo(
+        ProgramMethod method, Consumer<KeepMethodInfo.Joiner> consumer) {
       consumer.accept(
-          minimumKeepInfo.computeIfAbsent(method, ignoreKey(KeepMethodInfo::newEmptyJoiner)));
+          minimumSyntheticKeepInfo.computeIfAbsent(
+              method, ignoreKey(KeepMethodInfo::newEmptyJoiner)));
     }
 
     void enqueueWorkItems(Enqueuer enqueuer) {
@@ -4189,9 +4222,11 @@
                 enqueuer.appInfo(), clazz, itfs);
           });
 
-      minimumKeepInfo.forEach(
-          (method, minimumKeepInfoForMethod) ->
-              enqueuer.applyMinimumKeepInfoWhenLiveOrTargeted(method, minimumKeepInfoForMethod));
+      minimumSyntheticKeepInfo.forEach(
+          (method, minimumKeepInfoForMethod) -> {
+            enqueuer.getKeepInfo().registerCompilerSynthesizedMethod(method);
+            enqueuer.applyMinimumKeepInfoWhenLiveOrTargeted(method, minimumKeepInfoForMethod);
+          });
     }
   }
 
@@ -4501,12 +4536,9 @@
             keepInfo,
             rootSet.mayHaveSideEffects,
             amendWithCompanionMethods(rootSet.alwaysInline),
-            amendWithCompanionMethods(rootSet.neverInlineDueToSingleCaller),
             amendWithCompanionMethods(rootSet.whyAreYouNotInlining),
             amendWithCompanionMethods(rootSet.reprocess),
-            amendWithCompanionMethods(rootSet.neverReprocess),
             rootSet.alwaysClassInline,
-            rootSet.neverPropagateValue,
             joinIdentifierNameStrings(rootSet.identifierNameStrings, identifierNameStrings),
             emptySet(),
             Collections.emptyMap(),
@@ -4797,6 +4829,7 @@
     long result = liveTypes.getItems().size();
     result += liveMethods.items.size();
     result += liveFields.fields.size();
+    result += effectivelyLiveOriginalReferences.size();
     return result;
   }
 
diff --git a/src/main/java/com/android/tools/r8/shaking/GraphReporter.java b/src/main/java/com/android/tools/r8/shaking/GraphReporter.java
index 1e63e51..3ae9270 100644
--- a/src/main/java/com/android/tools/r8/shaking/GraphReporter.java
+++ b/src/main/java/com/android/tools/r8/shaking/GraphReporter.java
@@ -33,13 +33,13 @@
 import com.android.tools.r8.shaking.KeepReason.ReflectiveUseFrom;
 import com.android.tools.r8.utils.DequeUtils;
 import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.SetUtils;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableList.Builder;
 import com.google.common.collect.Sets;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Deque;
-import java.util.HashSet;
 import java.util.IdentityHashMap;
 import java.util.Map;
 import java.util.Set;
@@ -532,14 +532,12 @@
     }
     if (rule instanceof ProguardIfRule) {
       ProguardIfRule ifRule = (ProguardIfRule) rule;
-      assert !ifRule.getPreconditions().isEmpty();
+      assert ifRule.getPrecondition() != null;
       return ruleNodes.computeIfAbsent(
           ifRule,
           key -> {
-            Set<GraphNode> preconditions = new HashSet<>(ifRule.getPreconditions().size());
-            for (DexReference condition : ifRule.getPreconditions()) {
-              preconditions.add(getGraphNode(condition));
-            }
+            Set<GraphNode> preconditions =
+                SetUtils.newHashSet(getGraphNode(ifRule.getPrecondition().getReference()));
             return new KeepRuleGraphNode(ifRule, preconditions);
           });
     }
diff --git a/src/main/java/com/android/tools/r8/shaking/IfRuleEvaluator.java b/src/main/java/com/android/tools/r8/shaking/IfRuleEvaluator.java
index 32ec312..44ba57d 100644
--- a/src/main/java/com/android/tools/r8/shaking/IfRuleEvaluator.java
+++ b/src/main/java/com/android/tools/r8/shaking/IfRuleEvaluator.java
@@ -3,8 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.shaking;
 
-import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
-
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClass;
@@ -14,17 +12,14 @@
 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.DexReference;
-import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.SubtypingInfo;
-import com.android.tools.r8.shaking.InlineRule.Type;
+import com.android.tools.r8.shaking.InlineRule.InlineRuleType;
 import com.android.tools.r8.shaking.RootSetUtils.ConsequentRootSet;
 import com.android.tools.r8.shaking.RootSetUtils.ConsequentRootSetBuilder;
 import com.android.tools.r8.shaking.RootSetUtils.RootSetBuilder;
 import com.android.tools.r8.threading.TaskCollection;
 import com.android.tools.r8.utils.InternalOptions.TestingOptions.ProguardIfRuleEvaluationData;
 import com.google.common.base.Equivalence.Wrapper;
-import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Sets;
 import java.util.ArrayList;
@@ -98,48 +93,12 @@
                 if (appView.options().testing.measureProguardIfRuleEvaluations) {
                   ifRuleEvaluationData.numberOfProguardIfRuleMemberEvaluations++;
                 }
-                boolean matched = evaluateIfRuleMembersAndMaterialize(ifRule, clazz, clazz);
+                boolean matched = evaluateIfRuleMembersAndMaterialize(ifRule, clazz);
                 if (matched && canRemoveSubsequentKeepRule(ifRule)) {
                   toRemove.add(ifRule);
                 }
               }
             }
-
-            // Check if one of the types that have been merged into `clazz` satisfies the if-rule.
-            if (appView.getVerticallyMergedClasses() != null) {
-              Iterable<DexType> sources =
-                  appView.getVerticallyMergedClasses().getSourcesFor(clazz.type);
-              for (DexType sourceType : sources) {
-                // Note that, although `sourceType` has been merged into `type`, the dex class for
-                // `sourceType` is still available until the second round of tree shaking. This
-                // way we can still retrieve the access flags of `sourceType`.
-                DexProgramClass sourceClass =
-                    asProgramClassOrNull(
-                        appView.appInfo().definitionForWithoutExistenceAssert(sourceType));
-                if (sourceClass == null) {
-                  // TODO(b/266049507): The evaluation of -if rules in the final round of tree
-                  //  shaking and during -whyareyoukeeping should be the same. Currently the pruning
-                  //  of classes changes behavior.
-                  assert enqueuer.getMode().isWhyAreYouKeeping();
-                  continue;
-                }
-                if (appView.options().testing.measureProguardIfRuleEvaluations) {
-                  ifRuleEvaluationData.numberOfProguardIfRuleClassEvaluations++;
-                }
-                if (evaluateClassForIfRule(ifRuleKey, sourceClass)) {
-                  for (ProguardIfRule ifRule : ifRulesInEquivalence) {
-                    registerClassCapture(ifRule, sourceClass, clazz);
-                    if (appView.options().testing.measureProguardIfRuleEvaluations) {
-                      ifRuleEvaluationData.numberOfProguardIfRuleMemberEvaluations++;
-                    }
-                    if (evaluateIfRuleMembersAndMaterialize(ifRule, sourceClass, clazz)
-                        && canRemoveSubsequentKeepRule(ifRule)) {
-                      toRemove.add(ifRule);
-                    }
-                  }
-                }
-              }
-            }
           }
           if (ifRulesInEquivalence.size() == toRemove.size()) {
             it.remove();
@@ -203,12 +162,11 @@
     return true;
   }
 
-  @SuppressWarnings("ReferenceEquality")
-  private boolean evaluateIfRuleMembersAndMaterialize(
-      ProguardIfRule rule, DexClass sourceClass, DexClass targetClass) throws ExecutionException {
+  private boolean evaluateIfRuleMembersAndMaterialize(ProguardIfRule rule, DexProgramClass clazz)
+      throws ExecutionException {
     Collection<ProguardMemberRule> memberKeepRules = rule.getMemberRules();
     if (memberKeepRules.isEmpty()) {
-      materializeIfRule(rule, ImmutableSet.of(sourceClass.getReference()));
+      materializeIfRule(rule, clazz);
       return true;
     }
 
@@ -216,12 +174,12 @@
     Set<DexDefinition> filteredMembers = Sets.newIdentityHashSet();
     Iterables.addAll(
         filteredMembers,
-        targetClass.fields(
+        clazz.fields(
             f -> {
               // Fields that are javac inlined are unsound as predicates for conditional rules.
               // Ignore any such field members and record it for possible reporting later.
               if (isFieldInlinedByJavaC(f)) {
-                fieldsInlinedByJavaC.add(DexClassAndField.create(targetClass, f));
+                fieldsInlinedByJavaC.add(DexClassAndField.create(clazz, f));
                 return false;
               }
               // Fields referenced only by -keep may not be referenced, we therefore have to
@@ -229,18 +187,24 @@
               return (enqueuer.isFieldLive(f)
                       || enqueuer.isFieldReferenced(f)
                       || f.getOptimizationInfo().valueHasBeenPropagated())
-                  && (appView.graphLens().getOriginalFieldSignature(f.getReference()).holder
-                      == sourceClass.type);
+                  && appView
+                      .graphLens()
+                      .getOriginalFieldSignature(f.getReference())
+                      .getHolderType()
+                      .isIdenticalTo(clazz.getType());
             }));
     Iterables.addAll(
         filteredMembers,
-        targetClass.methods(
+        clazz.methods(
             m ->
                 (enqueuer.isMethodLive(m)
                         || enqueuer.isMethodTargeted(m)
                         || m.getOptimizationInfo().returnValueHasBeenPropagated())
-                    && appView.graphLens().getOriginalMethodSignature(m.getReference()).holder
-                        == sourceClass.type));
+                    && appView
+                        .graphLens()
+                        .getOriginalMethodSignature(m.getReference())
+                        .getHolderType()
+                        .isIdenticalTo(clazz.getType())));
 
     // Check if the rule could hypothetically have matched a javac inlined field.
     // If so mark the rule. Reporting happens only if the rule is otherwise unused.
@@ -271,11 +235,11 @@
         Sets.combinations(filteredMembers, memberKeepRules.size())) {
       Collection<DexClassAndField> fieldsInCombination =
           DexDefinition.filterDexEncodedField(
-                  combination.stream(), field -> DexClassAndField.create(targetClass, field))
+                  combination.stream(), field -> DexClassAndField.create(clazz, field))
               .collect(Collectors.toList());
       Collection<DexClassAndMethod> methodsInCombination =
           DexDefinition.filterDexEncodedMethod(
-                  combination.stream(), method -> DexClassAndMethod.create(targetClass, method))
+                  combination.stream(), method -> DexClassAndMethod.create(clazz, method))
               .collect(Collectors.toList());
       // Member rules are combined as AND logic: if found unsatisfied member rule, this
       // combination of live members is not a good fit.
@@ -287,7 +251,7 @@
                           || rootSetBuilder.ruleSatisfiedByMethods(
                               memberRule, methodsInCombination));
       if (satisfied) {
-        materializeIfRule(rule, ImmutableSet.of(sourceClass.getReference()));
+        materializeIfRule(rule, clazz);
         if (canRemoveSubsequentKeepRule(rule)) {
           return true;
         }
@@ -305,25 +269,17 @@
     return field.getOrComputeIsInlinableByJavaC(appView.dexItemFactory());
   }
 
-  @SuppressWarnings("BadImport")
-  private void materializeIfRule(ProguardIfRule rule, Set<DexReference> preconditions)
+  private void materializeIfRule(ProguardIfRule rule, DexProgramClass precondition)
       throws ExecutionException {
     DexItemFactory dexItemFactory = appView.dexItemFactory();
-    ProguardIfRule materializedRule = rule.materialize(dexItemFactory, preconditions);
+    ProguardIfRule materializedRule = rule.materialize(dexItemFactory, precondition);
 
     if (enqueuer.getMode().isInitialTreeShaking()
         && !rule.isUsed()
         && !rule.isTrivalAllClassMatch()) {
-      // We need to abort class inlining of classes that could be matched by the condition of this
-      // -if rule.
-      ClassInlineRule neverClassInlineRuleForCondition =
-          materializedRule.neverClassInlineRuleForCondition(dexItemFactory);
-      if (neverClassInlineRuleForCondition != null) {
-        rootSetBuilder.runPerRule(tasks, neverClassInlineRuleForCondition, null);
-      }
-
       InlineRule neverInlineForClassInliningRuleForCondition =
-          materializedRule.neverInlineRuleForCondition(dexItemFactory, Type.NEVER_CLASS_INLINE);
+          materializedRule.neverInlineRuleForCondition(
+              dexItemFactory, InlineRuleType.NEVER_CLASS_INLINE);
       if (neverInlineForClassInliningRuleForCondition != null) {
         rootSetBuilder.runPerRule(tasks, neverInlineForClassInliningRuleForCondition, null);
       }
@@ -332,17 +288,18 @@
       // ensure that the subsequent rule will be applied again in the second round of tree
       // shaking.
       InlineRule neverInlineRuleForCondition =
-          materializedRule.neverInlineRuleForCondition(dexItemFactory, Type.NEVER);
+          materializedRule.neverInlineRuleForCondition(dexItemFactory, InlineRuleType.NEVER);
       if (neverInlineRuleForCondition != null) {
         rootSetBuilder.runPerRule(tasks, neverInlineRuleForCondition, null);
       }
 
-      // Prevent horizontal class merging of any -if rule members.
-      NoHorizontalClassMergingRule noHorizontalClassMergingRule =
-          materializedRule.noHorizontalClassMergingRuleForCondition(dexItemFactory);
-      if (noHorizontalClassMergingRule != null) {
-        rootSetBuilder.runPerRule(tasks, noHorizontalClassMergingRule, null);
-      }
+      rootSetBuilder
+          .getDependentMinimumKeepInfo()
+          .getOrCreateUnconditionalMinimumKeepInfoFor(precondition.getType())
+          .asClassJoiner()
+          .disallowClassInlining()
+          .disallowHorizontalClassMerging()
+          .disallowVerticalClassMerging();
     }
 
     // Keep whatever is required by the -if rule.
diff --git a/src/main/java/com/android/tools/r8/shaking/InlineRule.java b/src/main/java/com/android/tools/r8/shaking/InlineRule.java
index cc813ad..4949e5a 100644
--- a/src/main/java/com/android/tools/r8/shaking/InlineRule.java
+++ b/src/main/java/com/android/tools/r8/shaking/InlineRule.java
@@ -10,7 +10,7 @@
 
 public class InlineRule extends ProguardConfigurationRule {
 
-  public enum Type {
+  public enum InlineRuleType {
     ALWAYS,
     NEVER,
     NEVER_CLASS_INLINE,
@@ -24,14 +24,14 @@
       super();
     }
 
-    Type type;
+    InlineRuleType type;
 
     @Override
     public Builder self() {
       return this;
     }
 
-    public Builder setType(Type type) {
+    public Builder setType(InlineRuleType type) {
       this.type = type;
       return this;
     }
@@ -56,7 +56,7 @@
     }
   }
 
-  private final Type type;
+  private final InlineRuleType type;
 
   protected InlineRule(
       Origin origin,
@@ -72,7 +72,7 @@
       ProguardTypeMatcher inheritanceClassName,
       boolean inheritanceIsExtends,
       List<ProguardMemberRule> memberRules,
-      Type type) {
+      InlineRuleType type) {
     super(
         origin,
         position,
@@ -94,7 +94,7 @@
     return new Builder();
   }
 
-  public Type getType() {
+  public InlineRuleType getType() {
     return type;
   }
 
diff --git a/src/main/java/com/android/tools/r8/shaking/KeepFieldInfo.java b/src/main/java/com/android/tools/r8/shaking/KeepFieldInfo.java
index 5981161..6ffab14 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepFieldInfo.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepFieldInfo.java
@@ -75,7 +75,7 @@
     return this.equals(bottom());
   }
 
-  public static class Builder extends KeepInfo.Builder<Builder, KeepFieldInfo> {
+  public static class Builder extends KeepMemberInfo.Builder<Builder, KeepFieldInfo> {
 
     private boolean allowFieldTypeStrengthening;
     private boolean allowRedundantFieldLoadElimination;
@@ -172,7 +172,7 @@
     }
   }
 
-  public static class Joiner extends KeepInfo.Joiner<Joiner, Builder, KeepFieldInfo> {
+  public static class Joiner extends KeepMemberInfo.Joiner<Joiner, Builder, KeepFieldInfo> {
 
     public Joiner(KeepFieldInfo info) {
       super(info.builder());
diff --git a/src/main/java/com/android/tools/r8/shaking/KeepInfo.java b/src/main/java/com/android/tools/r8/shaking/KeepInfo.java
index e09ed70..9a76113 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepInfo.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepInfo.java
@@ -514,6 +514,10 @@
       return joiner != null ? joiner.asFieldJoiner() : null;
     }
 
+    public KeepMemberInfo.Joiner<?, ?, ?> asMemberJoiner() {
+      return null;
+    }
+
     public KeepMethodInfo.Joiner asMethodJoiner() {
       return null;
     }
diff --git a/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java b/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java
index cd76ad3..32835e2 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java
@@ -91,6 +91,8 @@
    */
   public abstract KeepMethodInfo getMethodInfo(DexEncodedMethod method, DexProgramClass holder);
 
+  public abstract void registerCompilerSynthesizedMethod(ProgramMethod method);
+
   /**
    * Base accessor for keep info on a field.
    *
@@ -526,6 +528,25 @@
     }
 
     @Override
+    public void registerCompilerSynthesizedMethod(ProgramMethod method) {
+      assert !keepMethodInfo.containsKey(method.getReference());
+      keepMethodInfo.put(method.getReference(), SyntheticKeepMethodInfo.bottom());
+    }
+
+    public void registerCompilerSynthesizedMethods(KeepInfoCollection keepInfoCollection) {
+      keepInfoCollection.mutate(
+          mutableKeepInfoCollection -> {
+            mutableKeepInfoCollection.keepMethodInfo.forEach(
+                (m, info) -> {
+                  if (info instanceof SyntheticKeepMethodInfo) {
+                    assert !keepMethodInfo.containsKey(m);
+                    keepMethodInfo.put(m, info);
+                  }
+                });
+          });
+    }
+
+    @Override
     public KeepClassInfo getClassInfo(DexProgramClass clazz) {
       return keepClassInfo.getOrDefault(clazz.type, KeepClassInfo.bottom());
     }
diff --git a/src/main/java/com/android/tools/r8/shaking/KeepMemberInfo.java b/src/main/java/com/android/tools/r8/shaking/KeepMemberInfo.java
index 4f4355b..201c2f9 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepMemberInfo.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepMemberInfo.java
@@ -3,16 +3,22 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.shaking;
 
+import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.shaking.KeepInfo.Builder;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramMember;
+import com.android.tools.r8.shaking.KeepMemberInfo.Builder;
 
 /** Immutable keep requirements for a member. */
 @SuppressWarnings("BadImport")
-public abstract class KeepMemberInfo<B extends Builder<B, K>, K extends KeepInfo<B, K>>
+public abstract class KeepMemberInfo<B extends Builder<B, K>, K extends KeepMemberInfo<B, K>>
     extends KeepInfo<B, K> {
 
-  KeepMemberInfo(B builder) {
+  private final boolean allowValuePropagation;
+
+  protected KeepMemberInfo(B builder) {
     super(builder);
+    this.allowValuePropagation = builder.isValuePropagationAllowed();
   }
 
   @SuppressWarnings("BadImport")
@@ -22,4 +28,100 @@
     // before members.
     return holder.getKotlinInfo().isNoKotlinInformation() || !isPinned(configuration);
   }
+
+  public boolean isValuePropagationAllowed(
+      AppView<AppInfoWithLiveness> appView, ProgramMember<?, ?> member) {
+    DexType type =
+        member.isField() ? member.asField().getType() : member.asMethod().getReturnType();
+    boolean isTypeInstantiated = !type.isAlwaysNull(appView);
+    return isValuePropagationAllowed(appView.options(), isTypeInstantiated);
+  }
+
+  public boolean isValuePropagationAllowed(
+      GlobalKeepInfoConfiguration configuration, boolean isTypeInstantiated) {
+    if (!isOptimizationAllowed(configuration) && isTypeInstantiated) {
+      return false;
+    }
+    return internalIsValuePropagationAllowed();
+  }
+
+  boolean internalIsValuePropagationAllowed() {
+    return allowValuePropagation;
+  }
+
+  public abstract static class Builder<B extends Builder<B, K>, K extends KeepMemberInfo<B, K>>
+      extends KeepInfo.Builder<B, K> {
+
+    private boolean allowValuePropagation;
+
+    protected Builder() {
+      super();
+    }
+
+    protected Builder(K original) {
+      super(original);
+      allowValuePropagation = original.internalIsValuePropagationAllowed();
+    }
+
+    // Value propagation.
+
+    public boolean isValuePropagationAllowed() {
+      return allowValuePropagation;
+    }
+
+    public B setAllowValuePropagation(boolean allowValuePropagation) {
+      this.allowValuePropagation = allowValuePropagation;
+      return self();
+    }
+
+    public B allowValuePropagation() {
+      return setAllowValuePropagation(true);
+    }
+
+    public B disallowValuePropagation() {
+      return setAllowValuePropagation(false);
+    }
+
+    @Override
+    boolean internalIsEqualTo(K other) {
+      return super.internalIsEqualTo(other)
+          && isValuePropagationAllowed() == other.internalIsValuePropagationAllowed();
+    }
+
+    @Override
+    public B makeTop() {
+      return super.makeTop().disallowValuePropagation();
+    }
+
+    @Override
+    public B makeBottom() {
+      return super.makeBottom().allowValuePropagation();
+    }
+  }
+
+  public abstract static class Joiner<
+          J extends Joiner<J, B, K>, B extends Builder<B, K>, K extends KeepMemberInfo<B, K>>
+      extends KeepInfo.Joiner<J, B, K> {
+
+    protected Joiner(B builder) {
+      super(builder);
+    }
+
+    public J disallowValuePropagation() {
+      builder.disallowValuePropagation();
+      return self();
+    }
+
+    @Override
+    public Joiner<?, ?, ?> asMemberJoiner() {
+      return this;
+    }
+
+    @Override
+    public J merge(J joiner) {
+      // Should be extended to merge the fields of this class in case any are added.
+      return super.merge(joiner)
+          .applyIf(!joiner.builder.isValuePropagationAllowed(), Joiner::disallowValuePropagation);
+    }
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/shaking/KeepMethodInfo.java b/src/main/java/com/android/tools/r8/shaking/KeepMethodInfo.java
index 41ec85a..f9038bf 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepMethodInfo.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepMethodInfo.java
@@ -3,8 +3,10 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.shaking;
 
+import com.android.tools.r8.graph.ProgramMethod;
+
 /** Immutable keep requirements for a method. */
-public final class KeepMethodInfo extends KeepMemberInfo<KeepMethodInfo.Builder, KeepMethodInfo> {
+public class KeepMethodInfo extends KeepMemberInfo<KeepMethodInfo.Builder, KeepMethodInfo> {
 
   // Requires all aspects of a method to be kept.
   private static final KeepMethodInfo TOP = new Builder().makeTop().build();
@@ -32,11 +34,13 @@
   private final boolean allowParameterRemoval;
   private final boolean allowParameterReordering;
   private final boolean allowParameterTypeStrengthening;
+  private final boolean allowReprocessing;
   private final boolean allowReturnTypeStrengthening;
+  private final boolean allowSingleCallerInlining;
   private final boolean allowUnusedArgumentOptimization;
   private final boolean allowUnusedReturnValueOptimization;
 
-  private KeepMethodInfo(Builder builder) {
+  protected KeepMethodInfo(Builder builder) {
     super(builder);
     this.allowClassInlining = builder.isClassInliningAllowed();
     this.allowClosedWorldReasoning = builder.isClosedWorldReasoningAllowed();
@@ -46,7 +50,9 @@
     this.allowParameterRemoval = builder.isParameterRemovalAllowed();
     this.allowParameterReordering = builder.isParameterReorderingAllowed();
     this.allowParameterTypeStrengthening = builder.isParameterTypeStrengtheningAllowed();
+    this.allowReprocessing = builder.isReprocessingAllowed();
     this.allowReturnTypeStrengthening = builder.isReturnTypeStrengtheningAllowed();
+    this.allowSingleCallerInlining = builder.isSingleCallerInliningAllowed();
     this.allowUnusedArgumentOptimization = builder.isUnusedArgumentOptimizationAllowed();
     this.allowUnusedReturnValueOptimization = builder.isUnusedReturnValueOptimizationAllowed();
   }
@@ -140,6 +146,16 @@
     return allowParameterTypeStrengthening;
   }
 
+  public boolean isReprocessingAllowed(
+      GlobalKeepInfoConfiguration configuration, ProgramMethod method) {
+    return !method.getOptimizationInfo().hasBeenInlinedIntoSingleCallSite()
+        && internalIsReprocessingAllowed();
+  }
+
+  boolean internalIsReprocessingAllowed() {
+    return allowReprocessing;
+  }
+
   public boolean isReturnTypeStrengtheningAllowed(GlobalKeepInfoConfiguration configuration) {
     return isClosedWorldReasoningAllowed(configuration)
         && isOptimizationAllowed(configuration)
@@ -151,6 +167,14 @@
     return allowReturnTypeStrengthening;
   }
 
+  public boolean isSingleCallerInliningAllowed(GlobalKeepInfoConfiguration configuration) {
+    return internalIsSingleCallerInliningAllowed();
+  }
+
+  boolean internalIsSingleCallerInliningAllowed() {
+    return allowSingleCallerInlining;
+  }
+
   public boolean isUnusedArgumentOptimizationAllowed(GlobalKeepInfoConfiguration configuration) {
     return isClosedWorldReasoningAllowed(configuration)
         && isOptimizationAllowed(configuration)
@@ -188,7 +212,7 @@
     return this.equals(bottom());
   }
 
-  public static class Builder extends KeepInfo.Builder<Builder, KeepMethodInfo> {
+  public static class Builder extends KeepMemberInfo.Builder<Builder, KeepMethodInfo> {
 
     private boolean allowClassInlining;
     private boolean allowClosedWorldReasoning;
@@ -198,15 +222,17 @@
     private boolean allowParameterRemoval;
     private boolean allowParameterReordering;
     private boolean allowParameterTypeStrengthening;
+    private boolean allowReprocessing;
     private boolean allowReturnTypeStrengthening;
+    private boolean allowSingleCallerInlining;
     private boolean allowUnusedArgumentOptimization;
     private boolean allowUnusedReturnValueOptimization;
 
-    private Builder() {
+    public Builder() {
       super();
     }
 
-    private Builder(KeepMethodInfo original) {
+    protected Builder(KeepMethodInfo original) {
       super(original);
       allowClassInlining = original.internalIsClassInliningAllowed();
       allowClosedWorldReasoning = original.internalIsClosedWorldReasoningAllowed();
@@ -216,7 +242,9 @@
       allowParameterRemoval = original.internalIsParameterRemovalAllowed();
       allowParameterReordering = original.internalIsParameterReorderingAllowed();
       allowParameterTypeStrengthening = original.internalIsParameterTypeStrengtheningAllowed();
+      allowReprocessing = original.internalIsReprocessingAllowed();
       allowReturnTypeStrengthening = original.internalIsReturnTypeStrengtheningAllowed();
+      allowSingleCallerInlining = original.internalIsSingleCallerInliningAllowed();
       allowUnusedArgumentOptimization = original.internalIsUnusedArgumentOptimizationAllowed();
       allowUnusedReturnValueOptimization =
           original.internalIsUnusedReturnValueOptimizationAllowed();
@@ -374,6 +402,25 @@
       return setAllowParameterTypeStrengthening(false);
     }
 
+    // Reprocessing.
+
+    public boolean isReprocessingAllowed() {
+      return allowReprocessing;
+    }
+
+    public Builder setAllowReprocessing(boolean allowReprocessing) {
+      this.allowReprocessing = allowReprocessing;
+      return self();
+    }
+
+    public Builder allowReprocessing() {
+      return setAllowReprocessing(true);
+    }
+
+    public Builder disallowReprocessing() {
+      return setAllowReprocessing(false);
+    }
+
     // Return type strengthening.
 
     public boolean isReturnTypeStrengtheningAllowed() {
@@ -393,6 +440,25 @@
       return setAllowReturnTypeStrengthening(false);
     }
 
+    // Single caller inlining.
+
+    public boolean isSingleCallerInliningAllowed() {
+      return allowSingleCallerInlining;
+    }
+
+    public Builder setAllowSingleCallerInlining(boolean allowSingleCallerInlining) {
+      this.allowSingleCallerInlining = allowSingleCallerInlining;
+      return self();
+    }
+
+    public Builder allowSingleCallerInlining() {
+      return setAllowSingleCallerInlining(true);
+    }
+
+    public Builder disallowSingleCallerInlining() {
+      return setAllowSingleCallerInlining(false);
+    }
+
     // Unused argument optimization.
 
     public boolean isUnusedArgumentOptimizationAllowed() {
@@ -465,7 +531,9 @@
           && isParameterReorderingAllowed() == other.internalIsParameterReorderingAllowed()
           && isParameterTypeStrengtheningAllowed()
               == other.internalIsParameterTypeStrengtheningAllowed()
+          && isReprocessingAllowed() == other.internalIsReprocessingAllowed()
           && isReturnTypeStrengtheningAllowed() == other.internalIsReturnTypeStrengtheningAllowed()
+          && isSingleCallerInliningAllowed() == other.internalIsSingleCallerInliningAllowed()
           && isUnusedArgumentOptimizationAllowed()
               == other.internalIsUnusedArgumentOptimizationAllowed()
           && isUnusedReturnValueOptimizationAllowed()
@@ -488,7 +556,9 @@
           .disallowParameterRemoval()
           .disallowParameterReordering()
           .disallowParameterTypeStrengthening()
+          .disallowReprocessing()
           .disallowReturnTypeStrengthening()
+          .disallowSingleCallerInlining()
           .disallowUnusedArgumentOptimization()
           .disallowUnusedReturnValueOptimization();
     }
@@ -504,18 +574,24 @@
           .allowParameterRemoval()
           .allowParameterReordering()
           .allowParameterTypeStrengthening()
+          .allowReprocessing()
           .allowReturnTypeStrengthening()
+          .allowSingleCallerInlining()
           .allowUnusedArgumentOptimization()
           .allowUnusedReturnValueOptimization();
     }
   }
 
-  public static class Joiner extends KeepInfo.Joiner<Joiner, Builder, KeepMethodInfo> {
+  public static class Joiner extends KeepMemberInfo.Joiner<Joiner, Builder, KeepMethodInfo> {
 
     public Joiner(KeepMethodInfo info) {
       super(info.builder());
     }
 
+    protected Joiner(Builder builder) {
+      super(builder);
+    }
+
     public Joiner disallowClassInlining() {
       builder.disallowClassInlining();
       return self();
@@ -556,11 +632,21 @@
       return self();
     }
 
+    public Joiner disallowReprocessing() {
+      builder.disallowReprocessing();
+      return self();
+    }
+
     public Joiner disallowReturnTypeStrengthening() {
       builder.disallowReturnTypeStrengthening();
       return self();
     }
 
+    public Joiner disallowSingleCallerInlining() {
+      builder.disallowSingleCallerInlining();
+      return self();
+    }
+
     public Joiner disallowUnusedArgumentOptimization() {
       builder.disallowUnusedArgumentOptimization();
       return self();
@@ -594,10 +680,13 @@
           .applyIf(
               !joiner.builder.isParameterTypeStrengtheningAllowed(),
               Joiner::disallowParameterTypeStrengthening)
+          .applyIf(!joiner.builder.isReprocessingAllowed(), Joiner::disallowReprocessing)
           .applyIf(
               !joiner.builder.isReturnTypeStrengtheningAllowed(),
               Joiner::disallowReturnTypeStrengthening)
           .applyIf(
+              !joiner.builder.isSingleCallerInliningAllowed(), Joiner::disallowSingleCallerInlining)
+          .applyIf(
               !joiner.builder.isUnusedArgumentOptimizationAllowed(),
               Joiner::disallowUnusedArgumentOptimization)
           .applyIf(
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
index 6ae7d4c..b2dcea5 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
@@ -18,6 +18,7 @@
 import com.android.tools.r8.position.Position;
 import com.android.tools.r8.position.TextPosition;
 import com.android.tools.r8.position.TextRange;
+import com.android.tools.r8.shaking.InlineRule.InlineRuleType;
 import com.android.tools.r8.shaking.ProguardConfiguration.Builder;
 import com.android.tools.r8.shaking.ProguardTypeMatcher.ClassOrType;
 import com.android.tools.r8.shaking.ProguardWildcard.BackReference;
@@ -464,7 +465,7 @@
       } else if (acceptString("alwaysinline")) {
         InlineRule rule =
             parseRuleWithClassSpec(
-                optionStart, InlineRule.builder().setType(InlineRule.Type.ALWAYS));
+                optionStart, InlineRule.builder().setType(InlineRuleType.ALWAYS));
         configurationBuilder.addRule(rule);
       } else if (acceptString("adaptclassstrings")) {
         parseClassFilter(configurationBuilder::addAdaptClassStringsPattern);
@@ -566,14 +567,14 @@
         if (acceptString("neverinline")) {
           InlineRule rule =
               parseRuleWithClassSpec(
-                  optionStart, InlineRule.builder().setType(InlineRule.Type.NEVER));
+                  optionStart, InlineRule.builder().setType(InlineRuleType.NEVER));
           configurationBuilder.addRule(rule);
           return true;
         }
         if (acceptString("neversinglecallerinline")) {
           InlineRule rule =
               parseRuleWithClassSpec(
-                  optionStart, InlineRule.builder().setType(InlineRule.Type.NEVER_SINGLE_CALLER));
+                  optionStart, InlineRule.builder().setType(InlineRuleType.NEVER_SINGLE_CALLER));
           configurationBuilder.addRule(rule);
           return true;
         }
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardIfRule.java b/src/main/java/com/android/tools/r8/shaking/ProguardIfRule.java
index 2279a8e..cb3757c 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardIfRule.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardIfRule.java
@@ -5,9 +5,10 @@
 
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexReference;
+import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.position.Position;
+import com.android.tools.r8.shaking.InlineRule.InlineRuleType;
 import com.google.common.collect.Iterables;
 import java.util.List;
 import java.util.Map;
@@ -25,21 +26,14 @@
         }
       };
 
-  private static final Origin NO_HORIZONTAL_CLASS_MERGING_ORIGIN =
-      new Origin(Origin.root()) {
-        @Override
-        public String part() {
-          return "<SYNTHETIC_NO_HORIZONTAL_CLASS_MERGING_RULE>";
-        }
-      };
-
-  private final Set<DexReference> preconditions;
+  private final DexProgramClass precondition;
   final ProguardKeepRule subsequentRule;
 
   private Map<DexField, DexField> inlinableFieldsInPrecondition = new ConcurrentHashMap<>();
 
-  public Set<DexReference> getPreconditions() {
-    return preconditions;
+  public DexProgramClass getPrecondition() {
+    assert precondition != null;
+    return precondition;
   }
 
   public ProguardKeepRule getSubsequentRule() {
@@ -112,7 +106,7 @@
       boolean inheritanceIsExtends,
       List<ProguardMemberRule> memberRules,
       ProguardKeepRule subsequentRule,
-      Set<DexReference> preconditions) {
+      DexProgramClass precondition) {
     super(
         origin,
         position,
@@ -130,7 +124,7 @@
         ProguardKeepRuleType.CONDITIONAL,
         ProguardKeepRuleModifiers.builder().build());
     this.subsequentRule = subsequentRule;
-    this.preconditions = preconditions;
+    this.precondition = precondition;
   }
 
   public static Builder builder() {
@@ -153,7 +147,7 @@
   }
 
   protected ProguardIfRule materialize(
-      DexItemFactory dexItemFactory, Set<DexReference> preconditions) {
+      DexItemFactory dexItemFactory, DexProgramClass precondition) {
     return new ProguardIfRule(
         getOrigin(),
         getPosition(),
@@ -175,27 +169,7 @@
                 .map(memberRule -> memberRule.materialize(dexItemFactory))
                 .collect(Collectors.toList()),
         subsequentRule.materialize(dexItemFactory),
-        preconditions);
-  }
-
-  protected ClassInlineRule neverClassInlineRuleForCondition(DexItemFactory dexItemFactory) {
-    return new ClassInlineRule(
-        NEVER_INLINE_ORIGIN,
-        Position.UNKNOWN,
-        null,
-        ProguardTypeMatcher.materializeList(getClassAnnotations(), dexItemFactory),
-        getClassAccessFlags(),
-        getNegatedClassAccessFlags(),
-        getClassTypeNegated(),
-        getClassType(),
-        getClassNames().materialize(dexItemFactory),
-        ProguardTypeMatcher.materializeList(getInheritanceAnnotations(), dexItemFactory),
-        getInheritanceClassName() == null
-            ? null
-            : getInheritanceClassName().materialize(dexItemFactory),
-        getInheritanceIsExtends(),
-        getMemberRules(),
-        ClassInlineRule.Type.NEVER);
+        precondition);
   }
 
   /**
@@ -221,7 +195,7 @@
    * -neverinline rule for the condition of the -if rule.
    */
   protected InlineRule neverInlineRuleForCondition(
-      DexItemFactory dexItemFactory, InlineRule.Type type) {
+      DexItemFactory dexItemFactory, InlineRuleType type) {
     if (getMemberRules() == null || getMemberRules().isEmpty()) {
       return null;
     }
@@ -247,36 +221,6 @@
         type);
   }
 
-  protected NoHorizontalClassMergingRule noHorizontalClassMergingRuleForCondition(
-      DexItemFactory dexItemFactory) {
-    List<ProguardMemberRule> memberRules = null;
-    if (getMemberRules() != null) {
-      memberRules =
-          getMemberRules().stream()
-              .map(memberRule -> memberRule.materialize(dexItemFactory))
-              .collect(Collectors.toList());
-    }
-
-    return NoHorizontalClassMergingRule.builder()
-        .setOrigin(NO_HORIZONTAL_CLASS_MERGING_ORIGIN)
-        .addClassAnnotations(
-            ProguardTypeMatcher.materializeList(getClassAnnotations(), dexItemFactory))
-        .setClassAccessFlags(getClassAccessFlags())
-        .setNegatedClassAccessFlags(getNegatedClassAccessFlags())
-        .setClassType(getClassType())
-        .setClassTypeNegated(getClassTypeNegated())
-        .setClassNames(getClassNames().materialize(dexItemFactory))
-        .addInheritanceAnnotations(
-            ProguardTypeMatcher.materializeList(getInheritanceAnnotations(), dexItemFactory))
-        .setInheritanceClassName(
-            getInheritanceClassName() == null
-                ? null
-                : getInheritanceClassName().materialize(dexItemFactory))
-        .setInheritanceIsExtends(getInheritanceIsExtends())
-        .setMemberRules(memberRules)
-        .build();
-  }
-
   @Override
   public boolean equals(Object o) {
     if (!(o instanceof ProguardIfRule)) {
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 e478be4..9d30ea3 100644
--- a/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java
+++ b/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java
@@ -118,13 +118,10 @@
         DependentMinimumKeepInfoCollection.createConcurrent();
     private final LinkedHashMap<DexReference, DexReference> reasonAsked = new LinkedHashMap<>();
     private final Set<DexMethod> alwaysInline = Sets.newIdentityHashSet();
-    private final Set<DexMethod> neverInlineDueToSingleCaller = Sets.newIdentityHashSet();
     private final Set<DexMethod> bypassClinitforInlining = Sets.newIdentityHashSet();
     private final Set<DexMethod> whyAreYouNotInlining = Sets.newIdentityHashSet();
     private final Set<DexMethod> reprocess = Sets.newIdentityHashSet();
-    private final Set<DexMethod> neverReprocess = Sets.newIdentityHashSet();
     private final PredicateSet<DexType> alwaysClassInline = new PredicateSet<>();
-    private final Set<DexMember<?, ?>> neverPropagateValue = Sets.newIdentityHashSet();
     private final Map<DexType, Set<ProguardKeepRuleBase>> dependentKeepClassCompatRule =
         new IdentityHashMap<>();
     private final Map<DexReference, ProguardMemberRule> mayHaveSideEffects =
@@ -176,6 +173,10 @@
           null);
     }
 
+    public DependentMinimumKeepInfoCollection getDependentMinimumKeepInfo() {
+      return dependentMinimumKeepInfo;
+    }
+
     boolean isMainDexRootSetBuilder() {
       return false;
     }
@@ -391,13 +392,10 @@
           dependentMinimumKeepInfo,
           ImmutableList.copyOf(reasonAsked.values()),
           alwaysInline,
-          neverInlineDueToSingleCaller,
           bypassClinitforInlining,
           whyAreYouNotInlining,
           reprocess,
-          neverReprocess,
           alwaysClassInline,
-          neverPropagateValue,
           mayHaveSideEffects,
           dependentKeepClassCompatRule,
           identifierNameStrings,
@@ -463,7 +461,6 @@
 
     ConsequentRootSet buildConsequentRootSet() {
       return new ConsequentRootSet(
-          neverInlineDueToSingleCaller,
           dependentMinimumKeepInfo,
           dependentKeepClassCompatRule,
           Lists.newArrayList(delayedRootSetActionItems),
@@ -1184,7 +1181,10 @@
                   .disallowClassInlining();
               break;
             case NEVER_SINGLE_CALLER:
-              neverInlineDueToSingleCaller.add(reference);
+              dependentMinimumKeepInfo
+                  .getOrCreateUnconditionalMinimumKeepInfoFor(item.getReference())
+                  .asMethodJoiner()
+                  .disallowSingleCallerInlining();
               break;
             default:
               throw new Unreachable();
@@ -1292,20 +1292,12 @@
             .disallowReturnTypeStrengthening();
         context.markAsUsed();
       } else if (context instanceof NoValuePropagationRule) {
-        // Only add members from propgram classes to `neverPropagateValue` since class member values
-        // from library types are not propagated by default.
-        if (item.isField()) {
-          DexClassAndField field = item.asField();
-          if (field.isProgramField()) {
-            neverPropagateValue.add(field.getReference());
-            context.markAsUsed();
-          }
-        } else if (item.isMethod()) {
-          DexClassAndMethod method = item.asMethod();
-          if (method.isProgramMethod()) {
-            neverPropagateValue.add(method.getReference());
-            context.markAsUsed();
-          }
+        if (item.isProgramMember()) {
+          dependentMinimumKeepInfo
+              .getOrCreateUnconditionalMinimumKeepInfoFor(item.getReference())
+              .asMemberJoiner()
+              .disallowValuePropagation();
+          context.markAsUsed();
         }
       } else if (context instanceof ProguardIdentifierNameStringRule) {
         evaluateIdentifierNameStringRule(item, context, ifRule);
@@ -1317,7 +1309,11 @@
               reprocess.add(clazz.getClassInitializer().getReference());
               break;
             case NEVER:
-              neverReprocess.add(clazz.getClassInitializer().getReference());
+              dependentMinimumKeepInfo
+                  .getOrCreateUnconditionalMinimumKeepInfoFor(
+                      clazz.getClassInitializer().getReference())
+                  .asMethodJoiner()
+                  .disallowReprocessing();
               break;
             default:
               throw new Unreachable();
@@ -1332,7 +1328,10 @@
               reprocess.add(method.getReference());
               break;
             case NEVER:
-              neverReprocess.add(method.getReference());
+              dependentMinimumKeepInfo
+                  .getOrCreateUnconditionalMinimumKeepInfoFor(method.getReference())
+                  .asMethodJoiner()
+                  .disallowReprocessing();
               break;
             default:
               throw new Unreachable();
@@ -1796,19 +1795,16 @@
 
   abstract static class RootSetBase {
 
-    final Set<DexMethod> neverInlineDueToSingleCaller;
     private final DependentMinimumKeepInfoCollection dependentMinimumKeepInfo;
     final Map<DexType, Set<ProguardKeepRuleBase>> dependentKeepClassCompatRule;
     final List<DelayedRootSetActionItem> delayedRootSetActionItems;
     public final ProgramMethodMap<ProgramMethod> pendingMethodMoveInverse;
 
     RootSetBase(
-        Set<DexMethod> neverInlineDueToSingleCaller,
         DependentMinimumKeepInfoCollection dependentMinimumKeepInfo,
         Map<DexType, Set<ProguardKeepRuleBase>> dependentKeepClassCompatRule,
         List<DelayedRootSetActionItem> delayedRootSetActionItems,
         ProgramMethodMap<ProgramMethod> pendingMethodMoveInverse) {
-      this.neverInlineDueToSingleCaller = neverInlineDueToSingleCaller;
       this.dependentMinimumKeepInfo = dependentMinimumKeepInfo;
       this.dependentKeepClassCompatRule = dependentKeepClassCompatRule;
       this.delayedRootSetActionItems = delayedRootSetActionItems;
@@ -1831,9 +1827,7 @@
     public final Set<DexMethod> bypassClinitForInlining;
     public final Set<DexMethod> whyAreYouNotInlining;
     public final Set<DexMethod> reprocess;
-    public final Set<DexMethod> neverReprocess;
     public final PredicateSet<DexType> alwaysClassInline;
-    public final Set<DexMember<?, ?>> neverPropagateValue;
     public final Map<DexReference, ProguardMemberRule> mayHaveSideEffects;
     public final Set<DexMember<?, ?>> identifierNameStrings;
     public final Set<ProguardIfRule> ifRules;
@@ -1842,13 +1836,10 @@
         DependentMinimumKeepInfoCollection dependentMinimumKeepInfo,
         ImmutableList<DexReference> reasonAsked,
         Set<DexMethod> alwaysInline,
-        Set<DexMethod> neverInlineDueToSingleCaller,
         Set<DexMethod> bypassClinitForInlining,
         Set<DexMethod> whyAreYouNotInlining,
         Set<DexMethod> reprocess,
-        Set<DexMethod> neverReprocess,
         PredicateSet<DexType> alwaysClassInline,
-        Set<DexMember<?, ?>> neverPropagateValue,
         Map<DexReference, ProguardMemberRule> mayHaveSideEffects,
         Map<DexType, Set<ProguardKeepRuleBase>> dependentKeepClassCompatRule,
         Set<DexMember<?, ?>> identifierNameStrings,
@@ -1856,7 +1847,6 @@
         List<DelayedRootSetActionItem> delayedRootSetActionItems,
         ProgramMethodMap<ProgramMethod> pendingMethodMoveInverse) {
       super(
-          neverInlineDueToSingleCaller,
           dependentMinimumKeepInfo,
           dependentKeepClassCompatRule,
           delayedRootSetActionItems,
@@ -1866,9 +1856,7 @@
       this.bypassClinitForInlining = bypassClinitForInlining;
       this.whyAreYouNotInlining = whyAreYouNotInlining;
       this.reprocess = reprocess;
-      this.neverReprocess = neverReprocess;
       this.alwaysClassInline = alwaysClassInline;
-      this.neverPropagateValue = neverPropagateValue;
       this.mayHaveSideEffects = mayHaveSideEffects;
       this.identifierNameStrings = Collections.unmodifiableSet(identifierNameStrings);
       this.ifRules = Collections.unmodifiableSet(ifRules);
@@ -1898,7 +1886,6 @@
     }
 
     void addConsequentRootSet(ConsequentRootSet consequentRootSet) {
-      neverInlineDueToSingleCaller.addAll(consequentRootSet.neverInlineDueToSingleCaller);
       consequentRootSet.dependentKeepClassCompatRule.forEach(
           (type, rules) ->
               dependentKeepClassCompatRule
@@ -1974,13 +1961,10 @@
                 getDependentMinimumKeepInfo().rewrittenWithLens(graphLens, timing),
                 reasonAsked,
                 alwaysInline,
-                neverInlineDueToSingleCaller,
                 bypassClinitForInlining,
                 whyAreYouNotInlining,
                 reprocess,
-                neverReprocess,
                 alwaysClassInline,
-                neverPropagateValue,
                 mayHaveSideEffects,
                 dependentKeepClassCompatRule,
                 identifierNameStrings,
@@ -2216,13 +2200,11 @@
   public static class ConsequentRootSet extends RootSetBase {
 
     ConsequentRootSet(
-        Set<DexMethod> neverInlineDueToSingleCaller,
         DependentMinimumKeepInfoCollection dependentMinimumKeepInfo,
         Map<DexType, Set<ProguardKeepRuleBase>> dependentKeepClassCompatRule,
         List<DelayedRootSetActionItem> delayedRootSetActionItems,
         ProgramMethodMap<ProgramMethod> pendingMethodMoveInverse) {
       super(
-          neverInlineDueToSingleCaller,
           dependentMinimumKeepInfo,
           dependentKeepClassCompatRule,
           delayedRootSetActionItems,
@@ -2282,10 +2264,7 @@
           Collections.emptySet(),
           Collections.emptySet(),
           Collections.emptySet(),
-          Collections.emptySet(),
-          Collections.emptySet(),
           PredicateSet.empty(),
-          Collections.emptySet(),
           emptyMap(),
           emptyMap(),
           Collections.emptySet(),
diff --git a/src/main/java/com/android/tools/r8/shaking/SyntheticKeepMethodInfo.java b/src/main/java/com/android/tools/r8/shaking/SyntheticKeepMethodInfo.java
new file mode 100644
index 0000000..1b2c6a5
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/shaking/SyntheticKeepMethodInfo.java
@@ -0,0 +1,129 @@
+// Copyright (c) 2024, 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;
+
+public class SyntheticKeepMethodInfo extends KeepMethodInfo {
+
+  // Requires no aspects of a method to be kept.
+  private static final SyntheticKeepMethodInfo BOTTOM = new Builder().makeBottom().build();
+
+  public static SyntheticKeepMethodInfo bottom() {
+    return BOTTOM;
+  }
+
+  public static Joiner newEmptyJoiner() {
+    return bottom().joiner();
+  }
+
+  @Override
+  Builder builder() {
+    return new Builder(this);
+  }
+
+  public static class Builder extends KeepMethodInfo.Builder {
+
+    public Builder() {
+      super();
+    }
+
+    private Builder(SyntheticKeepMethodInfo original) {
+      super(original);
+    }
+
+    @Override
+    public Builder disallowMinification() {
+      // Ignore as synthetic items can always be minified.
+      return self();
+    }
+
+    @Override
+    public Builder disallowOptimization() {
+      // Ignore as synthetic items can always be optimized.
+      return self();
+    }
+
+    @Override
+    public Builder disallowShrinking() {
+      // Ignore as synthetic items can always be removed.
+      return self();
+    }
+
+    @Override
+    public SyntheticKeepMethodInfo doBuild() {
+      return new SyntheticKeepMethodInfo(this);
+    }
+
+    @Override
+    public SyntheticKeepMethodInfo build() {
+      return (SyntheticKeepMethodInfo) super.build();
+    }
+
+    @Override
+    public Builder makeBottom() {
+      super.makeBottom();
+      return self();
+    }
+
+    @Override
+    public Builder self() {
+      return this;
+    }
+  }
+
+  public static class Joiner extends KeepMethodInfo.Joiner {
+    public Joiner(SyntheticKeepMethodInfo info) {
+      super(info.builder());
+    }
+
+    @Override
+    public KeepMethodInfo.Joiner disallowMinification() {
+      // Ignore as synthetic items can always be minified.
+      return self();
+    }
+
+    @Override
+    public Joiner disallowOptimization() {
+      // Ignore as synthetic items can always be optimized.
+      return self();
+    }
+
+    @Override
+    public Joiner disallowShrinking() {
+      // Ignore as synthetic items can always be removed.
+      return self();
+    }
+
+    @Override
+    Joiner self() {
+      return this;
+    }
+  }
+
+  public SyntheticKeepMethodInfo(Builder builder) {
+    super(builder);
+  }
+
+  @Override
+  public boolean isMinificationAllowed(GlobalKeepInfoConfiguration configuration) {
+    // Synthetic items can always be minified.
+    return true;
+  }
+
+  @Override
+  public boolean isOptimizationAllowed(GlobalKeepInfoConfiguration configuration) {
+    // Synthetic items can always be minified.
+    return true;
+  }
+
+  @Override
+  public boolean isShrinkingAllowed(GlobalKeepInfoConfiguration configuration) {
+    // Synthetic items can always be minified.
+    return true;
+  }
+
+  @Override
+  public Joiner joiner() {
+    return new Joiner(this);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/shaking/rules/KeepAnnotationMatcher.java b/src/main/java/com/android/tools/r8/shaking/rules/KeepAnnotationMatcher.java
index 13b1b4f..82c28fb 100644
--- a/src/main/java/com/android/tools/r8/shaking/rules/KeepAnnotationMatcher.java
+++ b/src/main/java/com/android/tools/r8/shaking/rules/KeepAnnotationMatcher.java
@@ -107,6 +107,19 @@
               minimumKeepInfoCollection.getOrCreateMinimumKeepInfoFor(item.getReference());
           updateWithConstraints(item, joiner, result.constraints.get(i), result.edge);
         });
+    // TODO(b/323816623): Encode originals instead of soft-pinning class/field preconditions.
+    for (ProgramDefinition precondition : result.preconditions) {
+      if (precondition.isClass() || precondition.isField()) {
+        minimumKeepInfoCollection
+            .getOrCreateMinimumKeepInfoFor(precondition.getReference())
+            .disallowOptimization();
+        if (precondition.isField()) {
+          minimumKeepInfoCollection
+              .getOrCreateMinimumKeepInfoFor(precondition.getContextType())
+              .disallowOptimization();
+        }
+      }
+    }
     return minimumKeepInfoCollection;
   }
 
diff --git a/src/main/java/com/android/tools/r8/startup/generated/InstrumentationServerImplFactory.java b/src/main/java/com/android/tools/r8/startup/generated/InstrumentationServerImplFactory.java
index e9d64ab..f6d1bf4 100644
--- a/src/main/java/com/android/tools/r8/startup/generated/InstrumentationServerImplFactory.java
+++ b/src/main/java/com/android/tools/r8/startup/generated/InstrumentationServerImplFactory.java
@@ -126,6 +126,16 @@
               dexItemFactory.createField(
                   dexItemFactory.createType(
                       "Lcom/android/tools/r8/startup/InstrumentationServerImpl;"),
+                  dexItemFactory.createType("Z"),
+                  dexItemFactory.createString("writeToLogcatIncludeDuplicates")))
+          .setAccessFlags(FieldAccessFlags.fromCfAccessFlags(10))
+          .setApiLevel(ComputedApiLevel.unknown())
+          .build(),
+      DexEncodedField.syntheticBuilder()
+          .setField(
+              dexItemFactory.createField(
+                  dexItemFactory.createType(
+                      "Lcom/android/tools/r8/startup/InstrumentationServerImpl;"),
                   dexItemFactory.createType("Ljava/lang/String;"),
                   dexItemFactory.createString("logcatTag")))
           .setAccessFlags(FieldAccessFlags.fromCfAccessFlags(10))
@@ -162,7 +172,23 @@
                       dexItemFactory.createType(
                           "Lcom/android/tools/r8/startup/InstrumentationServerImpl;")),
                   dexItemFactory.createString("getInstance")))
-          .setCode(method -> createCfCode4_getInstance(dexItemFactory, method))
+          .setCode(method -> createCfCode5_getInstance(dexItemFactory, method))
+          .build(),
+      DexEncodedMethod.syntheticBuilder()
+          .setAccessFlags(MethodAccessFlags.fromCfAccessFlags(9, false))
+          .setApiLevelForCode(ComputedApiLevel.unknown())
+          .setApiLevelForDefinition(ComputedApiLevel.unknown())
+          .setClassFileVersion(CfVersion.V1_8)
+          .setMethod(
+              dexItemFactory.createMethod(
+                  dexItemFactory.createType(
+                      "Lcom/android/tools/r8/startup/InstrumentationServerImpl;"),
+                  dexItemFactory.createProto(
+                      dexItemFactory.createType("V"),
+                      dexItemFactory.createType("Ljava/lang/String;"),
+                      dexItemFactory.createType("Ljava/lang/String;")),
+                  dexItemFactory.createString("addCall")))
+          .setCode(method -> createCfCode2_addCall(dexItemFactory, method))
           .build(),
       DexEncodedMethod.syntheticBuilder()
           .setAccessFlags(MethodAccessFlags.fromCfAccessFlags(9, false))
@@ -177,7 +203,7 @@
                       dexItemFactory.createType("V"),
                       dexItemFactory.createType("Ljava/lang/String;")),
                   dexItemFactory.createString("addMethod")))
-          .setCode(method -> createCfCode3_addMethod(dexItemFactory, method))
+          .setCode(method -> createCfCode4_addMethod(dexItemFactory, method))
           .build(),
       DexEncodedMethod.syntheticBuilder()
           .setAccessFlags(MethodAccessFlags.fromCfAccessFlags(2, false))
@@ -192,10 +218,10 @@
                       dexItemFactory.createType("V"),
                       dexItemFactory.createType("Ljava/lang/String;")),
                   dexItemFactory.createString("addLine")))
-          .setCode(method -> createCfCode2_addLine(dexItemFactory, method))
+          .setCode(method -> createCfCode3_addLine(dexItemFactory, method))
           .build(),
       DexEncodedMethod.syntheticBuilder()
-          .setAccessFlags(MethodAccessFlags.fromCfAccessFlags(2, false))
+          .setAccessFlags(MethodAccessFlags.fromCfAccessFlags(10, false))
           .setApiLevelForCode(ComputedApiLevel.unknown())
           .setApiLevelForDefinition(ComputedApiLevel.unknown())
           .setClassFileVersion(CfVersion.V1_8)
@@ -207,7 +233,7 @@
                       dexItemFactory.createType("V"),
                       dexItemFactory.createType("Ljava/lang/String;")),
                   dexItemFactory.createString("writeToLogcat")))
-          .setCode(method -> createCfCode6_writeToLogcat(dexItemFactory, method))
+          .setCode(method -> createCfCode7_writeToLogcat(dexItemFactory, method))
           .build(),
       DexEncodedMethod.syntheticBuilder()
           .setAccessFlags(MethodAccessFlags.fromCfAccessFlags(8, true))
@@ -239,7 +265,7 @@
                   dexItemFactory.createProto(
                       dexItemFactory.createType("V"), dexItemFactory.createType("Ljava/io/File;")),
                   dexItemFactory.createString("writeToFile")))
-          .setCode(method -> createCfCode5_writeToFile(dexItemFactory, method))
+          .setCode(method -> createCfCode6_writeToFile(dexItemFactory, method))
           .build()
     };
   }
@@ -314,7 +340,71 @@
         ImmutableList.of());
   }
 
-  public static CfCode createCfCode2_addLine(DexItemFactory factory, DexMethod method) {
+  public static CfCode createCfCode2_addCall(DexItemFactory factory, DexMethod method) {
+    CfLabel label0 = new CfLabel();
+    CfLabel label1 = new CfLabel();
+    CfLabel label2 = new CfLabel();
+    return new CfCode(
+        method.holder,
+        2,
+        2,
+        ImmutableList.of(
+            label0,
+            new CfNew(factory.stringBuilderType),
+            new CfStackInstruction(CfStackInstruction.Opcode.Dup),
+            new CfInvoke(
+                183,
+                factory.createMethod(
+                    factory.stringBuilderType,
+                    factory.createProto(factory.voidType),
+                    factory.createString("<init>")),
+                false),
+            new CfLoad(ValueType.OBJECT, 0),
+            new CfInvoke(
+                182,
+                factory.createMethod(
+                    factory.stringBuilderType,
+                    factory.createProto(factory.stringBuilderType, factory.stringType),
+                    factory.createString("append")),
+                false),
+            new CfConstString(factory.createString(" -> ")),
+            new CfInvoke(
+                182,
+                factory.createMethod(
+                    factory.stringBuilderType,
+                    factory.createProto(factory.stringBuilderType, factory.stringType),
+                    factory.createString("append")),
+                false),
+            new CfLoad(ValueType.OBJECT, 1),
+            new CfInvoke(
+                182,
+                factory.createMethod(
+                    factory.stringBuilderType,
+                    factory.createProto(factory.stringBuilderType, factory.stringType),
+                    factory.createString("append")),
+                false),
+            new CfInvoke(
+                182,
+                factory.createMethod(
+                    factory.stringBuilderType,
+                    factory.createProto(factory.stringType),
+                    factory.createString("toString")),
+                false),
+            new CfInvoke(
+                184,
+                factory.createMethod(
+                    factory.createType("Lcom/android/tools/r8/startup/InstrumentationServerImpl;"),
+                    factory.createProto(factory.voidType, factory.stringType),
+                    factory.createString("writeToLogcat")),
+                false),
+            label1,
+            new CfReturnVoid(),
+            label2),
+        ImmutableList.of(),
+        ImmutableList.of());
+  }
+
+  public static CfCode createCfCode3_addLine(DexItemFactory factory, DexMethod method) {
     CfLabel label0 = new CfLabel();
     CfLabel label1 = new CfLabel();
     CfLabel label2 = new CfLabel();
@@ -327,12 +417,48 @@
     CfLabel label9 = new CfLabel();
     CfLabel label10 = new CfLabel();
     CfLabel label11 = new CfLabel();
+    CfLabel label12 = new CfLabel();
+    CfLabel label13 = new CfLabel();
+    CfLabel label14 = new CfLabel();
     return new CfCode(
         method.holder,
         2,
         4,
         ImmutableList.of(
             label0,
+            new CfStaticFieldRead(
+                factory.createField(
+                    factory.createType("Lcom/android/tools/r8/startup/InstrumentationServerImpl;"),
+                    factory.booleanType,
+                    factory.createString("writeToLogcat"))),
+            new CfIf(IfType.EQ, ValueType.INT, label3),
+            new CfStaticFieldRead(
+                factory.createField(
+                    factory.createType("Lcom/android/tools/r8/startup/InstrumentationServerImpl;"),
+                    factory.booleanType,
+                    factory.createString("writeToLogcatIncludeDuplicates"))),
+            new CfIf(IfType.EQ, ValueType.INT, label3),
+            label1,
+            new CfLoad(ValueType.OBJECT, 1),
+            new CfInvoke(
+                184,
+                factory.createMethod(
+                    factory.createType("Lcom/android/tools/r8/startup/InstrumentationServerImpl;"),
+                    factory.createProto(factory.voidType, factory.stringType),
+                    factory.createString("writeToLogcat")),
+                false),
+            label2,
+            new CfReturnVoid(),
+            label3,
+            new CfFrame(
+                new Int2ObjectAVLTreeMap<>(
+                    new int[] {0, 1},
+                    new FrameType[] {
+                      FrameType.initializedNonNullReference(
+                          factory.createType(
+                              "Lcom/android/tools/r8/startup/InstrumentationServerImpl;")),
+                      FrameType.initializedNonNullReference(factory.stringType)
+                    })),
             new CfLoad(ValueType.OBJECT, 0),
             new CfInstanceFieldRead(
                 factory.createField(
@@ -342,7 +468,7 @@
             new CfStackInstruction(CfStackInstruction.Opcode.Dup),
             new CfStore(ValueType.OBJECT, 2),
             new CfMonitor(MonitorType.ENTER),
-            label1,
+            label4,
             new CfLoad(ValueType.OBJECT, 0),
             new CfInstanceFieldRead(
                 factory.createField(
@@ -357,13 +483,13 @@
                     factory.createProto(factory.booleanType, factory.objectType),
                     factory.createString("add")),
                 false),
-            new CfIf(IfType.NE, ValueType.INT, label4),
-            label2,
+            new CfIf(IfType.NE, ValueType.INT, label7),
+            label5,
             new CfLoad(ValueType.OBJECT, 2),
             new CfMonitor(MonitorType.EXIT),
-            label3,
+            label6,
             new CfReturnVoid(),
-            label4,
+            label7,
             new CfFrame(
                 new Int2ObjectAVLTreeMap<>(
                     new int[] {0, 1, 2},
@@ -376,9 +502,9 @@
                     })),
             new CfLoad(ValueType.OBJECT, 2),
             new CfMonitor(MonitorType.EXIT),
-            label5,
-            new CfGoto(label8),
-            label6,
+            label8,
+            new CfGoto(label11),
+            label9,
             new CfFrame(
                 new Int2ObjectAVLTreeMap<>(
                     new int[] {0, 1, 2},
@@ -394,10 +520,10 @@
             new CfStore(ValueType.OBJECT, 3),
             new CfLoad(ValueType.OBJECT, 2),
             new CfMonitor(MonitorType.EXIT),
-            label7,
+            label10,
             new CfLoad(ValueType.OBJECT, 3),
             new CfThrow(),
-            label8,
+            label11,
             new CfFrame(
                 new Int2ObjectAVLTreeMap<>(
                     new int[] {0, 1},
@@ -412,18 +538,17 @@
                     factory.createType("Lcom/android/tools/r8/startup/InstrumentationServerImpl;"),
                     factory.booleanType,
                     factory.createString("writeToLogcat"))),
-            new CfIf(IfType.EQ, ValueType.INT, label10),
-            label9,
-            new CfLoad(ValueType.OBJECT, 0),
+            new CfIf(IfType.EQ, ValueType.INT, label13),
+            label12,
             new CfLoad(ValueType.OBJECT, 1),
             new CfInvoke(
-                183,
+                184,
                 factory.createMethod(
                     factory.createType("Lcom/android/tools/r8/startup/InstrumentationServerImpl;"),
                     factory.createProto(factory.voidType, factory.stringType),
                     factory.createString("writeToLogcat")),
                 false),
-            label10,
+            label13,
             new CfFrame(
                 new Int2ObjectAVLTreeMap<>(
                     new int[] {0, 1},
@@ -434,18 +559,21 @@
                       FrameType.initializedNonNullReference(factory.stringType)
                     })),
             new CfReturnVoid(),
-            label11),
+            label14),
         ImmutableList.of(
             new CfTryCatch(
-                label1, label3, ImmutableList.of(factory.throwableType), ImmutableList.of(label6)),
+                label4, label6, ImmutableList.of(factory.throwableType), ImmutableList.of(label9)),
             new CfTryCatch(
-                label4, label5, ImmutableList.of(factory.throwableType), ImmutableList.of(label6)),
+                label7, label8, ImmutableList.of(factory.throwableType), ImmutableList.of(label9)),
             new CfTryCatch(
-                label6, label7, ImmutableList.of(factory.throwableType), ImmutableList.of(label6))),
+                label9,
+                label10,
+                ImmutableList.of(factory.throwableType),
+                ImmutableList.of(label9))),
         ImmutableList.of());
   }
 
-  public static CfCode createCfCode3_addMethod(DexItemFactory factory, DexMethod method) {
+  public static CfCode createCfCode4_addMethod(DexItemFactory factory, DexMethod method) {
     CfLabel label0 = new CfLabel();
     CfLabel label1 = new CfLabel();
     CfLabel label2 = new CfLabel();
@@ -479,7 +607,7 @@
         ImmutableList.of());
   }
 
-  public static CfCode createCfCode4_getInstance(DexItemFactory factory, DexMethod method) {
+  public static CfCode createCfCode5_getInstance(DexItemFactory factory, DexMethod method) {
     CfLabel label0 = new CfLabel();
     return new CfCode(
         method.holder,
@@ -497,7 +625,7 @@
         ImmutableList.of());
   }
 
-  public static CfCode createCfCode5_writeToFile(DexItemFactory factory, DexMethod method) {
+  public static CfCode createCfCode6_writeToFile(DexItemFactory factory, DexMethod method) {
     CfLabel label0 = new CfLabel();
     CfLabel label1 = new CfLabel();
     CfLabel label2 = new CfLabel();
@@ -724,14 +852,14 @@
         ImmutableList.of());
   }
 
-  public static CfCode createCfCode6_writeToLogcat(DexItemFactory factory, DexMethod method) {
+  public static CfCode createCfCode7_writeToLogcat(DexItemFactory factory, DexMethod method) {
     CfLabel label0 = new CfLabel();
     CfLabel label1 = new CfLabel();
     CfLabel label2 = new CfLabel();
     return new CfCode(
         method.holder,
         2,
-        2,
+        1,
         ImmutableList.of(
             label0,
             new CfStaticFieldRead(
@@ -739,7 +867,7 @@
                     factory.createType("Lcom/android/tools/r8/startup/InstrumentationServerImpl;"),
                     factory.stringType,
                     factory.createString("logcatTag"))),
-            new CfLoad(ValueType.OBJECT, 1),
+            new CfLoad(ValueType.OBJECT, 0),
             new CfInvoke(
                 184,
                 factory.createMethod(
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 be887b7..707d77a 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -84,6 +84,7 @@
 import com.android.tools.r8.optimize.argumentpropagation.ArgumentPropagatorEventConsumer;
 import com.android.tools.r8.optimize.compose.JetpackComposeOptions;
 import com.android.tools.r8.optimize.redundantbridgeremoval.RedundantBridgeRemovalOptions;
+import com.android.tools.r8.optimize.singlecaller.SingleCallerInlinerOptions;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.position.Position;
 import com.android.tools.r8.profile.art.ArtProfileOptions;
@@ -714,7 +715,6 @@
       System.getProperty("com.android.tools.r8.ignoreBootClasspathEnumsForMaindexTracing") != null;
   public boolean pruneNonVissibleAnnotationClasses =
       System.getProperty("com.android.tools.r8.pruneNonVissibleAnnotationClasses") != null;
-  public List<String> logArgumentsFilter = ImmutableList.of();
 
   // Flag to turn on/offLoad/store optimization in the Cf back-end.
   public boolean enableLoadStoreOptimization = true;
@@ -932,6 +932,8 @@
   private final CfCodeAnalysisOptions cfCodeAnalysisOptions = new CfCodeAnalysisOptions();
   private final ClassInlinerOptions classInlinerOptions = new ClassInlinerOptions();
   private final InlinerOptions inlinerOptions = new InlinerOptions(this);
+  private final SingleCallerInlinerOptions singleCallerInlinerOptions =
+      new SingleCallerInlinerOptions(this);
   private final JetpackComposeOptions jetpackComposeOptions = new JetpackComposeOptions(this);
   private final HorizontalClassMergerOptions horizontalClassMergerOptions =
       new HorizontalClassMergerOptions();
@@ -990,6 +992,10 @@
     return jetpackComposeOptions;
   }
 
+  public SingleCallerInlinerOptions getSingleCallerInlinerOptions() {
+    return singleCallerInlinerOptions;
+  }
+
   public VerticalClassMergerOptions getVerticalClassMergerOptions() {
     return verticalClassMergerOptions;
   }
@@ -1515,16 +1521,6 @@
     return methodsFilter.contains(qualifiedName);
   }
 
-  public boolean methodMatchesLogArgumentsFilter(DexEncodedMethod method) {
-    // Not specifying a filter matches no methods.
-    if (logArgumentsFilter.size() == 0) {
-      return false;
-    }
-    // Currently the filter is simple string equality on the qualified name.
-    String qualifiedName = method.qualifiedName();
-    return logArgumentsFilter.contains(qualifiedName);
-  }
-
   public enum PackageObfuscationMode {
     // No package obfuscation.
     NONE,
@@ -2216,6 +2212,8 @@
         System.getProperty("com.android.tools.r8.dexVersion40ForApiLevel30") != null;
     public boolean dexContainerExperiment =
         System.getProperty("com.android.tools.r8.dexContainerExperiment") != null;
+    public boolean nullOutDebugInfo =
+        System.getProperty("com.android.tools.r8.nullOutDebugInfo") != null;
 
     // Testing options to analyse locality of items in DEX files when they are generated.
     public boolean calculateItemUseCountInDex = false;
@@ -2332,6 +2330,7 @@
 
     public boolean allowClassInliningOfSynthetics = true;
     public boolean allowInjectedAnnotationMethods = false;
+    public boolean allowInliningOfOutlines = true;
     public boolean allowInliningOfSynthetics = true;
     public boolean allowNullDynamicTypeInCodeScanner = true;
     public boolean allowTypeErrors =
diff --git a/src/main/java/com/android/tools/r8/utils/MapUtils.java b/src/main/java/com/android/tools/r8/utils/MapUtils.java
index ed49f66..c991a7d 100644
--- a/src/main/java/com/android/tools/r8/utils/MapUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/MapUtils.java
@@ -122,6 +122,9 @@
             return;
           }
           V2 newValue = valueMapping.apply(key, value);
+          if (newValue == null) {
+            return;
+          }
           V2 existingValue = result.put(newKey, newValue);
           if (existingValue != null) {
             result.put(newKey, valueMerger.apply(newKey, existingValue, newValue));
diff --git a/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java b/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java
index 7bdbaa8..7de494f 100644
--- a/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java
+++ b/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java
@@ -227,11 +227,6 @@
           appView.getNamingLens().lookupMethod(method.getReference(), appView.dexItemFactory());
       MethodSignature residualSignature = MethodSignature.fromDexMethod(residualMethod);
 
-      // TODO(b/261971803): This original method via lens is just to assert compatibility with the
-      //  previous implementation. Remove this as part of cleaning-up / reducing lens usage.
-      DexMethod lensOriginalMethod =
-          appView.graphLens().getOriginalMethodSignatureForMapping(method.getReference());
-
       DexMethod originalMethod;
       boolean canStripOuterFrame;
       boolean residualIsD8R8Synthesized;
@@ -240,14 +235,10 @@
       if (!definition.supportsPendingInlineFrame()) {
         residualIsD8R8Synthesized = markAsCompilerSynthetic(method);
         canStripOuterFrame = canStripOuterFrame(method, mappedPositions);
-        // TODO(b/261971803): Amend code generation of global synthetics to include original
-        //  position as an inline frame and remove this special handling of globals.
         originalMethod =
-            isGlobalSyntheticMethod(method)
-                ? lensOriginalMethod
-                : (useResidualForSynthetics && residualIsD8R8Synthesized
-                    ? residualMethod
-                    : method.getReference());
+            useResidualForSynthetics && residualIsD8R8Synthesized
+                ? residualMethod
+                : method.getReference();
       } else {
         assert mappedPositions.isEmpty();
         canStripOuterFrame = false;
@@ -256,20 +247,13 @@
           residualIsD8R8Synthesized = false;
         } else {
           residualIsD8R8Synthesized = markAsCompilerSynthetic(method);
-          // TODO(b/261971803): Amend code generation of global synthetics to include original
-          //  position as an inline frame and remove this special handling of globals.
           originalMethod =
-              isGlobalSyntheticMethod(method)
-                  ? lensOriginalMethod
-                  : (useResidualForSynthetics && residualIsD8R8Synthesized
-                      ? residualMethod
-                      : definition.getReference());
+              useResidualForSynthetics && residualIsD8R8Synthesized
+                  ? residualMethod
+                  : definition.getReference();
         }
       }
-      assert residualIsD8R8Synthesized
-          || originalMethod.isIdenticalTo(lensOriginalMethod)
-          // TODO(b/326562454): In some case the lens is mapping two methods to a common original.
-          || originalMethod.getHolderType().isIdenticalTo(lensOriginalMethod.getHolderType());
+      assert verifyMethodMapping(method, originalMethod, residualIsD8R8Synthesized);
 
       OneShotCollectionConsumer<MappingInformation> methodSpecificMappingInformation =
           OneShotCollectionConsumer.wrap(new ArrayList<>());
@@ -469,18 +453,21 @@
       return this;
     }
 
-    private boolean isGlobalSyntheticMethod(ProgramMethod method) {
-      return method.getDefinition().isD8R8Synthesized()
-          && appView.getSyntheticItems().isGlobalSyntheticClass(method.getHolder());
+    private boolean verifyMethodMapping(
+        ProgramMethod method, DexMethod originalMethod, boolean residualIsD8R8Synthesized) {
+      // TODO(b/261971803): This original method via lens is just to assert compatibility with the
+      //  previous implementation. Remove this as part of cleaning-up / reducing lens usage.
+      DexMethod lensOriginalMethod =
+          appView.graphLens().getOriginalMethodSignatureForMapping(method.getReference());
+      assert residualIsD8R8Synthesized
+          || originalMethod.isIdenticalTo(lensOriginalMethod)
+          // TODO(b/326562454): In some case the lens is mapping two methods to a common original.
+          || originalMethod.getHolderType().isIdenticalTo(lensOriginalMethod.getHolderType());
+      return true;
     }
 
     private boolean markAsCompilerSynthetic(ProgramMethod method) {
-      // We only do global synthetic classes when using names from the library. For such classes it
-      // is important that we do not filter out stack frames since they could appear from concrete
-      // classes in the library. Additionally, this is one place where it is helpful for developers
-      // to also get reported synthesized frames since stubbing can change control-flow and
-      // exceptions.
-      return method.getDefinition().isD8R8Synthesized() && !isGlobalSyntheticMethod(method);
+      return method.getDefinition().isD8R8Synthesized();
     }
 
     private boolean canStripOuterFrame(ProgramMethod method, List<MappedPosition> mappedPositions) {
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/IncompleteVerticalClassMergerBridgeCode.java b/src/main/java/com/android/tools/r8/verticalclassmerging/IncompleteVerticalClassMergerBridgeCode.java
index d8856f9..f852310 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/IncompleteVerticalClassMergerBridgeCode.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/IncompleteVerticalClassMergerBridgeCode.java
@@ -17,7 +17,6 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.UseRegistry;
-import com.android.tools.r8.graph.lens.GraphLens;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.InvokeType;
@@ -34,7 +33,7 @@
 
 /**
  * A short-lived piece of code that will be converted into {@link LirCode} using {@link
- * #toLirCode(AppView)}.
+ * #toLirCode(AppView, VerticalClassMergerGraphLens, ClassMergerMode)}.
  */
 public class IncompleteVerticalClassMergerBridgeCode extends Code {
 
@@ -87,10 +86,7 @@
     method = lens.getNextBridgeMethodSignature(method);
   }
 
-  public LirCode<?> toLirCode(
-      AppView<AppInfoWithLiveness> appView,
-      VerticalClassMergerGraphLens lens,
-      ClassMergerMode mode) {
+  public LirCode<?> toLirCode(AppView<AppInfoWithLiveness> appView) {
     boolean isD8R8Synthesized = true;
     LirEncodingStrategy<Value, Integer> strategy =
         LirStrategy.getDefaultStrategy().getEncodingStrategy();
@@ -128,21 +124,7 @@
       lirBuilder.addReturn(returnValue);
     }
 
-    LirCode<Integer> lirCode = lirBuilder.build();
-    return mode.isFinal()
-        ? lirCode
-        : new LirCode<>(lirCode) {
-
-          @Override
-          public boolean hasExplicitCodeLens() {
-            return true;
-          }
-
-          @Override
-          public GraphLens getCodeLens(AppView<?> appView) {
-            return lens;
-          }
-        };
+    return lirBuilder.build();
   }
 
   // Implement Code.
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMerger.java b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMerger.java
index 943f954..6772ced 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMerger.java
@@ -143,10 +143,11 @@
     rewriteCodeWithLens(executorService, timing);
 
     // Remove merged classes from app now that the code is fully rewritten.
-    removeMergedClasses(verticalClassMergerResult.getVerticallyMergedClasses(), timing);
+    removeMergedClasses(
+        verticalClassMergerResult.getVerticallyMergedClasses(), executorService, timing);
 
     // Convert the (incomplete) synthesized bridges to LIR.
-    finalizeSynthesizedBridges(verticalClassMergerResult.getSynthesizedBridges(), lens, timing);
+    finalizeSynthesizedBridges(verticalClassMergerResult.getSynthesizedBridges(), timing);
 
     // Finally update the code lens to signal that the code is fully up to date.
     markRewrittenWithLens(executorService, timing);
@@ -247,9 +248,6 @@
 
   private void rewriteCodeWithLens(ExecutorService executorService, Timing timing)
       throws ExecutionException {
-    if (mode.isInitial()) {
-      return;
-    }
     LirConverter.rewriteLirWithLens(appView, timing, executorService);
     new IdentifierMinifier(appView).rewriteDexItemBasedConstStringInStaticFields(executorService);
   }
@@ -292,11 +290,14 @@
     timing.end();
   }
 
-  private void removeMergedClasses(VerticallyMergedClasses verticallyMergedClasses, Timing timing) {
+  private void removeMergedClasses(
+      VerticallyMergedClasses verticallyMergedClasses,
+      ExecutorService executorService,
+      Timing timing)
+      throws ExecutionException {
     if (mode.isInitial()) {
       return;
     }
-
     timing.begin("Remove merged classes");
     DirectMappedDexApplication newApplication =
         appView
@@ -305,13 +306,17 @@
             .builder()
             .removeProgramClasses(clazz -> verticallyMergedClasses.isMergeSource(clazz.getType()))
             .build();
-    appView.setAppInfo(appView.appInfo().rebuildWithLiveness(newApplication));
+    PrunedItems prunedItems =
+        PrunedItems.builder()
+            .addRemovedClasses(verticallyMergedClasses.getSources())
+            .setPrunedApp(newApplication)
+            .build();
+    appView.setAppInfo(appView.appInfo().prunedCopyFrom(prunedItems, executorService, timing));
     timing.end();
   }
 
   private void finalizeSynthesizedBridges(
       List<IncompleteVerticalClassMergerBridgeCode> bridges,
-      VerticalClassMergerGraphLens lens,
       Timing timing) {
     timing.begin("Finalize synthesized bridges");
     KeepInfoCollection keepInfo = appView.getKeepInfo();
@@ -323,7 +328,7 @@
       assert target != null;
 
       // Finalize code.
-      bridge.setCode(code.toLirCode(appView, lens, mode), appView);
+      bridge.setCode(code.toLirCode(appView), appView);
 
       // Copy keep info to newly synthesized methods.
       keepInfo.mutate(
@@ -335,9 +340,6 @@
 
   private void markRewrittenWithLens(ExecutorService executorService, Timing timing)
       throws ExecutionException {
-    if (mode.isInitial()) {
-      return;
-    }
     timing.begin("Mark rewritten with lens");
     appView.clearCodeRewritings(executorService, timing);
     timing.end();
diff --git a/src/resourceshrinker/java/com/android/build/shrinker/r8integration/R8ResourceShrinkerState.java b/src/resourceshrinker/java/com/android/build/shrinker/r8integration/R8ResourceShrinkerState.java
index e43c68e..c3e2ad4 100644
--- a/src/resourceshrinker/java/com/android/build/shrinker/r8integration/R8ResourceShrinkerState.java
+++ b/src/resourceshrinker/java/com/android/build/shrinker/r8integration/R8ResourceShrinkerState.java
@@ -103,22 +103,16 @@
     } catch (IOException e) {
       throw errorHandler.apply(e);
     }
-    // TODO(b/329584653): Update processToolsAttributes in AGP to return the kept resources and
-    //  trace directly using this instead of iterating the full resource store below.
-    r8ResourceShrinkerModel.getResourceStore().processToolsAttributes();
-    traceLiveResources();
+    // ProcessToolsAttribute returns the resources that becomes live
+    r8ResourceShrinkerModel
+        .getResourceStore()
+        .processToolsAttributes()
+        .forEach(resource -> trace(resource.value));
     for (Supplier<InputStream> manifestProvider : manifestProviders) {
       traceXml("AndroidManifest.xml", manifestProvider.get());
     }
   }
 
-  private void traceLiveResources() {
-    r8ResourceShrinkerModel.getResourceStore().getResources().stream()
-        .filter(Resource::isReachable)
-        .map(r -> r.value)
-        .forEach(this::trace);
-  }
-
   public void setEnqueuerCallback(ClassReferenceCallback enqueuerCallback) {
     assert this.enqueuerCallback == null;
     this.enqueuerCallback = enqueuerCallback;
diff --git a/src/test/examplesJava17/backport/MathBackportJava17Main.java b/src/test/examplesJava17/backport/MathBackportJava17Main.java
deleted file mode 100644
index 7eeed95..0000000
--- a/src/test/examplesJava17/backport/MathBackportJava17Main.java
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright (c) 2023, 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 backport;
-
-public class MathBackportJava17Main {
-
-  public static void main(String[] args) {
-    // The methods are actually from Java 15, but we can test them from Java 17.
-    testAbsExactInteger();
-    testAbsExactLong();
-  }
-
-  private static void testAbsExactInteger() {
-    assertEquals(42, Math.absExact(42));
-    assertEquals(42, Math.absExact(-42));
-    assertEquals(Integer.MAX_VALUE, Math.absExact(Integer.MAX_VALUE));
-    try {
-      throw new AssertionError(Math.absExact(Integer.MIN_VALUE));
-    } catch (ArithmeticException expected) {
-
-    }
-  }
-
-  private static void testAbsExactLong() {
-    assertEquals(42L, Math.absExact(42L));
-    assertEquals(42L, Math.absExact(-42L));
-    assertEquals(Long.MAX_VALUE, Math.absExact(Long.MAX_VALUE));
-    try {
-      throw new AssertionError(Math.absExact(Long.MIN_VALUE));
-    } catch (ArithmeticException expected) {
-
-    }
-  }
-
-  private static void assertEquals(int expected, int actual) {
-    if (expected != actual) {
-      throw new AssertionError("Expected <" + expected + "> but was <" + actual + '>');
-    }
-  }
-
-  private static void assertEquals(long expected, long actual) {
-    if (expected != actual) {
-      throw new AssertionError("Expected <" + expected + "> but was <" + actual + '>');
-    }
-  }
-}
diff --git a/src/test/examplesJava17/backport/MathBackportJava17Test.java b/src/test/examplesJava17/backport/MathBackportJava17Test.java
new file mode 100644
index 0000000..bc6e800
--- /dev/null
+++ b/src/test/examplesJava17/backport/MathBackportJava17Test.java
@@ -0,0 +1,81 @@
+// Copyright (c) 2024, 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 backport;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfVm;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class MathBackportJava17Test extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection parameters() {
+    return getTestParameters()
+        .withDexRuntimes()
+        .withCfRuntimesStartingFromIncluding(CfVm.JDK17)
+        .withAllApiLevelsAlsoForCf()
+        .build();
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForDesugaring(parameters)
+        .addInnerClassesAndStrippedOuter(getClass())
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccess();
+  }
+
+  public static class TestClass {
+    public static void main(String[] args) {
+      // The methods are actually from Java 15, but we can test them from Java 17.
+      testAbsExactInteger();
+      testAbsExactLong();
+    }
+
+    private static void testAbsExactInteger() {
+      assertEquals(42, Math.absExact(42));
+      assertEquals(42, Math.absExact(-42));
+      assertEquals(Integer.MAX_VALUE, Math.absExact(Integer.MAX_VALUE));
+      try {
+        throw new AssertionError(Math.absExact(Integer.MIN_VALUE));
+      } catch (ArithmeticException expected) {
+
+      }
+    }
+
+    private static void testAbsExactLong() {
+      assertEquals(42L, Math.absExact(42L));
+      assertEquals(42L, Math.absExact(-42L));
+      assertEquals(Long.MAX_VALUE, Math.absExact(Long.MAX_VALUE));
+      try {
+        throw new AssertionError(Math.absExact(Long.MIN_VALUE));
+      } catch (ArithmeticException expected) {
+
+      }
+    }
+
+    private static void assertEquals(int expected, int actual) {
+      if (expected != actual) {
+        throw new AssertionError("Expected <" + expected + "> but was <" + actual + '>');
+      }
+    }
+
+    private static void assertEquals(long expected, long actual) {
+      if (expected != actual) {
+        throw new AssertionError("Expected <" + expected + "> but was <" + actual + '>');
+      }
+    }
+  }
+}
diff --git a/src/test/examplesJava17/backport/ObjectsBackportJava17Main.java b/src/test/examplesJava17/backport/ObjectsBackportJava17Main.java
deleted file mode 100644
index b950c17..0000000
--- a/src/test/examplesJava17/backport/ObjectsBackportJava17Main.java
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright (c) 2023, 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 backport;
-
-import java.util.Objects;
-
-public class ObjectsBackportJava17Main {
-
-  public static void main(String[] args) {
-    // The methods are actually from Java 16, but we can test them from Java 17.
-    testCheckIndex();
-    testCheckFromToIndex();
-    testCheckFromIndexSize();
-  }
-
-  private static void testCheckIndex() {
-    for (long i = 0L; i < 10L; i++) {
-      assertEquals(i, Objects.checkIndex(i, 10L));
-    }
-
-    try {
-      throw new AssertionError(Objects.checkIndex(-1L, 10L));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-    try {
-      throw new AssertionError(Objects.checkIndex(10L, 0L));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-    try {
-      throw new AssertionError(Objects.checkIndex(0L, 0L));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-  }
-
-  private static void testCheckFromToIndex() {
-    for (long i = 0L; i <= 10L; i++) {
-      for (long j = i; j <= 10L; j++) {
-        assertEquals(i, Objects.checkFromToIndex(i, j, 10L));
-      }
-    }
-    assertEquals(0L, Objects.checkFromToIndex(0L, 0L, 0L));
-
-    try {
-      throw new AssertionError(Objects.checkFromToIndex(4L, 2L, 10L));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-    try {
-      throw new AssertionError(Objects.checkFromToIndex(-1L, 5L, 10L));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-    try {
-      throw new AssertionError(Objects.checkFromToIndex(0L, -1L, 10L));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-    try {
-      throw new AssertionError(Objects.checkFromToIndex(11L, 11L, 10L));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-    try {
-      throw new AssertionError(Objects.checkFromToIndex(0L, 1L, 0L));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-    try {
-      throw new AssertionError(Objects.checkFromToIndex(1L, 1L, 0L));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-  }
-
-  private static void testCheckFromIndexSize() {
-    for (long i = 0L; i <= 10L; i++) {
-      for (long j = 10L - i; j >= 0L; j--) {
-        assertEquals(i, Objects.checkFromIndexSize(i, j, 10L));
-      }
-    }
-    assertEquals(0, Objects.checkFromIndexSize(0L, 0L, 0L));
-
-    try {
-      throw new AssertionError(Objects.checkFromIndexSize(8L, 4L, 10L));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-    try {
-      throw new AssertionError(Objects.checkFromIndexSize(-1L, 5L, 10L));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-    try {
-      throw new AssertionError(Objects.checkFromIndexSize(11L, 0L, 10L));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-    try {
-      throw new AssertionError(Objects.checkFromIndexSize(0L, 1L, 0L));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-    try {
-      throw new AssertionError(Objects.checkFromIndexSize(1L, 1L, 0L));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-
-    // Check for cases where overflow might occur producing incorrect results.
-    try {
-      throw new AssertionError(Objects.checkFromIndexSize(Long.MAX_VALUE, 1L, Long.MAX_VALUE));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-    try {
-      throw new AssertionError(Objects.checkFromIndexSize(0L, 1L, Long.MIN_VALUE));
-    } catch (IndexOutOfBoundsException expected) {
-    }
-  }
-
-  private static void assertEquals(long expected, long actual) {
-    if (expected != actual) {
-      throw new AssertionError("Expected <" + expected + "> but was <" + actual + '>');
-    }
-  }
-}
diff --git a/src/test/examplesJava17/backport/ObjectsBackportJava17Test.java b/src/test/examplesJava17/backport/ObjectsBackportJava17Test.java
new file mode 100644
index 0000000..32ba077
--- /dev/null
+++ b/src/test/examplesJava17/backport/ObjectsBackportJava17Test.java
@@ -0,0 +1,148 @@
+// Copyright (c) 2024, 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 backport;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfVm;
+import java.util.Objects;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ObjectsBackportJava17Test extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static Iterable<?> data() {
+    return getTestParameters()
+        .withDexRuntimes()
+        .withCfRuntimesStartingFromIncluding(CfVm.JDK17)
+        .withAllApiLevelsAlsoForCf()
+        .build();
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForDesugaring(parameters)
+        .addInnerClassesAndStrippedOuter(getClass())
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccess();
+  }
+
+  public static class TestClass {
+
+    public static void main(String[] args) {
+      // The methods are actually from Java 16, but we can test them from Java 17.
+      testCheckIndex();
+      testCheckFromToIndex();
+      testCheckFromIndexSize();
+    }
+
+    private static void testCheckIndex() {
+      for (long i = 0L; i < 10L; i++) {
+        assertEquals(i, Objects.checkIndex(i, 10L));
+      }
+
+      try {
+        throw new AssertionError(Objects.checkIndex(-1L, 10L));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+      try {
+        throw new AssertionError(Objects.checkIndex(10L, 0L));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+      try {
+        throw new AssertionError(Objects.checkIndex(0L, 0L));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+    }
+
+    private static void testCheckFromToIndex() {
+      for (long i = 0L; i <= 10L; i++) {
+        for (long j = i; j <= 10L; j++) {
+          assertEquals(i, Objects.checkFromToIndex(i, j, 10L));
+        }
+      }
+      assertEquals(0L, Objects.checkFromToIndex(0L, 0L, 0L));
+
+      try {
+        throw new AssertionError(Objects.checkFromToIndex(4L, 2L, 10L));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+      try {
+        throw new AssertionError(Objects.checkFromToIndex(-1L, 5L, 10L));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+      try {
+        throw new AssertionError(Objects.checkFromToIndex(0L, -1L, 10L));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+      try {
+        throw new AssertionError(Objects.checkFromToIndex(11L, 11L, 10L));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+      try {
+        throw new AssertionError(Objects.checkFromToIndex(0L, 1L, 0L));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+      try {
+        throw new AssertionError(Objects.checkFromToIndex(1L, 1L, 0L));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+    }
+
+    private static void testCheckFromIndexSize() {
+      for (long i = 0L; i <= 10L; i++) {
+        for (long j = 10L - i; j >= 0L; j--) {
+          assertEquals(i, Objects.checkFromIndexSize(i, j, 10L));
+        }
+      }
+      assertEquals(0, Objects.checkFromIndexSize(0L, 0L, 0L));
+
+      try {
+        throw new AssertionError(Objects.checkFromIndexSize(8L, 4L, 10L));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+      try {
+        throw new AssertionError(Objects.checkFromIndexSize(-1L, 5L, 10L));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+      try {
+        throw new AssertionError(Objects.checkFromIndexSize(11L, 0L, 10L));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+      try {
+        throw new AssertionError(Objects.checkFromIndexSize(0L, 1L, 0L));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+      try {
+        throw new AssertionError(Objects.checkFromIndexSize(1L, 1L, 0L));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+
+      // Check for cases where overflow might occur producing incorrect results.
+      try {
+        throw new AssertionError(Objects.checkFromIndexSize(Long.MAX_VALUE, 1L, Long.MAX_VALUE));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+      try {
+        throw new AssertionError(Objects.checkFromIndexSize(0L, 1L, Long.MIN_VALUE));
+      } catch (IndexOutOfBoundsException expected) {
+      }
+    }
+
+    private static void assertEquals(long expected, long actual) {
+      if (expected != actual) {
+        throw new AssertionError("Expected <" + expected + "> but was <" + actual + '>');
+      }
+    }
+  }
+}
diff --git a/src/test/examplesJava17/backport/StrictMathBackportJava17Main.java b/src/test/examplesJava17/backport/StrictMathBackportJava17Main.java
deleted file mode 100644
index 028e24f..0000000
--- a/src/test/examplesJava17/backport/StrictMathBackportJava17Main.java
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright (c) 2023, 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 backport;
-
-public class StrictMathBackportJava17Main {
-
-  public static void main(String[] args) {
-    // The methods are actually from Java 15, but we can test them from Java 17.
-    testAbsExactInteger();
-    testAbsExactLong();
-    // The methods are actually from Java 14, but we can test them from Java 17.
-    testDecrementExactInteger();
-    testDecrementExactLong();
-    testIncrementExactInteger();
-    testIncrementExactLong();
-    testNegateExactInteger();
-    testNegateExactLong();
-  }
-
-  private static void testAbsExactInteger() {
-    assertEquals(42, StrictMath.absExact(42));
-    assertEquals(42, StrictMath.absExact(-42));
-    assertEquals(Integer.MAX_VALUE, StrictMath.absExact(Integer.MAX_VALUE));
-    try {
-      throw new AssertionError(StrictMath.absExact(Integer.MIN_VALUE));
-    } catch (ArithmeticException expected) {
-
-    }
-  }
-
-  private static void testAbsExactLong() {
-    assertEquals(42L, StrictMath.absExact(42L));
-    assertEquals(42L, StrictMath.absExact(-42L));
-    assertEquals(Long.MAX_VALUE, StrictMath.absExact(Long.MAX_VALUE));
-    try {
-      throw new AssertionError(StrictMath.absExact(Long.MIN_VALUE));
-    } catch (ArithmeticException expected) {
-
-    }
-  }
-
-  private static void testDecrementExactInteger() {
-    assertEquals(-1, StrictMath.decrementExact(0));
-    assertEquals(Integer.MIN_VALUE, StrictMath.decrementExact(Integer.MIN_VALUE + 1));
-
-    try {
-      throw new AssertionError(StrictMath.decrementExact(Integer.MIN_VALUE));
-    } catch (ArithmeticException expected) {
-    }
-  }
-
-  private static void testDecrementExactLong() {
-    assertEquals(-1L, StrictMath.decrementExact(0L));
-    assertEquals(Long.MIN_VALUE, StrictMath.decrementExact(Long.MIN_VALUE + 1L));
-
-    try {
-      throw new AssertionError(StrictMath.decrementExact(Long.MIN_VALUE));
-    } catch (ArithmeticException expected) {
-    }
-  }
-
-  private static void testIncrementExactInteger() {
-    assertEquals(1, StrictMath.incrementExact(0));
-    assertEquals(Integer.MAX_VALUE, StrictMath.incrementExact(Integer.MAX_VALUE - 1));
-
-    try {
-      throw new AssertionError(StrictMath.incrementExact(Integer.MAX_VALUE));
-    } catch (ArithmeticException expected) {
-    }
-  }
-
-  private static void testIncrementExactLong() {
-    assertEquals(1L, StrictMath.incrementExact(0L));
-    assertEquals(Long.MAX_VALUE, StrictMath.incrementExact(Long.MAX_VALUE - 1L));
-
-    try {
-      throw new AssertionError(StrictMath.incrementExact(Long.MAX_VALUE));
-    } catch (ArithmeticException expected) {
-    }
-  }
-
-  private static void testNegateExactInteger() {
-    assertEquals(0, StrictMath.negateExact(0));
-    assertEquals(-1, StrictMath.negateExact(1));
-    assertEquals(1, StrictMath.negateExact(-1));
-    assertEquals(-2_147_483_647, StrictMath.negateExact(Integer.MAX_VALUE));
-
-    try {
-      throw new AssertionError(StrictMath.negateExact(Integer.MIN_VALUE));
-    } catch (ArithmeticException expected) {
-    }
-  }
-
-  private static void testNegateExactLong() {
-    assertEquals(0L, StrictMath.negateExact(0L));
-    assertEquals(-1L, StrictMath.negateExact(1L));
-    assertEquals(1L, StrictMath.negateExact(-1L));
-    assertEquals(-9_223_372_036_854_775_807L, StrictMath.negateExact(Long.MAX_VALUE));
-
-    try {
-      throw new AssertionError(StrictMath.negateExact(Long.MIN_VALUE));
-    } catch (ArithmeticException expected) {
-    }
-  }
-
-  private static void assertEquals(int expected, int actual) {
-    if (expected != actual) {
-      throw new AssertionError("Expected <" + expected + "> but was <" + actual + '>');
-    }
-  }
-
-  private static void assertEquals(long expected, long actual) {
-    if (expected != actual) {
-      throw new AssertionError("Expected <" + expected + "> but was <" + actual + '>');
-    }
-  }
-}
diff --git a/src/test/examplesJava17/backport/StrictMathBackportJava17Test.java b/src/test/examplesJava17/backport/StrictMathBackportJava17Test.java
new file mode 100644
index 0000000..0f71867
--- /dev/null
+++ b/src/test/examplesJava17/backport/StrictMathBackportJava17Test.java
@@ -0,0 +1,152 @@
+// Copyright (c) 2024, 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 backport;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfVm;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class StrictMathBackportJava17Test extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static Iterable<?> data() {
+    return getTestParameters()
+        .withDexRuntimes()
+        .withCfRuntimesStartingFromIncluding(CfVm.JDK17)
+        .withAllApiLevelsAlsoForCf()
+        .build();
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForDesugaring(parameters)
+        .addInnerClassesAndStrippedOuter(getClass())
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccess();
+  }
+
+  public static class TestClass {
+
+    public static void main(String[] args) {
+      // The methods are actually from Java 15, but we can test them from Java 17.
+      testAbsExactInteger();
+      testAbsExactLong();
+      // The methods are actually from Java 14, but we can test them from Java 17.
+      testDecrementExactInteger();
+      testDecrementExactLong();
+      testIncrementExactInteger();
+      testIncrementExactLong();
+      testNegateExactInteger();
+      testNegateExactLong();
+    }
+
+    private static void testAbsExactInteger() {
+      assertEquals(42, StrictMath.absExact(42));
+      assertEquals(42, StrictMath.absExact(-42));
+      assertEquals(Integer.MAX_VALUE, StrictMath.absExact(Integer.MAX_VALUE));
+      try {
+        throw new AssertionError(StrictMath.absExact(Integer.MIN_VALUE));
+      } catch (ArithmeticException expected) {
+
+      }
+    }
+
+    private static void testAbsExactLong() {
+      assertEquals(42L, StrictMath.absExact(42L));
+      assertEquals(42L, StrictMath.absExact(-42L));
+      assertEquals(Long.MAX_VALUE, StrictMath.absExact(Long.MAX_VALUE));
+      try {
+        throw new AssertionError(StrictMath.absExact(Long.MIN_VALUE));
+      } catch (ArithmeticException expected) {
+
+      }
+    }
+
+    private static void testDecrementExactInteger() {
+      assertEquals(-1, StrictMath.decrementExact(0));
+      assertEquals(Integer.MIN_VALUE, StrictMath.decrementExact(Integer.MIN_VALUE + 1));
+
+      try {
+        throw new AssertionError(StrictMath.decrementExact(Integer.MIN_VALUE));
+      } catch (ArithmeticException expected) {
+      }
+    }
+
+    private static void testDecrementExactLong() {
+      assertEquals(-1L, StrictMath.decrementExact(0L));
+      assertEquals(Long.MIN_VALUE, StrictMath.decrementExact(Long.MIN_VALUE + 1L));
+
+      try {
+        throw new AssertionError(StrictMath.decrementExact(Long.MIN_VALUE));
+      } catch (ArithmeticException expected) {
+      }
+    }
+
+    private static void testIncrementExactInteger() {
+      assertEquals(1, StrictMath.incrementExact(0));
+      assertEquals(Integer.MAX_VALUE, StrictMath.incrementExact(Integer.MAX_VALUE - 1));
+
+      try {
+        throw new AssertionError(StrictMath.incrementExact(Integer.MAX_VALUE));
+      } catch (ArithmeticException expected) {
+      }
+    }
+
+    private static void testIncrementExactLong() {
+      assertEquals(1L, StrictMath.incrementExact(0L));
+      assertEquals(Long.MAX_VALUE, StrictMath.incrementExact(Long.MAX_VALUE - 1L));
+
+      try {
+        throw new AssertionError(StrictMath.incrementExact(Long.MAX_VALUE));
+      } catch (ArithmeticException expected) {
+      }
+    }
+
+    private static void testNegateExactInteger() {
+      assertEquals(0, StrictMath.negateExact(0));
+      assertEquals(-1, StrictMath.negateExact(1));
+      assertEquals(1, StrictMath.negateExact(-1));
+      assertEquals(-2_147_483_647, StrictMath.negateExact(Integer.MAX_VALUE));
+
+      try {
+        throw new AssertionError(StrictMath.negateExact(Integer.MIN_VALUE));
+      } catch (ArithmeticException expected) {
+      }
+    }
+
+    private static void testNegateExactLong() {
+      assertEquals(0L, StrictMath.negateExact(0L));
+      assertEquals(-1L, StrictMath.negateExact(1L));
+      assertEquals(1L, StrictMath.negateExact(-1L));
+      assertEquals(-9_223_372_036_854_775_807L, StrictMath.negateExact(Long.MAX_VALUE));
+
+      try {
+        throw new AssertionError(StrictMath.negateExact(Long.MIN_VALUE));
+      } catch (ArithmeticException expected) {
+      }
+    }
+
+    private static void assertEquals(int expected, int actual) {
+      if (expected != actual) {
+        throw new AssertionError("Expected <" + expected + "> but was <" + actual + '>');
+      }
+    }
+
+    private static void assertEquals(long expected, long actual) {
+      if (expected != actual) {
+        throw new AssertionError("Expected <" + expected + "> but was <" + actual + '>');
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClInitMergeSuperTypeApiLevelTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClInitMergeSuperTypeApiLevelTest.java
index f0de7ae..6584d53 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClInitMergeSuperTypeApiLevelTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClInitMergeSuperTypeApiLevelTest.java
@@ -21,6 +21,7 @@
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.lang.reflect.AccessibleObject;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Executable;
 import java.lang.reflect.Method;
@@ -48,7 +49,7 @@
 
   private TypeReference getMergeReferenceForApiLevel() {
     return Reference.typeFromTypeName(
-        typeName(canUseExecutable() ? Executable.class : Object.class));
+        typeName(canUseExecutable() ? Executable.class : AccessibleObject.class));
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergingWithMissingTypeArgsSubstitutionTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergingWithMissingTypeArgsSubstitutionTest.java
index 966addb..cac41ff 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergingWithMissingTypeArgsSubstitutionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergingWithMissingTypeArgsSubstitutionTest.java
@@ -48,10 +48,10 @@
         .addKeepClassRules(A.class)
         .addKeepAttributeSignature()
         .addOptionsModification(
-            options ->
-                options
-                    .getVerticalClassMergerOptions()
-                    .setEnableBridgeAnalysis(enableBridgeAnalysis))
+            options -> {
+              options.getSingleCallerInlinerOptions().setEnable(false);
+              options.getVerticalClassMergerOptions().setEnableBridgeAnalysis(enableBridgeAnalysis);
+            })
         .addVerticallyMergedClassesInspector(
             inspector -> inspector.assertMergedIntoSubtype(B.class).assertNoOtherClassesMerged())
         .enableInliningAnnotations()
diff --git a/src/test/java/com/android/tools/r8/compilerapi/sampleapi/R8ApiUsageSampleTest.java b/src/test/java/com/android/tools/r8/compilerapi/sampleapi/R8ApiUsageSampleTest.java
index b3258e5..eae3116 100644
--- a/src/test/java/com/android/tools/r8/compilerapi/sampleapi/R8ApiUsageSampleTest.java
+++ b/src/test/java/com/android/tools/r8/compilerapi/sampleapi/R8ApiUsageSampleTest.java
@@ -496,9 +496,6 @@
       if (labelValue.isEmpty()) {
         throw new RuntimeException("Expected LABEL constant");
       }
-      if (Version.LABEL.isEmpty()) {
-        throw new RuntimeException("Expected LABEL constant");
-      }
       if (Version.getVersionString() == null) {
         throw new RuntimeException("Expected getVersionString API");
       }
diff --git a/src/test/java/com/android/tools/r8/desugar/backports/MathBackportJava17Test.java b/src/test/java/com/android/tools/r8/desugar/backports/MathBackportJava17Test.java
deleted file mode 100644
index c612792..0000000
--- a/src/test/java/com/android/tools/r8/desugar/backports/MathBackportJava17Test.java
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) 2023, 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.backports;
-
-import static com.android.tools.r8.utils.FileUtils.JAR_EXTENSION;
-
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestRuntime.CfVm;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.utils.AndroidApiLevel;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-
-@RunWith(Parameterized.class)
-public final class MathBackportJava17Test extends AbstractBackportTest {
-  @Parameters(name = "{0}")
-  public static Iterable<?> data() {
-    return getTestParameters()
-        .withDexRuntimes()
-        .withCfRuntimesStartingFromIncluding(CfVm.JDK17)
-        .withAllApiLevelsAlsoForCf()
-        .build();
-  }
-
-  private static final Path TEST_JAR =
-      Paths.get(ToolHelper.TESTS_BUILD_DIR).resolve("examplesJava17/backport" + JAR_EXTENSION);
-
-  public MathBackportJava17Test(TestParameters parameters) {
-    super(parameters, Math.class, TEST_JAR, "backport.MathBackportJava17Main");
-
-    // Math.absExact.
-    registerTarget(AndroidApiLevel.U, 8);
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/desugar/backports/ObjectsBackportJava17Test.java b/src/test/java/com/android/tools/r8/desugar/backports/ObjectsBackportJava17Test.java
deleted file mode 100644
index af9af9d..0000000
--- a/src/test/java/com/android/tools/r8/desugar/backports/ObjectsBackportJava17Test.java
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright (c) 2023, 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.backports;
-
-import static com.android.tools.r8.utils.FileUtils.JAR_EXTENSION;
-
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestRuntime.CfVm;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.utils.AndroidApiLevel;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.Objects;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-
-@RunWith(Parameterized.class)
-public final class ObjectsBackportJava17Test extends AbstractBackportTest {
-  @Parameters(name = "{0}")
-  public static Iterable<?> data() {
-    return getTestParameters()
-        .withDexRuntimes()
-        .withCfRuntimesStartingFromIncluding(CfVm.JDK17)
-        .withAllApiLevelsAlsoForCf()
-        .build();
-  }
-
-  private static final Path TEST_JAR =
-      Paths.get(ToolHelper.TESTS_BUILD_DIR).resolve("examplesJava17/backport" + JAR_EXTENSION);
-  private static final String TEST_CLASS = "backport.ObjectsBackportJava17Main";
-
-  public ObjectsBackportJava17Test(TestParameters parameters) {
-    super(parameters, Objects.class, TEST_JAR, TEST_CLASS);
-    // Objects.checkFromIndexSize, Objects.checkFromToIndex, Objects.checkIndex.
-    registerTarget(AndroidApiLevel.U, 21);
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/desugar/backports/StrictMathBackportJava17Test.java b/src/test/java/com/android/tools/r8/desugar/backports/StrictMathBackportJava17Test.java
deleted file mode 100644
index f180eab..0000000
--- a/src/test/java/com/android/tools/r8/desugar/backports/StrictMathBackportJava17Test.java
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright (c) 2023, 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.backports;
-
-import static com.android.tools.r8.utils.FileUtils.JAR_EXTENSION;
-
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestRuntime.CfVm;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.utils.AndroidApiLevel;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-
-@RunWith(Parameterized.class)
-public final class StrictMathBackportJava17Test extends AbstractBackportTest {
-
-  @Parameters(name = "{0}")
-  public static Iterable<?> data() {
-    return getTestParameters()
-        .withDexRuntimes()
-        .withCfRuntimesStartingFromIncluding(CfVm.JDK17)
-        .withAllApiLevelsAlsoForCf()
-        .build();
-  }
-
-  private static final Path TEST_JAR =
-      Paths.get(ToolHelper.TESTS_BUILD_DIR).resolve("examplesJava17/backport" + JAR_EXTENSION);
-
-  public StrictMathBackportJava17Test(TestParameters parameters) {
-    super(parameters, StrictMath.class, TEST_JAR, "backport.StrictMathBackportJava17Main");
-    registerTarget(AndroidApiLevel.U, 30);
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java b/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java
index 55a961e..64e4c42 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java
@@ -4,8 +4,8 @@
 
 package com.android.tools.r8.internal.proto;
 
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsentIf;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -249,9 +249,8 @@
 
     // Verify that the registry methods are still present in the output.
     //
-    // We expect findLiteExtensionByNumber2() to be inlined into findLiteExtensionByNumber1(). The
-    // method findLiteExtensionByNumber1() has two call sites from findLiteExtensionByNumber(),
-    // which prevents it from being single-caller inlined.
+    // We expect findLiteExtensionByNumber2() to be inlined into findLiteExtensionByNumber1() and
+    // findLiteExtensionByNumber1() to be inlined into findLiteExtensionByNumber().
     {
       ClassSubject generatedExtensionRegistryLoader = outputInspector.clazz(extensionRegistryName);
       assertThat(generatedExtensionRegistryLoader, isPresent());
@@ -262,11 +261,11 @@
       assertThat(
           generatedExtensionRegistryLoader.uniqueMethodWithOriginalName(
               "findLiteExtensionByNumber1"),
-          isPresent());
+          isAbsentIf(enableMinification));
       assertThat(
           generatedExtensionRegistryLoader.uniqueMethodWithOriginalName(
               "findLiteExtensionByNumber2"),
-          notIf(isPresent(), enableMinification));
+          isAbsentIf(enableMinification));
     }
 
     // Verify that unused extensions have been removed with -allowaccessmodification.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/B116282409.java b/src/test/java/com/android/tools/r8/ir/optimize/B116282409.java
index 6876898..0031854 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/B116282409.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/B116282409.java
@@ -4,24 +4,20 @@
 
 package com.android.tools.r8.ir.optimize;
 
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticType;
+import static org.hamcrest.CoreMatchers.allOf;
 import static org.hamcrest.CoreMatchers.containsString;
-import static org.junit.Assert.assertFalse;
 
-import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.jasmin.JasminBuilder;
 import com.android.tools.r8.jasmin.JasminBuilder.ClassBuilder;
 import com.android.tools.r8.jasmin.JasminTestBase;
-import com.android.tools.r8.utils.AbortException;
 import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.UnverifiableCfCodeDiagnostic;
 import com.google.common.collect.ImmutableList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
-import java.util.stream.Collectors;
-import org.hamcrest.BaseMatcher;
-import org.hamcrest.Description;
 import org.junit.BeforeClass;
 import org.junit.Rule;
 import org.junit.Test;
@@ -105,79 +101,36 @@
 
   @Test
   public void testR8() throws Exception {
-    if (enableVerticalClassMerging) {
-      exception.expect(CompilationFailedException.class);
-      exception.expectCause(
-          new CustomExceptionMatcher(
-              "Unable to rewrite `invoke-direct A.<init>(new B, ...)` in method "
-                  + "`void TestClass.main(java.lang.String[])` after type `A` was merged into `B`.",
-              "Please add the following rule to your Proguard configuration file: "
-                  + "`-keep,allowobfuscation class A`."));
-    }
-
-    R8TestCompileResult compileResult =
-        testForR8(parameters.getBackend())
-            .addProgramClassFileData(programClassFileData)
-            .addKeepMainRule("TestClass")
-            .addOptionsModification(
-                options ->
-                    options.getVerticalClassMergerOptions().setEnabled(enableVerticalClassMerging))
-            .allowDiagnosticWarningMessages()
-            .setMinApi(parameters)
-            .compile();
-
-    assertFalse(enableVerticalClassMerging);
-
-    compileResult
+    testForR8(parameters.getBackend())
+        .addProgramClassFileData(programClassFileData)
+        .addKeepMainRule("TestClass")
+        .addOptionsModification(
+            options ->
+                options.getVerticalClassMergerOptions().setEnabled(enableVerticalClassMerging))
+        .allowDiagnosticWarningMessages()
+        .setMinApi(parameters)
+        .compileWithExpectedDiagnostics(
+            diagnostics ->
+                diagnostics.assertWarningsMatch(
+                    allOf(
+                        diagnosticType(UnverifiableCfCodeDiagnostic.class),
+                        diagnosticMessage(
+                            containsString(
+                                "Constructor mismatch, expected constructor from B, but was"
+                                    + " A.<init>()")))))
         .run(parameters.getRuntime(), "TestClass")
         .applyIf(
-            parameters.isCfRuntime(),
+            (parameters.isCfRuntime() || parameters.getDexRuntimeVersion().isDalvik())
+                && !enableVerticalClassMerging,
             runResult ->
                 runResult
                     .assertFailureWithErrorThatThrows(VerifyError.class)
                     .assertFailureWithErrorThatMatches(
-                        containsString("Call to wrong initialization method")),
-            runResult -> {
-              if (parameters.getDexRuntimeVersion().isDalvik()) {
-                runResult.assertFailureWithErrorThatMatches(
-                    containsString(
-                        "VFY: invoke-direct <init> on super only allowed for 'this' in <init>"));
-              } else {
-                runResult.assertSuccessWithOutputLines("In A.<init>()", "42");
-              }
-            });
-  }
-
-  private static class CustomExceptionMatcher extends BaseMatcher<Throwable> {
-
-    private List<String> messages;
-
-    public CustomExceptionMatcher(String... messages) {
-      this.messages = Arrays.asList(messages);
-    }
-
-    @Override
-    public void describeTo(Description description) {
-      description
-          .appendText("a string containing ")
-          .appendText(
-              String.join(
-                  ", ", messages.stream().map(m -> "\"" + m + "\"").collect(Collectors.toList())));
-    }
-
-    @Override
-    public boolean matches(Object o) {
-      if (o instanceof AbortException) {
-        AbortException exception = (AbortException) o;
-        if (exception.getMessage() != null
-            && messages.stream().allMatch(message -> exception.getMessage().contains(message))) {
-          return true;
-        }
-        if (exception.getCause() != null) {
-          return matches(exception.getCause());
-        }
-      }
-      return false;
-    }
+                        containsString(
+                            parameters.isCfRuntime()
+                                ? "Call to wrong initialization method"
+                                : "VFY: invoke-direct <init> on super only allowed for 'this' in"
+                                    + " <init>")),
+            runResult -> runResult.assertSuccessWithOutputLines("In A.<init>()", "42"));
   }
 }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/BridgeWithCastsInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/BridgeWithCastsInliningTest.java
index cf1b311..f5e7361 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/BridgeWithCastsInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/BridgeWithCastsInliningTest.java
@@ -10,6 +10,7 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NeverSingleCallerInline;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.utils.BooleanUtils;
@@ -55,6 +56,7 @@
             })
         .enableInliningAnnotations()
         .enableNeverClassInliningAnnotations()
+        .enableNeverSingleCallerInlineAnnotations()
         .setMinApi(parameters)
         .compile()
         .inspect(this::inspect)
@@ -106,6 +108,7 @@
       foo(o, o, o, o, o);
     }
 
+    @NeverSingleCallerInline
     static void foo(Object o1, Object o2, Object o3, Object o4, Object o5) {
       A a1 = (A) o1;
       A a2 = (A) o2;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/BridgeWithUnboxingInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/BridgeWithUnboxingInliningTest.java
index 2623bc0..2dea095 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/BridgeWithUnboxingInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/BridgeWithUnboxingInliningTest.java
@@ -10,6 +10,7 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NeverSingleCallerInline;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.utils.BooleanUtils;
@@ -55,6 +56,7 @@
             })
         .enableInliningAnnotations()
         .enableNeverClassInliningAnnotations()
+        .enableNeverSingleCallerInlineAnnotations()
         .setMinApi(parameters)
         .compile()
         .inspect(this::inspect)
@@ -114,6 +116,7 @@
       foo(o1, o2, o3, o4, o5);
     }
 
+    @NeverSingleCallerInline
     static void foo(Integer o1, Integer o2, Integer o3, Integer o4, Integer o5) {
       int i1 = o1;
       int i2 = o2;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningOfVirtualMethodOnKeptClassTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningOfVirtualMethodOnKeptClassTest.java
index 2b4c4bb..946d711 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningOfVirtualMethodOnKeptClassTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InliningOfVirtualMethodOnKeptClassTest.java
@@ -4,8 +4,8 @@
 
 package com.android.tools.r8.ir.optimize.inliner;
 
+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.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 
 import com.android.tools.r8.NeverClassInline;
@@ -50,7 +50,7 @@
   private void verifyOutput(CodeInspector inspector) {
     ClassSubject classSubject = inspector.clazz(TestClass.class);
     assertThat(classSubject, isPresent());
-    assertThat(classSubject.uniqueMethodWithOriginalName("foo"), not(isPresent()));
+    assertThat(classSubject.uniqueMethodWithOriginalName("foo"), isAbsent());
     assertThat(classSubject.uniqueMethodWithOriginalName("bar"), isPresent());
     assertThat(classSubject.uniqueMethodWithOriginalName("baz"), isPresent());
   }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java
index 95cf23e..59e609d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/SingleTargetAfterInliningTest.java
@@ -50,9 +50,11 @@
         .addInnerClasses(SingleTargetAfterInliningTest.class)
         .addKeepMainRule(TestClass.class)
         .addOptionsModification(
-            options ->
-                options.inlinerOptions().applyInliningToInlineePredicateForTesting =
-                    (appView, inlinee, inliningDepth) -> inliningDepth <= maxInliningDepth)
+            options -> {
+              options.inlinerOptions().applyInliningToInlineePredicateForTesting =
+                  (appView, inlinee, inliningDepth) -> inliningDepth <= maxInliningDepth;
+              options.getSingleCallerInlinerOptions().setEnable(false);
+            })
         .enableAlwaysInliningAnnotations()
         .enableInliningAnnotations()
         .enableNeverClassInliningAnnotations()
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SwitchWithSimpleCasesInliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SwitchWithSimpleCasesInliningTest.java
index 3d8006e..29a4ece 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SwitchWithSimpleCasesInliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/conditionalsimpleinlining/SwitchWithSimpleCasesInliningTest.java
@@ -5,7 +5,7 @@
 
 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.NeverInline;
 import com.android.tools.r8.TestBase;
@@ -46,9 +46,7 @@
 
               MethodSubject mainMethodSubject = mainClassSubject.mainMethod();
               assertThat(mainMethodSubject, isPresent());
-              // TODO(b/331337747): Account for constant canonicalization in constraint analysis.
-              assertEquals(
-                  parameters.isCfRuntime(),
+              assertTrue(
                   mainMethodSubject
                       .streamInstructions()
                       .filter(InstructionSubject::isConstString)
diff --git a/src/test/java/com/android/tools/r8/keepanno/KeepAnnotationViaSuperTest.java b/src/test/java/com/android/tools/r8/keepanno/KeepAnnotationViaSuperTest.java
index a9dd273..a77f369 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepAnnotationViaSuperTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepAnnotationViaSuperTest.java
@@ -43,6 +43,7 @@
   @Test
   public void test() throws Exception {
     testForKeepAnno(parameters)
+        .enableNativeInterpretation()
         .addProgramClasses(getInputClasses())
         .addKeepMainRule(TestClass.class)
         .setExcludedOuterClass(getClass())
diff --git a/src/test/java/com/android/tools/r8/keepanno/KeepEmptyClassTest.java b/src/test/java/com/android/tools/r8/keepanno/KeepEmptyClassTest.java
index a80be3c..3e9b7ee 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepEmptyClassTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepEmptyClassTest.java
@@ -64,10 +64,14 @@
       assertTrue(parameters.isExtractRules());
       // PG and R8 with keep rules will keep the residual class.
       assertThat(classA, isPresentAndRenamed());
-      // R8 using keep rules will soft-pin the precondition method too.
+      // R8 using keep rules will soft-pin the precondition method too. The soft pinning is only
+      // applied in the first round of tree shaking, however, so R8 can still single caller inline
+      // the method after the final round of tree shaking.
       assertThat(
           classA.uniqueMethodWithOriginalName("foo"),
-          parameters.isPG() ? isAbsent() : isPresentAndRenamed());
+          parameters.isPG() || (parameters.isCurrentR8() && parameters.isExtractRules())
+              ? isAbsent()
+              : isPresentAndRenamed());
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/keepanno/KeepSameMethodTest.java b/src/test/java/com/android/tools/r8/keepanno/KeepSameMethodTest.java
index f1fe6f5..88047e4 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepSameMethodTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepSameMethodTest.java
@@ -4,6 +4,7 @@
 package com.android.tools.r8.keepanno;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsentIf;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
 
@@ -38,6 +39,7 @@
   @Test
   public void test() throws Exception {
     testForKeepAnno(parameters)
+        .enableNativeInterpretation()
         .addProgramClasses(getInputClasses())
         .addKeepMainRule(TestClass.class)
         .setExcludedOuterClass(getClass())
@@ -54,8 +56,10 @@
 
   private void checkOutput(CodeInspector inspector) throws Exception {
     assertThat(inspector.clazz(A.class).method(A.class.getMethod("foo")), isPresent());
-    // TODO(b/265892343): The extracted rule will match all params so this is incorrectly kept.
-    assertThat(inspector.clazz(A.class).method(A.class.getMethod("foo", int.class)), isPresent());
+    // The extracted rules must overapproximate by matching all params (see b/265892343).
+    assertThat(
+        inspector.clazz(A.class).method(A.class.getMethod("foo", int.class)),
+        isAbsentIf(parameters.isNativeR8()));
     // Bar is unused and thus removed.
     assertThat(inspector.clazz(A.class).uniqueMethodWithOriginalName("bar"), isAbsent());
   }
diff --git a/src/test/java/com/android/tools/r8/keepanno/KeepUsedByNativeAnnotationTest.java b/src/test/java/com/android/tools/r8/keepanno/KeepUsedByNativeAnnotationTest.java
index dfe0e2b..37f499a 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepUsedByNativeAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepUsedByNativeAnnotationTest.java
@@ -40,6 +40,7 @@
   @Test
   public void test() throws Exception {
     testForKeepAnno(parameters)
+        .enableNativeInterpretation()
         .addProgramClasses(getInputClasses())
         .addKeepMainRule(TestClass.class)
         .setExcludedOuterClass(getClass())
diff --git a/src/test/java/com/android/tools/r8/keepanno/KeepUsesReflectionAnnotationWithAdditionalPreconditionTest.java b/src/test/java/com/android/tools/r8/keepanno/KeepUsesReflectionAnnotationWithAdditionalPreconditionTest.java
index fe22453..edab850 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepUsesReflectionAnnotationWithAdditionalPreconditionTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepUsesReflectionAnnotationWithAdditionalPreconditionTest.java
@@ -35,6 +35,7 @@
   @Test
   public void test() throws Exception {
     testForKeepAnno(parameters)
+        .enableNativeInterpretation()
         .addProgramClasses(getInputClasses())
         .addKeepMainRule(TestClass.class)
         .setExcludedOuterClass(getClass())
@@ -68,7 +69,6 @@
           // way to express the conjunction with multiple distinct precondition classes in the
           // rule language. With direct annotation interpretation this limitation is avoided and
           // a more precise shrinking is possible.
-          // TODO(b/248408342): Check this once direct interpretation is supported.
           @KeepCondition(classConstant = B.class)
         })
     public void foo(Class<B> clazz) throws Exception {
diff --git a/src/test/java/com/android/tools/r8/keepanno/KeepUsesReflectionAnnotationWithAdditionalPreconditionUnsatisfiedTest.java b/src/test/java/com/android/tools/r8/keepanno/KeepUsesReflectionAnnotationWithAdditionalPreconditionUnsatisfiedTest.java
new file mode 100644
index 0000000..16f56ac
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepUsesReflectionAnnotationWithAdditionalPreconditionUnsatisfiedTest.java
@@ -0,0 +1,113 @@
+// Copyright (c) 2024, 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.keepanno;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsentIf;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.keepanno.annotations.KeepCondition;
+import com.android.tools.r8.keepanno.annotations.KeepTarget;
+import com.android.tools.r8.keepanno.annotations.UsesReflection;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+
+/**
+ * This test is a copy of KeepUsesReflectionAnnotationWithAdditionalPreconditionTest but where the
+ * preconditions are only partially met. Thus, the legacy variants will keep more than needed but
+ * the native keep rule variants will remove the code.
+ */
+@RunWith(Parameterized.class)
+public class KeepUsesReflectionAnnotationWithAdditionalPreconditionUnsatisfiedTest
+    extends KeepAnnoTestBase {
+
+  static final String EXPECTED = StringUtils.lines("Nothing called...");
+
+  @Parameter public KeepAnnoParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static List<KeepAnnoParameters> data() {
+    return createParameters(
+        getTestParameters().withDefaultRuntimes().withApiLevel(AndroidApiLevel.B).build());
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForKeepAnno(parameters)
+        .enableNativeInterpretation()
+        .addProgramClasses(getInputClasses())
+        .addKeepMainRule(TestClass.class)
+        .setExcludedOuterClass(getClass())
+        // The conditional on A.foo no long hits (but the one on B does)
+        .allowUnusedProguardConfigurationRules()
+        .run(TestClass.class)
+        .assertSuccessWithOutput(EXPECTED)
+        .applyIf(parameters.isShrinker(), r -> r.inspect(this::checkOutput));
+  }
+
+  public List<Class<?>> getInputClasses() {
+    return ImmutableList.of(TestClass.class, A.class, B.class);
+  }
+
+  private void checkOutput(CodeInspector inspector) {
+    // The B.class reference remains so it is always present.
+    assertThat(inspector.clazz(B.class), isPresent());
+    // The conditionally kept methods are gone on native interpretation only!
+    assertThat(
+        inspector.clazz(B.class).uniqueMethodWithOriginalName("<init>"),
+        isAbsentIf(parameters.isNativeR8()));
+    assertThat(
+        inspector.clazz(B.class).uniqueMethodWithOriginalName("bar"),
+        isAbsentIf(parameters.isNativeR8()));
+    // A.foo is unused, so it should always be removed.
+    assertThat(inspector.clazz(A.class).uniqueMethodWithOriginalName("foo"), isAbsent());
+  }
+
+  static class A {
+
+    @UsesReflection(
+        value = {
+          // Ensure B's constructor and method 'bar' remain as they are invoked by reflection.
+          @KeepTarget(classConstant = B.class, methodName = "<init>"),
+          @KeepTarget(classConstant = B.class, methodName = "bar")
+        },
+        additionalPreconditions = {
+          // The reflection depends on the class constant being used in the program in addition to
+          // this method. In rule extraction, this will lead to an over-approximation as the rules
+          // will need to keep the above live if either of the two conditions are met. There is no
+          // way to express the conjunction with multiple distinct precondition classes in the
+          // rule language. With direct annotation interpretation this limitation is avoided and
+          // a more precise shrinking is possible.
+          @KeepCondition(classConstant = B.class)
+        })
+    public void foo(Class<B> clazz) throws Exception {
+      if (clazz != null) {
+        clazz.getDeclaredMethod("bar").invoke(clazz.getDeclaredConstructor().newInstance());
+      } else {
+        System.out.println("Nothing called...");
+      }
+    }
+  }
+
+  static class B {
+    public static void bar() {
+      System.out.println("Hello, world");
+    }
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) throws Exception {
+      System.out.println(System.nanoTime() > 0 ? "Nothing called..." : B.class);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/keepanno/KeepUsesReflectionFieldAnnotationTest.java b/src/test/java/com/android/tools/r8/keepanno/KeepUsesReflectionFieldAnnotationTest.java
index 92f2515..15f96ab 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepUsesReflectionFieldAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepUsesReflectionFieldAnnotationTest.java
@@ -35,6 +35,7 @@
   @Test
   public void test() throws Exception {
     testForKeepAnno(parameters)
+        .enableNativeInterpretation()
         .addProgramClasses(getInputClasses())
         .addKeepMainRule(TestClass.class)
         .setExcludedOuterClass(getClass())
diff --git a/src/test/java/com/android/tools/r8/keepanno/KeepUsesReflectionOnFieldTest.java b/src/test/java/com/android/tools/r8/keepanno/KeepUsesReflectionOnFieldTest.java
index e1c5dd9..905cc81 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepUsesReflectionOnFieldTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepUsesReflectionOnFieldTest.java
@@ -38,13 +38,22 @@
   @Test
   public void test() throws Exception {
     testForKeepAnno(parameters)
+        .enableNativeInterpretation()
         .addProgramClasses(getInputClasses())
         .addKeepMainRule(TestClass.class)
         .setExcludedOuterClass(getClass())
         .inspectOutputConfig(
             rules -> {
-              assertThat(rules, containsString("context: " + descriptor(A.class) + "foo()V"));
-              assertThat(rules, containsString("description: Keep the\\nstring-valued fields"));
+              if (parameters.isNativeR8()) {
+                // TODO(b/323816623): Once a final distribution format is defined for normalized
+                //  edges, that format should likely be the bases of the annotation printing too.
+                assertThat(rules, containsString("context=" + descriptor(A.class) + "foo()V"));
+                assertThat(
+                    rules, containsString("description=\"Keep the\\nstring-valued fields\""));
+              } else {
+                assertThat(rules, containsString("context: " + descriptor(A.class) + "foo()V"));
+                assertThat(rules, containsString("description: Keep the\\nstring-valued fields"));
+              }
             })
         .run(TestClass.class)
         .assertSuccessWithOutput(EXPECTED)
diff --git a/src/test/java/com/android/tools/r8/keepanno/compatissues/BackReferenceIssuesTest.java b/src/test/java/com/android/tools/r8/keepanno/compatissues/BackReferenceIssuesTest.java
index 63692c5..85464e5 100644
--- a/src/test/java/com/android/tools/r8/keepanno/compatissues/BackReferenceIssuesTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/compatissues/BackReferenceIssuesTest.java
@@ -8,7 +8,6 @@
 import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 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.Assume.assumeTrue;
 
@@ -82,7 +81,7 @@
                 assertThat(
                     inspector.clazz(A.class).uniqueMethodWithOriginalName("foo"),
                     // The rule is not valid and does not keep the method in R8.
-                    shrinker.isPG() ? isPresentAndNotRenamed() : isPresentAndRenamed()));
+                    shrinker.isPG() ? isPresentAndNotRenamed() : isAbsent()));
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingInterfaceHierachyDefaultTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingInterfaceHierachyDefaultTest.java
new file mode 100644
index 0000000..8c46d0b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingInterfaceHierachyDefaultTest.java
@@ -0,0 +1,88 @@
+// Copyright (c) 2024, 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.memberrebinding;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestShrinkerBuilder;
+import com.android.tools.r8.utils.BooleanUtils;
+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;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+// This is a regression test for b/328859009.
+@RunWith(Parameterized.class)
+public class MemberRebindingInterfaceHierachyDefaultTest extends TestBase {
+
+  @Parameter(0)
+  public static TestParameters parameters;
+
+  @Parameter(1)
+  public static boolean dontOptimize;
+
+  @Parameters(name = "{0}, dontOptimize = {1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build(),
+        BooleanUtils.values());
+  }
+
+  private static final String EXPECTED_OUTPUT = StringUtils.lines("I::m", "TestClass::m");
+
+  @Test
+  public void testJvm() throws Exception {
+    parameters.assumeJvmTestParameters();
+    testForJvm(parameters)
+        .addInnerClasses(getClass())
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    parameters.assumeR8TestParameters();
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .setMinApi(parameters)
+        .addKeepMainRule(TestClass.class)
+        // Issue b/328859009 failed in DEBUG mode. Use -dontoptimize to get the same effect.
+        .applyIf(dontOptimize, TestShrinkerBuilder::addDontOptimize)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+
+  interface I {
+    default void m() {
+      System.out.println("I::m");
+    }
+  }
+
+  interface J extends I {}
+
+  interface K extends J {}
+
+  static class A implements K {
+    public void m() {
+      K.super.m();
+    }
+  }
+
+  static class B implements J {}
+
+  static class TestClass {
+
+    public static void m(J j) {
+      System.out.println("TestClass::m");
+    }
+
+    public static void main(String[] args) {
+      new A().m();
+      m(new B());
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingTest.java
index 72be6ed..6ed1857 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingTest.java
@@ -116,8 +116,8 @@
     assertTrue(iterator.next().holder().is("java.util.AbstractList"));
     assertTrue(iterator.next().holder().is("java.util.AbstractList"));
     assertTrue(iterator.next().holder().is("java.util.AbstractList"));
-    assertTrue(iterator.next().holder().is("memberrebinding.subpackage.PublicClassInTheMiddle"));
-    assertTrue(iterator.next().holder().is("memberrebinding.subpackage.PublicClassInTheMiddle"));
+    assertTrue(iterator.next().holder().is("memberrebinding.subpackage.PackagePrivateClass"));
+    assertTrue(iterator.next().holder().is("memberrebinding.subpackage.PackagePrivateClass"));
     // For the next three - test that we re-bind to the lowest library class.
     assertTrue(iterator.next().holder().is("memberrebindinglib.SubClass"));
     assertTrue(iterator.next().holder().is("memberrebindinglib.SubClass"));
@@ -170,7 +170,7 @@
     Iterator<InvokeInstructionSubject> iterator =
         main.iterateInstructions(InstructionSubject::isInvoke);
     assertTrue(iterator.next().holder().is("memberrebinding4.Memberrebinding$Inner"));
-    assertTrue(iterator.next().holder().is("memberrebinding4.subpackage.PublicInterface"));
+    assertTrue(iterator.next().holder().is("memberrebinding4.subpackage.PackagePrivateInterface"));
     assertFalse(iterator.hasNext());
   }
 
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/VerticalClassMergingRetraceTest.java b/src/test/java/com/android/tools/r8/naming/retrace/VerticalClassMergingRetraceTest.java
index cb94b5d..34b7502 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/VerticalClassMergingRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/VerticalClassMergingRetraceTest.java
@@ -73,7 +73,8 @@
   private int expectedActualStackTraceHeight() {
     // In RELEASE mode a synthetic bridge is added by the vertical class merger if the method is
     // targeted by the invoke-super (which is modeled by setting enableBridgeAnalysis to false).
-    return mode == CompilationMode.DEBUG || enableBridgeAnalysis ? 2 : 3;
+    // Due to single caller inlining we still end up with a stack trace height of 2.
+    return 2;
   }
 
   private boolean filterSynthesizedMethodWhenLineNumberAvailable(
diff --git a/src/test/java/com/android/tools/r8/rewrite/logarguments/LogArgumentsTest.java b/src/test/java/com/android/tools/r8/rewrite/logarguments/LogArgumentsTest.java
deleted file mode 100644
index 8f37d3d..0000000
--- a/src/test/java/com/android/tools/r8/rewrite/logarguments/LogArgumentsTest.java
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.rewrite.logarguments;
-
-import static org.junit.Assert.assertEquals;
-
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.utils.AndroidApp;
-import com.google.common.collect.ImmutableList;
-import org.junit.Test;
-
-public class LogArgumentsTest extends TestBase {
-
-  private static int occurrences(String match, String value) {
-    int count = 0;
-    int startIndex = 0;
-    while (true) {
-      int index = value.indexOf(match, startIndex);
-      if (index > 0) {
-        count++;
-      } else {
-        return count;
-      }
-      startIndex = index + match.length();
-    }
-  }
-
-  @Test
-  public void testStatic() throws Exception {
-    String qualifiedMethodName = "com.android.tools.r8.rewrite.logarguments.TestStatic.a";
-    String result =
-        testForR8(Backend.DEX)
-            .addProgramClasses(TestStatic.class)
-            .addOptionsModification(
-                options -> options.logArgumentsFilter = ImmutableList.of(qualifiedMethodName))
-            .assumeAllMethodsMayHaveSideEffects()
-            .addDontObfuscate()
-            .noTreeShaking()
-            .run(TestStatic.class)
-            .getStdOut();
-    assertEquals(7, occurrences(qualifiedMethodName, result));
-    assertEquals(3, occurrences("(primitive)", result));
-    assertEquals(3, occurrences("(null)", result));
-    assertEquals(1, occurrences("java.lang.Object", result));
-    assertEquals(1, occurrences("java.lang.Integer", result));
-    assertEquals(1, occurrences("java.lang.String", result));
-  }
-
-  @Test
-  public void testInstance() throws Exception {
-    String qualifiedMethodName = "com.android.tools.r8.rewrite.logarguments.TestInstance.a";
-    String result =
-        testForR8(Backend.DEX)
-            .addProgramClasses(TestInstance.class)
-            .addOptionsModification(
-                options -> options.logArgumentsFilter = ImmutableList.of(qualifiedMethodName))
-            .assumeAllMethodsMayHaveSideEffects()
-            .addDontObfuscate()
-            .noTreeShaking()
-            .run(TestInstance.class)
-            .getStdOut();
-    assertEquals(7, occurrences(qualifiedMethodName, result));
-    assertEquals(
-        7, occurrences("class com.android.tools.r8.rewrite.logarguments.TestInstance", result));
-    assertEquals(3, occurrences("(primitive)", result));
-    assertEquals(3, occurrences("(null)", result));
-    assertEquals(1, occurrences("java.lang.Object", result));
-    assertEquals(1, occurrences("java.lang.Integer", result));
-    assertEquals(1, occurrences("java.lang.String", result));
-  }
-
-  @Test
-  public void testInner() throws Exception {
-    String qualifiedMethodName = "com.android.tools.r8.rewrite.logarguments.TestInner$Inner.a";
-    AndroidApp app = compileWithR8(
-        readClasses(TestInner.class, TestInner.Inner.class),
-        options -> options.logArgumentsFilter = ImmutableList.of(qualifiedMethodName));
-    String result = runOnArt(app, TestInner.class);
-    assertEquals(7, occurrences(qualifiedMethodName, result));
-    assertEquals(
-        7, occurrences("class com.android.tools.r8.rewrite.logarguments.TestInner$Inner", result));
-    assertEquals(3, occurrences("(primitive)", result));
-    assertEquals(3, occurrences("(null)", result));
-    assertEquals(1, occurrences("java.lang.Object", result));
-    assertEquals(1, occurrences("java.lang.Integer", result));
-    assertEquals(1, occurrences("java.lang.String", result));
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/rewrite/logarguments/TestInner.java b/src/test/java/com/android/tools/r8/rewrite/logarguments/TestInner.java
deleted file mode 100644
index ad4bcbc..0000000
--- a/src/test/java/com/android/tools/r8/rewrite/logarguments/TestInner.java
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.rewrite.logarguments;
-
-public class TestInner {
-
-  public class Inner {
-
-    public int a() {
-      return 0;
-    }
-
-    public int a(int x) {
-      return x;
-    }
-
-    public int a(int x, int y) {
-      return x + y;
-    }
-
-    public Object a(Object o) {
-      return null;
-    }
-
-    public Object a(Object o1, Object o2) {
-      return null;
-    }
-  }
-
-  private Inner createInner() {
-    return new Inner();
-  }
-
-  public static void main(String[] args) {
-    Inner inner = new TestInner().createInner();
-    inner.a();
-    inner.a(1);
-    inner.a(1, 2);
-    inner.a(new Object());
-    inner.a(null);
-    inner.a(new Integer(0), "");
-    inner.a(null, null);
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/rewrite/logarguments/TestInstance.java b/src/test/java/com/android/tools/r8/rewrite/logarguments/TestInstance.java
deleted file mode 100644
index c08aa12..0000000
--- a/src/test/java/com/android/tools/r8/rewrite/logarguments/TestInstance.java
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.rewrite.logarguments;
-
-public class TestInstance {
-
-  public int a() {
-    return 0;
-  }
-
-  public int a(int x) {
-    return x;
-  }
-
-  public int a(int x, int y) {
-    return x + y;
-  }
-
-  public Object a(Object o) {
-    return null;
-  }
-
-  public Object a(Object o1, Object o2) {
-    return null;
-  }
-
-  public static void main(String[] args) {
-    TestInstance test = new TestInstance();
-    test.a();
-    test.a(1);
-    test.a(1, 2);
-    test.a(new Object());
-    test.a(null);
-    test.a(new Integer(0), "");
-    test.a(null, null);
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/rewrite/logarguments/TestStatic.java b/src/test/java/com/android/tools/r8/rewrite/logarguments/TestStatic.java
deleted file mode 100644
index d65a2f0..0000000
--- a/src/test/java/com/android/tools/r8/rewrite/logarguments/TestStatic.java
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.rewrite.logarguments;
-
-public class TestStatic {
-
-  public static int a() {
-    return 0;
-  }
-
-  public static int a(int x) {
-    return x;
-  }
-
-  public static int a(int x, int y) {
-    return x + y;
-  }
-
-  public static Object a(Object o) {
-    return null;
-  }
-
-  public static Object a(Object o1, Object o2) {
-    return null;
-  }
-
-  public static void main(String[] args) {
-    a();
-    a(1);
-    a(1, 2);
-    a(new Object());
-    a(null);
-    a(new Integer(0), "");
-    a(null, null);
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/IfMemberRuleWithUnusedParameterTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/IfMemberRuleWithUnusedParameterTest.java
index 2d871fc..4490fff 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/IfMemberRuleWithUnusedParameterTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/IfMemberRuleWithUnusedParameterTest.java
@@ -7,6 +7,7 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertTrue;
 
+import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
@@ -38,6 +39,7 @@
             "  public static void print(" + Object.class.getTypeName() + ");",
             "}",
             "-keep class " + KeptByIf.class.getTypeName())
+        .enableInliningAnnotations()
         .setMinApi(parameters)
         .compile()
         .inspect(
@@ -61,6 +63,7 @@
       print(args);
     }
 
+    @NeverInline
     public static void print(Object unused) {
       System.out.println("Hello, world!");
     }
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/inlining/IfRuleWithInlining.java b/src/test/java/com/android/tools/r8/shaking/ifrule/inlining/IfRuleWithInlining.java
index 07eb940..4f0a320 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/inlining/IfRuleWithInlining.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/inlining/IfRuleWithInlining.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.shaking.ifrule.inlining;
 
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsentIf;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
@@ -70,8 +71,10 @@
     CodeInspector inspector = new CodeInspector(app);
     ClassSubject clazzA = inspector.clazz(A.class);
     assertThat(clazzA, isPresent());
-    // A.a should not be inlined.
-    assertThat(clazzA.method("int", "a", ImmutableList.of()), isPresent());
+    // A.a may be inlined when neverInlineMethod is false.
+    assertThat(
+        clazzA.uniqueMethodWithOriginalName("a"),
+        isAbsentIf(shrinker.isR8() && !neverInlineMethod));
     assertThat(inspector.clazz(D.class), isPresent());
     ProcessResult result;
     if (shrinker == Shrinker.R8) {
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/CheckDiscardedFailuresWithIfRulesAndVerticalClassMergingTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/CheckDiscardedFailuresWithIfRulesAndVerticalClassMergingTest.java
index d422118..175b905 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/CheckDiscardedFailuresWithIfRulesAndVerticalClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/CheckDiscardedFailuresWithIfRulesAndVerticalClassMergingTest.java
@@ -6,7 +6,6 @@
 
 import static com.android.tools.r8.DiagnosticsMatcher.diagnosticType;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
 import static org.hamcrest.MatcherAssert.assertThat;
 
 import com.android.tools.r8.NoVerticalClassMerging;
@@ -16,6 +15,7 @@
 import com.android.tools.r8.errors.CheckDiscardDiagnostic;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.codeinspector.AssertUtils;
+import com.android.tools.r8.utils.codeinspector.VerticallyMergedClassesInspector;
 import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -55,13 +55,7 @@
                     "-if class " + A.class.getTypeName(), "-keep class " + C.class.getTypeName())
                 .addNoVerticalClassMergingAnnotations()
                 .addVerticallyMergedClassesInspector(
-                    inspector -> {
-                      if (enableVerticalClassMerging) {
-                        inspector.assertMergedIntoSubtype(A.class);
-                      } else {
-                        inspector.assertNoClassesMerged();
-                      }
-                    })
+                    VerticallyMergedClassesInspector::assertNoClassesMerged)
                 // Intentionally fail compilation due to -checkdiscard. This triggers the
                 // (re)running of the Enqueuer after the final round of tree shaking, for generating
                 // -whyareyoukeeping output.
@@ -81,14 +75,7 @@
                         diagnostics.assertNoMessages();
                       }
                     })
-                // TODO(b/266049507): It is questionable not to keep C when vertical class merging
-                // is enabled. A simple fix is to disable vertical class merging of classes matched
-                // by the -if condition.
-                .inspect(
-                    inspector ->
-                        assertThat(
-                            inspector.clazz(C.class),
-                            notIf(isPresent(), enableVerticalClassMerging)))
+                .inspect(inspector -> assertThat(inspector.clazz(C.class), isPresent()))
                 .run(parameters.getRuntime(), Main.class)
                 .assertSuccessWithOutputLines("B"));
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedFieldTypeTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedFieldTypeTest.java
index f28c2a5..3247e60 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedFieldTypeTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedFieldTypeTest.java
@@ -6,9 +6,7 @@
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.core.IsNot.not;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NoAccessModification;
@@ -89,6 +87,11 @@
     public void configure(R8FullTestBuilder builder) {
       super.configure(builder);
       builder
+          .addVerticallyMergedClassesInspector(
+              inspector ->
+                  inspector
+                      .applyIf(enableVerticalClassMerging, i -> i.assertMergedIntoSubtype(A.class))
+                      .assertNoOtherClassesMerged())
           .enableNeverClassInliningAnnotations()
           .enableNoRedundantFieldLoadEliminationAnnotations();
     }
@@ -116,16 +119,13 @@
       assertThat(testClassSubject, isPresent());
 
       if (enableVerticalClassMerging) {
-        // Verify that SuperTestClass has been merged into TestClass.
-        assertThat(inspector.clazz(SuperTestClass.class), not(isPresent()));
-        assertEquals(
-            "java.lang.Object", testClassSubject.getDexProgramClass().superType.toSourceString());
-
         // Verify that TestClass.field has been removed.
         assertEquals(1, testClassSubject.allFields().size());
 
-        // Verify that there was a naming conflict such that SuperTestClass.field was renamed.
-        assertNotEquals("field", testClassSubject.allFields().get(0).getFinalName());
+        // Due to the -if rule, the SuperTestClass is only merged into TestClass after the final
+        // round of tree shaking, at which point TestClass.field has already been removed.
+        // Therefore, we expect no collision to have happened.
+        assertEquals("field", testClassSubject.allFields().get(0).getFinalName());
       }
     }
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedParameterTypeTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedParameterTypeTest.java
index aa46e96..67ba97e 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedParameterTypeTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedParameterTypeTest.java
@@ -4,12 +4,11 @@
 
 package com.android.tools.r8.shaking.ifrule.verticalclassmerging;
 
-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;
-import static org.junit.Assert.assertNotEquals;
 
+import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.NoAccessModification;
 import com.android.tools.r8.NoHorizontalClassMerging;
 import com.android.tools.r8.R8FullTestBuilder;
@@ -59,6 +58,7 @@
     @NoHorizontalClassMerging
     static class SuperTestClass {
 
+      @NeverInline
       public static void method(A obj) {
         System.out.print(obj.getClass().getName());
       }
@@ -87,7 +87,14 @@
     @Override
     public void configure(R8FullTestBuilder builder) {
       super.configure(builder);
-      builder.enableNoHorizontalClassMergingAnnotations();
+      builder
+          .addVerticallyMergedClassesInspector(
+              inspector ->
+                  inspector
+                      .applyIf(enableVerticalClassMerging, i -> i.assertMergedIntoSubtype(A.class))
+                      .assertNoOtherClassesMerged())
+          .enableInliningAnnotations()
+          .enableNoHorizontalClassMergingAnnotations();
     }
 
     @Override
@@ -113,11 +120,6 @@
       assertThat(testClassSubject, isPresent());
 
       if (enableVerticalClassMerging) {
-        // Verify that SuperTestClass has been merged into TestClass.
-        assertThat(inspector.clazz(SuperTestClass.class), isAbsent());
-        assertEquals(
-            "java.lang.Object", testClassSubject.getDexProgramClass().superType.toSourceString());
-
         // Verify that TestClass.method has been removed.
         List<FoundMethodSubject> methods =
             testClassSubject.allMethods().stream()
@@ -125,8 +127,10 @@
                 .collect(Collectors.toList());
         assertEquals(1, methods.size());
 
-        // Verify that there was a naming conflict such that SuperTestClass.method was renamed.
-        assertNotEquals("method", methods.get(0).getFinalName());
+        // Due to the -if rule, the SuperTestClass is only merged into TestClass after the final
+        // round of tree shaking, at which point TestClass.method has already been removed.
+        // Therefore, we expect no collision to have happened.
+        assertEquals("method", methods.get(0).getFinalName());
       }
     }
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedReturnTypeTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedReturnTypeTest.java
index 9e98e16..57f5d05 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedReturnTypeTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/MergedReturnTypeTest.java
@@ -6,15 +6,15 @@
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.core.IsNot.not;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
 
 import com.android.tools.r8.AssumeMayHaveSideEffects;
+import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.NoAccessModification;
 import com.android.tools.r8.NoHorizontalClassMerging;
 import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.shaking.ifrule.verticalclassmerging.MergedParameterTypeTest.MergedParameterTypeWithCollisionTest.SuperTestClass;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
@@ -68,6 +68,7 @@
     static class SuperTestClass {
 
       @AssumeMayHaveSideEffects
+      @NeverInline
       public static A method() {
         return new B();
       }
@@ -96,7 +97,15 @@
     @Override
     public void configure(R8FullTestBuilder builder) {
       super.configure(builder);
-      builder.enableNoHorizontalClassMergingAnnotations().enableSideEffectAnnotations();
+      builder
+          .addVerticallyMergedClassesInspector(
+              inspector ->
+                  inspector
+                      .applyIf(enableVerticalClassMerging, i -> i.assertMergedIntoSubtype(A.class))
+                      .assertNoOtherClassesMerged())
+          .enableInliningAnnotations()
+          .enableNoHorizontalClassMergingAnnotations()
+          .enableSideEffectAnnotations();
     }
 
     @Override
@@ -122,11 +131,6 @@
       assertThat(testClassSubject, isPresent());
 
       if (enableVerticalClassMerging) {
-        // Verify that SuperTestClass has been merged into TestClass.
-        assertThat(inspector.clazz(SuperTestClass.class), not(isPresent()));
-        assertEquals(
-            "java.lang.Object", testClassSubject.getDexProgramClass().superType.toSourceString());
-
         // Verify that TestClass.method has been removed.
         List<FoundMethodSubject> methods =
             testClassSubject.allMethods().stream()
@@ -134,8 +138,10 @@
                 .collect(Collectors.toList());
         assertEquals(1, methods.size());
 
-        // Verify that there was a naming conflict such that SuperTestClass.method was renamed.
-        assertNotEquals("method", methods.get(0).getFinalName());
+        // Due to the -if rule, the SuperTestClass is only merged into TestClass after the final
+        // round of tree shaking, at which point TestClass.method has already been removed.
+        // Therefore, we expect no collision to have happened.
+        assertEquals("method", methods.get(0).getFinalName());
       }
     }
   }
diff --git a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByConditionalOnMethodTest.java b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByConditionalOnMethodTest.java
index 6a9341c..235de24 100644
--- a/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByConditionalOnMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keptgraph/KeptByConditionalOnMethodTest.java
@@ -7,6 +7,7 @@
 import static com.android.tools.r8.references.Reference.methodFromMethod;
 import static org.junit.Assert.assertEquals;
 
+import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
@@ -24,6 +25,7 @@
 public class KeptByConditionalOnMethodTest extends TestBase {
 
   public static class IfClass {
+    @NeverInline
     public void foo(String name) throws Exception {
       Class<?> clazz = Class.forName(name);
       Object object = clazz.getDeclaredConstructor().newInstance();
@@ -77,6 +79,7 @@
             .addProgramClasses(Main.class, IfClass.class, ThenClass.class)
             .addKeepMainRule(Main.class)
             .addKeepRules(ifRuleContent)
+            .enableInliningAnnotations()
             .setMinApi(parameters)
             .run(parameters.getRuntime(), Main.class, ThenClass.class.getTypeName())
             .assertSuccessWithOutput(EXPECTED)
diff --git a/src/test/java/com/android/tools/r8/startup/InstrumentationServerImpl.java b/src/test/java/com/android/tools/r8/startup/InstrumentationServerImpl.java
index 1f19f3c..11e586a 100644
--- a/src/test/java/com/android/tools/r8/startup/InstrumentationServerImpl.java
+++ b/src/test/java/com/android/tools/r8/startup/InstrumentationServerImpl.java
@@ -15,6 +15,7 @@
 
   // May be set to true by the instrumentation.
   private static boolean writeToLogcat;
+  private static boolean writeToLogcatIncludeDuplicates;
   private static String logcatTag;
 
   private final LinkedHashSet<String> lines = new LinkedHashSet<>();
@@ -25,11 +26,19 @@
     return InstrumentationServerImpl.INSTANCE;
   }
 
+  public static void addCall(String callerDescriptor, String calleeDescriptor) {
+    writeToLogcat(callerDescriptor + " -> " + calleeDescriptor);
+  }
+
   public static void addMethod(String descriptor) {
     getInstance().addLine(descriptor);
   }
 
   private void addLine(String line) {
+    if (writeToLogcat && writeToLogcatIncludeDuplicates) {
+      writeToLogcat(line);
+      return;
+    }
     synchronized (lines) {
       if (!lines.add(line)) {
         return;
@@ -54,7 +63,7 @@
     }
   }
 
-  private void writeToLogcat(String line) {
+  private static void writeToLogcat(String line) {
     android.util.Log.i(logcatTag, line);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/startup/StartupSyntheticPlacementTest.java b/src/test/java/com/android/tools/r8/startup/StartupSyntheticPlacementTest.java
index 2f41828..f391aff 100644
--- a/src/test/java/com/android/tools/r8/startup/StartupSyntheticPlacementTest.java
+++ b/src/test/java/com/android/tools/r8/startup/StartupSyntheticPlacementTest.java
@@ -162,6 +162,7 @@
             testBuilder ->
                 configureStartupOptions(
                     testBuilder, instrumentationCompileResult.inspector(), startupList))
+        .noInliningOfSynthetics()
         .setMinApi(parameters)
         .compile()
         .inspectDiagnosticMessages(
diff --git a/src/test/testbase/java/com/android/tools/r8/TestBuilder.java b/src/test/testbase/java/com/android/tools/r8/TestBuilder.java
index 84ccfd9..02d0e06 100644
--- a/src/test/testbase/java/com/android/tools/r8/TestBuilder.java
+++ b/src/test/testbase/java/com/android/tools/r8/TestBuilder.java
@@ -3,11 +3,14 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8;
 
+import static com.android.tools.r8.TestBase.descriptor;
+
 import com.android.tools.r8.ClassFileConsumer.ArchiveConsumer;
 import com.android.tools.r8.TestBase.Backend;
-import com.android.tools.r8.androidresources.AndroidResourceTestingUtils.AndroidTestResource;
 import com.android.tools.r8.debug.DebugTestConfig;
 import com.android.tools.r8.errors.Unimplemented;
+import com.android.tools.r8.transformers.ClassFileTransformer.FieldPredicate;
+import com.android.tools.r8.transformers.ClassFileTransformer.MethodPredicate;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.structural.Ordered;
@@ -144,6 +147,18 @@
     return addProgramFiles(getFilesForInnerClasses(classes));
   }
 
+  public T addInnerClassesAndStrippedOuter(Class<?> clazz) throws IOException {
+    return addProgramClassFileData(
+            TestBase.transformer(clazz)
+                .removeFields(FieldPredicate.all())
+                .removeMethods(MethodPredicate.all())
+                .removeAllAnnotations()
+                .setSuper(descriptor(Object.class))
+                .setImplements()
+                .transform())
+        .addInnerClasses(ImmutableList.of(clazz));
+  }
+
   public abstract T addLibraryFiles(Collection<Path> files);
 
   public T addLibraryClasses(Class<?>... classes) {
diff --git a/src/test/testbase/java/com/android/tools/r8/ToolHelper.java b/src/test/testbase/java/com/android/tools/r8/ToolHelper.java
index 9eea7dd..83c77e86 100644
--- a/src/test/testbase/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/testbase/java/com/android/tools/r8/ToolHelper.java
@@ -1573,16 +1573,29 @@
   public static Path getClassFileForTestClass(Class<?> clazz, TestDataSourceSet sourceSet) {
     List<String> parts = getNamePartsForTestClass(clazz);
     Path filePath = Paths.get("", parts.toArray(StringUtils.EMPTY_ARRAY));
-    Path resolve =
-        getClassPathForTestDataSourceSet(sourceSet)
-            .resolve(filePath);
-    if (!Files.exists(resolve)) {
-      resolve = sourceSet.getTestBaseClassLocation().resolve(filePath);
-      if (!Files.exists(resolve)) {
-        throw new RuntimeException("Could not find: " + resolve.toString());
-      }
+    Path resolveTestPath = getClassPathForTestDataSourceSet(sourceSet).resolve(filePath);
+    Path resolveBasePath = sourceSet.getTestBaseClassLocation().resolve(filePath);
+    boolean foundTestPath = Files.exists(resolveTestPath);
+    boolean foundBasePath = Files.exists(resolveBasePath);
+    if (resolveTestPath.equals(resolveBasePath)) {
+      throw new RuntimeException(
+          "Unexpected configuration with identical test and test-base path" + resolveTestPath);
     }
-    return resolve;
+    if (foundTestPath && foundBasePath) {
+      throw new RuntimeException(
+          "Ambiguous test file: " + resolveTestPath + " and " + resolveBasePath);
+    }
+    if (foundTestPath) {
+      return resolveTestPath;
+    }
+    if (foundBasePath) {
+      return resolveBasePath;
+    }
+    throw new RuntimeException(
+        "Could not find test class in either of paths:\n"
+            + resolveTestPath
+            + " and\n"
+            + resolveBasePath);
   }
 
   public static Collection<Path> getClassFilesForInnerClasses(Collection<Class<?>> classes)
diff --git a/third_party/binary_compatibility_tests/compiler_api_tests.tar.gz.sha1 b/third_party/binary_compatibility_tests/compiler_api_tests.tar.gz.sha1
index 32f7368..8192705 100644
--- a/third_party/binary_compatibility_tests/compiler_api_tests.tar.gz.sha1
+++ b/third_party/binary_compatibility_tests/compiler_api_tests.tar.gz.sha1
@@ -1 +1 @@
-34436ff2aee451c7d8e5c0f28193134822238d4b
\ No newline at end of file
+fa72d7e05d634554fcd59dcd30668ba824d519da
\ No newline at end of file
diff --git a/third_party/dependencies.tar.gz.sha1 b/third_party/dependencies.tar.gz.sha1
index 318fa05..adea68e 100644
--- a/third_party/dependencies.tar.gz.sha1
+++ b/third_party/dependencies.tar.gz.sha1
@@ -1 +1 @@
-b45ff19ad4f25508e04cf6c5fbff5279e4d04129
\ No newline at end of file
+9763dbe9e272504098a0f5ce55f7420f964b50f9
\ No newline at end of file
diff --git a/tools/compare_apk_sizes.py b/tools/compare_apk_sizes.py
index 5ed768b..57448f6 100755
--- a/tools/compare_apk_sizes.py
+++ b/tools/compare_apk_sizes.py
@@ -39,6 +39,11 @@
         default=False,
         action='store_true')
     result.add_option(
+        '--ignore_debug_info',
+        help='Do not include debug info in the comparison.',
+        default=False,
+        action='store_true')
+    result.add_option(
         '--report', help='Print comparison to this location instead of stdout')
     return result.parse_args()
 
@@ -66,7 +71,10 @@
     if options.no_build:
         args.extend(['--no-build'])
     args.extend(input)
-    if toolhelper.run('d8', args) is not 0:
+    extra_args = []
+    if options.ignore_debug_info:
+        extra_args.append('-Dcom.android.tools.r8.nullOutDebugInfo=1')
+    if toolhelper.run('d8', args, extra_args=extra_args) is not 0:
         raise Exception('Failed running d8')
 
 
diff --git a/tools/create_local_maven_with_dependencies.py b/tools/create_local_maven_with_dependencies.py
index 5ee21aa..b66a639 100755
--- a/tools/create_local_maven_with_dependencies.py
+++ b/tools/create_local_maven_with_dependencies.py
@@ -38,7 +38,7 @@
 # Resource shrinker dependency versions
 AAPT2_PROTO_VERSION = '8.2.0-alpha10-10154469'
 PROTOBUF_VERSION = '3.19.3'
-STUDIO_SDK_VERSION = '31.2.0-rc01'
+STUDIO_SDK_VERSION = '31.5.0-alpha04'
 
 BUILD_DEPENDENCIES = [
     'com.google.code.gson:gson:{version}'.format(version=GSON_VERSION),
diff --git a/tools/internal_test.py b/tools/internal_test.py
index ade752c..f0bdf4b 100755
--- a/tools/internal_test.py
+++ b/tools/internal_test.py
@@ -117,7 +117,7 @@
         '--java_max_memory_size=8G'
     ],
     # Ensure that all internal apps compile.
-    ['tools/run_on_app.py', '--run-all', '--out=out', '--workers', '4'],
+    ['tools/run_on_app.py', '--run-all', '--out=out', '--workers', '3'],
 ]
 
 # Command timeout, in seconds.
diff --git a/tools/run_on_app.py b/tools/run_on_app.py
index c3f8307..ffe4298 100755
--- a/tools/run_on_app.py
+++ b/tools/run_on_app.py
@@ -718,47 +718,53 @@
                 args.extend(
                     ['--desugared-lib-pg-conf-output', desugared_lib_pg_conf])
 
+            stdout_path = os.path.join(temp, 'stdout')
             stderr_path = os.path.join(temp, 'stderr')
-            with open(stderr_path, 'w') as stderr:
-                jar = None
-                main = None
-                if options.compiler_build == 'full':
-                    tool = options.compiler
-                else:
-                    assert (options.compiler_build == 'lib')
-                    tool = 'r8lib-' + options.compiler
-                if options.hash:
-                    jar = os.path.join(utils.LIBS,
-                                       'r8-' + options.hash + '.jar')
-                    main = 'com.android.tools.r8.' + options.compiler.upper()
-                if should_build(options):
-                    gradle.RunGradle([
-                        utils.GRADLE_TASK_R8LIB
-                        if tool.startswith('r8lib') else utils.GRADLE_TASK_R8
-                    ])
-                t0 = time.time()
-                exit_code = toolhelper.run(
-                    tool,
-                    args,
-                    build=False,
-                    debug=not options.disable_assertions,
-                    profile=options.profile,
-                    track_memory_file=options.track_memory_to_file,
-                    extra_args=extra_args,
-                    stdout=stdout,
-                    stderr=stderr,
-                    timeout=options.timeout,
-                    quiet=quiet,
-                    cmd_prefix=['taskset', '-c', options.cpu_list]
-                    if options.cpu_list else [],
-                    jar=jar,
-                    main=main,
-                    worker_id=worker_id)
+            with open(stdout_path, 'w') as stdout_workers:
+                with open(stderr_path, 'w') as stderr:
+                    jar = None
+                    main = None
+                    if options.compiler_build == 'full':
+                        tool = options.compiler
+                    else:
+                        assert (options.compiler_build == 'lib')
+                        tool = 'r8lib-' + options.compiler
+                    if options.hash:
+                        jar = os.path.join(utils.LIBS,
+                                           'r8-' + options.hash + '.jar')
+                        main = 'com.android.tools.r8.' + options.compiler.upper()
+                    if should_build(options):
+                        gradle.RunGradle([
+                            utils.GRADLE_TASK_R8LIB
+                            if tool.startswith('r8lib') else utils.GRADLE_TASK_R8
+                        ])
+                    t0 = time.time()
+                    exit_code = toolhelper.run(
+                        tool,
+                        args,
+                        build=False,
+                        debug=not options.disable_assertions,
+                        profile=options.profile,
+                        track_memory_file=options.track_memory_to_file,
+                        extra_args=extra_args,
+                        stdout=stdout if worker_id is None else stdout_workers,
+                        stderr=stderr,
+                        timeout=options.timeout,
+                        quiet=quiet,
+                        cmd_prefix=['taskset', '-c', options.cpu_list]
+                        if options.cpu_list else [],
+                        jar=jar,
+                        main=main,
+                        worker_id=worker_id)
+            if worker_id is not None:
+                with open(stdout_path) as stdout:
+                    stdout_text = stdout.read()
+                    print_thread(stdout_text, worker_id)
             if exit_code != 0:
                 with open(stderr_path) as stderr:
                     stderr_text = stderr.read()
                     if not quiet:
-                        print(stderr_text)
+                        print_thread(stderr_text, worker_id)
                     if 'java.lang.OutOfMemoryError' in stderr_text:
                         if not quiet:
                             print('Failure was OOM')
diff --git a/tools/thread_utils.py b/tools/thread_utils.py
index e92d2c8..397ebda 100755
--- a/tools/thread_utils.py
+++ b/tools/thread_utils.py
@@ -119,4 +119,5 @@
     if worker_id is None:
         print(msg)
     else:
-        print('WORKER %s: %s' % (worker_id, msg))
+        for line in msg.splitlines():
+            print('WORKER %s: %s' % (worker_id, line))