diff --git a/src/main/java/com/android/tools/r8/cf/LoadStoreHelper.java b/src/main/java/com/android/tools/r8/cf/LoadStoreHelper.java
index d7dbde7..9139e16 100644
--- a/src/main/java/com/android/tools/r8/cf/LoadStoreHelper.java
+++ b/src/main/java/com/android/tools/r8/cf/LoadStoreHelper.java
@@ -286,7 +286,7 @@
         return new DexItemBasedConstString(
             stackValue, computedConstant.getItem(), computedConstant.getNameComputationInfo());
       } else if (constant.isConstClass()) {
-        return new ConstClass(stackValue, constant.asConstClass().getValue());
+        return new ConstClass(stackValue, constant.asConstClass().getType());
       } else {
         throw new Unreachable("Unexpected constant value: " + value);
       }
diff --git a/src/main/java/com/android/tools/r8/graph/AccessFlags.java b/src/main/java/com/android/tools/r8/graph/AccessFlags.java
index d52e9ae..4151107 100644
--- a/src/main/java/com/android/tools/r8/graph/AccessFlags.java
+++ b/src/main/java/com/android/tools/r8/graph/AccessFlags.java
@@ -158,6 +158,10 @@
     return isSet(Constants.ACC_PUBLIC);
   }
 
+  public boolean wasPublic() {
+    return wasSet(Constants.ACC_PUBLIC);
+  }
+
   public void setPublic() {
     assert !isPrivate() && !isProtected();
     set(Constants.ACC_PUBLIC);
diff --git a/src/main/java/com/android/tools/r8/graph/AppServices.java b/src/main/java/com/android/tools/r8/graph/AppServices.java
index 5e03a38..da91743 100644
--- a/src/main/java/com/android/tools/r8/graph/AppServices.java
+++ b/src/main/java/com/android/tools/r8/graph/AppServices.java
@@ -12,10 +12,8 @@
 import com.android.tools.r8.ProgramResourceProvider;
 import com.android.tools.r8.ResourceException;
 import com.android.tools.r8.errors.CompilationError;
-import com.android.tools.r8.features.ClassToFeatureSplitMap;
 import com.android.tools.r8.graph.lens.GraphLens;
 import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.StringDiagnostic;
@@ -78,10 +76,6 @@
     assert verifyRewrittenWithLens();
     Map<FeatureSplit, List<DexType>> featureSplitListMap = services.get(serviceType);
     if (featureSplitListMap == null) {
-      assert false
-          : "Unexpected attempt to get service implementations for non-service type `"
-              + serviceType.toSourceString()
-              + "`";
       return ImmutableList.of();
     }
     ImmutableList.Builder<DexType> builder = ImmutableList.builder();
@@ -91,43 +85,8 @@
     return builder.build();
   }
 
-  public boolean hasServiceImplementationsInFeature(
-      AppView<? extends AppInfoWithLiveness> appView, DexType serviceType) {
-    ClassToFeatureSplitMap classToFeatureSplitMap = appView.appInfo().getClassToFeatureSplitMap();
-    if (classToFeatureSplitMap.isEmpty()) {
-      return false;
-    }
-    Map<FeatureSplit, List<DexType>> featureImplementations = services.get(serviceType);
-    if (featureImplementations == null || featureImplementations.isEmpty()) {
-      assert false
-          : "Unexpected attempt to get service implementations for non-service type `"
-              + serviceType.toSourceString()
-              + "`";
-      return true;
-    }
-    if (featureImplementations.keySet().stream().anyMatch(feature -> !feature.isBase())) {
-      return true;
-    }
-    // All service implementations are in one of the base splits.
-    assert featureImplementations.size() <= 2;
-    // Check if service is defined feature
-    DexProgramClass serviceClass = appView.definitionForProgramType(serviceType);
-    if (serviceClass != null && classToFeatureSplitMap.isInFeature(serviceClass, appView)) {
-      return true;
-    }
-    for (Entry<FeatureSplit, List<DexType>> entry : featureImplementations.entrySet()) {
-      FeatureSplit feature = entry.getKey();
-      assert feature.isBase();
-      List<DexType> implementationTypes = entry.getValue();
-      for (DexType implementationType : implementationTypes) {
-        DexProgramClass implementationClass = appView.definitionForProgramType(implementationType);
-        if (implementationClass != null
-            && classToFeatureSplitMap.isInFeature(implementationClass, appView)) {
-          return true;
-        }
-      }
-    }
-    return false;
+  public Map<FeatureSplit, List<DexType>> serviceImplementationsByFeatureFor(DexType serviceType) {
+    return services.get(serviceType);
   }
 
   public AppServices rewrittenWithLens(GraphLens graphLens, Timing timing) {
diff --git a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
index a7e37bc..3c056f8 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -249,6 +249,8 @@
 
   public final DexString runtimeExceptionDescriptor = createString("Ljava/lang/RuntimeException;");
   public final DexString assertionErrorDescriptor = createString("Ljava/lang/AssertionError;");
+  public final DexString noSuchElementExceptionDescriptor =
+      createString("Ljava/util/NoSuchElementException;");
   public final DexString charSequenceDescriptor = createString("Ljava/lang/CharSequence;");
   public final DexString charSequenceArrayDescriptor = createString("[Ljava/lang/CharSequence;");
   public final DexString stringDescriptor = createString("Ljava/lang/String;");
@@ -575,6 +577,11 @@
   public final DexType runtimeExceptionType = createStaticallyKnownType(runtimeExceptionDescriptor);
   public final DexType assertionErrorType = createStaticallyKnownType(assertionErrorDescriptor);
   public final DexType throwableType = createStaticallyKnownType(throwableDescriptor);
+  public final DexType noSuchElementExceptionType =
+      createStaticallyKnownType(noSuchElementExceptionDescriptor);
+  public final DexMethod noSuchElementExceptionInit =
+      createInstanceInitializer(noSuchElementExceptionType);
+
   public final DexType illegalAccessErrorType =
       createStaticallyKnownType(illegalAccessErrorDescriptor);
   public final DexType illegalArgumentExceptionType =
@@ -870,6 +877,7 @@
 
   public final ObjectMethodsMembers objectMethodsMembers = new ObjectMethodsMembers();
   public final ServiceLoaderMethods serviceLoaderMethods = new ServiceLoaderMethods();
+  public final IteratorMethods iteratorMethods = new IteratorMethods();
   public final StringConcatFactoryMembers stringConcatFactoryMembers =
       new StringConcatFactoryMembers();
 
@@ -2659,6 +2667,12 @@
     }
   }
 
+  public class IteratorMethods {
+    public final DexMethod hasNext =
+        createMethod(iteratorType, createProto(booleanType), "hasNext");
+    public final DexMethod next = createMethod(iteratorType, createProto(objectType), "next");
+  }
+
   private static <T extends DexItem> T canonicalize(Map<T, T> map, T item) {
     assert item != null;
     assert !DexItemFactory.isInternalSentinel(item);
diff --git a/src/main/java/com/android/tools/r8/graph/GenericSignatureContextBuilder.java b/src/main/java/com/android/tools/r8/graph/GenericSignatureContextBuilder.java
index 1a3e78f..0cc9356 100644
--- a/src/main/java/com/android/tools/r8/graph/GenericSignatureContextBuilder.java
+++ b/src/main/java/com/android/tools/r8/graph/GenericSignatureContextBuilder.java
@@ -249,6 +249,9 @@
       return typeParameterContext;
     }
     TypeParameterSubstitutions methodFormals = this.formalsInfo.get(reference);
+    if (methodFormals == null) {
+      return typeParameterContext;
+    }
     if (clazz != null && !prunedHere) {
       DexEncodedMethod method = clazz.lookupMethod(reference.asDexMethod());
       prunedHere =
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/equivalence/BasicBlockBehavioralSubsumption.java b/src/main/java/com/android/tools/r8/ir/analysis/equivalence/BasicBlockBehavioralSubsumption.java
index 35619e1..1da7136 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/equivalence/BasicBlockBehavioralSubsumption.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/equivalence/BasicBlockBehavioralSubsumption.java
@@ -282,7 +282,7 @@
       }
       ConstClass constClassInstruction = instruction.asConstClass();
       ConstClass otherConstClassInstruction = other.asConstClass();
-      return constClassInstruction.getValue() == otherConstClassInstruction.getValue();
+      return constClassInstruction.getType() == otherConstClassInstruction.getType();
     }
 
     if (instruction.isConstNumber()) {
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 d5f90ba..da5c7fc 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
@@ -35,6 +35,7 @@
 import com.android.tools.r8.ir.conversion.PostMethodProcessor;
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackDelayed;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.KeepFieldInfo;
 import com.android.tools.r8.threading.ThreadingModule;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.SetUtils;
@@ -126,7 +127,8 @@
   private void markFieldAsDead(DexEncodedField field) {
     // Don't mark pinned fields as dead, since they need to remain in the app even if all reads and
     // writes are removed.
-    if (appView.appInfo().isPinned(field)) {
+    KeepFieldInfo keepInfo = appView.getKeepInfo().getFieldInfo(field, appView);
+    if (!keepInfo.isOptimizationAllowed(appView.options())) {
       assert field.getType().isAlwaysNull(appView);
     } else {
       getSimpleFeedback().markFieldAsDead(field);
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/DataflowAnalysisResult.java b/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/DataflowAnalysisResult.java
index 73eeb55..550019d 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/DataflowAnalysisResult.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/DataflowAnalysisResult.java
@@ -44,6 +44,10 @@
       this.blockExitStates = blockExitStates;
     }
 
+    public StateType getBlockExitState(Block block) {
+      return blockExitStates.get(block);
+    }
+
     public StateType join(AppView<?> appView) {
       StateType result = null;
       for (StateType blockExitState : blockExitStates.values()) {
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/path/PathConstraintAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/path/PathConstraintAnalysis.java
new file mode 100644
index 0000000..dd5b2c9
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/path/PathConstraintAnalysis.java
@@ -0,0 +1,47 @@
+// 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.ir.analysis.path;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.ir.analysis.framework.intraprocedural.IntraproceduralDataflowAnalysis;
+import com.android.tools.r8.ir.analysis.path.state.PathConstraintAnalysisState;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+
+/**
+ * An analysis that computes the set of active path constraints for each program point. Each path
+ * constraint is an expression where only the arguments of the current method are allowed as open
+ * variables.
+ *
+ * <p>Consider the following example.
+ *
+ * <pre>
+ *   static Object Foo(Object o, int flags) {
+ *     if ((flags & 1) != 0) {
+ *       o = DEFAULT_VALUE;
+ *     }
+ *     return o;
+ *   }
+ * </pre>
+ *
+ * <ul>
+ *   <li>The path constraint for the entry block is the empty set, since control flow
+ *       unconditionally hits this block.
+ *   <li>The path constraint for the block containing {@code o = DEFAULT_VALUE} is [(flags & 1) !=
+ *       0].
+ *   <li>The path constraint for the (empty) ELSE block is [(flags & 1) == 0].
+ *   <li>The path constraint for the return block is the empty set.
+ * </ul>
+ */
+public class PathConstraintAnalysis
+    extends IntraproceduralDataflowAnalysis<PathConstraintAnalysisState> {
+
+  public PathConstraintAnalysis(AppView<AppInfoWithLiveness> appView, IRCode code) {
+    super(
+        appView,
+        PathConstraintAnalysisState.bottom(),
+        code,
+        new PathConstraintAnalysisTransferFunction(appView.abstractValueFactory()));
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/path/PathConstraintAnalysisTransferFunction.java b/src/main/java/com/android/tools/r8/ir/analysis/path/PathConstraintAnalysisTransferFunction.java
new file mode 100644
index 0000000..6b86310
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/path/PathConstraintAnalysisTransferFunction.java
@@ -0,0 +1,70 @@
+// 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.ir.analysis.path;
+
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.framework.intraprocedural.AbstractTransferFunction;
+import com.android.tools.r8.ir.analysis.framework.intraprocedural.TransferFunctionResult;
+import com.android.tools.r8.ir.analysis.path.state.PathConstraintAnalysisState;
+import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+import com.android.tools.r8.ir.code.BasicBlock;
+import com.android.tools.r8.ir.code.If;
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.optimize.argumentpropagation.computation.ComputationTreeBuilder;
+import com.android.tools.r8.optimize.argumentpropagation.computation.ComputationTreeNode;
+
+public class PathConstraintAnalysisTransferFunction
+    implements AbstractTransferFunction<BasicBlock, Instruction, PathConstraintAnalysisState> {
+
+  private final ComputationTreeBuilder computationTreeBuilder;
+
+  PathConstraintAnalysisTransferFunction(AbstractValueFactory abstractValueFactory) {
+    computationTreeBuilder = new ComputationTreeBuilder(abstractValueFactory);
+  }
+
+  @Override
+  public TransferFunctionResult<PathConstraintAnalysisState> apply(
+      Instruction instruction, PathConstraintAnalysisState state) {
+    // Instructions normally to not change the current path constraint.
+    //
+    // One exception is when information can be deduced from throwing instructions that succeed.
+    // For example, if the instruction `arg.method()` succeeds then it can be inferred that the
+    // subsequent instruction is only executed if `arg != null`.
+    return state;
+  }
+
+  @Override
+  public PathConstraintAnalysisState computeBlockEntryState(
+      BasicBlock block, BasicBlock predecessor, PathConstraintAnalysisState predecessorExitState) {
+    if (predecessorExitState.isUnknown()) {
+      return predecessorExitState;
+    }
+    // We currently only amend the path constraint in presence of if-instructions.
+    If theIf = predecessor.exit().asIf();
+    if (theIf != null) {
+      // TODO(b/302281503): Ensure the computed computation tree is cached in the builder so that
+      //  we do not rebuild the tree over-and-over again during the execution of this (worklist)
+      //  analysis.
+      ComputationTreeNode newPathConstraint = computationTreeBuilder.buildComputationTree(theIf);
+      if (!newPathConstraint.isUnknown()) {
+        boolean negate = block != theIf.getTrueTarget();
+        return predecessorExitState.add(newPathConstraint, negate);
+      }
+    }
+    return predecessorExitState;
+  }
+
+  @Override
+  public PathConstraintAnalysisState computeExceptionalBlockEntryState(
+      BasicBlock block,
+      DexType guard,
+      BasicBlock throwBlock,
+      Instruction throwInstruction,
+      PathConstraintAnalysisState throwState) {
+    // For the purpose of this analysis we don't (?) care much about the path constraints for blocks
+    // that are reached from catch handlers. Therefore, we currently set the state to UNKNOWN for
+    // all blocks that can be reached from a catch handler.
+    return PathConstraintAnalysisState.unknown();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/path/state/BottomPathConstraintAnalysisState.java b/src/main/java/com/android/tools/r8/ir/analysis/path/state/BottomPathConstraintAnalysisState.java
new file mode 100644
index 0000000..6ed306f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/path/state/BottomPathConstraintAnalysisState.java
@@ -0,0 +1,38 @@
+// 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.ir.analysis.path.state;
+
+import com.android.tools.r8.optimize.argumentpropagation.computation.ComputationTreeNode;
+
+public class BottomPathConstraintAnalysisState extends PathConstraintAnalysisState {
+
+  private static final BottomPathConstraintAnalysisState INSTANCE =
+      new BottomPathConstraintAnalysisState();
+
+  private BottomPathConstraintAnalysisState() {}
+
+  static BottomPathConstraintAnalysisState getInstance() {
+    return INSTANCE;
+  }
+
+  @Override
+  public PathConstraintAnalysisState add(ComputationTreeNode pathConstraint, boolean negate) {
+    return ConcretePathConstraintAnalysisState.create(pathConstraint, negate);
+  }
+
+  @Override
+  public boolean isBottom() {
+    return true;
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    return this == other;
+  }
+
+  @Override
+  public int hashCode() {
+    return System.identityHashCode(this);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/path/state/ConcretePathConstraintAnalysisState.java b/src/main/java/com/android/tools/r8/ir/analysis/path/state/ConcretePathConstraintAnalysisState.java
new file mode 100644
index 0000000..361ed99
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/path/state/ConcretePathConstraintAnalysisState.java
@@ -0,0 +1,160 @@
+// 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.ir.analysis.path.state;
+
+import com.android.tools.r8.optimize.argumentpropagation.computation.ComputationTreeNode;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * Represents a non-trivial (neither bottom nor top) path constraint that must be satisfied to reach
+ * a given program point.
+ *
+ * <p>The state should be interpreted as follows:
+ *
+ * <ol>
+ *   <li>If a path constraint is BOTH in {@link #pathConstraints} AND {@link
+ *       #negatedPathConstraints} then the path constraint should be IGNORED.
+ *   <li>If a path constraint is ONLY in {@link #pathConstraints} then the current program point can
+ *       only be reached if the path constraint is satisfied.
+ *   <li>If a path constraint is ONLY in {@link #negatedPathConstraints} then the current program
+ *       point can only be reached if the path constraint is NOT satisfied.
+ * </ol>
+ *
+ * <p>Example: In the below example, when entering the IF-THEN branch, we add the path constraint
+ * [(flags & 1) != 0] to {@link #pathConstraints}. When entering the (empty) IF-ELSE branch, we add
+ * the same path constraint to {@link #negatedPathConstraints}. When reaching the return block, the
+ * two path constraint states are joined, resulting in the state where {@link #pathConstraints} and
+ * {@link #negatedPathConstraints} both contains the constraint [(flags & 1) != 0].
+ *
+ * <pre>
+ *   static Object Foo(Object o, int flags) {
+ *     if ((flags & 1) != 0) {
+ *       o = DEFAULT_VALUE;
+ *     }
+ *     return o;
+ *   }
+ * </pre>
+ */
+public class ConcretePathConstraintAnalysisState extends PathConstraintAnalysisState {
+
+  private final Set<ComputationTreeNode> pathConstraints;
+  private final Set<ComputationTreeNode> negatedPathConstraints;
+
+  ConcretePathConstraintAnalysisState(
+      Set<ComputationTreeNode> pathConstraints, Set<ComputationTreeNode> negatedPathConstraints) {
+    this.pathConstraints = pathConstraints;
+    this.negatedPathConstraints = negatedPathConstraints;
+  }
+
+  static ConcretePathConstraintAnalysisState create(
+      ComputationTreeNode pathConstraint, boolean negate) {
+    Set<ComputationTreeNode> pathConstraints = Collections.singleton(pathConstraint);
+    if (negate) {
+      return new ConcretePathConstraintAnalysisState(Collections.emptySet(), pathConstraints);
+    } else {
+      return new ConcretePathConstraintAnalysisState(pathConstraints, Collections.emptySet());
+    }
+  }
+
+  @Override
+  public PathConstraintAnalysisState add(ComputationTreeNode pathConstraint, boolean negate) {
+    if (negate) {
+      if (negatedPathConstraints.contains(pathConstraint)) {
+        return this;
+      }
+      return new ConcretePathConstraintAnalysisState(
+          pathConstraints, add(pathConstraint, negatedPathConstraints));
+    } else {
+      if (pathConstraints.contains(pathConstraint)) {
+        return this;
+      }
+      return new ConcretePathConstraintAnalysisState(
+          add(pathConstraint, pathConstraints), negatedPathConstraints);
+    }
+  }
+
+  private static Set<ComputationTreeNode> add(
+      ComputationTreeNode pathConstraint, Set<ComputationTreeNode> pathConstraints) {
+    if (pathConstraints.isEmpty()) {
+      return Collections.singleton(pathConstraint);
+    }
+    assert !pathConstraints.contains(pathConstraint);
+    Set<ComputationTreeNode> newPathConstraints = new HashSet<>(pathConstraints);
+    newPathConstraints.add(pathConstraint);
+    return newPathConstraints;
+  }
+
+  public Set<ComputationTreeNode> getPathConstraints() {
+    return pathConstraints;
+  }
+
+  public Set<ComputationTreeNode> getNegatedPathConstraints() {
+    return negatedPathConstraints;
+  }
+
+  @Override
+  public boolean isConcrete() {
+    return true;
+  }
+
+  @Override
+  public ConcretePathConstraintAnalysisState asConcreteState() {
+    return this;
+  }
+
+  public ConcretePathConstraintAnalysisState join(ConcretePathConstraintAnalysisState other) {
+    Set<ComputationTreeNode> newPathConstraints = join(pathConstraints, other.pathConstraints);
+    Set<ComputationTreeNode> newNegatedPathConstraints =
+        join(negatedPathConstraints, other.negatedPathConstraints);
+    if (identical(newPathConstraints, newNegatedPathConstraints)) {
+      return this;
+    }
+    if (other.identical(newPathConstraints, newNegatedPathConstraints)) {
+      return other;
+    }
+    return new ConcretePathConstraintAnalysisState(newPathConstraints, newNegatedPathConstraints);
+  }
+
+  private static Set<ComputationTreeNode> join(
+      Set<ComputationTreeNode> pathConstraints, Set<ComputationTreeNode> otherPathConstraints) {
+    if (pathConstraints.isEmpty()) {
+      return otherPathConstraints;
+    }
+    if (otherPathConstraints.isEmpty()) {
+      return pathConstraints;
+    }
+    Set<ComputationTreeNode> newPathConstraints =
+        new HashSet<>(pathConstraints.size() + otherPathConstraints.size());
+    newPathConstraints.addAll(pathConstraints);
+    newPathConstraints.addAll(otherPathConstraints);
+    return newPathConstraints;
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (this == obj) {
+      return true;
+    }
+    if (!(obj instanceof ConcretePathConstraintAnalysisState)) {
+      return false;
+    }
+    ConcretePathConstraintAnalysisState state = (ConcretePathConstraintAnalysisState) obj;
+    return pathConstraints.equals(state.pathConstraints)
+        && negatedPathConstraints.equals(state.negatedPathConstraints);
+  }
+
+  public boolean identical(
+      Set<ComputationTreeNode> pathConstraints, Set<ComputationTreeNode> negatedPathConstraints) {
+    return this.pathConstraints == pathConstraints
+        && this.negatedPathConstraints == negatedPathConstraints;
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(pathConstraints, negatedPathConstraints);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/path/state/PathConstraintAnalysisState.java b/src/main/java/com/android/tools/r8/ir/analysis/path/state/PathConstraintAnalysisState.java
new file mode 100644
index 0000000..fea03cc
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/path/state/PathConstraintAnalysisState.java
@@ -0,0 +1,55 @@
+// 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.ir.analysis.path.state;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.ir.analysis.framework.intraprocedural.AbstractState;
+import com.android.tools.r8.optimize.argumentpropagation.computation.ComputationTreeNode;
+
+public abstract class PathConstraintAnalysisState
+    extends AbstractState<PathConstraintAnalysisState> {
+
+  public static BottomPathConstraintAnalysisState bottom() {
+    return BottomPathConstraintAnalysisState.getInstance();
+  }
+
+  public static UnknownPathConstraintAnalysisState unknown() {
+    return UnknownPathConstraintAnalysisState.getInstance();
+  }
+
+  public abstract PathConstraintAnalysisState add(
+      ComputationTreeNode pathConstraint, boolean negate);
+
+  public boolean isBottom() {
+    return false;
+  }
+
+  public boolean isConcrete() {
+    return false;
+  }
+
+  public boolean isUnknown() {
+    return false;
+  }
+
+  @Override
+  public PathConstraintAnalysisState asAbstractState() {
+    return this;
+  }
+
+  public ConcretePathConstraintAnalysisState asConcreteState() {
+    return null;
+  }
+
+  @Override
+  public PathConstraintAnalysisState join(AppView<?> appView, PathConstraintAnalysisState other) {
+    if (isBottom() || other.isUnknown()) {
+      return other;
+    }
+    if (other.isBottom() || isUnknown()) {
+      return this;
+    }
+    return asConcreteState().join(other.asConcreteState());
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/path/state/UnknownPathConstraintAnalysisState.java b/src/main/java/com/android/tools/r8/ir/analysis/path/state/UnknownPathConstraintAnalysisState.java
new file mode 100644
index 0000000..17684e6
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/path/state/UnknownPathConstraintAnalysisState.java
@@ -0,0 +1,38 @@
+// 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.ir.analysis.path.state;
+
+import com.android.tools.r8.optimize.argumentpropagation.computation.ComputationTreeNode;
+
+public class UnknownPathConstraintAnalysisState extends PathConstraintAnalysisState {
+
+  private static final UnknownPathConstraintAnalysisState INSTANCE =
+      new UnknownPathConstraintAnalysisState();
+
+  private UnknownPathConstraintAnalysisState() {}
+
+  static UnknownPathConstraintAnalysisState getInstance() {
+    return INSTANCE;
+  }
+
+  @Override
+  public PathConstraintAnalysisState add(ComputationTreeNode pathConstraint, boolean negate) {
+    return this;
+  }
+
+  @Override
+  public boolean isUnknown() {
+    return true;
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    return this == other;
+  }
+
+  @Override
+  public int hashCode() {
+    return System.identityHashCode(this);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/proto/RawMessageInfoDecoder.java b/src/main/java/com/android/tools/r8/ir/analysis/proto/RawMessageInfoDecoder.java
index ef36cea..226e172 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/proto/RawMessageInfoDecoder.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/proto/RawMessageInfoDecoder.java
@@ -202,7 +202,7 @@
       Instruction definition = root.definition;
       if (definition.isConstClass()) {
         ConstClass constClass = definition.asConstClass();
-        return new ProtoTypeObject(constClass.getValue());
+        return new ProtoTypeObject(constClass.getType());
       } else if (definition.isConstString()) {
         ConstString constString = definition.asConstString();
         DexEncodedField field =
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java
index cc8cfb9..b83c92e 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java
@@ -9,9 +9,11 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.lens.GraphLens;
 import com.android.tools.r8.ir.analysis.value.objectstate.ObjectState;
+import com.android.tools.r8.optimize.argumentpropagation.computation.ComputationTreeNode;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import java.util.function.IntFunction;
 
-public abstract class AbstractValue {
+public abstract class AbstractValue implements ComputationTreeNode {
 
   public static BottomValue bottom() {
     return BottomValue.getInstance();
@@ -21,6 +23,12 @@
     return UnknownValue.getInstance();
   }
 
+  @Override
+  public AbstractValue evaluate(
+      IntFunction<AbstractValue> argumentAssignment, AbstractValueFactory abstractValueFactory) {
+    return this;
+  }
+
   public abstract boolean isNonTrivial();
 
   public boolean isSingleBoolean() {
@@ -241,6 +249,7 @@
     return false;
   }
 
+  @Override
   public boolean isUnknown() {
     return false;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValueFactory.java b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValueFactory.java
index 27534c2..cf6875d 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValueFactory.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValueFactory.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.ir.analysis.value.objectstate.KnownLengthArrayState;
 import com.android.tools.r8.ir.analysis.value.objectstate.ObjectState;
 import com.android.tools.r8.naming.dexitembasedstring.NameComputationInfo;
+import com.android.tools.r8.utils.BooleanUtils;
 import java.util.concurrent.ConcurrentHashMap;
 
 public class AbstractValueFactory {
@@ -102,6 +103,10 @@
         : new SingleStatefulFieldValue(field, state);
   }
 
+  public SingleNumberValue createSingleBooleanValue(boolean value) {
+    return createUncheckedSingleNumberValue(BooleanUtils.intValue(value));
+  }
+
   public SingleNumberValue createSingleNumberValue(long value, TypeElement type) {
     assert type.isPrimitiveType();
     return createUncheckedSingleNumberValue(value);
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/arithmetic/AbstractCalculator.java b/src/main/java/com/android/tools/r8/ir/analysis/value/arithmetic/AbstractCalculator.java
index 9b37213..92e4816 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/arithmetic/AbstractCalculator.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/arithmetic/AbstractCalculator.java
@@ -7,12 +7,18 @@
 
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
 import com.android.tools.r8.utils.BitUtils;
 
 public class AbstractCalculator {
 
   public static AbstractValue andIntegers(
       AppView<?> appView, AbstractValue left, AbstractValue right) {
+    return andIntegers(appView.abstractValueFactory(), left, right);
+  }
+
+  public static AbstractValue andIntegers(
+      AbstractValueFactory abstractValueFactory, AbstractValue left, AbstractValue right) {
     if (left.isZero()) {
       return left;
     }
@@ -22,25 +28,21 @@
     if (left.isSingleNumberValue() && right.isSingleNumberValue()) {
       int result =
           left.asSingleNumberValue().getIntValue() & right.asSingleNumberValue().getIntValue();
-      return appView.abstractValueFactory().createUncheckedSingleNumberValue(result);
+      return abstractValueFactory.createUncheckedSingleNumberValue(result);
     }
     if (left.hasDefinitelySetAndUnsetBitsInformation()
         && right.hasDefinitelySetAndUnsetBitsInformation()) {
-      return appView
-          .abstractValueFactory()
-          .createDefiniteBitsNumberValue(
-              left.getDefinitelySetIntBits() & right.getDefinitelySetIntBits(),
-              left.getDefinitelyUnsetIntBits() | right.getDefinitelyUnsetIntBits());
+      return abstractValueFactory.createDefiniteBitsNumberValue(
+          left.getDefinitelySetIntBits() & right.getDefinitelySetIntBits(),
+          left.getDefinitelyUnsetIntBits() | right.getDefinitelyUnsetIntBits());
     }
     if (left.hasDefinitelySetAndUnsetBitsInformation()) {
-      return appView
-          .abstractValueFactory()
-          .createDefiniteBitsNumberValue(0, left.getDefinitelyUnsetIntBits());
+      return abstractValueFactory.createDefiniteBitsNumberValue(
+          0, left.getDefinitelyUnsetIntBits());
     }
     if (right.hasDefinitelySetAndUnsetBitsInformation()) {
-      return appView
-          .abstractValueFactory()
-          .createDefiniteBitsNumberValue(0, right.getDefinitelyUnsetIntBits());
+      return abstractValueFactory.createDefiniteBitsNumberValue(
+          0, right.getDefinitelyUnsetIntBits());
     }
     return AbstractValue.unknown();
   }
diff --git a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
index 2efeeae..d1fc0ed 100644
--- a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
@@ -229,30 +229,6 @@
     return dstIterator;
   }
 
-  @Override
-  public BasicBlock addThrowingInstructionToPossiblyThrowingBlock(
-      IRCode code,
-      ListIterator<BasicBlock> blockIterator,
-      Instruction instruction,
-      InternalOptions options) {
-    if (block.hasCatchHandlers()) {
-      BasicBlock splitBlock = split(code, blockIterator, false);
-      splitBlock.listIterator(code).add(instruction);
-      assert !block.hasCatchHandlers();
-      assert splitBlock.hasCatchHandlers();
-      block.copyCatchHandlers(code, blockIterator, splitBlock, options);
-      if (blockIterator != null) {
-        while (IteratorUtils.peekPrevious(blockIterator) != splitBlock) {
-          blockIterator.previous();
-        }
-      }
-      return splitBlock;
-    } else {
-      add(instruction);
-      return null;
-    }
-  }
-
   /**
    * Replaces the last instruction returned by {@link #next} or {@link #previous} with the specified
    * instruction.
diff --git a/src/main/java/com/android/tools/r8/ir/code/ConstClass.java b/src/main/java/com/android/tools/r8/ir/code/ConstClass.java
index 72721d2..fe1c8b3 100644
--- a/src/main/java/com/android/tools/r8/ir/code/ConstClass.java
+++ b/src/main/java/com/android/tools/r8/ir/code/ConstClass.java
@@ -68,17 +68,13 @@
 
   public static ConstClass copyOf(Value newValue, ConstClass original) {
     assert newValue != original.outValue();
-    return new ConstClass(newValue, original.getValue());
+    return new ConstClass(newValue, original.getType());
   }
 
   public Value dest() {
     return outValue;
   }
 
-  public DexType getValue() {
-    return clazz;
-  }
-
   @Override
   public void buildDex(DexBuilder builder) {
     int dest = builder.allocatedRegister(dest(), getNumber());
@@ -123,7 +119,7 @@
       ProgramMethod context,
       AbstractValueSupplier abstractValueSupplier,
       SideEffectAssumption assumption) {
-    DexType baseType = getValue().toBaseType(appView.dexItemFactory());
+    DexType baseType = getType().toBaseType(appView.dexItemFactory());
     if (baseType.isPrimitiveType()) {
       return false;
     }
diff --git a/src/main/java/com/android/tools/r8/ir/code/ConstNumber.java b/src/main/java/com/android/tools/r8/ir/code/ConstNumber.java
index 634225b..95df669 100644
--- a/src/main/java/com/android/tools/r8/ir/code/ConstNumber.java
+++ b/src/main/java/com/android/tools/r8/ir/code/ConstNumber.java
@@ -339,13 +339,16 @@
   @Override
   public AbstractValue getAbstractValue(
       AppView<?> appView, ProgramMethod context, AbstractValueSupplier abstractValueSupplier) {
+    return getAbstractValue(appView.abstractValueFactory());
+  }
+
+  public AbstractValue getAbstractValue(AbstractValueFactory abstractValueFactory) {
     if (outValue.hasLocalInfo()) {
       return AbstractValue.unknown();
     }
-    AbstractValueFactory factory = appView.abstractValueFactory();
     return getOutType().isReferenceType()
-        ? factory.createNullValue(getOutType())
-        : factory.createSingleNumberValue(value, getOutType());
+        ? abstractValueFactory.createNullValue(getOutType())
+        : abstractValueFactory.createSingleNumberValue(value, getOutType());
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/code/ConstantValueUtils.java b/src/main/java/com/android/tools/r8/ir/code/ConstantValueUtils.java
index 9855ee6..381f4b4 100644
--- a/src/main/java/com/android/tools/r8/ir/code/ConstantValueUtils.java
+++ b/src/main/java/com/android/tools/r8/ir/code/ConstantValueUtils.java
@@ -24,7 +24,7 @@
     }
 
     if (alias.definition.isConstClass()) {
-      return alias.definition.asConstClass().getValue();
+      return alias.definition.asConstClass().getType();
     }
 
     if (alias.definition.isInvokeStatic()) {
diff --git a/src/main/java/com/android/tools/r8/ir/code/IRCode.java b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
index 5077746..307acdf 100644
--- a/src/main/java/com/android/tools/r8/ir/code/IRCode.java
+++ b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
@@ -1109,7 +1109,7 @@
     return new IRCodeInstructionIterator(this);
   }
 
-  public InstructionListIterator instructionListIterator() {
+  public IRCodeInstructionListIterator instructionListIterator() {
     return new IRCodeInstructionListIterator(this);
   }
 
@@ -1241,6 +1241,14 @@
     return createNumberConstant(Float.floatToIntBits(value), TypeElement.getFloat(), local);
   }
 
+  public ConstNumber createBooleanConstant(boolean value) {
+    return createBooleanConstant(value, null);
+  }
+
+  public ConstNumber createBooleanConstant(boolean value, DebugLocalInfo local) {
+    return createNumberConstant(value ? 1 : 0, TypeElement.getInt(), local);
+  }
+
   public ConstNumber createIntConstant(int value) {
     return createIntConstant(value, null);
   }
diff --git a/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java
index 6b33cca..13e393a 100644
--- a/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java
@@ -35,6 +35,10 @@
     this.instructionIterator = blockIterator.next().listIterator(code);
   }
 
+  public IRCode getCode() {
+    return code;
+  }
+
   @Override
   public Value insertConstNumberInstruction(
       IRCode code, InternalOptions options, long value, TypeElement type) {
@@ -244,14 +248,11 @@
         code, blockIterator, instructionsToAdd, options);
   }
 
-  @Override
-  public BasicBlock addThrowingInstructionToPossiblyThrowingBlock(
-      IRCode code,
-      ListIterator<BasicBlock> blockIterator,
-      Instruction instruction,
-      InternalOptions options) {
-    return instructionIterator.addThrowingInstructionToPossiblyThrowingBlock(
-        code, blockIterator, instruction, options);
+  public void addPossiblyThrowingInstructionsToPossiblyThrowingBlock(
+      Collection<? extends Instruction> instructionsToAdd, InternalOptions options) {
+    instructionIterator =
+        instructionIterator.addPossiblyThrowingInstructionsToPossiblyThrowingBlock(
+            code, blockIterator, instructionsToAdd, options);
   }
 
   @Override
@@ -259,6 +260,13 @@
     instructionIterator.remove();
   }
 
+  public void removeRemainingInBlockIgnoreOutValue() {
+    while (instructionIterator.hasNext()) {
+      instructionIterator.next();
+      instructionIterator.removeInstructionIgnoreOutValue();
+    }
+  }
+
   @Override
   public void set(Instruction instruction) {
     instructionIterator.set(instruction);
diff --git a/src/main/java/com/android/tools/r8/ir/code/IfType.java b/src/main/java/com/android/tools/r8/ir/code/IfType.java
index eef3f3b..5babdae 100644
--- a/src/main/java/com/android/tools/r8/ir/code/IfType.java
+++ b/src/main/java/com/android/tools/r8/ir/code/IfType.java
@@ -4,14 +4,63 @@
 package com.android.tools.r8.ir.code;
 
 import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+import com.android.tools.r8.ir.analysis.value.SingleNumberValue;
 
 public enum IfType {
-  EQ,
-  GE,
-  GT,
-  LE,
-  LT,
-  NE;
+  EQ {
+    @Override
+    public AbstractValue evaluate(
+        SingleNumberValue operand, AbstractValueFactory abstractValueFactory) {
+      return abstractValueFactory.createSingleBooleanValue(operand.getValue() == 0);
+    }
+  },
+  GE {
+    @Override
+    public AbstractValue evaluate(
+        SingleNumberValue operand, AbstractValueFactory abstractValueFactory) {
+      return abstractValueFactory.createSingleBooleanValue(operand.getValue() >= 0);
+    }
+  },
+  GT {
+    @Override
+    public AbstractValue evaluate(
+        SingleNumberValue operand, AbstractValueFactory abstractValueFactory) {
+      return abstractValueFactory.createSingleBooleanValue(operand.getValue() > 0);
+    }
+  },
+  LE {
+    @Override
+    public AbstractValue evaluate(
+        SingleNumberValue operand, AbstractValueFactory abstractValueFactory) {
+      return abstractValueFactory.createSingleBooleanValue(operand.getValue() <= 0);
+    }
+  },
+  LT {
+    @Override
+    public AbstractValue evaluate(
+        SingleNumberValue operand, AbstractValueFactory abstractValueFactory) {
+      return abstractValueFactory.createSingleBooleanValue(operand.getValue() < 0);
+    }
+  },
+  NE {
+    @Override
+    public AbstractValue evaluate(
+        SingleNumberValue operand, AbstractValueFactory abstractValueFactory) {
+      return abstractValueFactory.createSingleBooleanValue(operand.getValue() != 0);
+    }
+  };
+
+  public AbstractValue evaluate(AbstractValue operand, AbstractValueFactory abstractValueFactory) {
+    if (operand.isSingleNumberValue()) {
+      return evaluate(operand.asSingleNumberValue(), abstractValueFactory);
+    }
+    return AbstractValue.unknown();
+  }
+
+  public abstract AbstractValue evaluate(
+      SingleNumberValue operand, AbstractValueFactory abstractValueFactory);
 
   public boolean isEqualsOrNotEquals() {
     return this == EQ || this == NE;
diff --git a/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java
index 19c675b..c1e8aa6 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java
@@ -20,6 +20,7 @@
 import com.google.common.collect.Sets;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.ListIterator;
 import java.util.Set;
@@ -69,11 +70,14 @@
         code, blockIterator, Arrays.asList(instructionsToAdd), options);
   }
 
-  BasicBlock addThrowingInstructionToPossiblyThrowingBlock(
+  default InstructionListIterator addPossiblyThrowingInstructionToPossiblyThrowingBlock(
       IRCode code,
-      ListIterator<BasicBlock> blockIterator,
-      Instruction instruction,
-      InternalOptions options);
+      BasicBlockIterator blockIterator,
+      Instruction instructionToAdd,
+      InternalOptions options) {
+    return addPossiblyThrowingInstructionsToPossiblyThrowingBlock(
+        code, blockIterator, Collections.singleton(instructionToAdd), options);
+  }
 
   default void addAndPositionBeforeNewInstruction(Instruction instruction) {
     add(instruction);
diff --git a/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java
index 63c5c94..0885e72 100644
--- a/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java
@@ -210,16 +210,6 @@
   }
 
   @Override
-  public BasicBlock addThrowingInstructionToPossiblyThrowingBlock(
-      IRCode code,
-      ListIterator<BasicBlock> blockIterator,
-      Instruction instruction,
-      InternalOptions options) {
-    return currentBlockIterator.addThrowingInstructionToPossiblyThrowingBlock(
-        code, blockIterator, instruction, options);
-  }
-
-  @Override
   public void removeOrReplaceByDebugLocalRead() {
     currentBlockIterator.removeOrReplaceByDebugLocalRead();
   }
diff --git a/src/main/java/com/android/tools/r8/ir/code/NextUntilIterator.java b/src/main/java/com/android/tools/r8/ir/code/NextUntilIterator.java
index d87fed8..8877b0e 100644
--- a/src/main/java/com/android/tools/r8/ir/code/NextUntilIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/NextUntilIterator.java
@@ -24,4 +24,19 @@
     }
     return null;
   }
+
+  /**
+   * Continue to call {@link #next} until it returns the given item.
+   *
+   * @returns item if it was found, null otherwise.
+   */
+  @SuppressWarnings({"TypeParameterUnusedInFormals", "unchecked"})
+  default <S extends T> S nextUntil(T item) {
+    while (hasNext()) {
+      if (next() == item) {
+        return (S) item;
+      }
+    }
+    return null;
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/NumericType.java b/src/main/java/com/android/tools/r8/ir/code/NumericType.java
index 85b80b5..4e8d0d0 100644
--- a/src/main/java/com/android/tools/r8/ir/code/NumericType.java
+++ b/src/main/java/com/android/tools/r8/ir/code/NumericType.java
@@ -16,6 +16,10 @@
   FLOAT,
   DOUBLE;
 
+  public boolean isInt() {
+    return this == INT;
+  }
+
   public DexType toDexType(DexItemFactory factory) {
     switch (this) {
       case BYTE:
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 7383048..dcc3abf 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
@@ -898,7 +898,7 @@
       timing.end();
     }
 
-    if (options.debug || appView.getKeepInfo(code.context()).isPinned(options)) {
+    if (options.debug || appView.getKeepInfo(code.context()).isCodeReplacementAllowed(options)) {
       return;
     }
 
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 ca0f4269..679a884 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
@@ -116,6 +116,7 @@
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.LazyBox;
 import com.android.tools.r8.verticalclassmerging.InterfaceTypeToClassTypeLensCodeRewriterHelper;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Sets;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
@@ -721,7 +722,7 @@
               Instruction replacement =
                   new InstructionReplacer(code, current, iterator, affectedPhis)
                       .replaceInstructionIfTypeChanged(
-                          constClass.getValue(),
+                          constClass.getType(),
                           (t, v) ->
                               t.isPrimitiveType() || t.isVoidType()
                                   ? StaticGet.builder()
@@ -1062,7 +1063,8 @@
             .setOutValue(castOutValue)
             .setPosition(fieldGet.asFieldInstruction())
             .build();
-    iterator.addThrowingInstructionToPossiblyThrowingBlock(code, blocks, checkCast, options);
+    iterator.addPossiblyThrowingInstructionsToPossiblyThrowingBlock(
+        code, blocks, ImmutableList.of(checkCast), options);
     affectedPhis.addAll(checkCast.outValue().uniquePhiUsers());
   }
 
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 a8fe188..d31a884 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
@@ -52,13 +52,17 @@
       CallGraph callGraph,
       MethodProcessorEventConsumer eventConsumer,
       ProgramMethodSet methodsToProcess) {
-    this.callSiteInformation = callGraph.createCallSiteInformation(appView, this);
     this.eventConsumer = eventConsumer;
     this.methodsToProcess = methodsToProcess;
     this.processorContext = appView.createProcessorContext();
+    this.callSiteInformation = callGraph.createCallSiteInformation(appView, this);
     this.waves = createWaves(callGraph);
   }
 
+  public void addMethodToProcess(ProgramMethod method) {
+    methodsToProcess.add(method);
+  }
+
   public void markCallersForProcessing(ProgramMethod method) {
     assert wave.contains(method);
     synchronized (methodsToProcess) {
@@ -173,10 +177,6 @@
             });
         put(set);
       }
-      if (methodsToReprocessBuilder.isEmpty()) {
-        // Nothing to revisit.
-        return null;
-      }
       ProgramMethodSet methodsToReprocess = methodsToReprocessBuilder.build(appView);
       // TODO(b/333677610): Check this assert when bridges synthesized by member rebinding is
       //  always removed
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 84685ae..f89b900 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
@@ -140,15 +140,19 @@
             }
           }
           Set<Node> callersWithDeterministicOrder = node.getCallersWithDeterministicOrder();
-          DexMethod caller = reference;
+          ProgramMethod caller = method;
           // We can have recursive methods where the recursive call is the only call site. We do
           // not track callers for these.
           if (!callersWithDeterministicOrder.isEmpty()) {
             assert callersWithDeterministicOrder.size() == 1;
-            caller = callersWithDeterministicOrder.iterator().next().getMethod().getReference();
+            caller = callersWithDeterministicOrder.iterator().next().getProgramMethod();
           }
           assert !singleCallerMethods.containsKey(reference);
-          singleCallerMethods.put(reference, caller);
+          singleCallerMethods.put(reference, caller.getReference());
+          if (methodProcessor.isPostMethodProcessor()
+              && appView.getKeepInfo(caller).isReprocessingAllowed(options, caller)) {
+            methodProcessor.asPostMethodProcessor().addMethodToProcess(caller);
+          }
         } else if (numberOfCallSites > 1 && methodProcessor.isPrimaryMethodProcessor()) {
           multiCallerInlineCandidates.add(reference);
         }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/callgraph/InvokeExtractor.java b/src/main/java/com/android/tools/r8/ir/conversion/callgraph/InvokeExtractor.java
index 809f647..5ab36a6 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/callgraph/InvokeExtractor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/callgraph/InvokeExtractor.java
@@ -57,13 +57,13 @@
       // We don't care about calls to native methods.
       return;
     }
-    if (!appViewWithLiveness
+    if (appViewWithLiveness
         .getKeepInfo(callee)
-        .isOptimizationAllowed(appViewWithLiveness.options())) {
-      // Since the callee is kept and optimizations are disallowed, we cannot inline it into the
-      // caller, and we also cannot collect any optimization info for the method. Therefore, we
-      // drop the call edge to reduce the total number of call graph edges, which should lead to
-      // fewer call graph cycles.
+        .isCodeReplacementAllowed(appViewWithLiveness.options())) {
+      // Since the code of the callee may be replaced, we cannot inline it into the caller, and we
+      // also cannot collect any optimization info for the method. Therefore, we drop the call edge
+      // to reduce the total number of call graph edges, which should lead to fewer call graph
+      // cycles.
       return;
     }
     nodeFactory.apply(callee).addCallerConcurrently(currentMethod, likelySpuriousCallEdge);
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/ClassGetNameOptimizer.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/ClassGetNameOptimizer.java
index 73f5f8a..9941ea0 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/ClassGetNameOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/ClassGetNameOptimizer.java
@@ -100,7 +100,7 @@
       }
 
       ConstClass constClass = in.definition.asConstClass();
-      DexType type = constClass.getValue();
+      DexType type = constClass.getType();
       int arrayDepth = type.getNumberOfLeadingSquareBrackets();
       DexType baseType = type.toBaseType(dexItemFactory);
       // Make sure base type is a class type.
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/FilledNewArrayRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/FilledNewArrayRewriter.java
index c5e7aaa..e408515 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/FilledNewArrayRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/FilledNewArrayRewriter.java
@@ -582,7 +582,7 @@
         if (elementValue.isConstString()) {
           addOccurrence(elementValue.getDefinition().asConstString().getValue());
         } else if (elementValue.isConstClass()) {
-          addOccurrence(elementValue.getDefinition().asConstClass().getValue());
+          addOccurrence(elementValue.getDefinition().asConstClass().getType());
         } else if (elementValue.isDefinedByInstructionSatisfying(Instruction::isStaticGet)) {
           addOccurrence(elementValue.getDefinition().asStaticGet().getField());
         }
@@ -600,7 +600,7 @@
           return value;
         }
       } else if (elementValue.isConstClass()) {
-        DexType type = elementValue.getDefinition().asConstClass().getValue();
+        DexType type = elementValue.getDefinition().asConstClass().getType();
         Value value = constantValue.get(type);
         if (value != null) {
           seenOcourence(type);
@@ -657,7 +657,7 @@
         return instruction.asStaticGet().getField();
       } else {
         assert instruction.isConstClass();
-        return instruction.asConstClass().getValue();
+        return instruction.asConstClass().getType();
       }
     }
 
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/TrivialCheckCastAndInstanceOfRemover.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/TrivialCheckCastAndInstanceOfRemover.java
index 984e829..4a2d298 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/TrivialCheckCastAndInstanceOfRemover.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/TrivialCheckCastAndInstanceOfRemover.java
@@ -274,8 +274,7 @@
     if (checkCast.isSafeCheckCast()
         || checkCast
             .getFirstOperand()
-            .getDynamicType(appViewWithLiveness)
-            .getDynamicUpperBoundType()
+            .getDynamicUpperBoundType(appViewWithLiveness)
             .lessThanOrEqualUpToNullability(castTypeLattice, appView)) {
       TypeElement useType =
           TypeUtils.computeUseType(appViewWithLiveness, context, checkCast.outValue());
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 b6804e7..f8b502a 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
@@ -563,7 +563,7 @@
       Value inValue = invoke.inValues().get(0);
       return !inValue.isPhi()
           && inValue.definition.isConstClass()
-          && inValue.definition.asConstClass().getValue() == clazz.type;
+          && inValue.definition.asConstClass().getType() == clazz.type;
     }
     return false;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ConstantCanonicalizer.java b/src/main/java/com/android/tools/r8/ir/optimize/ConstantCanonicalizer.java
index 13a06ea..7a18075 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ConstantCanonicalizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ConstantCanonicalizer.java
@@ -163,7 +163,7 @@
                 assert candidate.instructionTypeCanBeCanonicalized();
                 switch (candidate.opcode()) {
                   case CONST_CLASS:
-                    return candidate.asConstClass().getValue().hashCode();
+                    return candidate.asConstClass().getType().hashCode();
                   case CONST_NUMBER:
                     return Long.hashCode(candidate.asConstNumber().getRawValue())
                         + 13 * candidate.outType().hashCode();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
index 4b9c547..99463ac 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
@@ -1299,15 +1299,28 @@
           // Convert and remove virtual single caller inlined methods to abstract or throw null.
           singleCallerInlinedMethodsForClass.removeIf(
               (callee, caller) -> {
-                // TODO(b/203188583): Enable pruning of methods with generic signatures. For this to
-                //  work we need to pass in a seed to GenericSignatureContextBuilder.create in R8.
-                if (callee.getDefinition().belongsToVirtualPool()
-                    || callee.getDefinition().getGenericSignature().hasSignature()) {
+                boolean convertToAbstractOrThrowNullMethod =
+                    callee.getDefinition().belongsToVirtualPool();
+                if (callee.getDefinition().getGenericSignature().hasSignature()) {
+                  // TODO(b/203188583): Enable pruning of methods with generic signatures. For this
+                  //  to work we need to pass in a seed to GenericSignatureContextBuilder.create in
+                  //  R8.
+                  convertToAbstractOrThrowNullMethod = true;
+                } else if (appView.options().configurationDebugging
+                    && appView.getSyntheticItems().isSynthetic(callee.getHolder())) {
+                  // If static synthetic methods are removed after being single caller inlined, we
+                  // need to unregister them as synthetic methods in the synthetic items collection.
+                  // This means that they will not be renamed to ExternalSynthetic leading to
+                  // assertion errors. This should only be a problem when configuration debugging is
+                  // enabled, since configuration debugging disables shrinking of the synthetic
+                  // method's holder.
+                  convertToAbstractOrThrowNullMethod = true;
+                }
+                if (convertToAbstractOrThrowNullMethod) {
                   callee.convertToAbstractOrThrowNullMethod(appView);
                   converter.onMethodCodePruned(callee);
-                  return true;
                 }
-                return false;
+                return convertToAbstractOrThrowNullMethod;
               });
 
           // Remove direct single caller inlined methods from the application.
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ServiceLoaderRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/ServiceLoaderRewriter.java
index 86706f2..d7bf459 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ServiceLoaderRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ServiceLoaderRewriter.java
@@ -4,34 +4,45 @@
 
 package com.android.tools.r8.ir.optimize;
 
+import com.android.tools.r8.FeatureSplit;
 import com.android.tools.r8.androidapi.AndroidApiLevelCompute;
 import com.android.tools.r8.contexts.CompilationContext.MethodProcessingContext;
+import com.android.tools.r8.features.ClassToFeatureSplitMap;
 import com.android.tools.r8.graph.AppServices;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexItemFactory.IteratorMethods;
 import com.android.tools.r8.graph.DexItemFactory.ServiceLoaderMethods;
-import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexProto;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.code.BasicBlock;
 import com.android.tools.r8.ir.code.ConstClass;
 import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.IRCodeInstructionListIterator;
 import com.android.tools.r8.ir.code.Instruction;
-import com.android.tools.r8.ir.code.InstructionListIterator;
+import com.android.tools.r8.ir.code.InvokeDirect;
+import com.android.tools.r8.ir.code.InvokeMethod;
 import com.android.tools.r8.ir.code.InvokeStatic;
 import com.android.tools.r8.ir.code.InvokeVirtual;
+import com.android.tools.r8.ir.code.NewInstance;
+import com.android.tools.r8.ir.code.Position;
+import com.android.tools.r8.ir.code.Throw;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.conversion.MethodProcessor;
 import com.android.tools.r8.ir.conversion.passes.CodeRewriterPass;
 import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
 import com.android.tools.r8.ir.desugar.ServiceLoaderSourceCode;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.BooleanBox;
+import com.android.tools.r8.utils.ConsumerUtils;
 import com.android.tools.r8.utils.ListUtils;
-import com.google.common.collect.ImmutableList;
+import com.android.tools.r8.utils.WorkList;
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
@@ -67,11 +78,16 @@
 
   private final AndroidApiLevelCompute apiLevelCompute;
   private final ServiceLoaderMethods serviceLoaderMethods;
+  private final IteratorMethods iteratorMethods;
+  private final boolean hasAssumeNoSideEffects;
 
   public ServiceLoaderRewriter(AppView<?> appView) {
     super(appView);
     this.apiLevelCompute = appView.apiLevelCompute();
     this.serviceLoaderMethods = appView.dexItemFactory().serviceLoaderMethods;
+    this.iteratorMethods = appView.dexItemFactory().iteratorMethods;
+    hasAssumeNoSideEffects =
+        appView.getAssumeInfoCollection().isSideEffectFree(serviceLoaderMethods.load);
   }
 
   @Override
@@ -100,156 +116,396 @@
       IRCode code,
       MethodProcessor methodProcessor,
       MethodProcessingContext methodProcessingContext) {
-    InstructionListIterator instructionIterator = code.instructionListIterator();
     // Create a map from service type to loader methods local to this context since two
     // service loader calls to the same type in different methods and in the same wave can race.
     Map<DexType, DexEncodedMethod> synthesizedServiceLoaders = new IdentityHashMap<>();
-    while (instructionIterator.hasNext()) {
-      Instruction instruction = instructionIterator.next();
+    IRCodeInstructionListIterator iterator = code.instructionListIterator();
+    Map<Instruction, Instruction> replacements = new HashMap<>();
+    Map<Instruction, List<Instruction>> replacementExtras = new HashMap<>();
 
-      // Check if instruction is an invoke static on the desired form of ServiceLoader.load.
-      if (!instruction.isInvokeStatic()) {
+    while (iterator.hasNext()) {
+      Instruction instruction = iterator.next();
+
+      // Find ServiceLoader.load() calls.
+      InvokeStatic invokeInstr = instruction.asInvokeStatic();
+      if (invokeInstr == null
+          || !serviceLoaderMethods.isLoadMethod(invokeInstr.getInvokedMethod())) {
         continue;
       }
 
-      InvokeStatic serviceLoaderLoad = instruction.asInvokeStatic();
-      DexMethod invokedMethod = serviceLoaderLoad.getInvokedMethod();
-      if (!serviceLoaderMethods.isLoadMethod(invokedMethod)) {
+      // See if it can be optimized.
+      ServiceLoaderLoadResult loadResult = analyzeServiceLoaderLoad(code, invokeInstr);
+      if (loadResult == null) {
         continue;
       }
+      // See if there is a subsequent iterator() call that can be optimized.
+      DirectRewriteResult directRewriteResult = analyzeForDirectRewrite(loadResult);
 
-      // Check that the first argument is a const class.
-      Value argument = serviceLoaderLoad.getFirstArgument().getAliasedValue();
-      if (!argument.isDefinedByInstructionSatisfying(Instruction::isConstClass)) {
-        report(code.context(), null, "The service loader type could not be determined");
-        continue;
+      // Remove ServiceLoader.load()
+      replacements.put(loadResult.loadInvoke, code.createConstNull());
+      // Remove getClassLoader() if we are about to remove all users.
+      if (loadResult.classLoaderInvoke != null
+          && loadResult.classLoaderInvoke.outValue().aliasedUsers().stream()
+              .allMatch(ins -> ins.isAssume() || replacements.containsKey(ins))) {
+        replacements.put(loadResult.classLoaderInvoke, code.createConstNull());
       }
-
-      ConstClass constClass = argument.getDefinition().asConstClass();
-      if (invokedMethod.isNotIdenticalTo(serviceLoaderMethods.loadWithClassLoader)) {
-        report(
-            code.context(),
-            constClass.getType(),
-            "Inlining is only supported for `java.util.ServiceLoader.load(java.lang.Class,"
-                + " java.lang.ClassLoader)`");
-        continue;
+      if (directRewriteResult != null) {
+        populateDirectRewriteChanges(
+            code, replacements, replacementExtras, loadResult, directRewriteResult);
+      } else {
+        populateSyntheticChanges(
+            code,
+            methodProcessor,
+            methodProcessingContext,
+            synthesizedServiceLoaders,
+            replacements,
+            loadResult);
       }
-
-      String invalidUserMessage =
-          "The returned ServiceLoader instance must only be used in a call to `java.util.Iterator"
-              + " java.lang.ServiceLoader.iterator()`";
-      Value serviceLoaderLoadOut = serviceLoaderLoad.outValue();
-      if (!serviceLoaderLoadOut.hasSingleUniqueUser() || serviceLoaderLoadOut.hasPhiUsers()) {
-        report(code.context(), constClass.getType(), invalidUserMessage);
-        continue;
-      }
-
-      // Check that the only user is a call to iterator().
-      InvokeVirtual singleUniqueUser = serviceLoaderLoadOut.singleUniqueUser().asInvokeVirtual();
-      if (singleUniqueUser == null
-          || singleUniqueUser.getInvokedMethod().isNotIdenticalTo(serviceLoaderMethods.iterator)) {
-        report(
-            code.context(), constClass.getType(), invalidUserMessage + ", but found other usages");
-        continue;
-      }
-
-      // Check that the service is not kept.
-      if (appView().appInfo().isPinnedWithDefinitionLookup(constClass.getValue())) {
-        report(code.context(), constClass.getType(), "The service loader type is kept");
-        continue;
-      }
-
-      // Check that the service is configured in the META-INF/services.
-      AppServices appServices = appView.appServices();
-      if (!appServices.allServiceTypes().contains(constClass.getValue())) {
-        // Error already reported in the Enqueuer.
-        continue;
-      }
-
-      // Check that we are not service loading anything from a feature into base.
-      if (appServices.hasServiceImplementationsInFeature(appView(), constClass.getValue())) {
-        report(
-            code.context(),
-            constClass.getType(),
-            "The service loader type has implementations in a feature split");
-        continue;
-      }
-
-      // Check that ClassLoader used is the ClassLoader defined for the service configuration
-      // that we are instantiating or NULL.
-      Value classLoaderValue = serviceLoaderLoad.getLastArgument().getAliasedValue();
-      if (classLoaderValue.isPhi()) {
-        report(
-            code.context(),
-            constClass.getType(),
-            "The java.lang.ClassLoader argument must be defined locally as null or "
-                + constClass.getType()
-                + ".class.getClassLoader()");
-        continue;
-      }
-      InvokeVirtual classLoaderInvoke = classLoaderValue.getDefinition().asInvokeVirtual();
-      boolean isGetClassLoaderOnConstClassOrNull =
-          classLoaderValue.getType().isNullType()
-              || (classLoaderInvoke != null
-                  && classLoaderInvoke.arguments().size() == 1
-                  && classLoaderInvoke.getReceiver().getAliasedValue().isConstClass()
-                  && classLoaderInvoke
-                      .getReceiver()
-                      .getAliasedValue()
-                      .getDefinition()
-                      .asConstClass()
-                      .getValue()
-                      .isIdenticalTo(constClass.getValue()));
-      if (!isGetClassLoaderOnConstClassOrNull) {
-        report(
-            code.context(),
-            constClass.getType(),
-            "The java.lang.ClassLoader argument must be defined locally as null or "
-                + constClass.getType()
-                + ".class.getClassLoader()");
-        continue;
-      }
-
-      List<DexType> dexTypes = appServices.serviceImplementationsFor(constClass.getValue());
-      List<DexClass> classes = new ArrayList<>(dexTypes.size());
-      boolean seenNull = false;
-      for (DexType serviceImpl : dexTypes) {
-        DexClass serviceImplementation = appView.definitionFor(serviceImpl);
-        if (serviceImplementation == null) {
-          report(
-              code.context(),
-              constClass.getType(),
-              "Unable to find definition for service implementation " + serviceImpl.getTypeName());
-          seenNull = true;
-        }
-        classes.add(serviceImplementation);
-      }
-      if (seenNull) {
-        continue;
-      }
-
-      // We can perform the rewrite of the ServiceLoader.load call.
-      DexEncodedMethod synthesizedMethod =
-          synthesizedServiceLoaders.computeIfAbsent(
-              constClass.getValue(),
-              service -> {
-                DexEncodedMethod addedMethod =
-                    createSynthesizedMethod(
-                        service, classes, methodProcessor, methodProcessingContext);
-                if (appView.options().isGeneratingClassFiles()) {
-                  addedMethod.upgradeClassFileVersion(
-                      code.context().getDefinition().getClassFileVersion());
-                }
-                return addedMethod;
-              });
-
-      new Rewriter(code, instructionIterator, serviceLoaderLoad)
-          .perform(classLoaderInvoke, synthesizedMethod.getReference());
     }
+
+    if (replacements.isEmpty()) {
+      return CodeRewriterResult.NO_CHANGE;
+    }
+
+    AffectedValues affectedValues = new AffectedValues();
+    iterator = code.instructionListIterator();
+    while (iterator.hasNext()) {
+      Instruction instruction = iterator.next();
+      Instruction replacement = replacements.get(instruction);
+      if (replacement == null) {
+        continue;
+      }
+      iterator.replaceCurrentInstruction(replacement, affectedValues);
+      List<Instruction> extras = replacementExtras.get(instruction);
+      if (extras != null) {
+        iterator.addPossiblyThrowingInstructionsToPossiblyThrowingBlock(extras, options);
+        if (ListUtils.last(extras).isThrow()) {
+          iterator.removeRemainingInBlockIgnoreOutValue();
+        }
+      }
+    }
+
+    code.removeUnreachableBlocks(affectedValues, ConsumerUtils.emptyConsumer());
+    code.removeRedundantBlocks();
+    affectedValues.narrowingWithAssumeRemoval(appView, code);
     assert code.isConsistentSSA(appView);
-    return synthesizedServiceLoaders.isEmpty()
-        ? CodeRewriterResult.NO_CHANGE
-        : CodeRewriterResult.HAS_CHANGED;
+
+    return CodeRewriterResult.HAS_CHANGED;
+  }
+
+  private void populateSyntheticChanges(
+      IRCode code,
+      MethodProcessor methodProcessor,
+      MethodProcessingContext methodProcessingContext,
+      Map<DexType, DexEncodedMethod> synthesizedServiceLoaders,
+      Map<Instruction, Instruction> replacements,
+      ServiceLoaderLoadResult loadResult) {
+    DexEncodedMethod synthesizedMethod =
+        synthesizedServiceLoaders.computeIfAbsent(
+            loadResult.serviceType,
+            service -> {
+              DexEncodedMethod addedMethod =
+                  createSynthesizedMethod(
+                      service, loadResult.implClasses, methodProcessor, methodProcessingContext);
+              if (appView.options().isGeneratingClassFiles()) {
+                addedMethod.upgradeClassFileVersion(
+                    code.context().getDefinition().getClassFileVersion());
+              }
+              return addedMethod;
+            });
+    InvokeStatic synthesizedInvoke =
+        new InvokeStatic(
+            synthesizedMethod.getReference(),
+            loadResult.iteratorInvoke.outValue(),
+            Collections.emptyList());
+    replacements.put(loadResult.iteratorInvoke, synthesizedInvoke);
+  }
+
+  private void populateDirectRewriteChanges(
+      IRCode code,
+      Map<Instruction, Instruction> replacements,
+      Map<Instruction, List<Instruction>> replacementExtras,
+      ServiceLoaderLoadResult loadResult,
+      DirectRewriteResult directRewriteResult) {
+    // Remove ServiceLoader.iterator()
+    replacements.put(loadResult.iteratorInvoke, code.createConstNull());
+
+    // Iterator.hasNext() --> true / false
+    if (directRewriteResult.hasNextInstr != null) {
+      replacements.put(
+          directRewriteResult.hasNextInstr,
+          code.createBooleanConstant(!loadResult.implClasses.isEmpty()));
+    }
+    if (directRewriteResult.nextInstr != null) {
+      Position position = directRewriteResult.nextInstr.getPosition();
+      if (loadResult.implClasses.isEmpty()) {
+        // Iterator.next() -> null
+        replacements.put(directRewriteResult.nextInstr, code.createConstNull());
+
+        // throw new NoSuchElementException()
+        NewInstance newInstanceInstr =
+            new NewInstance(
+                dexItemFactory.noSuchElementExceptionType,
+                code.createValue(
+                    dexItemFactory.noSuchElementExceptionType.toNonNullTypeElement(appView)));
+        InvokeDirect initInstr =
+            new InvokeDirect(
+                dexItemFactory.noSuchElementExceptionInit,
+                null,
+                List.of(newInstanceInstr.outValue()));
+        Throw throwInstr = new Throw(newInstanceInstr.outValue());
+
+        newInstanceInstr.setPosition(position);
+        initInstr.setPosition(position);
+        throwInstr.setPosition(position);
+        replacementExtras.put(
+            directRewriteResult.nextInstr, List.of(newInstanceInstr, initInstr, throwInstr));
+      } else {
+        // Iterator.next() -> new ServiceImpl()
+        DexType clazz = loadResult.implClasses.get(0).getType();
+        NewInstance newInstance =
+            new NewInstance(
+                clazz,
+                code.createValue(
+                    clazz.toNonNullTypeElement(appView),
+                    directRewriteResult.nextInstr.getLocalInfo()));
+        replacements.put(directRewriteResult.nextInstr, newInstance);
+        InvokeDirect initInstr =
+            new InvokeDirect(
+                dexItemFactory.createInstanceInitializer(clazz),
+                null,
+                List.of(newInstance.outValue()));
+        initInstr.setPosition(position);
+        replacementExtras.put(directRewriteResult.nextInstr, List.of(initInstr));
+      }
+    }
+  }
+
+  private ServiceLoaderLoadResult analyzeServiceLoaderLoad(IRCode code, InvokeStatic invokeInstr) {
+    // Check that the first argument is a const class.
+    Value argument = invokeInstr.getFirstArgument().getAliasedValue();
+    if (!argument.isDefinedByInstructionSatisfying(Instruction::isConstClass)) {
+      report(code.context(), null, "The service loader type could not be determined");
+      return null;
+    }
+
+    ConstClass constClass = argument.getDefinition().asConstClass();
+    DexType serviceType = constClass.getType();
+    if (invokeInstr.getInvokedMethod().isNotIdenticalTo(serviceLoaderMethods.loadWithClassLoader)) {
+      report(
+          code.context(),
+          serviceType,
+          "Inlining is only supported for `java.util.ServiceLoader.load(java.lang.Class,"
+              + " java.lang.ClassLoader)`");
+      return null;
+    }
+
+    String invalidUserMessage =
+        "The returned ServiceLoader instance must only be used in a call to `java.util.Iterator"
+            + " java.lang.ServiceLoader.iterator()`";
+    Value serviceLoaderLoadOut = invokeInstr.outValue();
+    if (!serviceLoaderLoadOut.hasSingleUniqueUser() || serviceLoaderLoadOut.hasPhiUsers()) {
+      report(code.context(), serviceType, invalidUserMessage);
+      return null;
+    }
+
+    // Check that the only user is a call to iterator().
+    InvokeVirtual iteratorInvoke = serviceLoaderLoadOut.singleUniqueUser().asInvokeVirtual();
+    if (iteratorInvoke == null
+        || iteratorInvoke.getInvokedMethod().isNotIdenticalTo(serviceLoaderMethods.iterator)) {
+      report(code.context(), serviceType, invalidUserMessage + ", but found other usages");
+      return null;
+    }
+
+    // Check that the service is not kept.
+    if (appView().appInfo().isPinnedWithDefinitionLookup(serviceType)) {
+      report(code.context(), serviceType, "The service loader type is kept");
+      return null;
+    }
+
+    // Check that ClassLoader used is the ClassLoader defined for the service configuration
+    // that we are instantiating or NULL.
+    Value classLoaderValue = invokeInstr.getLastArgument().getAliasedValue();
+    if (classLoaderValue.isPhi()) {
+      report(
+          code.context(),
+          serviceType,
+          "The java.lang.ClassLoader argument must be defined locally as null or "
+              + serviceType
+              + ".class.getClassLoader()");
+      return null;
+    }
+    boolean isNullClassLoader = classLoaderValue.getType().isNullType();
+    InvokeVirtual classLoaderInvoke = classLoaderValue.getDefinition().asInvokeVirtual();
+    boolean isGetClassLoaderOnConstClass =
+        classLoaderInvoke != null
+            && classLoaderInvoke.arguments().size() == 1
+            && classLoaderInvoke.getReceiver().getAliasedValue().isConstClass()
+            && classLoaderInvoke
+                .getReceiver()
+                .getAliasedValue()
+                .getDefinition()
+                .asConstClass()
+                .getType()
+                .isIdenticalTo(serviceType);
+    if (!isNullClassLoader && !isGetClassLoaderOnConstClass) {
+      report(
+          code.context(),
+          serviceType,
+          "The java.lang.ClassLoader argument must be defined locally as null or "
+              + serviceType
+              + ".class.getClassLoader()");
+      return null;
+    }
+
+    // Check that we are not service loading anything from a feature into base.
+    AppServices appServices = appView.appServices();
+    // Check that we are not service loading anything from a feature into base.
+    if (hasServiceImplementationInDifferentFeature(code, serviceType, isNullClassLoader)) {
+      return null;
+    }
+
+    List<DexType> dexTypes = appServices.serviceImplementationsFor(serviceType);
+    List<DexClass> implClasses = new ArrayList<>(dexTypes.size());
+    for (DexType serviceImpl : dexTypes) {
+      DexClass serviceImplementation = appView.definitionFor(serviceImpl);
+      if (serviceImplementation == null) {
+        report(
+            code.context(),
+            serviceType,
+            "Unable to find definition for service implementation " + serviceImpl.getTypeName());
+        return null;
+      }
+      if (appView.isSubtype(serviceImpl, serviceType).isFalse()) {
+        report(
+            code.context(),
+            serviceType,
+            "Implementation is not a subtype of the service: " + serviceImpl.getTypeName());
+        return null;
+      }
+      DexEncodedMethod method = serviceImplementation.getDefaultInitializer();
+      if (method == null) {
+        report(
+            code.context(),
+            serviceType,
+            "Implementation has no default constructor: " + serviceImpl.getTypeName());
+        return null;
+      }
+      if (!method.getAccessFlags().wasPublic()) {
+        // A non-public constructor causes a ServiceConfigurationError on APIs 24 & 25 (Nougat).
+        report(
+            code.context(),
+            serviceType,
+            "Implementation's default constructor is not public: " + serviceImpl.getTypeName());
+        return null;
+      }
+      implClasses.add(serviceImplementation);
+    }
+
+    return new ServiceLoaderLoadResult(
+        invokeInstr, classLoaderInvoke, serviceType, implClasses, iteratorInvoke);
+  }
+
+  /**
+   * Checks that:
+   *
+   * <pre>
+   *   * -assumenosideeffects for ServiceLoader.load() is set.
+   *   * ServiceLoader.iterator() is used only by a single .hasNext() and/or .next()
+   *   * .iterator(), .hasNext(), and .next() are all in the same try/catch.
+   *   * .hasNext() never comes after a call to .next()
+   *   * .hasNext() and .next() are not in a loop.
+   * </pre>
+   */
+  private DirectRewriteResult analyzeForDirectRewrite(ServiceLoaderLoadResult loadResult) {
+    // Require -assumenosideeffects class java.util.ServiceLoader { java.lang.Object load(...); }
+    // because this direct rewriting does not wrap exceptions in ServiceConfigurationError.
+    if (!hasAssumeNoSideEffects) {
+      return null;
+    }
+    InvokeVirtual iteratorInvoke = loadResult.iteratorInvoke;
+
+    if (iteratorInvoke.outValue().hasPhiUsers()) {
+      return null;
+    }
+    InvokeMethod hasNextInstr = null;
+    InvokeMethod nextInstr = null;
+    // We only bother to support a single call to hasNext() and next(), and they must appear within
+    // the same try/catch.
+    for (Instruction user : iteratorInvoke.outValue().aliasedUsers()) {
+      if (user.isAssume()) {
+        if (user.outValue().hasPhiUsers()) {
+          return null;
+        }
+        continue;
+      }
+      if (!user.getBlock().hasEquivalentCatchHandlers(iteratorInvoke.getBlock())) {
+        return null;
+      }
+      InvokeMethod curCall = user.asInvokeMethod();
+      if (curCall == null) {
+        return null;
+      }
+      if (curCall.getInvokedMethod().isIdenticalTo(iteratorMethods.hasNext)) {
+        if (hasNextInstr != null) {
+          return null;
+        }
+        hasNextInstr = curCall;
+      } else if (curCall.getInvokedMethod().isIdenticalTo(iteratorMethods.next)) {
+        if (nextInstr != null) {
+          return null;
+        }
+        nextInstr = curCall;
+      } else {
+        return null;
+      }
+    }
+
+    BasicBlock iteratorBlock = iteratorInvoke.getBlock();
+    BasicBlock hasNextBlock = hasNextInstr != null ? hasNextInstr.getBlock() : null;
+    BasicBlock nextBlock = nextInstr != null ? nextInstr.getBlock() : null;
+    if (hasNextBlock != null && nextBlock != null) {
+      // See if hasNext() is reachable after next().
+      if (hasNextBlock == nextBlock) {
+        if (nextBlock.iterator(nextInstr).nextUntil(hasNextInstr) != null) {
+          return null;
+        }
+      } else if (hasPredecessorPathTo(iteratorBlock, hasNextBlock, nextBlock)) {
+        return null;
+      }
+    }
+
+    // Make sure each instruction can be run at most once (no loops).
+    if (hasNextBlock != null && loopExists(iteratorBlock, hasNextBlock)) {
+      return null;
+    }
+    if (nextBlock != null && loopExists(iteratorBlock, nextBlock)) {
+      return null;
+    }
+
+    return new DirectRewriteResult(hasNextInstr, nextInstr);
+  }
+
+  private static boolean loopExists(BasicBlock subgraphEntryBlock, BasicBlock targetBlock) {
+    return hasPredecessorPathTo(subgraphEntryBlock, targetBlock, targetBlock);
+  }
+
+  private static boolean hasPredecessorPathTo(
+      BasicBlock subgraphEntryBlock, BasicBlock subgraphExitBlock, BasicBlock targetBlock) {
+    if (subgraphEntryBlock == subgraphExitBlock) {
+      return false;
+    }
+    WorkList<BasicBlock> workList = WorkList.newIdentityWorkList();
+    workList.markAsSeen(subgraphEntryBlock);
+    workList.addIfNotSeen(subgraphExitBlock.getPredecessors());
+    while (workList.hasNext()) {
+      BasicBlock curBlock = workList.next();
+      if (curBlock == targetBlock) {
+        return true;
+      }
+      workList.addIfNotSeen(curBlock.getPredecessors());
+    }
+    return false;
   }
 
   private void report(ProgramMethod method, DexType serviceLoaderType, String message) {
@@ -268,6 +524,64 @@
     }
   }
 
+  private boolean hasServiceImplementationInDifferentFeature(
+      IRCode code, DexType serviceType, boolean baseFeatureOnly) {
+    AppView<AppInfoWithLiveness> appViewWithClasses = appView();
+    ClassToFeatureSplitMap classToFeatureSplitMap =
+        appViewWithClasses.appInfo().getClassToFeatureSplitMap();
+    if (classToFeatureSplitMap.isEmpty()) {
+      return false;
+    }
+    Map<FeatureSplit, List<DexType>> featureImplementations =
+        appView.appServices().serviceImplementationsByFeatureFor(serviceType);
+    if (featureImplementations == null || featureImplementations.isEmpty()) {
+      return false;
+    }
+    DexProgramClass serviceClass = appView.definitionForProgramType(serviceType);
+    if (serviceClass == null) {
+      return false;
+    }
+    FeatureSplit serviceFeature =
+        classToFeatureSplitMap.getFeatureSplit(serviceClass, appViewWithClasses);
+    if (baseFeatureOnly && !serviceFeature.isBase()) {
+      report(
+          code.context(),
+          serviceType,
+          "ClassLoader arg was null and service interface is in non-base feature");
+      return true;
+    }
+    for (var entry : featureImplementations.entrySet()) {
+      FeatureSplit metaInfFeature = entry.getKey();
+      if (!metaInfFeature.isBase()) {
+        if (baseFeatureOnly) {
+          report(
+              code.context(),
+              serviceType,
+              "ClassLoader arg was null and META-INF/ service entry found in non-base feature");
+          return true;
+        }
+        if (metaInfFeature != serviceFeature) {
+          report(
+              code.context(),
+              serviceType,
+              "META-INF/ service found in different feature from service interface");
+          return true;
+        }
+      }
+      for (DexType impl : entry.getValue()) {
+        FeatureSplit implFeature = classToFeatureSplitMap.getFeatureSplit(impl, appViewWithClasses);
+        if (implFeature != serviceFeature) {
+          report(
+              code.context(),
+              serviceType,
+              "Implementation found in different feature from service interface: " + impl);
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
   private DexEncodedMethod createSynthesizedMethod(
       DexType serviceType,
       List<DexClass> classes,
@@ -300,77 +614,34 @@
     return method.getDefinition();
   }
 
-  /**
-   * Rewriter assumes that the code is of the form:
-   *
-   * <pre>
-   * ConstClass         v1 <- X
-   * ConstClass         v2 <- X or NULL
-   * Invoke-Virtual     v3 <- v2; method: java.lang.ClassLoader java.lang.Class.getClassLoader()
-   * Invoke-Static      v4 <- v1, v3; method: java.util.ServiceLoader java.util.ServiceLoader
-   *     .load(java.lang.Class, java.lang.ClassLoader)
-   * Invoke-Virtual     v5 <- v4; method: java.util.Iterator java.util.ServiceLoader.iterator()
-   * </pre>
-   *
-   * and rewrites it to:
-   *
-   * <pre>
-   * Invoke-Static      v5 <- ; method: java.util.Iterator syn(X)()
-   * </pre>
-   *
-   * where syn(X) is the synthesized method generated for the service class.
-   *
-   * <p>We rely on the DeadCodeRemover to remove the ConstClasses and any aliased values no longer
-   * used.
-   */
-  private static class Rewriter {
+  private static class ServiceLoaderLoadResult {
+    public final InvokeStatic loadInvoke;
+    public final InvokeVirtual classLoaderInvoke;
+    public final DexType serviceType;
+    public final List<DexClass> implClasses;
+    public final InvokeVirtual iteratorInvoke;
 
-    private final IRCode code;
-    private final InvokeStatic serviceLoaderLoad;
-
-    private final InstructionListIterator iterator;
-
-    Rewriter(IRCode code, InstructionListIterator iterator, InvokeStatic serviceLoaderLoad) {
-      this.iterator = iterator;
-      this.code = code;
-      this.serviceLoaderLoad = serviceLoaderLoad;
-    }
-
-    public void perform(InvokeVirtual classLoaderInvoke, DexMethod method) {
-      // Remove the ClassLoader call since this can throw and will not be removed otherwise.
-      if (classLoaderInvoke != null) {
-        BooleanBox allClassLoaderUsersAreServiceLoaders =
-            new BooleanBox(!classLoaderInvoke.outValue().hasPhiUsers());
-        classLoaderInvoke
-            .outValue()
-            .aliasedUsers()
-            .forEach(user -> allClassLoaderUsersAreServiceLoaders.and(user == serviceLoaderLoad));
-        if (allClassLoaderUsersAreServiceLoaders.get()) {
-          clearGetClassLoader(classLoaderInvoke);
-          iterator.nextUntil(i -> i == serviceLoaderLoad);
-        }
+    public ServiceLoaderLoadResult(
+        InvokeStatic loadInvoke,
+        InvokeVirtual classLoaderInvoke,
+        DexType serviceType,
+        List<DexClass> implClasses,
+        InvokeVirtual iteratorInvoke) {
+      this.loadInvoke = loadInvoke;
+      this.classLoaderInvoke = classLoaderInvoke;
+      this.serviceType = serviceType;
+      this.implClasses = implClasses;
+      this.iteratorInvoke = iteratorInvoke;
       }
+  }
 
-      // Remove the ServiceLoader.load call.
-      InvokeVirtual serviceLoaderIterator =
-          serviceLoaderLoad.outValue().singleUniqueUser().asInvokeVirtual();
-      iterator.replaceCurrentInstruction(code.createConstNull());
+  private static class DirectRewriteResult {
+    public final InvokeMethod nextInstr;
+    public final InvokeMethod hasNextInstr;
 
-      // Find the iterator instruction and replace it.
-      iterator.nextUntil(x -> x == serviceLoaderIterator);
-      InvokeStatic synthesizedInvoke =
-          new InvokeStatic(method, serviceLoaderIterator.outValue(), ImmutableList.of());
-      iterator.replaceCurrentInstruction(synthesizedInvoke);
-    }
-
-    private void clearGetClassLoader(InvokeVirtual classLoaderInvoke) {
-      while (iterator.hasPrevious()) {
-        Instruction instruction = iterator.previous();
-        if (instruction == classLoaderInvoke) {
-          iterator.replaceCurrentInstruction(code.createConstNull());
-          break;
-        }
-      }
+    public DirectRewriteResult(InvokeMethod hasNextInstr, InvokeMethod nextInstr) {
+      this.hasNextInstr = hasNextInstr;
+      this.nextInstr = nextInstr;
     }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxerImpl.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxerImpl.java
index b26ed45..7a20f638 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxerImpl.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxerImpl.java
@@ -485,7 +485,7 @@
     //    MyEnum a = Enum.valueOf(MyEnum.class, "A");
     // - as a receiver for a name method, to allow unboxing of:
     //    MyEnum.class.getName();
-    DexType enumType = constClass.getValue();
+    DexType enumType = constClass.getType();
     if (!enumUnboxingCandidatesInfo.isCandidate(enumType)) {
       return;
     }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
index aabff86..bbfd363 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
@@ -614,8 +614,7 @@
         if (!invoke.getFirstArgument().isConstClass()) {
           return;
         }
-        DexType enumType =
-            invoke.getFirstArgument().getConstInstruction().asConstClass().getValue();
+        DexType enumType = invoke.getFirstArgument().getConstInstruction().asConstClass().getType();
         if (!unboxedEnumsData.isUnboxedEnum(enumType)) {
           return;
         }
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 c2b8988..fbf3767 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
@@ -247,8 +247,6 @@
       IRCode code,
       OptimizationFeedback feedback,
       InstanceFieldInitializationInfoCollection instanceFieldInitializationInfos) {
-    assert !appView.appInfo().isPinned(method);
-
     if (!method.isInstanceInitializer()) {
       return;
     }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodResolutionOptimizationInfoAnalysis.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodResolutionOptimizationInfoAnalysis.java
index 7cd5d83..291d46c 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodResolutionOptimizationInfoAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodResolutionOptimizationInfoAnalysis.java
@@ -169,9 +169,9 @@
       } else {
         for (DexEncodedMethod method : clazz.virtualMethods()) {
           KeepMethodInfo keepInfo = appViewWithLiveness.getKeepInfo().getMethodInfo(method, clazz);
-          if (!keepInfo.isShrinkingAllowed(appViewWithLiveness.options())) {
-            // Method is kept and could be overridden outside app (e.g., in tests). Verify we don't
-            // have any optimization info recorded for non-abstract methods.
+          if (keepInfo.isCodeReplacementAllowed(appViewWithLiveness.options())) {
+            // Method can be replaced. Verify we don't have any optimization info recorded for
+            // non-abstract methods.
             assert method.isAbstract()
                 || method.getOptimizationInfo().isDefault()
                 || method.getOptimizationInfo().returnValueHasBeenPropagated();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/inliner/InlinerUtils.java b/src/main/java/com/android/tools/r8/ir/optimize/inliner/InlinerUtils.java
index a29b465..970ecac 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/inliner/InlinerUtils.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/inliner/InlinerUtils.java
@@ -33,7 +33,7 @@
     if (monitorEnterValue.isPhi() || !monitorEnterValue.definition.isConstClass()) {
       nonConstantMonitorEnterValues.add(monitorEnterValue);
     } else {
-      constantMonitorEnterValues.add(monitorEnterValue.definition.asConstClass().getValue());
+      constantMonitorEnterValues.add(monitorEnterValue.definition.asConstClass().getType());
     }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/library/EnumMethodOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/library/EnumMethodOptimizer.java
index f5cc0a5..6af000b 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/library/EnumMethodOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/library/EnumMethodOptimizer.java
@@ -66,7 +66,7 @@
     if (invoke.getBlock().hasCatchHandlers()) {
       return;
     }
-    DexType enumType = invoke.inValues().get(0).getConstInstruction().asConstClass().getValue();
+    DexType enumType = invoke.inValues().get(0).getConstInstruction().asConstClass().getType();
     DexProgramClass enumClass = appView.definitionForProgramType(enumType);
     if (enumClass == null
         || !enumClass.isEnum()
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/typechecks/CheckCastAndInstanceOfMethodSpecialization.java b/src/main/java/com/android/tools/r8/ir/optimize/typechecks/CheckCastAndInstanceOfMethodSpecialization.java
index 2e2c0a1..7bda442 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/typechecks/CheckCastAndInstanceOfMethodSpecialization.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/typechecks/CheckCastAndInstanceOfMethodSpecialization.java
@@ -119,10 +119,10 @@
       return;
     }
 
-    // Verify that the methods are not pinned. They shouldn't be, since we've computed an abstract
-    // return value for both.
-    assert !appView.appInfo().isPinned(method);
-    assert !appView.appInfo().isPinned(parentMethod);
+    // Verify that the methods are not replaceable. They shouldn't be, since we've computed an
+    // abstract return value for both.
+    assert !appView.getKeepInfo(method).isCodeReplacementAllowed(appView.options());
+    assert !appView.getKeepInfo(parentMethod).isCodeReplacementAllowed(appView.options());
 
     if (appView
         .appInfo()
diff --git a/src/main/java/com/android/tools/r8/naming/IdentifierNameStringUtils.java b/src/main/java/com/android/tools/r8/naming/IdentifierNameStringUtils.java
index 9074bdb..f312d7d 100644
--- a/src/main/java/com/android/tools/r8/naming/IdentifierNameStringUtils.java
+++ b/src/main/java/com/android/tools/r8/naming/IdentifierNameStringUtils.java
@@ -245,7 +245,7 @@
       if (!classValue.isConstClass()) {
         return null;
       }
-      DexType holderType = classValue.getConstInstruction().asConstClass().getValue();
+      DexType holderType = classValue.getConstInstruction().asConstClass().getType();
       if (holderType.isArrayType()) {
         // None of the fields or methods of an array type will be renamed, since they are all
         // declared in the library. Hence there is no need to handle this case.
@@ -262,7 +262,7 @@
         if (!fieldTypeValue.isConstClass()) {
           return null;
         }
-        DexType fieldType = fieldTypeValue.getConstInstruction().asConstClass().getValue();
+        DexType fieldType = fieldTypeValue.getConstInstruction().asConstClass().getType();
         return IdentifierNameStringLookupResult.fromUncategorized(
             inferFieldInHolder(holder, dexString.toString(), fieldType));
       }
@@ -419,7 +419,7 @@
       return null;
     }
     if (value.isConstant() && value.getConstInstruction().isConstClass()) {
-      return value.getConstInstruction().asConstClass().getValue();
+      return value.getConstInstruction().asConstClass().getType();
     }
     if (value.definition.isStaticGet()) {
       return factory.primitiveTypesBoxedTypeFields.boxedFieldTypeToPrimitiveType(
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 4f374e6..8b19ac3 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
@@ -211,644 +211,610 @@
       IRCode code,
       AbstractValueSupplier abstractValueSupplier,
       Timing timing) {
-    timing.begin("Argument propagation scanner");
-    for (Instruction instruction : code.instructions()) {
-      if (instruction.isFieldPut()) {
-        scan(instruction.asFieldPut(), abstractValueSupplier, method, timing);
-      } else if (instruction.isInvokeMethod()) {
-        scan(instruction.asInvokeMethod(), abstractValueSupplier, method, timing);
-      } else if (instruction.isInvokeCustom()) {
-        scan(instruction.asInvokeCustom());
-      }
-    }
-    timing.end();
+    new CodeScanner(abstractValueSupplier, code, method).scan(timing);
   }
 
-  private void scan(
-      FieldPut fieldPut,
-      AbstractValueSupplier abstractValueSupplier,
-      ProgramMethod context,
-      Timing timing) {
-    ProgramField field = fieldPut.resolveField(appView, context).getProgramField();
-    if (field == null) {
-      // Nothing to propagate.
-      return;
-    }
-    addTemporaryFieldState(fieldPut, field, abstractValueSupplier, context, timing);
-  }
+  protected class CodeScanner {
 
-  private void addTemporaryFieldState(
-      FieldPut fieldPut,
-      ProgramField field,
-      AbstractValueSupplier abstractValueSupplier,
-      ProgramMethod context,
-      Timing timing) {
-    timing.begin("Add field state");
-    fieldStates.addTemporaryFieldState(
-        field,
-        () -> computeFieldState(fieldPut, field, abstractValueSupplier, context, timing),
-        timing,
-        (existingFieldState, fieldStateToAdd) -> {
-          DexType inStaticType = null;
-          NonEmptyValueState newFieldState =
-              existingFieldState.mutableJoin(
-                  appView,
-                  fieldStateToAdd,
-                  inStaticType,
-                  field.getType(),
-                  StateCloner.getCloner(),
-                  Action.empty());
-          return narrowFieldState(field, newFieldState);
-        });
-    timing.end();
-  }
+    protected final AbstractValueSupplier abstractValueSupplier;
+    protected final IRCode code;
+    protected final ProgramMethod context;
 
-  private NonEmptyValueState computeFieldState(
-      FieldPut fieldPut,
-      ProgramField resolvedField,
-      AbstractValueSupplier abstractValueSupplier,
-      ProgramMethod context,
-      Timing timing) {
-    timing.begin("Compute field state for field-put");
-    NonEmptyValueState result =
-        computeFieldState(fieldPut, resolvedField, abstractValueSupplier, context);
-    timing.end();
-    return result;
-  }
-
-  private NonEmptyValueState computeFieldState(
-      FieldPut fieldPut,
-      ProgramField field,
-      AbstractValueSupplier abstractValueSupplier,
-      ProgramMethod context) {
-    TypeElement fieldType = field.getType().toTypeElement(appView);
-    if (!fieldPut.value().getType().lessThanOrEqual(fieldType, appView)) {
-      return ValueState.unknown();
+    protected CodeScanner(
+        AbstractValueSupplier abstractValueSupplier, IRCode code, ProgramMethod method) {
+      this.abstractValueSupplier = abstractValueSupplier;
+      this.code = code;
+      this.context = method;
     }
 
-    NonEmptyValueState inFlowState = computeInFlowState(field.getType(), fieldPut.value(), context);
-    if (inFlowState != null) {
-      return inFlowState;
-    }
-
-    if (field.getType().isArrayType()) {
-      Nullability nullability = fieldPut.value().getType().nullability();
-      return ConcreteArrayTypeValueState.create(nullability);
-    }
-
-    AbstractValue abstractValue = abstractValueSupplier.getAbstractValue(fieldPut.value());
-    if (abstractValue.isUnknown()) {
-      abstractValue =
-          getFallbackAbstractValueForField(
-              field,
-              () -> ObjectStateAnalysis.computeObjectState(fieldPut.value(), appView, context));
-    }
-    if (field.getType().isClassType()) {
-      DynamicType dynamicType =
-          WideningUtils.widenDynamicNonReceiverType(
-              appView, fieldPut.value().getDynamicType(appView), field.getType());
-      return ConcreteClassTypeValueState.create(abstractValue, dynamicType);
-    } else {
-      assert field.getType().isPrimitiveType();
-      return ConcretePrimitiveTypeValueState.create(abstractValue);
-    }
-  }
-
-  // If the value is an argument of the enclosing method or defined by a field-get, then clearly we
-  // have no information about its abstract value (yet). Instead of treating this as having an
-  // unknown runtime value, we instead record a flow constraint.
-  private InFlow computeInFlow(DexType staticType, Value value, ProgramMethod context) {
-    Value valueRoot = value.getAliasedValue(aliasedValueConfiguration);
-    if (valueRoot.isArgument()) {
-      MethodParameter inParameter =
-          methodParameterFactory.create(context, valueRoot.getDefinition().asArgument().getIndex());
-      return castBaseInFlow(widenBaseInFlow(staticType, inParameter, context), value);
-    } else if (valueRoot.isDefinedByInstructionSatisfying(Instruction::isFieldGet)) {
-      FieldGet fieldGet = valueRoot.getDefinition().asFieldGet();
-      ProgramField field = fieldGet.resolveField(appView, context).getProgramField();
-      if (field == null) {
-        return null;
-      }
-      if (fieldGet.isInstanceGet()) {
-        Value receiverValue = fieldGet.asInstanceGet().object();
-        BaseInFlow receiverInFlow =
-            asBaseInFlowOrNull(computeInFlow(staticType, receiverValue, context));
-        if (receiverInFlow != null
-            && receiverInFlow.equals(widenBaseInFlow(staticType, receiverInFlow, context))) {
-          return new InstanceFieldReadAbstractFunction(receiverInFlow, field.getReference());
+    public void scan(Timing timing) {
+      timing.begin("Argument propagation scanner");
+      for (Instruction instruction : code.instructions()) {
+        if (instruction.isFieldPut()) {
+          scanFieldPut(instruction.asFieldPut(), timing);
+        } else if (instruction.isInvokeMethod()) {
+          scanInvoke(instruction.asInvokeMethod(), timing);
+        } else if (instruction.isInvokeCustom()) {
+          scanInvokeCustom(instruction.asInvokeCustom());
         }
       }
-      return castBaseInFlow(
-          widenBaseInFlow(staticType, fieldValueFactory.create(field), context), value);
+      timing.end();
     }
-    return null;
-  }
 
-  private InFlow castBaseInFlow(InFlow inFlow, Value value) {
-    if (inFlow.isUnknownAbstractFunction()) {
-      return inFlow;
-    }
-    assert inFlow.isBaseInFlow();
-    Value valueRoot = value.getAliasedValue();
-    if (!valueRoot.isDefinedByInstructionSatisfying(Instruction::isCheckCast)) {
-      return inFlow;
-    }
-    CheckCast checkCast = valueRoot.getDefinition().asCheckCast();
-    return new CastAbstractFunction(inFlow.asBaseInFlow(), checkCast.getType());
-  }
-
-  private InFlow widenBaseInFlow(DexType staticType, BaseInFlow inFlow, ProgramMethod context) {
-    if (inFlow.isFieldValue()) {
-      if (isFieldValueAlreadyUnknown(staticType, inFlow.asFieldValue().getField())) {
-        return AbstractFunction.unknown();
+    private void scanFieldPut(FieldPut fieldPut, Timing timing) {
+      ProgramField field = fieldPut.resolveField(appView, context).getProgramField();
+      if (field == null) {
+        // Nothing to propagate.
+        return;
       }
-    } else {
-      assert inFlow.isMethodParameter();
-      if (isMethodParameterAlreadyUnknown(staticType, inFlow.asMethodParameter(), context)) {
-        return AbstractFunction.unknown();
-      }
+      addTemporaryFieldState(fieldPut, field, timing);
     }
-    return inFlow;
-  }
 
-  private NonEmptyValueState computeInFlowState(
-      DexType staticType, Value value, ProgramMethod context) {
-    InFlow inFlow = computeInFlow(staticType, value, context);
-    if (inFlow == null) {
-      return null;
+    private void addTemporaryFieldState(FieldPut fieldPut, ProgramField field, Timing timing) {
+      timing.begin("Add field state");
+      fieldStates.addTemporaryFieldState(
+          field,
+          () -> computeFieldState(fieldPut, field, timing),
+          timing,
+          (existingFieldState, fieldStateToAdd) -> {
+            DexType inStaticType = null;
+            NonEmptyValueState newFieldState =
+                existingFieldState.mutableJoin(
+                    appView,
+                    fieldStateToAdd,
+                    inStaticType,
+                    field.getType(),
+                    StateCloner.getCloner(),
+                    Action.empty());
+            return narrowFieldState(field, newFieldState);
+          });
+      timing.end();
     }
-    if (inFlow.isUnknownAbstractFunction()) {
-      return ValueState.unknown();
-    }
-    assert inFlow.isBaseInFlow()
-        || inFlow.isCastAbstractFunction()
-        || inFlow.isInstanceFieldReadAbstractFunction();
-    return ConcreteValueState.create(staticType, inFlow);
-  }
 
-  // Strengthens the abstract value of static final fields to a (self-)SingleFieldValue when the
-  // abstract value is unknown. The soundness of this is based on the fact that static final fields
-  // will never have their value changed after the <clinit> finishes, so value in a static final
-  // field can always be rematerialized by reading the field.
-  private NonEmptyValueState narrowFieldState(ProgramField field, NonEmptyValueState fieldState) {
-    AbstractValue fallbackAbstractValue =
-        getFallbackAbstractValueForField(field, ObjectState::empty);
-    if (!fallbackAbstractValue.isUnknown()) {
-      AbstractValue abstractValue = fieldState.getAbstractValue(appView);
-      if (!abstractValue.isUnknown()) {
-        return fieldState;
+    private NonEmptyValueState computeFieldState(
+        FieldPut fieldPut, ProgramField resolvedField, Timing timing) {
+      timing.begin("Compute field state for field-put");
+      NonEmptyValueState result = computeFieldState(fieldPut, resolvedField);
+      timing.end();
+      return result;
+    }
+
+    private NonEmptyValueState computeFieldState(FieldPut fieldPut, ProgramField field) {
+      TypeElement fieldType = field.getType().toTypeElement(appView);
+      if (!fieldPut.value().getType().lessThanOrEqual(fieldType, appView)) {
+        return ValueState.unknown();
       }
+
+      NonEmptyValueState inFlowState =
+          computeInFlowState(field.getType(), fieldPut.value(), context);
+      if (inFlowState != null) {
+        return inFlowState;
+      }
+
       if (field.getType().isArrayType()) {
-        // We do not track an abstract value for array types.
-        return fieldState;
+        Nullability nullability = fieldPut.value().getType().nullability();
+        return ConcreteArrayTypeValueState.create(nullability);
+      }
+
+      AbstractValue abstractValue = abstractValueSupplier.getAbstractValue(fieldPut.value());
+      if (abstractValue.isUnknown()) {
+        abstractValue =
+            getFallbackAbstractValueForField(
+                field,
+                () -> ObjectStateAnalysis.computeObjectState(fieldPut.value(), appView, context));
       }
       if (field.getType().isClassType()) {
         DynamicType dynamicType =
-            fieldState.isReferenceState()
-                ? fieldState.asReferenceState().getDynamicType()
-                : DynamicType.unknown();
-        return new ConcreteClassTypeValueState(fallbackAbstractValue, dynamicType);
+            WideningUtils.widenDynamicNonReceiverType(
+                appView, fieldPut.value().getDynamicType(appView), field.getType());
+        return ConcreteClassTypeValueState.create(abstractValue, dynamicType);
       } else {
         assert field.getType().isPrimitiveType();
-        return new ConcretePrimitiveTypeValueState(fallbackAbstractValue);
+        return ConcretePrimitiveTypeValueState.create(abstractValue);
       }
     }
-    return fieldState;
-  }
 
-  private AbstractValue getFallbackAbstractValueForField(
-      ProgramField field, Supplier<ObjectState> objectStateSupplier) {
-    if (field.isFinalOrEffectivelyFinal(appView) && field.getAccessFlags().isStatic()) {
-      return appView
-          .abstractValueFactory()
-          .createSingleFieldValue(field.getReference(), objectStateSupplier.get());
-    }
-    return AbstractValue.unknown();
-  }
-
-  private void scan(
-      InvokeMethod invoke,
-      AbstractValueSupplier abstractValueSupplier,
-      ProgramMethod context,
-      Timing timing) {
-    DexMethod invokedMethod = invoke.getInvokedMethod();
-    if (invokedMethod.getHolderType().isArrayType()) {
-      // Nothing to propagate; the targeted method is not a program method.
-      return;
+    // If the value is an argument of the enclosing method or defined by a field-get, then clearly
+    // we have no information about its abstract value (yet). Instead of treating this as having an
+    // unknown runtime value, we instead record a flow constraint.
+    private InFlow computeInFlow(DexType staticType, Value value, ProgramMethod context) {
+      Value valueRoot = value.getAliasedValue(aliasedValueConfiguration);
+      if (valueRoot.isArgument()) {
+        MethodParameter inParameter =
+            methodParameterFactory.create(
+                context, valueRoot.getDefinition().asArgument().getIndex());
+        return castBaseInFlow(widenBaseInFlow(staticType, inParameter, context), value);
+      } else if (valueRoot.isDefinedByInstructionSatisfying(Instruction::isFieldGet)) {
+        FieldGet fieldGet = valueRoot.getDefinition().asFieldGet();
+        ProgramField field = fieldGet.resolveField(appView, context).getProgramField();
+        if (field == null) {
+          return null;
+        }
+        if (fieldGet.isInstanceGet()) {
+          Value receiverValue = fieldGet.asInstanceGet().object();
+          BaseInFlow receiverInFlow =
+              asBaseInFlowOrNull(computeInFlow(staticType, receiverValue, context));
+          if (receiverInFlow != null
+              && receiverInFlow.equals(widenBaseInFlow(staticType, receiverInFlow, context))) {
+            return new InstanceFieldReadAbstractFunction(receiverInFlow, field.getReference());
+          }
+        }
+        return castBaseInFlow(
+            widenBaseInFlow(staticType, fieldValueFactory.create(field), context), value);
+      }
+      return null;
     }
 
-    if (appView.options().testing.checkReceiverAlwaysNullInCallSiteOptimization
-        && invoke.isInvokeMethodWithReceiver()
-        && invoke.asInvokeMethodWithReceiver().getReceiver().isAlwaysNull(appView)) {
-      // Nothing to propagate; the invoke instruction always fails.
-      return;
+    private InFlow castBaseInFlow(InFlow inFlow, Value value) {
+      if (inFlow.isUnknownAbstractFunction()) {
+        return inFlow;
+      }
+      assert inFlow.isBaseInFlow();
+      Value valueRoot = value.getAliasedValue();
+      if (!valueRoot.isDefinedByInstructionSatisfying(Instruction::isCheckCast)) {
+        return inFlow;
+      }
+      CheckCast checkCast = valueRoot.getDefinition().asCheckCast();
+      return new CastAbstractFunction(inFlow.asBaseInFlow(), checkCast.getType());
     }
 
-    SingleResolutionResult<?> resolutionResult =
-        invoke.resolveMethod(appView, context).asSingleResolution();
-    if (resolutionResult == null) {
-      // Nothing to propagate; the invoke instruction fails.
-      return;
+    private InFlow widenBaseInFlow(DexType staticType, BaseInFlow inFlow, ProgramMethod context) {
+      if (inFlow.isFieldValue()) {
+        if (isFieldValueAlreadyUnknown(staticType, inFlow.asFieldValue().getField())) {
+          return AbstractFunction.unknown();
+        }
+      } else {
+        assert inFlow.isMethodParameter();
+        if (isMethodParameterAlreadyUnknown(staticType, inFlow.asMethodParameter(), context)) {
+          return AbstractFunction.unknown();
+        }
+      }
+      return inFlow;
     }
 
-    if (!resolutionResult.getResolvedHolder().isProgramClass()) {
-      // Nothing to propagate; this could dispatch to a program method, but we cannot optimize
-      // methods that override non-program methods.
-      return;
+    private NonEmptyValueState computeInFlowState(
+        DexType staticType, Value value, ProgramMethod context) {
+      InFlow inFlow = computeInFlow(staticType, value, context);
+      if (inFlow == null) {
+        return null;
+      }
+      if (inFlow.isUnknownAbstractFunction()) {
+        return ValueState.unknown();
+      }
+      assert inFlow.isBaseInFlow()
+          || inFlow.isCastAbstractFunction()
+          || inFlow.isInstanceFieldReadAbstractFunction();
+      return ConcreteValueState.create(staticType, inFlow);
     }
 
-    ProgramMethod resolvedMethod = resolutionResult.getResolvedProgramMethod();
-    if (resolvedMethod.getDefinition().isLibraryMethodOverride().isPossiblyTrue()) {
-      assert resolvedMethod.getDefinition().isLibraryMethodOverride().isTrue();
-      // Nothing to propagate; we don't know anything about methods that can be called from outside
-      // the program.
-      return;
+    // Strengthens the abstract value of static final fields to a (self-)SingleFieldValue when the
+    // abstract value is unknown. The soundness of this is based on the fact that static final
+    // fields will never have their value changed after the <clinit> finishes, so value in a static
+    // final field can always be rematerialized by reading the field.
+    private NonEmptyValueState narrowFieldState(ProgramField field, NonEmptyValueState fieldState) {
+      AbstractValue fallbackAbstractValue =
+          getFallbackAbstractValueForField(field, ObjectState::empty);
+      if (!fallbackAbstractValue.isUnknown()) {
+        AbstractValue abstractValue = fieldState.getAbstractValue(appView);
+        if (!abstractValue.isUnknown()) {
+          return fieldState;
+        }
+        if (field.getType().isArrayType()) {
+          // We do not track an abstract value for array types.
+          return fieldState;
+        }
+        if (field.getType().isClassType()) {
+          DynamicType dynamicType =
+              fieldState.isReferenceState()
+                  ? fieldState.asReferenceState().getDynamicType()
+                  : DynamicType.unknown();
+          return new ConcreteClassTypeValueState(fallbackAbstractValue, dynamicType);
+        } else {
+          assert field.getType().isPrimitiveType();
+          return new ConcretePrimitiveTypeValueState(fallbackAbstractValue);
+        }
+      }
+      return fieldState;
     }
 
-    if (invoke.arguments().size() != resolvedMethod.getDefinition().getNumberOfArguments()
-        || invoke.isInvokeStatic() != resolvedMethod.getAccessFlags().isStatic()) {
-      // Nothing to propagate; the invoke instruction fails.
-      return;
+    private AbstractValue getFallbackAbstractValueForField(
+        ProgramField field, Supplier<ObjectState> objectStateSupplier) {
+      if (field.isFinalOrEffectivelyFinal(appView) && field.getAccessFlags().isStatic()) {
+        return appView
+            .abstractValueFactory()
+            .createSingleFieldValue(field.getReference(), objectStateSupplier.get());
+      }
+      return AbstractValue.unknown();
     }
 
-    if (invoke.isInvokeInterface()) {
-      if (!resolutionResult.getInitialResolutionHolder().isInterface()) {
+    private void scanInvoke(InvokeMethod invoke, Timing timing) {
+      DexMethod invokedMethod = invoke.getInvokedMethod();
+      if (invokedMethod.getHolderType().isArrayType()) {
+        // Nothing to propagate; the targeted method is not a program method.
+        return;
+      }
+
+      if (appView.options().testing.checkReceiverAlwaysNullInCallSiteOptimization
+          && invoke.isInvokeMethodWithReceiver()
+          && invoke.asInvokeMethodWithReceiver().getReceiver().isAlwaysNull(appView)) {
+        // Nothing to propagate; the invoke instruction always fails.
+        return;
+      }
+
+      SingleResolutionResult<?> resolutionResult =
+          invoke.resolveMethod(appView, context).asSingleResolution();
+      if (resolutionResult == null) {
         // Nothing to propagate; the invoke instruction fails.
         return;
       }
-    }
 
-    if (invoke.isInvokeSuper()) {
-      // Use the super target instead of the resolved method to ensure that we propagate the
-      // argument information to the targeted method.
-      DexClassAndMethod target =
-          resolutionResult.lookupInvokeSuperTarget(context.getHolder(), appView);
-      if (target == null) {
+      if (!resolutionResult.getResolvedHolder().isProgramClass()) {
+        // Nothing to propagate; this could dispatch to a program method, but we cannot optimize
+        // methods that override non-program methods.
+        return;
+      }
+
+      ProgramMethod resolvedMethod = resolutionResult.getResolvedProgramMethod();
+      if (resolvedMethod.getDefinition().isLibraryMethodOverride().isPossiblyTrue()) {
+        assert resolvedMethod.getDefinition().isLibraryMethodOverride().isTrue();
+        // Nothing to propagate; we don't know anything about methods that can be called from
+        // outside the program.
+        return;
+      }
+
+      if (invoke.arguments().size() != resolvedMethod.getDefinition().getNumberOfArguments()
+          || invoke.isInvokeStatic() != resolvedMethod.getAccessFlags().isStatic()) {
         // Nothing to propagate; the invoke instruction fails.
         return;
       }
-      if (!target.isProgramMethod()) {
-        throw new Unreachable(
-            "Expected super target of a non-library override to be a program method ("
-                + "resolved program method: "
-                + resolvedMethod
-                + ", "
-                + "super non-program method: "
-                + target
-                + ")");
+
+      if (invoke.isInvokeInterface()) {
+        if (!resolutionResult.getInitialResolutionHolder().isInterface()) {
+          // Nothing to propagate; the invoke instruction fails.
+          return;
+        }
       }
-      resolvedMethod = target.asProgramMethod();
+
+      if (invoke.isInvokeSuper()) {
+        // Use the super target instead of the resolved method to ensure that we propagate the
+        // argument information to the targeted method.
+        DexClassAndMethod target =
+            resolutionResult.lookupInvokeSuperTarget(context.getHolder(), appView);
+        if (target == null) {
+          // Nothing to propagate; the invoke instruction fails.
+          return;
+        }
+        if (!target.isProgramMethod()) {
+          throw new Unreachable(
+              "Expected super target of a non-library override to be a program method ("
+                  + "resolved program method: "
+                  + resolvedMethod
+                  + ", "
+                  + "super non-program method: "
+                  + target
+                  + ")");
+        }
+        resolvedMethod = target.asProgramMethod();
+      }
+
+      // Find the method where to store the information about the arguments from this invoke.
+      // If the invoke may dispatch to more than one method, we intentionally do not compute all
+      // possible dispatch targets and propagate the information to these methods (this is
+      // expensive). Instead we record the information in one place and then later propagate the
+      // information to all dispatch targets.
+      addTemporaryMethodState(invoke, resolvedMethod, timing);
     }
 
-    // Find the method where to store the information about the arguments from this invoke.
-    // If the invoke may dispatch to more than one method, we intentionally do not compute all
-    // possible dispatch targets and propagate the information to these methods (this is expensive).
-    // Instead we record the information in one place and then later propagate the information to
-    // all dispatch targets.
-    addTemporaryMethodState(invoke, resolvedMethod, abstractValueSupplier, context, timing);
-  }
+    protected void addTemporaryMethodState(
+        InvokeMethod invoke, ProgramMethod resolvedMethod, Timing timing) {
+      timing.begin("Add method state");
+      methodStates.addTemporaryMethodState(
+          appView,
+          getRepresentative(invoke, resolvedMethod),
+          existingMethodState ->
+              computeMethodState(invoke, resolvedMethod, existingMethodState, timing),
+          timing);
+      timing.end();
+    }
 
-  protected void addTemporaryMethodState(
-      InvokeMethod invoke,
-      ProgramMethod resolvedMethod,
-      AbstractValueSupplier abstractValueSupplier,
-      ProgramMethod context,
-      Timing timing) {
-    timing.begin("Add method state");
-    methodStates.addTemporaryMethodState(
-        appView,
-        getRepresentative(invoke, resolvedMethod),
-        existingMethodState ->
-            computeMethodState(
+    private MethodState computeMethodState(
+        InvokeMethod invoke,
+        ProgramMethod resolvedMethod,
+        MethodState existingMethodState,
+        Timing timing) {
+      assert !existingMethodState.isUnknown();
+
+      // If this invoke may target at most one method, then we compute a state that maps each
+      // parameter to the abstract value and dynamic type provided by this call site. Otherwise, we
+      // compute a polymorphic method state, which includes information about the receiver's dynamic
+      // type bounds.
+      timing.begin("Compute method state for invoke");
+      MethodState result;
+      if (shouldUsePolymorphicMethodState(invoke, resolvedMethod)) {
+        assert existingMethodState.isBottom() || existingMethodState.isPolymorphic();
+        result =
+            computePolymorphicMethodState(
+                invoke.asInvokeMethodWithReceiver(),
+                resolvedMethod,
+                existingMethodState.asPolymorphicOrBottom());
+      } else {
+        assert existingMethodState.isBottom() || existingMethodState.isMonomorphic();
+        result =
+            computeMonomorphicMethodState(
                 invoke,
                 resolvedMethod,
-                abstractValueSupplier,
-                context,
-                existingMethodState,
-                timing),
-        timing);
-    timing.end();
-  }
+                invoke.lookupSingleProgramTarget(appView, context),
+                existingMethodState.asMonomorphicOrBottom());
+      }
+      timing.end();
+      return result;
+    }
 
-  private MethodState computeMethodState(
-      InvokeMethod invoke,
-      ProgramMethod resolvedMethod,
-      AbstractValueSupplier abstractValueSupplier,
-      ProgramMethod context,
-      MethodState existingMethodState,
-      Timing timing) {
-    assert !existingMethodState.isUnknown();
+    // TODO(b/190154391): Add a strategy that widens the dynamic receiver type to allow easily
+    //  experimenting with the performance/size trade-off between precise/imprecise handling of
+    //  dynamic dispatch.
+    private MethodState computePolymorphicMethodState(
+        InvokeMethodWithReceiver invoke,
+        ProgramMethod resolvedMethod,
+        ConcretePolymorphicMethodStateOrBottom existingMethodState) {
+      DynamicTypeWithUpperBound dynamicReceiverType = invoke.getReceiver().getDynamicType(appView);
+      // TODO(b/331587404): Investigate if we can replace the receiver by null before entering this
+      //  pass, so that this special case is not needed.
+      if (dynamicReceiverType.isNullType()) {
+        assert appView.testing().allowNullDynamicTypeInCodeScanner : "b/250634405";
+        // This can happen if we were unable to determine that the receiver is a phi value where
+        // null information has not been propagated down. Ideally this case would never happen as it
+        // should be possible to replace the receiver by the null constant in this case. Since the
+        // receiver is known to be null, no argument information should be propagated to the
+        // callees, so we return bottom here.
+        return MethodState.bottom();
+      }
 
-    // If this invoke may target at most one method, then we compute a state that maps each
-    // parameter to the abstract value and dynamic type provided by this call site. Otherwise, we
-    // compute a polymorphic method state, which includes information about the receiver's dynamic
-    // type bounds.
-    timing.begin("Compute method state for invoke");
-    MethodState result;
-    if (shouldUsePolymorphicMethodState(invoke, resolvedMethod)) {
-      assert existingMethodState.isBottom() || existingMethodState.isPolymorphic();
-      result =
-          computePolymorphicMethodState(
-              invoke.asInvokeMethodWithReceiver(),
-              resolvedMethod,
-              abstractValueSupplier,
-              context,
-              existingMethodState.asPolymorphicOrBottom());
-    } else {
-      assert existingMethodState.isBottom() || existingMethodState.isMonomorphic();
-      result =
+      ProgramMethod singleTarget = invoke.lookupSingleProgramTarget(appView, context);
+      DynamicTypeWithUpperBound bounds =
+          computeBoundsForPolymorphicMethodState(resolvedMethod, singleTarget, dynamicReceiverType);
+      MethodState existingMethodStateForBounds =
+          existingMethodState.isPolymorphic()
+              ? existingMethodState.asPolymorphic().getMethodStateForBounds(bounds)
+              : MethodState.bottom();
+
+      if (existingMethodStateForBounds.isPolymorphic()) {
+        assert false;
+        return MethodState.unknown();
+      }
+
+      // If we already don't know anything about the parameters for the given type bounds, then
+      // don't compute a method state.
+      if (existingMethodStateForBounds.isUnknown()) {
+        return MethodState.bottom();
+      }
+
+      ConcreteMonomorphicMethodStateOrUnknown methodStateForBounds =
           computeMonomorphicMethodState(
               invoke,
               resolvedMethod,
-              invoke.lookupSingleProgramTarget(appView, context),
-              abstractValueSupplier,
-              context,
-              existingMethodState.asMonomorphicOrBottom());
-    }
-    timing.end();
-    return result;
-  }
-
-  // TODO(b/190154391): Add a strategy that widens the dynamic receiver type to allow easily
-  //  experimenting with the performance/size trade-off between precise/imprecise handling of
-  //  dynamic dispatch.
-  private MethodState computePolymorphicMethodState(
-      InvokeMethodWithReceiver invoke,
-      ProgramMethod resolvedMethod,
-      AbstractValueSupplier abstractValueSupplier,
-      ProgramMethod context,
-      ConcretePolymorphicMethodStateOrBottom existingMethodState) {
-    DynamicTypeWithUpperBound dynamicReceiverType = invoke.getReceiver().getDynamicType(appView);
-    // TODO(b/331587404): Investigate if we can replace the receiver by null before entering this
-    //  pass, so that this special case is not needed.
-    if (dynamicReceiverType.isNullType()) {
-      assert appView.testing().allowNullDynamicTypeInCodeScanner : "b/250634405";
-      // This can happen if we were unable to determine that the receiver is a phi value where null
-      // information has not been propagated down. Ideally this case would never happen as it should
-      // be possible to replace the receiver by the null constant in this case.
-      //
-      // Since the receiver is known to be null, no argument information should be propagated to the
-      // callees, so we return bottom here.
-      return MethodState.bottom();
+              singleTarget,
+              existingMethodStateForBounds.asMonomorphicOrBottom(),
+              dynamicReceiverType);
+      return ConcretePolymorphicMethodState.create(bounds, methodStateForBounds);
     }
 
-    ProgramMethod singleTarget = invoke.lookupSingleProgramTarget(appView, context);
-    DynamicTypeWithUpperBound bounds =
-        computeBoundsForPolymorphicMethodState(resolvedMethod, singleTarget, dynamicReceiverType);
-    MethodState existingMethodStateForBounds =
-        existingMethodState.isPolymorphic()
-            ? existingMethodState.asPolymorphic().getMethodStateForBounds(bounds)
-            : MethodState.bottom();
+    private DynamicTypeWithUpperBound computeBoundsForPolymorphicMethodState(
+        ProgramMethod resolvedMethod,
+        ProgramMethod singleTarget,
+        DynamicTypeWithUpperBound dynamicReceiverType) {
+      DynamicTypeWithUpperBound bounds =
+          singleTarget != null
+              ? DynamicType.createExact(
+                  singleTarget.getHolderType().toTypeElement(appView).asClassType())
+              : dynamicReceiverType.withNullability(Nullability.maybeNull());
 
-    if (existingMethodStateForBounds.isPolymorphic()) {
-      assert false;
-      return MethodState.unknown();
-    }
+      // We intentionally drop the nullability for the type bounds. This increases the number of
+      // collisions in the polymorphic method states, which does not change the precision (since the
+      // nullability does not have any impact on the possible dispatch targets) and is good for
+      // state pruning.
+      assert bounds.getDynamicUpperBoundType().nullability().isMaybeNull();
 
-    // If we already don't know anything about the parameters for the given type bounds, then don't
-    // compute a method state.
-    if (existingMethodStateForBounds.isUnknown()) {
-      return MethodState.bottom();
-    }
+      // If the bounds are trivial (i.e., the upper bound is equal to the holder of the virtual root
+      // method), then widen the type bounds to 'unknown'.
+      DexMethod virtualRootMethod = getVirtualRootMethod(resolvedMethod);
+      if (virtualRootMethod == null) {
+        assert false : "Unexpected virtual method without root: " + resolvedMethod;
+        return bounds;
+      }
 
-    ConcreteMonomorphicMethodStateOrUnknown methodStateForBounds =
-        computeMonomorphicMethodState(
-            invoke,
-            resolvedMethod,
-            singleTarget,
-            abstractValueSupplier,
-            context,
-            existingMethodStateForBounds.asMonomorphicOrBottom(),
-            dynamicReceiverType);
-    return ConcretePolymorphicMethodState.create(bounds, methodStateForBounds);
-  }
-
-  private DynamicTypeWithUpperBound computeBoundsForPolymorphicMethodState(
-      ProgramMethod resolvedMethod,
-      ProgramMethod singleTarget,
-      DynamicTypeWithUpperBound dynamicReceiverType) {
-    DynamicTypeWithUpperBound bounds =
-        singleTarget != null
-            ? DynamicType.createExact(
-                singleTarget.getHolderType().toTypeElement(appView).asClassType())
-            : dynamicReceiverType.withNullability(Nullability.maybeNull());
-
-    // We intentionally drop the nullability for the type bounds. This increases the number of
-    // collisions in the polymorphic method states, which does not change the precision (since the
-    // nullability does not have any impact on the possible dispatch targets) and is good for state
-    // pruning.
-    assert bounds.getDynamicUpperBoundType().nullability().isMaybeNull();
-
-    // If the bounds are trivial (i.e., the upper bound is equal to the holder of the virtual root
-    // method), then widen the type bounds to 'unknown'.
-    DexMethod virtualRootMethod = getVirtualRootMethod(resolvedMethod);
-    if (virtualRootMethod == null) {
-      assert false : "Unexpected virtual method without root: " + resolvedMethod;
+      DynamicType trivialBounds =
+          DynamicType.create(
+              appView, virtualRootMethod.getHolderType().toTypeElement(appView).asClassType());
+      if (bounds.equals(trivialBounds)) {
+        return DynamicType.unknown();
+      }
       return bounds;
     }
 
-    DynamicType trivialBounds =
-        DynamicType.create(
-            appView, virtualRootMethod.getHolderType().toTypeElement(appView).asClassType());
-    if (bounds.equals(trivialBounds)) {
-      return DynamicType.unknown();
-    }
-    return bounds;
-  }
-
-  private ConcreteMonomorphicMethodStateOrUnknown computeMonomorphicMethodState(
-      InvokeMethod invoke,
-      ProgramMethod resolvedMethod,
-      ProgramMethod singleTarget,
-      AbstractValueSupplier abstractValueSupplier,
-      ProgramMethod context,
-      ConcreteMonomorphicMethodStateOrBottom existingMethodState) {
-    return computeMonomorphicMethodState(
-        invoke,
-        resolvedMethod,
-        singleTarget,
-        abstractValueSupplier,
-        context,
-        existingMethodState,
-        invoke.isInvokeMethodWithReceiver()
-            ? invoke.getFirstArgument().getDynamicType(appView)
-            : null);
-  }
-
-  @SuppressWarnings("UnusedVariable")
-  private ConcreteMonomorphicMethodStateOrUnknown computeMonomorphicMethodState(
-      InvokeMethod invoke,
-      ProgramMethod resolvedMethod,
-      ProgramMethod singleTarget,
-      AbstractValueSupplier abstractValueSupplier,
-      ProgramMethod context,
-      ConcreteMonomorphicMethodStateOrBottom existingMethodState,
-      DynamicType dynamicReceiverType) {
-    List<ValueState> parameterStates = new ArrayList<>(invoke.arguments().size());
-
-    MethodReprocessingCriteria methodReprocessingCriteria =
-        singleTarget != null
-            ? reprocessingCriteriaCollection.getReprocessingCriteria(singleTarget)
-            : MethodReprocessingCriteria.alwaysReprocess();
-
-    int argumentIndex = 0;
-    if (invoke.isInvokeMethodWithReceiver()) {
-      assert dynamicReceiverType != null;
-      parameterStates.add(
-          computeParameterStateForReceiver(
-              resolvedMethod,
-              dynamicReceiverType,
-              existingMethodState,
-              methodReprocessingCriteria.getParameterReprocessingCriteria(0)));
-      argumentIndex++;
+    private ConcreteMonomorphicMethodStateOrUnknown computeMonomorphicMethodState(
+        InvokeMethod invoke,
+        ProgramMethod resolvedMethod,
+        ProgramMethod singleTarget,
+        ConcreteMonomorphicMethodStateOrBottom existingMethodState) {
+      return computeMonomorphicMethodState(
+          invoke,
+          resolvedMethod,
+          singleTarget,
+          existingMethodState,
+          invoke.isInvokeMethodWithReceiver()
+              ? invoke.getFirstArgument().getDynamicType(appView)
+              : null);
     }
 
-    for (; argumentIndex < invoke.arguments().size(); argumentIndex++) {
-      parameterStates.add(
-          computeParameterStateForNonReceiver(
-              invoke,
-              singleTarget,
-              argumentIndex,
-              invoke.getArgument(argumentIndex),
-              abstractValueSupplier,
-              context,
-              existingMethodState));
+    @SuppressWarnings("UnusedVariable")
+    private ConcreteMonomorphicMethodStateOrUnknown computeMonomorphicMethodState(
+        InvokeMethod invoke,
+        ProgramMethod resolvedMethod,
+        ProgramMethod singleTarget,
+        ConcreteMonomorphicMethodStateOrBottom existingMethodState,
+        DynamicType dynamicReceiverType) {
+      List<ValueState> parameterStates = new ArrayList<>(invoke.arguments().size());
+
+      MethodReprocessingCriteria methodReprocessingCriteria =
+          singleTarget != null
+              ? reprocessingCriteriaCollection.getReprocessingCriteria(singleTarget)
+              : MethodReprocessingCriteria.alwaysReprocess();
+
+      int argumentIndex = 0;
+      if (invoke.isInvokeMethodWithReceiver()) {
+        assert dynamicReceiverType != null;
+        parameterStates.add(
+            computeParameterStateForReceiver(
+                resolvedMethod,
+                dynamicReceiverType,
+                existingMethodState,
+                methodReprocessingCriteria.getParameterReprocessingCriteria(0)));
+        argumentIndex++;
+      }
+
+      for (; argumentIndex < invoke.arguments().size(); argumentIndex++) {
+        parameterStates.add(
+            computeParameterStateForNonReceiver(
+                invoke,
+                singleTarget,
+                argumentIndex,
+                invoke.getArgument(argumentIndex),
+                existingMethodState));
+      }
+
+      // We simulate that the return value is used for methods with void return type. This ensures
+      // that we will widen the method state to unknown if/when all parameter states become unknown.
+      boolean isReturnValueUsed = invoke.getReturnType().isVoidType() || invoke.hasUsedOutValue();
+      return ConcreteMonomorphicMethodState.create(isReturnValueUsed, parameterStates);
     }
 
-    // We simulate that the return value is used for methods with void return type. This ensures
-    // that we will widen the method state to unknown if/when all parameter states become unknown.
-    boolean isReturnValueUsed = invoke.getReturnType().isVoidType() || invoke.hasUsedOutValue();
-    return ConcreteMonomorphicMethodState.create(isReturnValueUsed, parameterStates);
-  }
+    // For receivers there is not much point in trying to track an abstract value. Therefore we only
+    // track the dynamic type for receivers.
+    // TODO(b/190154391): Consider validating the above hypothesis by using
+    //  computeParameterStateForNonReceiver() for receivers.
+    private ValueState computeParameterStateForReceiver(
+        ProgramMethod resolvedMethod,
+        DynamicType dynamicReceiverType,
+        ConcreteMonomorphicMethodStateOrBottom existingMethodState,
+        ParameterReprocessingCriteria parameterReprocessingCriteria) {
+      // Don't compute a state for this parameter if the stored state is already unknown.
+      if (existingMethodState.isMonomorphic()
+          && existingMethodState.asMonomorphic().getParameterState(0).isUnknown()) {
+        return ValueState.unknown();
+      }
 
-  // For receivers there is not much point in trying to track an abstract value. Therefore we only
-  // track the dynamic type for receivers.
-  // TODO(b/190154391): Consider validating the above hypothesis by using
-  //  computeParameterStateForNonReceiver() for receivers.
-  private ValueState computeParameterStateForReceiver(
-      ProgramMethod resolvedMethod,
-      DynamicType dynamicReceiverType,
-      ConcreteMonomorphicMethodStateOrBottom existingMethodState,
-      ParameterReprocessingCriteria parameterReprocessingCriteria) {
-    // Don't compute a state for this parameter if the stored state is already unknown.
-    if (existingMethodState.isMonomorphic()
-        && existingMethodState.asMonomorphic().getParameterState(0).isUnknown()) {
-      return ValueState.unknown();
+      // For receivers we only track the dynamic type. Therefore, if there is no need to track the
+      // dynamic type of the receiver of the targeted method, then just return unknown.
+      if (!parameterReprocessingCriteria.shouldReprocessDueToDynamicType()) {
+        return ValueState.unknown();
+      }
+
+      DynamicType widenedDynamicReceiverType =
+          WideningUtils.widenDynamicReceiverType(appView, resolvedMethod, dynamicReceiverType);
+      return widenedDynamicReceiverType.isUnknown()
+          ? ValueState.unknown()
+          : new ConcreteReceiverValueState(dynamicReceiverType);
     }
 
-    // For receivers we only track the dynamic type. Therefore, if there is no need to track the
-    // dynamic type of the receiver of the targeted method, then just return unknown.
-    if (!parameterReprocessingCriteria.shouldReprocessDueToDynamicType()) {
-      return ValueState.unknown();
+    @SuppressWarnings("UnusedVariable")
+    private ValueState computeParameterStateForNonReceiver(
+        InvokeMethod invoke,
+        ProgramMethod singleTarget,
+        int argumentIndex,
+        Value argument,
+        ConcreteMonomorphicMethodStateOrBottom existingMethodState) {
+      ValueState modeledState =
+          modeling.modelParameterStateForArgumentToFunction(
+              invoke, singleTarget, argumentIndex, argument, context);
+      if (modeledState != null) {
+        return modeledState;
+      }
+
+      // Don't compute a state for this parameter if the stored state is already unknown.
+      if (existingMethodState.isMonomorphic()
+          && existingMethodState.asMonomorphic().getParameterState(argumentIndex).isUnknown()) {
+        return ValueState.unknown();
+      }
+
+      DexType parameterType =
+          invoke.getInvokedMethod().getArgumentType(argumentIndex, invoke.isInvokeStatic());
+
+      // If the value is an argument of the enclosing method, then clearly we have no information
+      // about its abstract value. Instead of treating this as having an unknown runtime value, we
+      // instead record a flow constraint that specifies that all values that flow into the
+      // parameter of this enclosing method also flows into the corresponding parameter of the
+      // methods potentially called from this invoke instruction.
+      NonEmptyValueState inFlowState = computeInFlowState(parameterType, argument, context);
+      if (inFlowState != null) {
+        return inFlowState;
+      }
+
+      // Only track the nullability for array types.
+      if (parameterType.isArrayType()) {
+        Nullability nullability = argument.getType().nullability();
+        return ConcreteArrayTypeValueState.create(nullability);
+      }
+
+      AbstractValue abstractValue = abstractValueSupplier.getAbstractValue(argument);
+
+      // For class types, we track both the abstract value and the dynamic type. If both are
+      // unknown, then use UnknownParameterState.
+      if (parameterType.isClassType()) {
+        DynamicType dynamicType = argument.getDynamicType(appView);
+        DynamicType widenedDynamicType =
+            WideningUtils.widenDynamicNonReceiverType(appView, dynamicType, parameterType);
+        return ConcreteClassTypeValueState.create(abstractValue, widenedDynamicType);
+      } else {
+        // For primitive types, we only track the abstract value, thus if the abstract value is
+        // unknown, we use UnknownParameterState.
+        assert parameterType.isPrimitiveType();
+        return ConcretePrimitiveTypeValueState.create(abstractValue);
+      }
     }
 
-    DynamicType widenedDynamicReceiverType =
-        WideningUtils.widenDynamicReceiverType(appView, resolvedMethod, dynamicReceiverType);
-    return widenedDynamicReceiverType.isUnknown()
-        ? ValueState.unknown()
-        : new ConcreteReceiverValueState(dynamicReceiverType);
-  }
+    @SuppressWarnings("ReferenceEquality")
+    private DexMethod getRepresentative(InvokeMethod invoke, ProgramMethod resolvedMethod) {
+      if (resolvedMethod.getDefinition().belongsToDirectPool()) {
+        return resolvedMethod.getReference();
+      }
 
-  @SuppressWarnings("UnusedVariable")
-  private ValueState computeParameterStateForNonReceiver(
-      InvokeMethod invoke,
-      ProgramMethod singleTarget,
-      int argumentIndex,
-      Value argument,
-      AbstractValueSupplier abstractValueSupplier,
-      ProgramMethod context,
-      ConcreteMonomorphicMethodStateOrBottom existingMethodState) {
-    ValueState modeledState =
-        modeling.modelParameterStateForArgumentToFunction(
-            invoke, singleTarget, argumentIndex, argument, context);
-    if (modeledState != null) {
-      return modeledState;
+      if (isMonomorphicVirtualMethod(resolvedMethod)) {
+        return resolvedMethod.getReference();
+      }
+
+      if (invoke.isInvokeInterface()) {
+        assert !isMonomorphicVirtualMethod(resolvedMethod);
+        return getVirtualRootMethod(resolvedMethod);
+      }
+
+      assert invoke.isInvokeSuper() || invoke.isInvokeVirtual();
+
+      DexMethod rootMethod = getVirtualRootMethod(resolvedMethod);
+      assert rootMethod != null;
+      assert !isMonomorphicVirtualMethod(resolvedMethod)
+          || rootMethod == resolvedMethod.getReference();
+      return rootMethod;
     }
 
-    // Don't compute a state for this parameter if the stored state is already unknown.
-    if (existingMethodState.isMonomorphic()
-        && existingMethodState.asMonomorphic().getParameterState(argumentIndex).isUnknown()) {
-      return ValueState.unknown();
+    private boolean shouldUsePolymorphicMethodState(
+        InvokeMethod invoke, ProgramMethod resolvedMethod) {
+      return !resolvedMethod.getDefinition().belongsToDirectPool()
+          && !isMonomorphicVirtualMethod(getRepresentative(invoke, resolvedMethod));
     }
 
-    DexType parameterType =
-        invoke.getInvokedMethod().getArgumentType(argumentIndex, invoke.isInvokeStatic());
-
-    // If the value is an argument of the enclosing method, then clearly we have no information
-    // about its abstract value. Instead of treating this as having an unknown runtime value, we
-    // instead record a flow constraint that specifies that all values that flow into the parameter
-    // of this enclosing method also flows into the corresponding parameter of the methods
-    // potentially called from this invoke instruction.
-    NonEmptyValueState inFlowState = computeInFlowState(parameterType, argument, context);
-    if (inFlowState != null) {
-      return inFlowState;
-    }
-
-    // Only track the nullability for array types.
-    if (parameterType.isArrayType()) {
-      Nullability nullability = argument.getType().nullability();
-      return ConcreteArrayTypeValueState.create(nullability);
-    }
-
-    AbstractValue abstractValue = abstractValueSupplier.getAbstractValue(argument);
-
-    // For class types, we track both the abstract value and the dynamic type. If both are unknown,
-    // then use UnknownParameterState.
-    if (parameterType.isClassType()) {
-      DynamicType dynamicType = argument.getDynamicType(appView);
-      DynamicType widenedDynamicType =
-          WideningUtils.widenDynamicNonReceiverType(appView, dynamicType, parameterType);
-      return ConcreteClassTypeValueState.create(abstractValue, widenedDynamicType);
-    } else {
-      // For primitive types, we only track the abstract value, thus if the abstract value is
-      // unknown,
-      // we use UnknownParameterState.
-      assert parameterType.isPrimitiveType();
-      return ConcretePrimitiveTypeValueState.create(abstractValue);
-    }
-  }
-
-  @SuppressWarnings("ReferenceEquality")
-  private DexMethod getRepresentative(InvokeMethod invoke, ProgramMethod resolvedMethod) {
-    if (resolvedMethod.getDefinition().belongsToDirectPool()) {
-      return resolvedMethod.getReference();
-    }
-
-    if (isMonomorphicVirtualMethod(resolvedMethod)) {
-      return resolvedMethod.getReference();
-    }
-
-    if (invoke.isInvokeInterface()) {
-      assert !isMonomorphicVirtualMethod(resolvedMethod);
-      return getVirtualRootMethod(resolvedMethod);
-    }
-
-    assert invoke.isInvokeSuper() || invoke.isInvokeVirtual();
-
-    DexMethod rootMethod = getVirtualRootMethod(resolvedMethod);
-    assert rootMethod != null;
-    assert !isMonomorphicVirtualMethod(resolvedMethod)
-        || rootMethod == resolvedMethod.getReference();
-    return rootMethod;
-  }
-
-  private boolean shouldUsePolymorphicMethodState(
-      InvokeMethod invoke, ProgramMethod resolvedMethod) {
-    return !resolvedMethod.getDefinition().belongsToDirectPool()
-        && !isMonomorphicVirtualMethod(getRepresentative(invoke, resolvedMethod));
-  }
-
-  private void scan(InvokeCustom invoke) {
-    // If the bootstrap method is program declared it will be called. The call is with runtime
-    // provided arguments so ensure that the argument information is unknown.
-    DexMethodHandle bootstrapMethod = invoke.getCallSite().bootstrapMethod;
-    SingleResolutionResult<?> resolution =
-        appView
-            .appInfo()
-            .resolveMethodLegacy(bootstrapMethod.asMethod(), bootstrapMethod.isInterface)
-            .asSingleResolution();
-    if (resolution != null && resolution.getResolvedHolder().isProgramClass()) {
-      methodStates.set(resolution.getResolvedProgramMethod(), UnknownMethodState.get());
+    private void scanInvokeCustom(InvokeCustom invoke) {
+      // If the bootstrap method is program declared it will be called. The call is with runtime
+      // provided arguments so ensure that the argument information is unknown.
+      DexMethodHandle bootstrapMethod = invoke.getCallSite().bootstrapMethod;
+      SingleResolutionResult<?> resolution =
+          appView
+              .appInfo()
+              .resolveMethodLegacy(bootstrapMethod.asMethod(), bootstrapMethod.isInterface)
+              .asSingleResolution();
+      if (resolution != null && resolution.getResolvedHolder().isProgramClass()) {
+        methodStates.set(resolution.getResolvedProgramMethod(), UnknownMethodState.get());
+      }
     }
   }
 
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeArgumentNode.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeArgumentNode.java
new file mode 100644
index 0000000..2ea279f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeArgumentNode.java
@@ -0,0 +1,57 @@
+// 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.computation;
+
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+import com.android.tools.r8.utils.ArrayUtils;
+import java.util.Objects;
+import java.util.function.IntFunction;
+
+/** Represents the read of an argument. */
+public class ComputationTreeArgumentNode extends ComputationTreeBaseNode {
+
+  private static final int NUM_CANONICALIZED_INSTANCES = 32;
+  private static final ComputationTreeArgumentNode[] CANONICALIZED_INSTANCES =
+      ArrayUtils.initialize(
+          new ComputationTreeArgumentNode[NUM_CANONICALIZED_INSTANCES],
+          ComputationTreeArgumentNode::new);
+
+  private final int argumentIndex;
+
+  private ComputationTreeArgumentNode(int argumentIndex) {
+    this.argumentIndex = argumentIndex;
+  }
+
+  public static ComputationTreeArgumentNode create(int argumentIndex) {
+    return argumentIndex < NUM_CANONICALIZED_INSTANCES
+        ? CANONICALIZED_INSTANCES[argumentIndex]
+        : new ComputationTreeArgumentNode(argumentIndex);
+  }
+
+  @Override
+  public AbstractValue evaluate(
+      IntFunction<AbstractValue> argumentAssignment, AbstractValueFactory abstractValueFactory) {
+    return argumentAssignment.apply(argumentIndex);
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (this == obj) {
+      return true;
+    }
+    if (!(obj instanceof ComputationTreeArgumentNode)) {
+      return false;
+    }
+    ComputationTreeArgumentNode node = (ComputationTreeArgumentNode) obj;
+    assert argumentIndex >= NUM_CANONICALIZED_INSTANCES
+        || node.argumentIndex >= NUM_CANONICALIZED_INSTANCES;
+    return argumentIndex == node.argumentIndex;
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(getClass(), argumentIndex);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeBaseNode.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeBaseNode.java
new file mode 100644
index 0000000..2228c3e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeBaseNode.java
@@ -0,0 +1,16 @@
+// 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.computation;
+
+/**
+ * Represents a computation tree with no open variables other than the arguments of a given method.
+ */
+abstract class ComputationTreeBaseNode implements ComputationTreeNode {
+
+  @Override
+  public abstract boolean equals(Object obj);
+
+  @Override
+  public abstract int hashCode();
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeBuilder.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeBuilder.java
new file mode 100644
index 0000000..aca8a03
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeBuilder.java
@@ -0,0 +1,84 @@
+// 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.computation;
+
+import static com.android.tools.r8.ir.code.Opcodes.AND;
+import static com.android.tools.r8.ir.code.Opcodes.ARGUMENT;
+import static com.android.tools.r8.ir.code.Opcodes.CONST_NUMBER;
+import static com.android.tools.r8.ir.code.Opcodes.IF;
+
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+import com.android.tools.r8.ir.analysis.value.UnknownValue;
+import com.android.tools.r8.ir.code.And;
+import com.android.tools.r8.ir.code.Argument;
+import com.android.tools.r8.ir.code.ConstNumber;
+import com.android.tools.r8.ir.code.If;
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.code.Value;
+
+public class ComputationTreeBuilder {
+
+  private final AbstractValueFactory abstractValueFactory;
+
+  public ComputationTreeBuilder(AbstractValueFactory abstractValueFactory) {
+    this.abstractValueFactory = abstractValueFactory;
+  }
+
+  // TODO(b/302281503): "Long lived" computation trees (i.e., the ones that survive past the IR
+  //  conversion of the current method) should be canonicalized.
+  // TODO(b/302281503): If we start building larger computation trees then make sure to the
+  //  computation trees for intermediate instructions to ensure that we do not build the computation
+  //  tree for a given instruction more than once.
+  public ComputationTreeNode buildComputationTree(Instruction instruction) {
+    switch (instruction.opcode()) {
+      case AND:
+        {
+          And and = instruction.asAnd();
+          ComputationTreeNode left = buildComputationTreeFromValue(and.leftValue());
+          ComputationTreeNode right = buildComputationTreeFromValue(and.rightValue());
+          return ComputationTreeLogicalBinopAndNode.create(left, right);
+        }
+      case ARGUMENT:
+        {
+          Argument argument = instruction.asArgument();
+          if (argument.getOutType().isInt()) {
+            return ComputationTreeArgumentNode.create(argument.getIndex());
+          }
+          break;
+        }
+      case CONST_NUMBER:
+        {
+          ConstNumber constNumber = instruction.asConstNumber();
+          if (constNumber.getOutType().isInt()) {
+            return constNumber.getAbstractValue(abstractValueFactory);
+          }
+          break;
+        }
+      case IF:
+        {
+          If theIf = instruction.asIf();
+          if (theIf.isZeroTest()) {
+            ComputationTreeNode operand = buildComputationTreeFromValue(theIf.lhs());
+            return ComputationTreeUnopCompareNode.create(operand, theIf.getType());
+          }
+          break;
+        }
+      default:
+        break;
+    }
+    return AbstractValue.unknown();
+  }
+
+  private ComputationTreeNode buildComputationTreeFromValue(Value value) {
+    if (value.isPhi()) {
+      return unknown();
+    }
+    return buildComputationTree(value.getDefinition());
+  }
+
+  private static UnknownValue unknown() {
+    return AbstractValue.unknown();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeLogicalBinopAndNode.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeLogicalBinopAndNode.java
new file mode 100644
index 0000000..f18f081
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeLogicalBinopAndNode.java
@@ -0,0 +1,50 @@
+// 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.computation;
+
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+import com.android.tools.r8.ir.analysis.value.arithmetic.AbstractCalculator;
+import java.util.Objects;
+import java.util.function.IntFunction;
+
+public class ComputationTreeLogicalBinopAndNode extends ComputationTreeLogicalBinopNode {
+
+  private ComputationTreeLogicalBinopAndNode(ComputationTreeNode left, ComputationTreeNode right) {
+    super(left, right);
+  }
+
+  public static ComputationTreeNode create(ComputationTreeNode left, ComputationTreeNode right) {
+    if (left.isUnknown() && right.isUnknown()) {
+      return AbstractValue.unknown();
+    }
+    return new ComputationTreeLogicalBinopAndNode(left, right);
+  }
+
+  @Override
+  public AbstractValue evaluate(
+      IntFunction<AbstractValue> argumentAssignment, AbstractValueFactory abstractValueFactory) {
+    assert getNumericType().isInt();
+    AbstractValue leftValue = left.evaluate(argumentAssignment, abstractValueFactory);
+    AbstractValue rightValue = right.evaluate(argumentAssignment, abstractValueFactory);
+    return AbstractCalculator.andIntegers(abstractValueFactory, leftValue, rightValue);
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (this == obj) {
+      return true;
+    }
+    if (!(obj instanceof ComputationTreeLogicalBinopAndNode)) {
+      return false;
+    }
+    ComputationTreeLogicalBinopAndNode node = (ComputationTreeLogicalBinopAndNode) obj;
+    return internalIsEqualTo(node);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(getClass(), left, right);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeLogicalBinopNode.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeLogicalBinopNode.java
new file mode 100644
index 0000000..8f0c95f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeLogicalBinopNode.java
@@ -0,0 +1,26 @@
+// 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.computation;
+
+import com.android.tools.r8.ir.code.NumericType;
+
+public abstract class ComputationTreeLogicalBinopNode extends ComputationTreeBaseNode {
+
+  final ComputationTreeNode left;
+  final ComputationTreeNode right;
+
+  ComputationTreeLogicalBinopNode(ComputationTreeNode left, ComputationTreeNode right) {
+    assert !left.isUnknown() || !right.isUnknown();
+    this.left = left;
+    this.right = right;
+  }
+
+  public NumericType getNumericType() {
+    return NumericType.INT;
+  }
+
+  boolean internalIsEqualTo(ComputationTreeLogicalBinopNode node) {
+    return left.equals(node.left) && right.equals(node.right);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeNode.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeNode.java
new file mode 100644
index 0000000..f055cff
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeNode.java
@@ -0,0 +1,22 @@
+// 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.computation;
+
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+import java.util.function.IntFunction;
+
+/**
+ * Represents a computation tree with no open variables other than the arguments of a given method.
+ */
+public interface ComputationTreeNode {
+
+  /** Evaluates the current computation tree on the given argument assignment. */
+  AbstractValue evaluate(
+      IntFunction<AbstractValue> argumentAssignment, AbstractValueFactory abstractValueFactory);
+
+  default boolean isUnknown() {
+    return false;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeUnopCompareNode.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeUnopCompareNode.java
new file mode 100644
index 0000000..fb4c465
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeUnopCompareNode.java
@@ -0,0 +1,51 @@
+// 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.computation;
+
+import com.android.tools.r8.ir.analysis.value.AbstractValue;
+import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+import com.android.tools.r8.ir.code.IfType;
+import java.util.Objects;
+import java.util.function.IntFunction;
+
+public class ComputationTreeUnopCompareNode extends ComputationTreeUnopNode {
+
+  private final IfType type;
+
+  private ComputationTreeUnopCompareNode(ComputationTreeNode operand, IfType type) {
+    super(operand);
+    this.type = type;
+  }
+
+  public static ComputationTreeNode create(ComputationTreeNode operand, IfType type) {
+    if (operand.isUnknown()) {
+      return AbstractValue.unknown();
+    }
+    return new ComputationTreeUnopCompareNode(operand, type);
+  }
+
+  @Override
+  public AbstractValue evaluate(
+      IntFunction<AbstractValue> argumentAssignment, AbstractValueFactory abstractValueFactory) {
+    AbstractValue operandValue = operand.evaluate(argumentAssignment, abstractValueFactory);
+    return type.evaluate(operandValue, abstractValueFactory);
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (this == obj) {
+      return true;
+    }
+    if (!(obj instanceof ComputationTreeUnopCompareNode)) {
+      return false;
+    }
+    ComputationTreeUnopCompareNode node = (ComputationTreeUnopCompareNode) obj;
+    return type == node.type && internalIsEqualTo(node);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(getClass(), operand, type);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeUnopNode.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeUnopNode.java
new file mode 100644
index 0000000..3c3fc1e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/computation/ComputationTreeUnopNode.java
@@ -0,0 +1,18 @@
+// 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.computation;
+
+public abstract class ComputationTreeUnopNode extends ComputationTreeBaseNode {
+
+  final ComputationTreeNode operand;
+
+  ComputationTreeUnopNode(ComputationTreeNode operand) {
+    assert !operand.isUnknown();
+    this.operand = operand;
+  }
+
+  boolean internalIsEqualTo(ComputationTreeUnopNode node) {
+    return operand.equals(node.operand);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/propagation/DefaultFieldValueJoiner.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/propagation/DefaultFieldValueJoiner.java
index 45848ad..28d0ead 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/propagation/DefaultFieldValueJoiner.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/propagation/DefaultFieldValueJoiner.java
@@ -25,6 +25,7 @@
 import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcreteArrayTypeValueState;
 import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcreteClassTypeValueState;
 import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcretePrimitiveTypeValueState;
+import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcreteReferenceTypeValueState;
 import com.android.tools.r8.optimize.argumentpropagation.codescanner.ConcreteValueState;
 import com.android.tools.r8.optimize.argumentpropagation.codescanner.FieldStateCollection;
 import com.android.tools.r8.optimize.argumentpropagation.codescanner.NonEmptyValueState;
@@ -120,9 +121,12 @@
             if (state.isUnknown()) {
               return;
             }
-            if (state.isReferenceState()
-                && state.asReferenceState().getNullability().isNullable()) {
-              return;
+            if (state.isReferenceState()) {
+              ConcreteReferenceTypeValueState referenceState = state.asReferenceState();
+              if (referenceState.getNullability().isNullable()
+                  && referenceState.getAbstractValue(appView).isUnknown()) {
+                return;
+              }
             }
             fieldsOfInterest
                 .computeIfAbsent(field.getHolder(), ignoreKey(ArrayList::new))
diff --git a/src/main/java/com/android/tools/r8/optimize/bridgehoisting/BridgeHoisting.java b/src/main/java/com/android/tools/r8/optimize/bridgehoisting/BridgeHoisting.java
index a1de155..b91bff4 100644
--- a/src/main/java/com/android/tools/r8/optimize/bridgehoisting/BridgeHoisting.java
+++ b/src/main/java/com/android/tools/r8/optimize/bridgehoisting/BridgeHoisting.java
@@ -26,13 +26,13 @@
 import com.google.common.base.Equivalence.Wrapper;
 import com.google.common.collect.Iterables;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Comparator;
 import java.util.HashMap;
-import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
-import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 
@@ -102,38 +102,42 @@
         eligibleSubclasses.add(subclass);
       }
     }
-    for (Wrapper<DexMethod> candidate : getCandidatesForHoisting(eligibleSubclasses)) {
-      hoistBridgeIfPossible(candidate.get(), clazz, eligibleSubclasses);
+    for (ProgramMethod candidate : getCandidatesForHoisting(eligibleSubclasses)) {
+      hoistBridgeIfPossible(candidate, clazz, eligibleSubclasses);
     }
   }
 
-  private Set<Wrapper<DexMethod>> getCandidatesForHoisting(List<DexProgramClass> subclasses) {
+  private Collection<ProgramMethod> getCandidatesForHoisting(List<DexProgramClass> subclasses) {
     Equivalence<DexMethod> equivalence = MethodSignatureEquivalence.get();
-    Set<Wrapper<DexMethod>> candidates = new HashSet<>();
+    Map<Wrapper<DexMethod>, ProgramMethod> candidates = new LinkedHashMap<>();
     for (DexProgramClass subclass : subclasses) {
-      for (DexEncodedMethod method : subclass.virtualMethods()) {
+      for (ProgramMethod method : subclass.virtualProgramMethods()) {
+        if (appView.getKeepInfo(method).isPinned(appView.options())) {
+          continue;
+        }
         BridgeInfo bridgeInfo = method.getOptimizationInfo().getBridgeInfo();
         if (bridgeInfo != null && bridgeInfo.isVirtualBridgeInfo()) {
-          candidates.add(equivalence.wrap(method.getReference()));
+          candidates.put(equivalence.wrap(method.getReference()), method);
         }
       }
     }
-    return candidates;
+    return candidates.values();
   }
 
   private void hoistBridgeIfPossible(
-      DexMethod method, DexProgramClass clazz, List<DexProgramClass> subclasses) {
+      ProgramMethod method, DexProgramClass clazz, List<DexProgramClass> subclasses) {
     // If the method is defined on the parent class, we cannot hoist the bridge.
     // TODO(b/153147967): If the declared method is abstract, we could replace it by the bridge.
     //  Add a test.
-    if (clazz.lookupProgramMethod(method) != null) {
+    DexMethod methodReference = method.getReference();
+    if (clazz.lookupProgramMethod(methodReference) != null) {
       return;
     }
 
     // Bail out if the bridge is also declared in the parent class. In that case, hoisting would
     // change the behavior of calling the bridge on an instance of the parent class.
     MethodResolutionResult res =
-        appView.appInfo().resolveMethodOnClass(clazz.getSuperType(), method);
+        appView.appInfo().resolveMethodOnClass(clazz.getSuperType(), methodReference);
     if (res.isSingleResolution()) {
       if (!res.getResolvedMethod().isAbstract()) {
         return;
@@ -147,10 +151,13 @@
     // implicitly defined by the signature of the invoke-virtual instruction).
     Map<Wrapper<DexMethod>, List<DexProgramClass>> eligibleVirtualInvokeBridges = new HashMap<>();
     for (DexProgramClass subclass : subclasses) {
-      DexEncodedMethod definition = subclass.lookupVirtualMethod(method);
+      DexEncodedMethod definition = subclass.lookupVirtualMethod(methodReference);
       if (definition == null) {
         DexEncodedMethod resolutionTarget =
-            appView.appInfo().resolveMethodOnClassLegacy(subclass, method).getSingleTarget();
+            appView
+                .appInfo()
+                .resolveMethodOnClassLegacy(subclass, methodReference)
+                .getSingleTarget();
         if (resolutionTarget == null || resolutionTarget.isAbstract()) {
           // The fact that this class does not declare the bridge (or the bridge is abstract) should
           // not prevent us from hoisting the bridge.
@@ -208,7 +215,7 @@
 
     // Choose one of the bridge definitions as the one that we will be moving to the superclass.
     List<ProgramMethod> eligibleBridgeMethods =
-        getBridgesEligibleForHoisting(eligibleSubclasses, method);
+        getBridgesEligibleForHoisting(eligibleSubclasses, methodReference);
     ProgramMethod representative = eligibleBridgeMethods.iterator().next();
 
     // Guard against accessibility issues.
@@ -234,8 +241,7 @@
     feedback.setBridgeInfo(representative, new VirtualBridgeInfo(methodToInvoke));
 
     // Move the bridge method to the super class, and record this in the graph lens.
-    DexMethod newMethodReference =
-        appView.dexItemFactory().createMethod(clazz.type, method.proto, method.name);
+    DexMethod newMethodReference = methodReference.withHolder(clazz, appView.dexItemFactory());
     DexEncodedMethod newMethod =
         representative
             .getDefinition()
@@ -250,9 +256,8 @@
         representative.getReference());
 
     // Remove all of the bridges in the eligible subclasses.
-    assert !appView.appInfo().isPinnedWithDefinitionLookup(method);
     for (DexProgramClass subclass : eligibleSubclasses) {
-      DexEncodedMethod removed = subclass.removeMethod(method);
+      DexEncodedMethod removed = subclass.removeMethod(methodReference);
       assert removed != null;
     }
   }
diff --git a/src/main/java/com/android/tools/r8/optimize/compose/ArgumentPropagatorCodeScannerForComposableFunctions.java b/src/main/java/com/android/tools/r8/optimize/compose/ArgumentPropagatorCodeScannerForComposableFunctions.java
index 174e8ba..2116f3a 100644
--- a/src/main/java/com/android/tools/r8/optimize/compose/ArgumentPropagatorCodeScannerForComposableFunctions.java
+++ b/src/main/java/com/android/tools/r8/optimize/compose/ArgumentPropagatorCodeScannerForComposableFunctions.java
@@ -7,6 +7,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.code.AbstractValueSupplier;
+import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.InvokeMethod;
 import com.android.tools.r8.optimize.argumentpropagation.ArgumentPropagatorCodeScanner;
 import com.android.tools.r8.optimize.argumentpropagation.codescanner.MethodParameter;
@@ -25,16 +26,12 @@
   }
 
   @Override
-  protected void addTemporaryMethodState(
-      InvokeMethod invoke,
-      ProgramMethod resolvedMethod,
+  public void scan(
+      ProgramMethod method,
+      IRCode code,
       AbstractValueSupplier abstractValueSupplier,
-      ProgramMethod context,
       Timing timing) {
-    ComposableCallGraphNode node = callGraph.getNodes().get(resolvedMethod);
-    if (node != null && node.isComposable()) {
-      super.addTemporaryMethodState(invoke, resolvedMethod, abstractValueSupplier, context, timing);
-    }
+    new CodeScanner(abstractValueSupplier, code, method).scan(timing);
   }
 
   @Override
@@ -43,4 +40,21 @@
     // We haven't defined the virtual root mapping, so we can't tell.
     return false;
   }
+
+  private class CodeScanner extends ArgumentPropagatorCodeScanner.CodeScanner {
+
+    protected CodeScanner(
+        AbstractValueSupplier abstractValueSupplier, IRCode code, ProgramMethod method) {
+      super(abstractValueSupplier, code, method);
+    }
+
+    @Override
+    protected void addTemporaryMethodState(
+        InvokeMethod invoke, ProgramMethod resolvedMethod, Timing timing) {
+      ComposableCallGraphNode node = callGraph.getNodes().get(resolvedMethod);
+      if (node != null && node.isComposable()) {
+        super.addTemporaryMethodState(invoke, resolvedMethod, timing);
+      }
+    }
+  }
 }
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 1766f40..147ce09 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -3921,7 +3921,7 @@
         timing.begin("Retain keep info");
         applicableRules = keepInfoCollection.getApplicableRules();
         EnqueuerEvent preconditionEvent = UnconditionalKeepInfoEvent.get();
-        keepInfo.registerCompilerSynthesizedMethods(keepInfoCollection);
+        keepInfo.registerCompilerSynthesizedItems(keepInfoCollection);
         keepInfoCollection.forEachRuleInstance(
             appView,
             (clazz, minimumKeepInfo) ->
@@ -5594,7 +5594,7 @@
     // SomeEnumClass.valueOf(java.lang.String) which is generated by javac for all enums will
     // call this method.
     if (invoke.inValues().get(0).isConstClass()) {
-      DexType type = invoke.inValues().get(0).definition.asConstClass().getValue();
+      DexType type = invoke.inValues().get(0).definition.asConstClass().getType();
       DexProgramClass clazz = getProgramClassOrNull(type, method);
       if (clazz != null && clazz.isEnum()) {
         markEnumValuesAsReachable(clazz, KeepReason.invokedFrom(method));
@@ -5610,7 +5610,7 @@
 
     Value argument = invoke.inValues().get(0).getAliasedValue();
     if (!argument.isPhi() && argument.definition.isConstClass()) {
-      DexType serviceType = argument.definition.asConstClass().getValue();
+      DexType serviceType = argument.definition.asConstClass().getType();
       if (!appView.appServices().allServiceTypes().contains(serviceType)) {
         // Should never happen.
         return;
diff --git a/src/main/java/com/android/tools/r8/shaking/GlobalKeepInfoConfiguration.java b/src/main/java/com/android/tools/r8/shaking/GlobalKeepInfoConfiguration.java
index 7dfbfeb..994e94c 100644
--- a/src/main/java/com/android/tools/r8/shaking/GlobalKeepInfoConfiguration.java
+++ b/src/main/java/com/android/tools/r8/shaking/GlobalKeepInfoConfiguration.java
@@ -6,6 +6,8 @@
 /** Globally controlled settings that affect the default values for kept items. */
 public interface GlobalKeepInfoConfiguration {
 
+  boolean isCodeReplacementForceEnabled();
+
   boolean isTreeShakingEnabled();
 
   boolean isMinificationEnabled();
diff --git a/src/main/java/com/android/tools/r8/shaking/KeepClassInfo.java b/src/main/java/com/android/tools/r8/shaking/KeepClassInfo.java
index c1c5ec0..3bb0f20 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepClassInfo.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepClassInfo.java
@@ -11,7 +11,7 @@
 import java.util.function.Function;
 
 /** Immutable keep requirements for a class. */
-public final class KeepClassInfo extends KeepInfo<KeepClassInfo.Builder, KeepClassInfo> {
+public class KeepClassInfo extends KeepInfo<KeepClassInfo.Builder, KeepClassInfo> {
 
   // Requires all aspects of a class to be kept.
   private static final KeepClassInfo TOP =
@@ -53,16 +53,18 @@
   private final boolean allowHorizontalClassMerging;
   private final boolean allowPermittedSubclassesRemoval;
   private final boolean allowRepackaging;
+  private final boolean allowSyntheticSharing;
   private final boolean allowUnusedInterfaceRemoval;
   private final boolean allowVerticalClassMerging;
   private final boolean checkEnumUnboxed;
 
-  private KeepClassInfo(Builder builder) {
+  KeepClassInfo(Builder builder) {
     super(builder);
     this.allowClassInlining = builder.isClassInliningAllowed();
     this.allowHorizontalClassMerging = builder.isHorizontalClassMergingAllowed();
     this.allowPermittedSubclassesRemoval = builder.isPermittedSubclassesRemovalAllowed();
     this.allowRepackaging = builder.isRepackagingAllowed();
+    this.allowSyntheticSharing = builder.isSyntheticSharingAllowed();
     this.allowUnusedInterfaceRemoval = builder.isUnusedInterfaceRemovalAllowed();
     this.allowVerticalClassMerging = builder.isVerticalClassMergingAllowed();
     this.checkEnumUnboxed = builder.isCheckEnumUnboxedEnabled();
@@ -147,6 +149,14 @@
     return allowRepackaging;
   }
 
+  public boolean isSyntheticSharingAllowed() {
+    return internalIsSyntheticSharingAllowed();
+  }
+
+  private boolean internalIsSyntheticSharingAllowed() {
+    return allowSyntheticSharing;
+  }
+
   boolean internalIsUnusedInterfaceRemovalAllowed() {
     return allowUnusedInterfaceRemoval;
   }
@@ -182,20 +192,22 @@
     private boolean allowHorizontalClassMerging;
     private boolean allowPermittedSubclassesRemoval;
     private boolean allowRepackaging;
+    private boolean allowSyntheticSharing;
     private boolean allowUnusedInterfaceRemoval;
     private boolean allowVerticalClassMerging;
     private boolean checkEnumUnboxed;
 
-    private Builder() {
+    Builder() {
       super();
     }
 
-    private Builder(KeepClassInfo original) {
+    Builder(KeepClassInfo original) {
       super(original);
       allowClassInlining = original.internalIsClassInliningAllowed();
       allowHorizontalClassMerging = original.internalIsHorizontalClassMergingAllowed();
       allowPermittedSubclassesRemoval = original.internalIsPermittedSubclassesRemovalAllowed();
       allowRepackaging = original.internalIsRepackagingAllowed();
+      allowSyntheticSharing = original.internalIsSyntheticSharingAllowed();
       allowUnusedInterfaceRemoval = original.internalIsUnusedInterfaceRemovalAllowed();
       allowVerticalClassMerging = original.internalIsVerticalClassMergingAllowed();
       checkEnumUnboxed = original.internalIsCheckEnumUnboxedEnabled();
@@ -296,6 +308,17 @@
       return setAllowRepackaging(false);
     }
 
+    // Synthetic sharing.
+
+    public boolean isSyntheticSharingAllowed() {
+      return allowSyntheticSharing;
+    }
+
+    private Builder setAllowSyntheticSharing(boolean allowSyntheticSharing) {
+      this.allowSyntheticSharing = allowSyntheticSharing;
+      return self();
+    }
+
     // Unused interface removal.
 
     public Builder allowUnusedInterfaceRemoval() {
@@ -363,6 +386,7 @@
           && isPermittedSubclassesRemovalAllowed()
               == other.internalIsPermittedSubclassesRemovalAllowed()
           && isRepackagingAllowed() == other.internalIsRepackagingAllowed()
+          && isSyntheticSharingAllowed() == other.internalIsSyntheticSharingAllowed()
           && isUnusedInterfaceRemovalAllowed() == other.internalIsUnusedInterfaceRemovalAllowed()
           && isVerticalClassMergingAllowed() == other.internalIsVerticalClassMergingAllowed();
     }
@@ -379,6 +403,8 @@
           .disallowHorizontalClassMerging()
           .disallowPermittedSubclassesRemoval()
           .disallowRepackaging()
+          // Synthetic sharing is always allowed, unless explicitly set to false.
+          .setAllowSyntheticSharing(true)
           .disallowUnusedInterfaceRemoval()
           .disallowVerticalClassMerging()
           .unsetCheckEnumUnboxed();
@@ -391,6 +417,7 @@
           .allowHorizontalClassMerging()
           .allowPermittedSubclassesRemoval()
           .allowRepackaging()
+          .setAllowSyntheticSharing(true)
           .allowUnusedInterfaceRemoval()
           .allowVerticalClassMerging()
           .unsetCheckEnumUnboxed();
@@ -403,6 +430,10 @@
       super(info.builder());
     }
 
+    protected Joiner(KeepClassInfo.Builder builder) {
+      super(builder);
+    }
+
     public Joiner disallowClassInlining() {
       builder.disallowClassInlining();
       return self();
@@ -423,6 +454,11 @@
       return self();
     }
 
+    public Joiner disallowSyntheticSharing() {
+      builder.setAllowSyntheticSharing(false);
+      return self();
+    }
+
     public Joiner disallowUnusedInterfaceRemoval() {
       builder.disallowUnusedInterfaceRemoval();
       return self();
@@ -460,6 +496,7 @@
               !joiner.builder.isPermittedSubclassesRemovalAllowed(),
               Joiner::disallowPermittedSubclassesRemoval)
           .applyIf(!joiner.builder.isRepackagingAllowed(), Joiner::disallowRepackaging)
+          .applyIf(!joiner.builder.isSyntheticSharingAllowed(), Joiner::disallowSyntheticSharing)
           .applyIf(
               !joiner.builder.isUnusedInterfaceRemovalAllowed(),
               Joiner::disallowUnusedInterfaceRemoval)
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 990c260..69f6f02 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepInfoCollection.java
@@ -531,15 +531,26 @@
       }
     }
 
+    public void ensureCompilerSynthesizedClass(DexProgramClass clazz) {
+      keepClassInfo.computeIfAbsent(clazz.getType(), ignoreKey(SyntheticKeepClassInfo::bottom));
+    }
+
     @Override
     public void registerCompilerSynthesizedMethod(ProgramMethod method) {
       assert !keepMethodInfo.containsKey(method.getReference());
       keepMethodInfo.put(method.getReference(), SyntheticKeepMethodInfo.bottom());
     }
 
-    public void registerCompilerSynthesizedMethods(KeepInfoCollection keepInfoCollection) {
+    public void registerCompilerSynthesizedItems(KeepInfoCollection keepInfoCollection) {
       keepInfoCollection.mutate(
           mutableKeepInfoCollection -> {
+            mutableKeepInfoCollection.keepClassInfo.forEach(
+                (c, info) -> {
+                  if (info instanceof SyntheticKeepClassInfo) {
+                    assert !keepClassInfo.containsKey(c);
+                    keepClassInfo.put(c, info);
+                  }
+                });
             mutableKeepInfoCollection.keepMethodInfo.forEach(
                 (m, info) -> {
                   if (info instanceof SyntheticKeepMethodInfo) {
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 7394058..ab20efa 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepMemberInfo.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepMemberInfo.java
@@ -8,6 +8,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMember;
 import com.android.tools.r8.shaking.KeepMemberInfo.Builder;
+import com.android.tools.r8.utils.InternalOptions;
 
 /** Immutable keep requirements for a member. */
 @SuppressWarnings("BadImport")
@@ -21,7 +22,6 @@
     this.allowValuePropagation = builder.isValuePropagationAllowed();
   }
 
-  @SuppressWarnings("BadImport")
   public boolean isKotlinMetadataRemovalAllowed(
       DexProgramClass holder, GlobalKeepInfoConfiguration configuration) {
     // Checking the holder for missing kotlin information relies on the holder being processed
@@ -31,18 +31,17 @@
 
   public boolean isValuePropagationAllowed(
       AppView<AppInfoWithLiveness> appView, ProgramMember<?, ?> member) {
+    InternalOptions options = appView.options();
+    if (!internalIsValuePropagationAllowed()) {
+      return false;
+    }
+    if (member.isMethod() && !asMethodInfo().isCodeReplacementAllowed(options)) {
+      return true;
+    }
     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();
+    return isOptimizationAllowed(options) || !isTypeInstantiated;
   }
 
   boolean internalIsValuePropagationAllowed() {
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 571d3e8..a40c7e6 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepMethodInfo.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepMethodInfo.java
@@ -31,6 +31,7 @@
   private final boolean allowThrowsRemoval;
   private final boolean allowClassInlining;
   private final boolean allowClosedWorldReasoning;
+  private final boolean allowCodeReplacement;
   private final boolean allowConstantArgumentOptimization;
   private final boolean allowInlining;
   private final boolean allowMethodStaticizing;
@@ -50,6 +51,7 @@
     this.allowThrowsRemoval = builder.isThrowsRemovalAllowed();
     this.allowClassInlining = builder.isClassInliningAllowed();
     this.allowClosedWorldReasoning = builder.isClosedWorldReasoningAllowed();
+    this.allowCodeReplacement = builder.isCodeReplacementAllowed();
     this.allowConstantArgumentOptimization = builder.isConstantArgumentOptimizationAllowed();
     this.allowInlining = builder.isInliningAllowed();
     this.allowMethodStaticizing = builder.isMethodStaticizingAllowed();
@@ -129,6 +131,16 @@
     return allowClosedWorldReasoning;
   }
 
+  public boolean isCodeReplacementAllowed(GlobalKeepInfoConfiguration configuration) {
+    return configuration.isCodeReplacementForceEnabled()
+        ? !isOptimizationAllowed(configuration)
+        : internalIsCodeReplacementAllowed();
+  }
+
+  boolean internalIsCodeReplacementAllowed() {
+    return allowCodeReplacement;
+  }
+
   public boolean isConstantArgumentOptimizationAllowed(GlobalKeepInfoConfiguration configuration) {
     return isOptimizationAllowed(configuration) && internalIsConstantArgumentOptimizationAllowed();
   }
@@ -273,6 +285,7 @@
     private boolean allowThrowsRemoval;
     private boolean allowClassInlining;
     private boolean allowClosedWorldReasoning;
+    private boolean allowCodeReplacement;
     private boolean allowConstantArgumentOptimization;
     private boolean allowInlining;
     private boolean allowMethodStaticizing;
@@ -296,6 +309,7 @@
       allowThrowsRemoval = original.internalIsThrowsRemovalAllowed();
       allowClassInlining = original.internalIsClassInliningAllowed();
       allowClosedWorldReasoning = original.internalIsClosedWorldReasoningAllowed();
+      allowCodeReplacement = original.internalIsCodeReplacementAllowed();
       allowConstantArgumentOptimization = original.internalIsConstantArgumentOptimizationAllowed();
       allowInlining = original.internalIsInliningAllowed();
       allowMethodStaticizing = original.internalIsMethodStaticizingAllowed();
@@ -339,6 +353,15 @@
       return self();
     }
 
+    public boolean isCodeReplacementAllowed() {
+      return allowCodeReplacement;
+    }
+
+    public Builder setAllowCodeReplacement(boolean allowCodeReplacement) {
+      this.allowCodeReplacement = allowCodeReplacement;
+      return self();
+    }
+
     public boolean isConstantArgumentOptimizationAllowed() {
       return allowConstantArgumentOptimization;
     }
@@ -483,6 +506,7 @@
           && isThrowsRemovalAllowed() == other.internalIsThrowsRemovalAllowed()
           && isClassInliningAllowed() == other.internalIsClassInliningAllowed()
           && isClosedWorldReasoningAllowed() == other.internalIsClosedWorldReasoningAllowed()
+          && isCodeReplacementAllowed() == other.internalIsCodeReplacementAllowed()
           && isConstantArgumentOptimizationAllowed()
               == other.internalIsConstantArgumentOptimizationAllowed()
           && isInliningAllowed() == other.internalIsInliningAllowed()
@@ -513,6 +537,7 @@
           .setAllowThrowsRemoval(false)
           .setAllowClassInlining(false)
           .setAllowClosedWorldReasoning(false)
+          .setAllowCodeReplacement(true)
           .setAllowConstantArgumentOptimization(false)
           .setAllowInlining(false)
           .setAllowMethodStaticizing(false)
@@ -534,6 +559,7 @@
           .setAllowThrowsRemoval(true)
           .setAllowClassInlining(true)
           .setAllowClosedWorldReasoning(true)
+          .setAllowCodeReplacement(false)
           .setAllowConstantArgumentOptimization(true)
           .setAllowInlining(true)
           .setAllowMethodStaticizing(true)
@@ -575,6 +601,11 @@
       return self();
     }
 
+    public Joiner allowCodeReplacement() {
+      builder.setAllowCodeReplacement(true);
+      return self();
+    }
+
     public Joiner disallowConstantArgumentOptimization() {
       builder.setAllowConstantArgumentOptimization(false);
       return self();
@@ -662,6 +693,7 @@
           .applyIf(!joiner.builder.isClassInliningAllowed(), Joiner::disallowClassInlining)
           .applyIf(
               !joiner.builder.isClosedWorldReasoningAllowed(), Joiner::disallowClosedWorldReasoning)
+          .applyIf(joiner.builder.isCodeReplacementAllowed(), Joiner::allowCodeReplacement)
           .applyIf(
               !joiner.builder.isConstantArgumentOptimizationAllowed(),
               Joiner::disallowConstantArgumentOptimization)
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 f511bee..5b11df3 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
@@ -1074,6 +1074,8 @@
           } else if (options.isTestingOptionsEnabled()) {
             if (acceptString("annotationremoval")) {
               builder.getModifiersBuilder().setAllowsAnnotationRemoval(true);
+            } else if (acceptString("codereplacement")) {
+              builder.getModifiersBuilder().setAllowsCodeReplacement(true);
             }
           }
         } else if (acceptString("includedescriptorclasses")) {
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardKeepRuleBase.java b/src/main/java/com/android/tools/r8/shaking/ProguardKeepRuleBase.java
index 308ab6e..fb02899 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardKeepRuleBase.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardKeepRuleBase.java
@@ -22,10 +22,6 @@
       super();
     }
 
-    public ProguardKeepRuleType getKeepRuleType() {
-      return type;
-    }
-
     public B setType(ProguardKeepRuleType type) {
       this.type = type;
       return self();
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardKeepRuleModifiers.java b/src/main/java/com/android/tools/r8/shaking/ProguardKeepRuleModifiers.java
index 6073953..c904cc0 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardKeepRuleModifiers.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardKeepRuleModifiers.java
@@ -10,6 +10,8 @@
 
     private boolean allowsAccessModification = false;
     private boolean allowsAnnotationRemoval = false;
+    // The default value is determined by InternalOptions.
+    private boolean allowsCodeReplacement = false;
     private boolean allowsRepackaging = false;
     private boolean allowsShrinking = false;
     private boolean allowsOptimization = false;
@@ -22,6 +24,7 @@
     public Builder setAllowsAll() {
       setAllowsAccessModification(true);
       setAllowsAnnotationRemoval(true);
+      setAllowsCodeReplacement(false);
       setAllowsObfuscation(true);
       setAllowsOptimization(true);
       setAllowsRepackaging(true);
@@ -39,6 +42,11 @@
       return this;
     }
 
+    public Builder setAllowsCodeReplacement(boolean allowsCodeReplacement) {
+      this.allowsCodeReplacement = allowsCodeReplacement;
+      return this;
+    }
+
     public Builder setAllowsShrinking(boolean allowsShrinking) {
       this.allowsShrinking = allowsShrinking;
       return this;
@@ -75,6 +83,7 @@
       return new ProguardKeepRuleModifiers(
           allowsAccessModification,
           allowsAnnotationRemoval,
+          allowsCodeReplacement,
           allowsRepackaging,
           allowsShrinking,
           allowsOptimization,
@@ -86,6 +95,7 @@
 
   public final boolean allowsAccessModification;
   public final boolean allowsAnnotationRemoval;
+  public final boolean allowsCodeReplacement;
   public final boolean allowsRepackaging;
   public final boolean allowsShrinking;
   public final boolean allowsOptimization;
@@ -96,6 +106,7 @@
   private ProguardKeepRuleModifiers(
       boolean allowsAccessModification,
       boolean allowsAnnotationRemoval,
+      boolean allowsCodeReplacement,
       boolean allowsRepackaging,
       boolean allowsShrinking,
       boolean allowsOptimization,
@@ -104,6 +115,7 @@
       boolean allowsPermittedSubclassesRemoval) {
     this.allowsAccessModification = allowsAccessModification;
     this.allowsAnnotationRemoval = allowsAnnotationRemoval;
+    this.allowsCodeReplacement = allowsCodeReplacement;
     this.allowsRepackaging = allowsRepackaging;
     this.allowsShrinking = allowsShrinking;
     this.allowsOptimization = allowsOptimization;
@@ -122,6 +134,7 @@
   public boolean isBottom() {
     return allowsAccessModification
         && allowsAnnotationRemoval
+        && !allowsCodeReplacement
         && allowsRepackaging
         && allowsObfuscation
         && allowsOptimization
@@ -138,6 +151,7 @@
     ProguardKeepRuleModifiers that = (ProguardKeepRuleModifiers) o;
     return allowsAccessModification == that.allowsAccessModification
         && allowsAnnotationRemoval == that.allowsAnnotationRemoval
+        && allowsCodeReplacement == that.allowsCodeReplacement
         && allowsRepackaging == that.allowsRepackaging
         && allowsShrinking == that.allowsShrinking
         && allowsOptimization == that.allowsOptimization
@@ -151,6 +165,7 @@
     return Objects.hash(
         allowsAccessModification,
         allowsAnnotationRemoval,
+        allowsCodeReplacement,
         allowsRepackaging,
         allowsShrinking,
         allowsOptimization,
@@ -164,6 +179,7 @@
     StringBuilder builder = new StringBuilder();
     appendWithComma(builder, allowsAccessModification, "allowaccessmodification");
     appendWithComma(builder, allowsAnnotationRemoval, "allowannotationremoval");
+    appendWithComma(builder, allowsCodeReplacement, "allowcodereplacement");
     appendWithComma(builder, allowsRepackaging, "allowrepackaging");
     appendWithComma(builder, allowsObfuscation, "allowobfuscation");
     appendWithComma(builder, allowsShrinking, "allowshrinking");
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 e0170ef..4836910 100644
--- a/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java
+++ b/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java
@@ -1713,6 +1713,13 @@
         context.markAsUsed();
       }
 
+      if (item.isProgramMethod()
+          && !appView.options().isCodeReplacementForceEnabled()
+          && modifiers.allowsCodeReplacement) {
+        itemJoiner.computeIfAbsent().asMethodJoiner().allowCodeReplacement();
+        context.markAsUsed();
+      }
+
       if (item.isProgramClass()
           && appView.options().isKeepPermittedSubclassesEnabled()
           && !modifiers.allowsPermittedSubclassesRemoval) {
diff --git a/src/main/java/com/android/tools/r8/shaking/SyntheticKeepClassInfo.java b/src/main/java/com/android/tools/r8/shaking/SyntheticKeepClassInfo.java
new file mode 100644
index 0000000..7a64979
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/shaking/SyntheticKeepClassInfo.java
@@ -0,0 +1,130 @@
+// 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 SyntheticKeepClassInfo extends KeepClassInfo {
+
+  // Requires no aspects of a method to be kept.
+  private static final SyntheticKeepClassInfo BOTTOM = new Builder().makeBottom().build();
+
+  public static SyntheticKeepClassInfo bottom() {
+    return BOTTOM;
+  }
+
+  public static Joiner newEmptyJoiner() {
+    return bottom().joiner();
+  }
+
+  @Override
+  Builder builder() {
+    return new Builder(this);
+  }
+
+  public static class Builder extends KeepClassInfo.Builder {
+
+    public Builder() {
+      super();
+    }
+
+    private Builder(SyntheticKeepClassInfo original) {
+      super(original);
+    }
+
+    @Override
+    public boolean isMinificationAllowed() {
+      // Synthetic items can always be minified.
+      return true;
+    }
+
+    @Override
+    public boolean isOptimizationAllowed() {
+      // Synthetic items can always be optimized.
+      return true;
+    }
+
+    @Override
+    public boolean isShrinkingAllowed() {
+      // Synthetic items can always be removed.
+      return true;
+    }
+
+    @Override
+    public SyntheticKeepClassInfo doBuild() {
+      return new SyntheticKeepClassInfo(this);
+    }
+
+    @Override
+    public SyntheticKeepClassInfo build() {
+      return (SyntheticKeepClassInfo) super.build();
+    }
+
+    @Override
+    public Builder makeBottom() {
+      super.makeBottom();
+      return self();
+    }
+
+    @Override
+    public Builder self() {
+      return this;
+    }
+  }
+
+  public static class Joiner extends KeepClassInfo.Joiner {
+
+    public Joiner(SyntheticKeepClassInfo info) {
+      super(info.builder());
+    }
+
+    @Override
+    public 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 SyntheticKeepClassInfo(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/synthesis/SyntheticFinalization.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
index 4644989..ece8caa 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
@@ -26,8 +26,10 @@
 import com.android.tools.r8.graph.lens.NonIdentityGraphLens;
 import com.android.tools.r8.ir.code.NumberGenerator;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.KeepClassInfo;
 import com.android.tools.r8.shaking.KeepInfoCollection;
 import com.android.tools.r8.shaking.MainDexInfo;
+import com.android.tools.r8.shaking.SyntheticKeepClassInfo;
 import com.android.tools.r8.synthesis.SyntheticItems.State;
 import com.android.tools.r8.synthesis.SyntheticNaming.Phase;
 import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
@@ -298,7 +300,9 @@
         mainDexInfoBuilder.build());
   }
 
-  private <R extends SyntheticReference<R, D, ?>, D extends SyntheticDefinition<R, D, ?>>
+  private <
+          R extends SyntheticReference<R, D, DexProgramClass>,
+          D extends SyntheticDefinition<R, D, DexProgramClass>>
       Map<DexType, EquivalenceGroup<D>> computeEquivalences(
           AppView<?> appView,
           ImmutableMap<DexType, List<R>> references,
@@ -314,6 +318,7 @@
     timing.begin("Potential equivalences");
     Collection<List<D>> potentialEquivalences =
         computePotentialEquivalences(
+            appView,
             definitions,
             intermediate,
             appView.options(),
@@ -836,8 +841,9 @@
   }
 
   @SuppressWarnings("MixedMutabilityReturnType")
-  private static <T extends SyntheticDefinition<?, T, ?>>
+  private static <T extends SyntheticDefinition<?, T, DexProgramClass>>
       Collection<List<T>> computePotentialEquivalences(
+          AppView<?> appView,
           Map<DexType, T> definitions,
           boolean intermediate,
           InternalOptions options,
@@ -870,12 +876,24 @@
     }
     RepresentativeMap map = t -> syntheticTypes.contains(t) ? options.dexItemFactory().voidType : t;
     Map<HashCode, List<T>> equivalences = new HashMap<>(definitions.size());
+    List<List<T>> result = new ArrayList<>();
     for (T definition : definitions.values()) {
-      HashCode hash =
-          definition.computeHash(map, intermediate, classToFeatureSplitMap, syntheticItems);
-      equivalences.computeIfAbsent(hash, k -> new ArrayList<>()).add(definition);
+      DexProgramClass holder = definition.getHolder();
+      KeepClassInfo keepInfo =
+          appView.getKeepInfoOrDefault(holder, SyntheticKeepClassInfo.bottom());
+      if (keepInfo.isSyntheticSharingAllowed()) {
+        HashCode hash =
+            definition.computeHash(map, intermediate, classToFeatureSplitMap, syntheticItems);
+        equivalences.computeIfAbsent(hash, k -> new ArrayList<>()).add(definition);
+      } else {
+        result.add(ImmutableList.of(definition));
+      }
     }
-    return equivalences.values();
+    if (result.isEmpty()) {
+      return equivalences.values();
+    }
+    result.addAll(equivalences.values());
+    return result;
   }
 
   private <R extends SyntheticReference<R, D, ?>, D extends SyntheticDefinition<R, D, ?>>
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 615f440..8ac9315 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -797,6 +797,11 @@
   }
 
   @Override
+  public boolean isCodeReplacementForceEnabled() {
+    return getTestingOptions().allowCodeReplacement;
+  }
+
+  @Override
   public boolean isTreeShakingEnabled() {
     return isShrinking();
   }
@@ -2401,6 +2406,7 @@
     public boolean addCallEdgesForLibraryInvokes = false;
 
     public boolean allowClassInliningOfSynthetics = true;
+    public boolean allowCodeReplacement = true;
     public boolean allowInjectedAnnotationMethods = false;
     public boolean allowInliningOfOutlines = true;
     public boolean allowInliningOfSynthetics = true;
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 6772ced..acb8b0d 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticalClassMerger.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.DirectMappedDexApplication;
 import com.android.tools.r8.graph.ImmediateProgramSubtypingInfo;
 import com.android.tools.r8.graph.ProgramMethod;
@@ -24,6 +25,7 @@
 import com.android.tools.r8.profile.art.ArtProfileCompletenessChecker;
 import com.android.tools.r8.profile.rewriting.ProfileCollectionAdditions;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.KeepClassInfo.Joiner;
 import com.android.tools.r8.shaking.KeepInfoCollection;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.ThreadUtils;
@@ -286,6 +288,13 @@
               PrunedItems.builder()
                   .setRemovedClasses(verticallyMergedClasses.getSources())
                   .build());
+          for (DexType target : verticallyMergedClasses.getTargets()) {
+            DexProgramClass targetClass = appView.definitionFor(target).asProgramClass();
+            if (appView.getSyntheticItems().isSynthetic(targetClass)) {
+              mutator.ensureCompilerSynthesizedClass(targetClass);
+              mutator.joinClass(targetClass, Joiner::disallowSyntheticSharing);
+            }
+          }
         });
     timing.end();
   }
diff --git a/src/test/examples/identifiernamestring/keep-rules-1.txt b/src/test/examples/identifiernamestring/keep-rules-1.txt
index 682999f..2e0c2ca 100644
--- a/src/test/examples/identifiernamestring/keep-rules-1.txt
+++ b/src/test/examples/identifiernamestring/keep-rules-1.txt
@@ -9,4 +9,5 @@
 
 -keepnames class identifiernamestring.A
 
+-dontoptimize
 -dontshrink
diff --git a/src/test/examples/memberrebinding3/keep-rules.txt b/src/test/examples/memberrebinding3/keep-rules.txt
new file mode 100644
index 0000000..51b9f3c
--- /dev/null
+++ b/src/test/examples/memberrebinding3/keep-rules.txt
@@ -0,0 +1 @@
+-dontoptimize
diff --git a/src/test/examplesJava11/nesthostexample/FullNestOnProgramPathTest.java b/src/test/examplesJava11/nesthostexample/FullNestOnProgramPathTest.java
index c36a73b..5bc8808 100644
--- a/src/test/examplesJava11/nesthostexample/FullNestOnProgramPathTest.java
+++ b/src/test/examplesJava11/nesthostexample/FullNestOnProgramPathTest.java
@@ -106,7 +106,7 @@
     parameters.assumeR8TestParameters();
     R8TestCompileResult compileResult =
         testForR8(parameters.getBackend())
-            .noTreeShaking()
+            .addDontShrink()
             .addDontObfuscate()
             .addKeepAllAttributes()
             .addOptionsModification(options -> options.enableNestReduction = false)
@@ -134,7 +134,7 @@
     parameters.assumeR8TestParameters();
     for (Class<?> clazz : NEST_MAIN_RESULT.keySet()) {
       testForR8(parameters.getBackend())
-          .noTreeShaking()
+          .addDontShrink()
           .addDontObfuscate()
           .addKeepAllAttributes()
           .setMinApi(parameters)
diff --git a/src/test/examplesJava11/nesthostexample/NestAttributesUpdateTest.java b/src/test/examplesJava11/nesthostexample/NestAttributesUpdateTest.java
index 52960eb..ecac6fb 100644
--- a/src/test/examplesJava11/nesthostexample/NestAttributesUpdateTest.java
+++ b/src/test/examplesJava11/nesthostexample/NestAttributesUpdateTest.java
@@ -125,7 +125,7 @@
       throws Exception {
     testForR8(parameters.getBackend())
         .addKeepMainRule(mainClass)
-        .minification(minification)
+        .addDontObfuscateUnless(minification)
         .addOptionsModification(
             options -> {
               // Disable optimizations else additional classes are removed since they become unused.
diff --git a/src/test/examplesJava11/nesthostexample/NestConstructorRemovedArgTest.java b/src/test/examplesJava11/nesthostexample/NestConstructorRemovedArgTest.java
index 70c0120..216673a 100644
--- a/src/test/examplesJava11/nesthostexample/NestConstructorRemovedArgTest.java
+++ b/src/test/examplesJava11/nesthostexample/NestConstructorRemovedArgTest.java
@@ -56,7 +56,7 @@
   public void testRemoveArgConstructorNestsR8NoTreeShaking() throws Exception {
     parameters.assumeR8TestParameters();
     testForR8(parameters.getBackend())
-        .noTreeShaking()
+        .addDontShrink()
         .addKeepMainRule(MAIN_CLASS)
         .addDontObfuscate()
         .setMinApi(parameters)
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/RemoveVisibilityBridgeMethodsTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/RemoveVisibilityBridgeMethodsTest.java
index 2c372de..8d9654e 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/RemoveVisibilityBridgeMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/RemoveVisibilityBridgeMethodsTest.java
@@ -43,7 +43,7 @@
         .addInnerClasses(RemoveVisibilityBridgeMethodsTest.class)
         .addKeepMainRule(Main.class)
         .allowAccessModification()
-        .minification(minification)
+        .addDontObfuscateUnless(minification)
         .setMinApi(parameters)
         .compile()
         .inspect(this::inspect)
@@ -106,7 +106,7 @@
         .addKeepMainRule(mainClass.name)
         .addOptionsModification(options -> options.inlinerOptions().enableInlining = false)
         .allowAccessModification()
-        .minification(minification)
+        .addDontObfuscateUnless(minification)
         .setMinApi(parameters)
         .compile()
         .inspect(
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
index 52fd6e9..33dea90 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
@@ -60,7 +60,7 @@
         .enableNeverClassInliningAnnotations()
         .enableNoVerticalClassMergingAnnotations()
         .enableProguardTestOptions()
-        .minification(minification)
+        .addDontObfuscateUnless(minification)
         .setMinApi(parameters)
         .compile()
         .inspect(
diff --git a/src/test/java/com/android/tools/r8/cf/AlwaysNullGetItemTestRunner.java b/src/test/java/com/android/tools/r8/cf/AlwaysNullGetItemTestRunner.java
index a8f2ac2..9a2e6e4 100644
--- a/src/test/java/com/android/tools/r8/cf/AlwaysNullGetItemTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/AlwaysNullGetItemTestRunner.java
@@ -39,7 +39,7 @@
         .addProgramClassesAndInnerClasses(CLASS)
         .debug()
         .addDontObfuscate()
-        .noTreeShaking()
+        .addDontShrink()
         .setMinApi(parameters)
         .compile()
         .run(parameters.getRuntime(), CLASS)
diff --git a/src/test/java/com/android/tools/r8/cf/CloserTestRunner.java b/src/test/java/com/android/tools/r8/cf/CloserTestRunner.java
index dea6642..8fa6bb6 100644
--- a/src/test/java/com/android/tools/r8/cf/CloserTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/CloserTestRunner.java
@@ -45,7 +45,7 @@
         .addKeepMainRule(CloserTest.class)
         .setMode(CompilationMode.RELEASE)
         .addDontObfuscate()
-        .noTreeShaking()
+        .addDontShrink()
         .enableInliningAnnotations()
         .compile()
         .run(CloserTest.class)
diff --git a/src/test/java/com/android/tools/r8/cf/DebugInfoTestRunner.java b/src/test/java/com/android/tools/r8/cf/DebugInfoTestRunner.java
index 6ab2aef..d0023d0 100644
--- a/src/test/java/com/android/tools/r8/cf/DebugInfoTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/DebugInfoTestRunner.java
@@ -60,7 +60,7 @@
   private R8FullTestBuilder builder() {
     return testForR8(parameters.getBackend())
         .debug()
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .addOptionsModification(o -> o.invalidDebugInfoFatal = true)
         .setMinApi(parameters);
diff --git a/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java b/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java
index e002b80..6716f80 100644
--- a/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/KeepDeserializeLambdaMethodTestRunner.java
@@ -91,7 +91,7 @@
           // TODO(b/148836254): Support deserialized lambdas without the need of additional rules.
           "-keep class * { private static synthetic void lambda$*(); }");
     } else {
-      builder.addDontObfuscate().noTreeShaking();
+      builder.addDontObfuscate().addDontShrink();
     }
     builder
         .run(parameters.getRuntime(), getMainClass())
diff --git a/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java b/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java
index 5d9dd66..89f13b9 100644
--- a/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java
+++ b/src/test/java/com/android/tools/r8/cf/PrintSeedsWithDeserializeLambdaMethodTest.java
@@ -59,7 +59,7 @@
         .addPrintSeeds()
         .allowStdoutMessages()
         .addDontObfuscate()
-        .noTreeShaking()
+        .addDontShrink()
         .run(parameters.getRuntime(), getMainClass())
         .assertSuccessWithOutput(EXPECTED)
         .inspect(this::checkPresenceOfDeserializedLambdas);
diff --git a/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java b/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java
index 80a7beb..21ee0fc 100644
--- a/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/TryRangeTestRunner.java
@@ -55,7 +55,7 @@
         .addKeepMainRule(TryRangeTest.class)
         .setMode(CompilationMode.RELEASE)
         .addDontObfuscate()
-        .noTreeShaking()
+        .addDontShrink()
         .enableInliningAnnotations()
         .addOptionsModification(o -> o.enableLoadStoreOptimization = false)
         .run(parameters.getRuntime(), TryRangeTest.class)
@@ -70,7 +70,7 @@
             .addKeepMainRule(TryRangeTestLimitRange.class)
             .setMode(CompilationMode.RELEASE)
             .addDontObfuscate()
-            .noTreeShaking()
+            .addDontShrink()
             .enableInliningAnnotations()
             .addOptionsModification(
                 o -> {
diff --git a/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedOverriddenMethodTest.java b/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedOverriddenMethodTest.java
index 6227c12..c321302 100644
--- a/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedOverriddenMethodTest.java
+++ b/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedOverriddenMethodTest.java
@@ -50,7 +50,7 @@
           .enableNeverClassInliningAnnotations()
           .enableInliningAnnotations()
           .enableNoVerticalClassMergingAnnotations()
-          .minification(minification)
+          .addDontObfuscateUnless(minification)
           .setMinApi(parameters)
           // Asserting that -checkdiscard is not giving any information out on an un-removed
           // sub-type member.
diff --git a/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedTest.java b/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedTest.java
index ef048be..7260ad8 100644
--- a/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedTest.java
+++ b/src/test/java/com/android/tools/r8/checkdiscarded/CheckDiscardedTest.java
@@ -58,7 +58,7 @@
                   UnusedClass.class, UsedClass.class, Main.class, WillBeGone.class, WillStay.class)
               .addKeepMainRule(Main.class)
               .addKeepRules(checkDiscardRule(checkMembers, annotation))
-              .minification(minify)
+              .addDontObfuscateUnless(minify)
               .addOptionsModification(this::noInlining)
               .compile();
       assertNull(onCompilationFailure);
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstClassAfterVerticalClassMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstClassAfterVerticalClassMergingTest.java
new file mode 100644
index 0000000..4f44022
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstClassAfterVerticalClassMergingTest.java
@@ -0,0 +1,74 @@
+// 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.classmerging.horizontal;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+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 ConstClassAfterVerticalClassMergingTest extends TestBase {
+
+  @Parameter(0)
+  public boolean enableSyntheticSharing;
+
+  @Parameter(1)
+  public TestParameters parameters;
+
+  @Parameters(name = "{1}, synthetic sharing: {0}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .addHorizontallyMergedClassesInspector(
+            HorizontallyMergedClassesInspector::assertNoClassesMerged)
+        .addVerticallyMergedClassesInspector(
+            inspector ->
+                inspector
+                    .applyIf(
+                        parameters.isDexRuntime(), i -> i.assertMergedIntoSubtype(I.class, J.class))
+                    .assertNoOtherClassesMerged())
+        .setMinApi(parameters)
+        .addOptionsModification(
+            options -> options.getTestingOptions().enableSyntheticSharing = enableSyntheticSharing)
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("2");
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      Map<Class<?>, Object> map = new HashMap<>();
+      map.put(I.class, (I) () -> System.out.println("I"));
+      map.put(J.class, (J) () -> System.out.println("J"));
+      System.out.println(map.size());
+    }
+  }
+
+  interface I {
+
+    void f();
+  }
+
+  interface J {
+
+    void g();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java
index 723e674..627c16f 100644
--- a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerTest.java
@@ -855,7 +855,6 @@
         ImmutableSet.of(
             "classmerging.SuperCallToMergedClassIsRewrittenTest",
             "classmerging.A",
-            "classmerging.D",
             "classmerging.F");
 
     JasminBuilder jasminBuilder = new JasminBuilder();
diff --git a/src/test/java/com/android/tools/r8/classpath/SuperclassOfLocalClassesOnClasspathTest.java b/src/test/java/com/android/tools/r8/classpath/SuperclassOfLocalClassesOnClasspathTest.java
new file mode 100644
index 0000000..8f5f324
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classpath/SuperclassOfLocalClassesOnClasspathTest.java
@@ -0,0 +1,138 @@
+// 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.classpath;
+
+package com.android.tools.r8.classpath;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.ZipUtils.ZipBuilder;
+import java.nio.file.Path;
+import org.junit.BeforeClass;
+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 SuperclassOfLocalClassesOnClasspathTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  static Path classpathDex;
+  static Path classpathCf;
+
+  @BeforeClass
+  public static void setUpClasspath() throws Exception {
+    // Build classpath DEX with API level 1 to work with all API levels.
+    classpathDex =
+        testForD8(getStaticTemp())
+            .addProgramClasses(A.class)
+            .setMinApi(AndroidApiLevel.B)
+            .compile()
+            .writeToZip();
+    classpathCf = getStaticTemp().newFile("classpath2.zip").toPath();
+    ZipBuilder.builder(classpathCf)
+        .addFile(
+            DescriptorUtils.getPathFromJavaType(A.class),
+            ToolHelper.getClassFileForTestClass(A.class))
+        .build();
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    parameters.assumeDexRuntime();
+    testForD8()
+        .addClasspathClasses(A.class)
+        .addInnerClasses(A.class)
+        .addProgramClasses(I.class)
+        .addProgramClasses(TestClass.class)
+        .setMinApi(parameters)
+        .addRunClasspathFiles(classpathDex)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccess();
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        // Split A and its inner classes on classpath/program.
+        .addClasspathClasses(A.class)
+        .addInnerClasses(A.class)
+        .addProgramClasses(I.class)
+        .addProgramClasses(TestClass.class)
+        .addKeepMainRule(TestClass.class)
+        .addKeepRules("-keep class " + A.class.getTypeName() + "$* { *; }")
+        .setMinApi(parameters)
+        .addRunClasspathFiles(parameters.isDexRuntime() ? classpathDex : classpathCf)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccess();
+  }
+
+  interface I {
+    void m();
+  }
+
+  static class A {
+    static {
+      // Anonymous local class in <clinit>.
+      new I() {
+        public void m() {}
+      };
+    }
+
+    static {
+      // Named local class in <clinit>.
+      class Local {}
+      new Local();
+    }
+
+    public A() {
+      anonymousLocalClass();
+      namedLocalClass();
+
+      // Anonymous local class in <init>.
+      new I() {
+        public void m() {}
+      };
+
+      // Named local class in <init>.
+      class Local {
+        public void m() {}
+      }
+
+      new Local();
+    }
+
+    private void anonymousLocalClass() {
+      new I() {
+        public void m() {}
+      };
+    }
+
+    private void namedLocalClass() {
+      class Local {
+        public void m() {}
+      }
+      new Local();
+    }
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) {
+      new A();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/compatproguard/ForNameTest.java b/src/test/java/com/android/tools/r8/compatproguard/ForNameTest.java
index 97cb7c9..9c7cf17 100644
--- a/src/test/java/com/android/tools/r8/compatproguard/ForNameTest.java
+++ b/src/test/java/com/android/tools/r8/compatproguard/ForNameTest.java
@@ -43,7 +43,7 @@
                     // Add main dex rule to disable Class.forName() optimization.
                     .addMainDexRules("-keep class " + CLASS_NAME)
                     .addDontOptimize()
-                    .noTreeShaking()
+                    .addDontShrink()
                     .setMinApi(AndroidApiLevel.B));
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
@@ -79,7 +79,7 @@
                     .addMainDexRules("-keep class " + CLASS_NAME)
                     .addDontOptimize()
                     .addDontObfuscate()
-                    .noTreeShaking()
+                    .addDontShrink()
                     .setMinApi(AndroidApiLevel.B));
 
     ClassSubject clazz = inspector.clazz(CLASS_NAME);
diff --git a/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java b/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java
index 7a10656..11b4f24 100644
--- a/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java
+++ b/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java
@@ -80,7 +80,7 @@
         .addKeepAllAttributes()
         .allowDiagnosticWarningMessages()
         .addDontObfuscate()
-        .noTreeShaking()
+        .addDontShrink()
         .setMode(CompilationMode.DEBUG)
         .setMinApi(parameters)
         .applyIf(
diff --git a/src/test/java/com/android/tools/r8/debug/LambdaOuterContextTestRunner.java b/src/test/java/com/android/tools/r8/debug/LambdaOuterContextTestRunner.java
index d6b8dc4..72f67f8 100644
--- a/src/test/java/com/android/tools/r8/debug/LambdaOuterContextTestRunner.java
+++ b/src/test/java/com/android/tools/r8/debug/LambdaOuterContextTestRunner.java
@@ -60,7 +60,7 @@
         .addProgramClassesAndInnerClasses(CLASS)
         .debug()
         .addDontObfuscate()
-        .noTreeShaking()
+        .addDontShrink()
         .setMinApi(parameters)
         .run(parameters.getRuntime(), CLASS)
         .assertSuccessWithOutput(EXPECTED)
diff --git a/src/test/java/com/android/tools/r8/debug/LineNumberOptimizationTest.java b/src/test/java/com/android/tools/r8/debug/LineNumberOptimizationTest.java
index ec4a891..a811ca2 100644
--- a/src/test/java/com/android/tools/r8/debug/LineNumberOptimizationTest.java
+++ b/src/test/java/com/android/tools/r8/debug/LineNumberOptimizationTest.java
@@ -52,7 +52,7 @@
             .addProgramClasses(LineNumberOptimization1.class, LineNumberOptimization2.class)
             .setMinApi(parameters)
             .setMode(dontOptimizeByEnablingDebug ? CompilationMode.DEBUG : CompilationMode.RELEASE)
-            .noTreeShaking()
+            .addDontShrink()
             .addDontObfuscate()
             .addKeepAttributeSourceFile()
             .addKeepAttributeLineNumberTable()
diff --git a/src/test/java/com/android/tools/r8/debug/LoadInvokeLoadOptimizationTestRunner.java b/src/test/java/com/android/tools/r8/debug/LoadInvokeLoadOptimizationTestRunner.java
index e33be2e..d2e3120 100644
--- a/src/test/java/com/android/tools/r8/debug/LoadInvokeLoadOptimizationTestRunner.java
+++ b/src/test/java/com/android/tools/r8/debug/LoadInvokeLoadOptimizationTestRunner.java
@@ -58,7 +58,7 @@
   @Test
   public void testR8() throws Throwable {
     testForR8(parameters.getBackend())
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .addKeepRules("-keepattributes SourceFile,LineNumberTable")
         .addProgramClasses(CLASS)
diff --git a/src/test/java/com/android/tools/r8/debug/LocalsTest.java b/src/test/java/com/android/tools/r8/debug/LocalsTest.java
index add47dc..8b914ad 100644
--- a/src/test/java/com/android/tools/r8/debug/LocalsTest.java
+++ b/src/test/java/com/android/tools/r8/debug/LocalsTest.java
@@ -48,8 +48,8 @@
             .addProgramClasses(Locals.class)
             .setMinApi(parameters)
             .debug()
-            .treeShaking(false)
-            .minification(false)
+            .addDontShrink()
+            .addDontObfuscate()
             .addKeepAllClassesRule()
             .debugConfig(parameters.getRuntime())
         : testForRuntime(parameters)
diff --git a/src/test/java/com/android/tools/r8/debug/SynchronizedBlockTest.java b/src/test/java/com/android/tools/r8/debug/SynchronizedBlockTest.java
index 6aafde3..c7ee7f1 100644
--- a/src/test/java/com/android/tools/r8/debug/SynchronizedBlockTest.java
+++ b/src/test/java/com/android/tools/r8/debug/SynchronizedBlockTest.java
@@ -45,8 +45,8 @@
             .addProgramClasses(SynchronizedBlock.class)
             .setMinApi(parameters)
             .debug()
-            .treeShaking(false)
-            .minification(false)
+            .addDontShrink()
+            .addDontObfuscate()
             .addKeepAllClassesRule()
             .debugConfig(parameters.getRuntime())
         : testForRuntime(parameters)
diff --git a/src/test/java/com/android/tools/r8/debuginfo/KotlinDebugInfoTestRunner.java b/src/test/java/com/android/tools/r8/debuginfo/KotlinDebugInfoTestRunner.java
index f2fa291..6b2e7f0 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/KotlinDebugInfoTestRunner.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/KotlinDebugInfoTestRunner.java
@@ -86,7 +86,7 @@
         .apply(configuration)
         .debug()
         .addDontObfuscate()
-        .noTreeShaking()
+        .addDontShrink()
         .compile()
         .run(parameters.getRuntime(), className)
         .assertSuccessWithOutput(runInput.stdout);
diff --git a/src/test/java/com/android/tools/r8/debuginfo/pc2pc/DifferentParameterCountMultilineCodeTestRunner.java b/src/test/java/com/android/tools/r8/debuginfo/pc2pc/DifferentParameterCountMultilineCodeTestRunner.java
index 8cd026d..5c35005 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/pc2pc/DifferentParameterCountMultilineCodeTestRunner.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/pc2pc/DifferentParameterCountMultilineCodeTestRunner.java
@@ -43,7 +43,7 @@
         .addProgramClasses(CLASS)
         .addKeepMainRule(CLASS)
         // Keep all the methods but allow renaming.
-        .noTreeShaking()
+        .addDontShrink()
         .addKeepAttributeLineNumberTable()
         .addKeepAttributeSourceFile()
         .addKeepRules("-renamesourcefileattribute " + (customSourceFile ? "X" : "SourceFile"))
diff --git a/src/test/java/com/android/tools/r8/debuginfo/pc2pc/DifferentParameterCountSingleLineCodeTestRunner.java b/src/test/java/com/android/tools/r8/debuginfo/pc2pc/DifferentParameterCountSingleLineCodeTestRunner.java
index 6c31cf2..7a1bd68 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/pc2pc/DifferentParameterCountSingleLineCodeTestRunner.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/pc2pc/DifferentParameterCountSingleLineCodeTestRunner.java
@@ -43,7 +43,7 @@
         .addProgramClasses(CLASS)
         .addKeepMainRule(CLASS)
         // Keep all the methods but allow renaming.
-        .noTreeShaking()
+        .addDontShrink()
         .addKeepAttributeLineNumberTable()
         .addKeepAttributeSourceFile()
         .addKeepRules("-renamesourcefileattribute " + (customSourceFile ? "X" : "SourceFile"))
diff --git a/src/test/java/com/android/tools/r8/desugar/DefaultLambdaWithInvokeInterfaceTestRunner.java b/src/test/java/com/android/tools/r8/desugar/DefaultLambdaWithInvokeInterfaceTestRunner.java
index 42e6975..e9a894d 100644
--- a/src/test/java/com/android/tools/r8/desugar/DefaultLambdaWithInvokeInterfaceTestRunner.java
+++ b/src/test/java/com/android/tools/r8/desugar/DefaultLambdaWithInvokeInterfaceTestRunner.java
@@ -55,7 +55,7 @@
         testForR8(Backend.CF)
             .addProgramClassesAndInnerClasses(CLASS)
             .addDontObfuscate()
-            .noTreeShaking()
+            .addDontShrink()
             .debug()
             .compile();
     compileResult
diff --git a/src/test/java/com/android/tools/r8/desugar/DefaultLambdaWithSelfReferenceTestRunner.java b/src/test/java/com/android/tools/r8/desugar/DefaultLambdaWithSelfReferenceTestRunner.java
index ce5f0bd..04f4efe 100644
--- a/src/test/java/com/android/tools/r8/desugar/DefaultLambdaWithSelfReferenceTestRunner.java
+++ b/src/test/java/com/android/tools/r8/desugar/DefaultLambdaWithSelfReferenceTestRunner.java
@@ -100,7 +100,7 @@
         .addProgramClassesAndInnerClasses(CLASS)
         .setMinApi(parameters)
         .addDontObfuscate()
-        .noTreeShaking()
+        .addDontShrink()
         .addKeepAllAttributes()
         .debug()
         .compile()
diff --git a/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java b/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java
index 9284fa8..4b9b180 100644
--- a/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/backports/BackportDuplicationTest.java
@@ -90,7 +90,7 @@
         .addKeepMainRule(TestClass.class)
         .addKeepClassAndMembersRules(MiniAssert.class)
         .setMinApi(parameters)
-        .minification(minify)
+        .addDontObfuscateUnless(minify)
         .run(parameters.getRuntime(), TestClass.class)
         .assertSuccessWithOutput(EXPECTED)
         .inspect(this::checkNoOriginalsAndNoInternalSynthetics);
diff --git a/src/test/java/com/android/tools/r8/desugar/jdk8272564/Jdk8272564Test.java b/src/test/java/com/android/tools/r8/desugar/jdk8272564/Jdk8272564Test.java
index 43853de..52809ee 100644
--- a/src/test/java/com/android/tools/r8/desugar/jdk8272564/Jdk8272564Test.java
+++ b/src/test/java/com/android/tools/r8/desugar/jdk8272564/Jdk8272564Test.java
@@ -155,7 +155,7 @@
     testForR8(parameters.getBackend())
         .addProgramFiles(Jdk8272564.jar())
         .setMinApi(parameters)
-        .noTreeShaking()
+        .addDontShrink()
         .addKeepClassAndMembersRules(Jdk8272564.Main.typeName())
         .run(parameters.getRuntime(), Jdk8272564.Main.typeName())
         .inspect(this::assertJdk8272564NotFixedCodeR8)
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaInStacktraceTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaInStacktraceTest.java
index 7c2fab0..1aeff4d 100644
--- a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaInStacktraceTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaInStacktraceTest.java
@@ -9,7 +9,6 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.ToolHelper.DexVm.Version;
 import com.android.tools.r8.utils.StringUtils;
 import java.util.ArrayList;
 import java.util.List;
@@ -85,7 +84,7 @@
             .addKeepMainRule(TestRunner.class)
             .addKeepAttributeSourceFile()
             .addKeepRules("-renamesourcefileattribute SourceFile")
-            .noTreeShaking()
+            .addDontShrink()
             .addDontOptimize()
             .run(parameters.getRuntime(), TestRunner.class, Boolean.toString(isDalvik))
             .assertSuccess()
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaStaticInstanceFieldDuplicationTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaStaticInstanceFieldDuplicationTest.java
index a33995b..4d56e6a 100644
--- a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaStaticInstanceFieldDuplicationTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaStaticInstanceFieldDuplicationTest.java
@@ -72,7 +72,7 @@
         // Prevent R8 from eliminating the lambdas by keeping the application of them.
         .addKeepClassAndMembersRules(Accept.class)
         .setMinApi(parameters)
-        .minification(minify)
+        .addDontObfuscateUnless(minify)
         .run(parameters.getRuntime(), TestClass.class)
         .assertSuccessWithOutput(EXPECTED)
         .inspect(this::checkNoOriginalsAndNoInternalSynthetics);
diff --git a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaToSysOutPrintlnDuplicationTest.java b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaToSysOutPrintlnDuplicationTest.java
index 0581c23..05870c7 100644
--- a/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaToSysOutPrintlnDuplicationTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/lambdas/LambdaToSysOutPrintlnDuplicationTest.java
@@ -70,7 +70,7 @@
         .addProgramClasses(CLASSES)
         .addKeepMainRule(TestClass.class)
         .setMinApi(parameters)
-        .minification(minify)
+        .addDontObfuscateUnless(minify)
         .run(parameters.getRuntime(), TestClass.class)
         .assertSuccessWithOutput(EXPECTED)
         .inspect(this::checkNoOriginalsAndNoInternalSynthetics);
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java
index 9ac144b..ec66458 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java
@@ -93,7 +93,7 @@
           .addProgramFiles(matchingClasses);
     } else {
       return testForR8(parameters.getBackend())
-          .noTreeShaking()
+          .addDontShrink()
           .addDontObfuscate()
           .addKeepAllAttributes()
           .setMinApi(parameters)
diff --git a/src/test/java/com/android/tools/r8/desugar/records/EmptyRecordTest.java b/src/test/java/com/android/tools/r8/desugar/records/EmptyRecordTest.java
index 7b1065a..9c88c93 100644
--- a/src/test/java/com/android/tools/r8/desugar/records/EmptyRecordTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/records/EmptyRecordTest.java
@@ -81,7 +81,7 @@
         .applyIf(
             parameters.isCfRuntime(),
             testBuilder -> testBuilder.addLibraryFiles(RecordTestUtils.getJdk15LibraryFiles(temp)))
-        .minification(enableMinification)
+        .addDontObfuscateUnless(enableMinification)
         .applyIf(enableRepackaging, b -> b.addKeepRules("-repackageclasses p"))
         .setMinApi(parameters)
         .compile()
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordShrinkFieldTest.java b/src/test/java/com/android/tools/r8/desugar/records/RecordShrinkFieldTest.java
index 0c007f2..e8587ca 100644
--- a/src/test/java/com/android/tools/r8/desugar/records/RecordShrinkFieldTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordShrinkFieldTest.java
@@ -67,7 +67,7 @@
         .addProgramClassFileData(PROGRAM_DATA)
         .setMinApi(parameters)
         .addKeepMainRule(MAIN_TYPE)
-        .minification(minifying)
+        .addDontObfuscateUnless(minifying)
         .compile()
         .inspect(inspector -> inspect(inspector, false))
         .run(parameters.getRuntime(), MAIN_TYPE)
@@ -82,7 +82,7 @@
         testForR8(Backend.CF)
             .addProgramClassFileData(PROGRAM_DATA)
             .addKeepMainRule(MAIN_TYPE)
-            .minification(minifying)
+            .addDontObfuscateUnless(minifying)
             .addLibraryFiles(RecordTestUtils.getJdk15LibraryFiles(temp))
             .compile()
             .writeToZip();
@@ -90,7 +90,7 @@
         .addProgramFiles(desugared)
         .setMinApi(parameters)
         .addKeepMainRule(MAIN_TYPE)
-        .minification(minifying)
+        .addDontObfuscateUnless(minifying)
         .compile()
         .inspect(inspector -> inspect(inspector, true))
         .run(parameters.getRuntime(), MAIN_TYPE)
diff --git a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/Regress148461139.java b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/Regress148461139.java
index e7219f1..d73eeb6 100644
--- a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/Regress148461139.java
+++ b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/Regress148461139.java
@@ -33,7 +33,7 @@
     testForR8(parameters.getBackend())
         .setMinApi(parameters)
         .addProgramClasses(Condition.class)
-        .noTreeShaking()
+        .addDontShrink()
         .compile()
         .inspect(i -> assertTrue(i.clazz(Condition.class).isAbstract()));
   }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingEnumUnboxingTest.java
index bd6b65d..df5e669 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingEnumUnboxingTest.java
@@ -61,7 +61,7 @@
             .addKeepRules(enumKeepRules.getKeepRules())
             .enableNeverClassInliningAnnotations()
             .enableInliningAnnotations()
-            .minification(minification)
+            .addDontObfuscateUnless(minification)
             .compile()
             .writeToZip();
     // Compile the app with the lib.
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingMergeEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingMergeEnumUnboxingTest.java
index aa341a7..a5d0de3 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingMergeEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingMergeEnumUnboxingTest.java
@@ -81,7 +81,7 @@
         .addKeepRules(enumKeepRules.getKeepRules())
         .enableNeverClassInliningAnnotations()
         .enableInliningAnnotations()
-        .minification(minification)
+        .addDontObfuscateUnless(minification)
         .addKeepPackageNamesRule(libClass.getPackage())
         .compile()
         .writeToZip();
diff --git a/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java b/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
index 333ab92..2a502d7 100644
--- a/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
+++ b/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
@@ -69,7 +69,7 @@
                 .addKeepAllClassesRule()
                 .addKeepAllAttributes()
                 .addDontObfuscate()
-                .noTreeShaking()
+                .addDontShrink()
                 .enableInliningAnnotations()
                 .enableNoHorizontalClassMergingAnnotations()
                 .debug()
diff --git a/src/test/java/com/android/tools/r8/internal/Regression127524985.java b/src/test/java/com/android/tools/r8/internal/Regression127524985.java
index 8bfef9e..c9e61ed 100644
--- a/src/test/java/com/android/tools/r8/internal/Regression127524985.java
+++ b/src/test/java/com/android/tools/r8/internal/Regression127524985.java
@@ -68,7 +68,7 @@
     assumeTrue(parameters.isCfRuntime());
     testForR8(parameters.getBackend())
         .debug()
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .addKeepAllAttributes()
         .addKeepRules("-dontwarn")
diff --git a/src/test/java/com/android/tools/r8/internal/opensourceapps/TiviTest.java b/src/test/java/com/android/tools/r8/internal/opensourceapps/TiviTest.java
index 05d0d8b..b11215a 100644
--- a/src/test/java/com/android/tools/r8/internal/opensourceapps/TiviTest.java
+++ b/src/test/java/com/android/tools/r8/internal/opensourceapps/TiviTest.java
@@ -50,6 +50,7 @@
   public void testR8() throws Exception {
     testForR8(Backend.DEX)
         .addProgramFiles(outDirectory.resolve("program.jar"))
+        .addOptionsModification(options -> options.getTestingOptions().allowCodeReplacement = false)
         .apply(this::configure)
         .compile();
   }
diff --git a/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java b/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java
index 21314c0..375c5bc 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/Proto3ShrinkingTest.java
@@ -68,7 +68,7 @@
         .allowUnusedDontWarnPatterns()
         .allowUnusedProguardConfigurationRules()
         .enableProtoShrinking()
-        .minification(enableMinification)
+        .addDontObfuscateUnless(enableMinification)
         .setMinApi(parameters)
         .compile()
         .assertAllInfoMessagesMatch(
@@ -120,7 +120,7 @@
         .allowUnusedDontWarnPatterns()
         .allowUnusedProguardConfigurationRules()
         .enableProtoShrinking()
-        .minification(enableMinification)
+        .addDontObfuscateUnless(enableMinification)
         .setMinApi(parameters)
         .compile()
         .assertAllInfoMessagesMatch(
diff --git a/src/test/java/com/android/tools/r8/internal/proto/ProtoShrinkingTest.java b/src/test/java/com/android/tools/r8/internal/proto/ProtoShrinkingTest.java
index e9181de..71c43bf 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/ProtoShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/ProtoShrinkingTest.java
@@ -110,7 +110,7 @@
             .allowUnusedProguardConfigurationRules()
             .enableProguardTestOptions()
             .enableProtoShrinking()
-            .minification(enableMinification)
+            .addDontObfuscateUnless(enableMinification)
             .setMinApi(parameters)
             .compile()
             .assertAllInfoMessagesMatch(
@@ -425,7 +425,7 @@
         .allowUnusedDontWarnPatterns()
         .allowUnusedProguardConfigurationRules()
         .enableProtoShrinking()
-        .minification(enableMinification)
+        .addDontObfuscateUnless(enableMinification)
         .setMinApi(parameters)
         .compile()
         .assertAllInfoMessagesMatch(
@@ -454,7 +454,7 @@
         .allowUnusedDontWarnPatterns()
         .allowUnusedProguardConfigurationRules()
         .enableProtoShrinking()
-        .minification(enableMinification)
+        .addDontObfuscateUnless(enableMinification)
         .setMinApi(parameters)
         .compile()
         .assertAllInfoMessagesMatch(
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/constant/B132897042.java b/src/test/java/com/android/tools/r8/ir/analysis/constant/B132897042.java
index 253612a..3415ebc 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/constant/B132897042.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/constant/B132897042.java
@@ -35,7 +35,7 @@
                 "-assumevalues class" + LibClass.class.getName() + " {",
                 "  static int SDK_INT return 1..28;",
                 "}"))
-        .noTreeShaking()
+        .addDontShrink()
         .setMinApi(parameters)
         .compile()
         .assertNoMessages();
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/path/PathConstraintAnalysisUnitTest.java b/src/test/java/com/android/tools/r8/ir/analysis/path/PathConstraintAnalysisUnitTest.java
new file mode 100644
index 0000000..56573a5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/analysis/path/PathConstraintAnalysisUnitTest.java
@@ -0,0 +1,112 @@
+// 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.ir.analysis.path;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.ir.analysis.framework.intraprocedural.DataflowAnalysisResult;
+import com.android.tools.r8.ir.analysis.framework.intraprocedural.DataflowAnalysisResult.SuccessfulDataflowAnalysisResult;
+import com.android.tools.r8.ir.analysis.path.state.ConcretePathConstraintAnalysisState;
+import com.android.tools.r8.ir.analysis.path.state.PathConstraintAnalysisState;
+import com.android.tools.r8.ir.code.BasicBlock;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.optimize.argumentpropagation.computation.ComputationTreeNode;
+import com.android.tools.r8.optimize.argumentpropagation.computation.ComputationTreeUnopCompareNode;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+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 PathConstraintAnalysisUnitTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withNoneRuntime().build();
+  }
+
+  @Test
+  public void test() throws Exception {
+    AndroidApp app =
+        AndroidApp.builder()
+            .addProgramFiles(ToolHelper.getClassFileForTestClass(Main.class))
+            .addLibraryFile(ToolHelper.getMostRecentAndroidJar())
+            .build();
+    AppView<AppInfoWithLiveness> appView = computeAppViewWithLiveness(app);
+    CodeInspector inspector = new CodeInspector(app);
+    IRCode code =
+        inspector.clazz(Main.class).uniqueMethodWithOriginalName("greet").buildIR(appView);
+    PathConstraintAnalysis analysis = new PathConstraintAnalysis(appView, code);
+    DataflowAnalysisResult result = analysis.run(code.entryBlock());
+    assertTrue(result.isSuccessfulAnalysisResult());
+    SuccessfulDataflowAnalysisResult<BasicBlock, PathConstraintAnalysisState> successfulResult =
+        result.asSuccessfulAnalysisResult();
+
+    // Inspect ENTRY state.
+    PathConstraintAnalysisState entryConstraint =
+        successfulResult.getBlockExitState(code.entryBlock());
+    assertTrue(entryConstraint.isBottom());
+
+    // Inspect THEN state.
+    PathConstraintAnalysisState thenConstraint =
+        successfulResult.getBlockExitState(code.entryBlock().exit().asIf().getTrueTarget());
+    assertTrue(thenConstraint.isConcrete());
+
+    ConcretePathConstraintAnalysisState concreteThenConstraint = thenConstraint.asConcreteState();
+    assertEquals(1, concreteThenConstraint.getPathConstraints().size());
+    assertEquals(0, concreteThenConstraint.getNegatedPathConstraints().size());
+
+    ComputationTreeNode thenPathConstraint =
+        concreteThenConstraint.getPathConstraints().iterator().next();
+    assertTrue(thenPathConstraint instanceof ComputationTreeUnopCompareNode);
+
+    // Inspect ELSE state.
+    PathConstraintAnalysisState elseConstraint =
+        successfulResult.getBlockExitState(code.entryBlock().exit().asIf().fallthroughBlock());
+    assertTrue(elseConstraint.isConcrete());
+
+    ConcretePathConstraintAnalysisState concreteElseConstraint = elseConstraint.asConcreteState();
+    assertEquals(0, concreteElseConstraint.getPathConstraints().size());
+    assertEquals(1, concreteElseConstraint.getNegatedPathConstraints().size());
+
+    ComputationTreeNode elsePathConstraint =
+        concreteElseConstraint.getNegatedPathConstraints().iterator().next();
+    assertEquals(thenPathConstraint, elsePathConstraint);
+
+    // Inspect RETURN state.
+    PathConstraintAnalysisState returnConstraint =
+        successfulResult.getBlockExitState(code.computeNormalExitBlocks().get(0));
+    assertTrue(returnConstraint.isConcrete());
+
+    ConcretePathConstraintAnalysisState concreteReturnConstraint =
+        returnConstraint.asConcreteState();
+    assertEquals(1, concreteReturnConstraint.getPathConstraints().size());
+    assertEquals(
+        concreteReturnConstraint.getPathConstraints(),
+        concreteReturnConstraint.getNegatedPathConstraints());
+  }
+
+  static class Main {
+
+    public static void greet(String greeting, int flags) {
+      if ((flags & 1) != 0) {
+        greeting = "Hello, world!";
+      }
+      System.out.println(greeting);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/AllowCodeReplacementTest.java b/src/test/java/com/android/tools/r8/ir/optimize/AllowCodeReplacementTest.java
new file mode 100644
index 0000000..0180424
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/AllowCodeReplacementTest.java
@@ -0,0 +1,122 @@
+// 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.ir.optimize;
+
+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;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class AllowCodeReplacementTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDefaultRuntimes().withMinimumApiLevel().build();
+  }
+
+  @Test
+  public void testFeatureDisabledByDefault() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .addKeepRules(
+            "-keepclassmembers,allowshrinking class " + Main.class.getTypeName() + " {",
+            "  boolean alwaysFalse();",
+            "}")
+        .addOptionsModification(options -> assertTrue(options.testing.allowCodeReplacement))
+        .setMinApi(parameters)
+        .compile()
+        .inspect(inspector -> inspect(inspector, false))
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("Hello, world!");
+  }
+
+  @Test
+  public void testAnalyzeKeptMethod() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .addKeepRules(
+            "-keepclassmembers,allowshrinking class " + Main.class.getTypeName() + " {",
+            "  boolean alwaysFalse();",
+            "}")
+        .addOptionsModification(options -> options.testing.allowCodeReplacement = false)
+        .setMinApi(parameters)
+        .compile()
+        .inspect(inspector -> inspect(inspector, true))
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("Hello, world!");
+  }
+
+  @Test
+  public void testKeepForCodeReplacement() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .addKeepRules(
+            "-keepclassmembers,allowcodereplacement,allowshrinking class "
+                + Main.class.getTypeName()
+                + " {",
+            "  boolean alwaysFalse();",
+            "}")
+        .addOptionsModification(options -> options.testing.allowCodeReplacement = false)
+        .enableProguardTestOptions()
+        .setMinApi(parameters)
+        .compile()
+        .inspect(inspector -> inspect(inspector, false))
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("Hello, world!");
+  }
+
+  private void inspect(CodeInspector inspector, boolean isOptimized) {
+    ClassSubject mainClassSubject = inspector.clazz(Main.class);
+    assertThat(mainClassSubject, isPresent());
+
+    MethodSubject mainMethodSubject = mainClassSubject.mainMethod();
+    assertThat(mainMethodSubject, isPresent());
+    assertEquals(
+        isOptimized,
+        inspector
+            .clazz(Main.class)
+            .mainMethod()
+            .streamInstructions()
+            .noneMatch(i -> i.isConstString("Unreachable")));
+
+    MethodSubject alwaysFalseMethodSubject =
+        mainClassSubject.uniqueMethodWithOriginalName("alwaysFalse");
+    assertThat(alwaysFalseMethodSubject, isAbsentIf(isOptimized));
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      if (alwaysFalse()) {
+        System.out.println("Unreachable");
+      } else {
+        System.out.println("Hello, world!");
+      }
+    }
+
+    static boolean alwaysFalse() {
+      return false;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/RestartLambdaPropagationWithDefaultArgumentTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/RestartLambdaPropagationWithDefaultArgumentTest.java
new file mode 100644
index 0000000..9d571ee
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/RestartLambdaPropagationWithDefaultArgumentTest.java
@@ -0,0 +1,154 @@
+// 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.ir.optimize.callsites;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.isInvokeWithTarget;
+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;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class RestartLambdaPropagationWithDefaultArgumentTest extends TestBase {
+
+  // Deliberately setting the highest bit in this mask to be able to distinguish it from the int 2.
+  private static final int FLAGS = 0b10 | (1 << 31);
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDexRuntimesAndAllApiLevels().build();
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .enableInliningAnnotations()
+        .setMinApi(parameters)
+        .compile()
+        .inspect(
+            inspector -> {
+              ClassSubject mainClassSubject = inspector.clazz(Main.class);
+              assertThat(mainClassSubject, isPresent());
+
+              ClassSubject lambdaClassSubject =
+                  inspector.clazz(SyntheticItemsTestUtils.syntheticLambdaClass(Main.class, 0));
+              assertThat(lambdaClassSubject, isPresent());
+              // TODO(b/302281503): Lambda should not capture the two constant string arguments.
+              assertEquals(2, lambdaClassSubject.allInstanceFields().size());
+
+              MethodSubject lambdaInitSubject = lambdaClassSubject.uniqueInstanceInitializer();
+              assertThat(lambdaInitSubject, isPresent());
+              // TODO(b/302281503): Lambda should not capture the two constant string arguments.
+              assertEquals(2, lambdaInitSubject.getParameters().size());
+              assertTrue(lambdaInitSubject.getParameter(0).is(String.class));
+              assertTrue(lambdaInitSubject.getParameter(1).is(String.class));
+
+              MethodSubject mainMethodSubject = mainClassSubject.mainMethod();
+              assertThat(mainMethodSubject, isPresent());
+              // TODO(b/302281503): This argument should be removed as a result of constant
+              //  propagation into the restartableMethod.
+              assertTrue(
+                  mainMethodSubject
+                      .streamInstructions()
+                      .anyMatch(instruction -> instruction.isConstString("DefaultValueNeverUsed")));
+              // TODO(b/302281503): This argument is never used and should be removed.
+              assertTrue(
+                  mainMethodSubject
+                      .streamInstructions()
+                      .anyMatch(
+                          instruction ->
+                              instruction.isConstString("Unused[DefaultValueAlwaysUsed]")));
+
+              MethodSubject restartableMethodSubject =
+                  mainClassSubject.uniqueMethodWithOriginalName("restartableMethod");
+              assertThat(restartableMethodSubject, isPresent());
+              assertTrue(
+                  restartableMethodSubject
+                      .streamInstructions()
+                      .anyMatch(instruction -> instruction.isConstNumber(FLAGS)));
+              assertTrue(
+                  restartableMethodSubject
+                      .streamInstructions()
+                      .noneMatch(
+                          instruction ->
+                              instruction.isConstString("Unused[DefaultValueNeverUsed]")));
+              assertTrue(
+                  restartableMethodSubject
+                      .streamInstructions()
+                      .anyMatch(
+                          instruction -> instruction.isConstString("DefaultValueAlwaysUsed")));
+              assertTrue(
+                  restartableMethodSubject
+                      .streamInstructions()
+                      .anyMatch(
+                          instruction -> isInvokeWithTarget(lambdaInitSubject).test(instruction)));
+            })
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(
+            "Postponing!",
+            "Restarting!",
+            "DefaultValueNeverUsed",
+            "DefaultValueAlwaysUsed",
+            Integer.toString(FLAGS),
+            "Stopping!");
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      Runnable restarter =
+          restartableMethod("DefaultValueNeverUsed", "Unused[DefaultValueAlwaysUsed]", FLAGS, true);
+      restarter.run();
+    }
+
+    @NeverInline
+    static Runnable restartableMethod(
+        String defaultValueNeverUsed, String defaultValueAlwaysUsed, int flags, boolean doRestart) {
+      if ((flags & 1) != 0) {
+        defaultValueNeverUsed = "Unused[DefaultValueNeverUsed]";
+      }
+      if ((flags & 2) != 0) {
+        defaultValueAlwaysUsed = "DefaultValueAlwaysUsed";
+      }
+      if (doRestart) {
+        System.out.println("Postponing!");
+        String finalDefaultValueNeverUsed = defaultValueNeverUsed;
+        String finalDefaultValueAlwaysUsed = defaultValueAlwaysUsed;
+        return () -> {
+          System.out.println("Restarting!");
+          Runnable restarter =
+              restartableMethod(
+                  finalDefaultValueNeverUsed, finalDefaultValueAlwaysUsed, flags, false);
+          if (restarter == null) {
+            System.out.println("Stopping!");
+          } else {
+            throw new RuntimeException();
+          }
+        };
+      }
+      System.out.println(defaultValueNeverUsed);
+      System.out.println(defaultValueAlwaysUsed);
+      System.out.println(flags);
+      return null;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/DexItemBasedConstStringCanonicalizationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/DexItemBasedConstStringCanonicalizationTest.java
index a8bd35a..372423d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/DexItemBasedConstStringCanonicalizationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/canonicalization/DexItemBasedConstStringCanonicalizationTest.java
@@ -113,7 +113,7 @@
         testForR8(parameters.getBackend())
             .addProgramClasses(MAIN, CanonicalizationTestClass.class)
             .addKeepMainRule(MAIN)
-            .minification(enableMinification)
+            .addDontObfuscateUnless(enableMinification)
             .setMinApi(parameters)
             .addOptionsModification(this::configure)
             .run(parameters.getRuntime(), MAIN)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CastInDeadCodeafterInstanceOfOptimizationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CastInDeadCodeafterInstanceOfOptimizationTest.java
new file mode 100644
index 0000000..c690efd
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CastInDeadCodeafterInstanceOfOptimizationTest.java
@@ -0,0 +1,61 @@
+// 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.ir.optimize.checkcast;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.StringUtils;
+import 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/358913905.
+@RunWith(Parameterized.class)
+public class CastInDeadCodeafterInstanceOfOptimizationTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  private static final String EXPECTED_OUTPUT = StringUtils.lines("Hello, world!");
+
+  @Test
+  public void testD8() throws Exception {
+    parameters.assumeDexRuntime();
+    testForD8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .setMinApi(parameters)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(TestClass.class)
+        .setMinApi(parameters)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) {
+      Object object = new Object();
+      if (object instanceof int[]) {
+        int[] object2 = (int[]) object;
+      }
+      System.out.println("Hello, world!");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CheckCastInterfaceArrayTest.java b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CheckCastInterfaceArrayTest.java
index 9887c3f..6d45501 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CheckCastInterfaceArrayTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/checkcast/CheckCastInterfaceArrayTest.java
@@ -44,7 +44,7 @@
         .addKeepMainRule(TestClass.class)
         .setMinApi(parameters)
         .addDontObfuscate()
-        .noTreeShaking()
+        .addDontShrink()
         .compile()
         .run(parameters.getRuntime(), TestClass.class)
         .assertSuccessWithOutput(EXPECTED);
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 59e609d..3bd367b 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
@@ -25,13 +25,17 @@
 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 SingleTargetAfterInliningTest extends TestBase {
 
-  private final int maxInliningDepth;
-  private final TestParameters parameters;
+  @Parameter(0)
+  public int maxInliningDepth;
+
+  @Parameter(1)
+  public TestParameters parameters;
 
   @Parameters(name = "{1}, max inlining depth: {0}")
   public static List<Object[]> data() {
@@ -39,11 +43,6 @@
         ImmutableList.of(0, 1), getTestParameters().withAllRuntimesAndApiLevels().build());
   }
 
-  public SingleTargetAfterInliningTest(int maxInliningDepth, TestParameters parameters) {
-    this.maxInliningDepth = maxInliningDepth;
-    this.parameters = parameters;
-  }
-
   @Test
   public void test() throws Exception {
     testForR8(parameters.getBackend())
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/DefaultFieldValueJoinerWithUnknownDynamicTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/DefaultFieldValueJoinerWithUnknownDynamicTypeTest.java
new file mode 100644
index 0000000..0a5e1ab
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/DefaultFieldValueJoinerWithUnknownDynamicTypeTest.java
@@ -0,0 +1,103 @@
+// 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.ir.optimize.membervaluepropagation;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+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 DefaultFieldValueJoinerWithUnknownDynamicTypeTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .addKeepRules(
+            "-keepclassmembers class " + Main.class.getTypeName() + "{",
+            "  *** emptyList();",
+            "  *** emptySet(boolean);",
+            "}")
+        .enableInliningAnnotations()
+        .enableNeverClassInliningAnnotations()
+        .setMinApi(parameters)
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithEmptyOutput();
+  }
+
+  @NeverClassInline
+  static class Main {
+
+    static final Collection<Object> DEFAULT = emptyList();
+
+    Collection<Object> cache;
+
+    public static void main(String[] args) {
+      Main main = new Main();
+      Collection<Object> emptySet = main.test(false);
+      Collection<Object> emptyList = main.test(true);
+      checkNotIdentical(emptySet, emptyList);
+      Collection<Object> cachedEmptyList = main.test(true);
+      checkIdentical(emptyList, cachedEmptyList);
+    }
+
+    @NeverInline
+    Collection<Object> test(boolean doThrow) {
+      if (cache != null) {
+        return cache;
+      }
+      try {
+        return emptySet(doThrow);
+      } catch (Throwable t) {
+        cache = DEFAULT;
+        return cache;
+      }
+    }
+
+    // @Keep
+    static Collection<Object> emptyList() {
+      return new ArrayList<>();
+    }
+
+    // @Keep
+    static Collection<Object> emptySet(boolean doThrow) {
+      if (doThrow) {
+        throw new RuntimeException();
+      }
+      return Collections.emptySet();
+    }
+
+    static void checkIdentical(Object o1, Object o2) {
+      if (o1 != o2) {
+        throw new RuntimeException();
+      }
+    }
+
+    static void checkNotIdentical(Object o1, Object o2) {
+      if (o1 == o2) {
+        throw new RuntimeException();
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWriteBeforeFieldReadTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWriteBeforeFieldReadTest.java
index a603d83..4a681ad 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWriteBeforeFieldReadTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/FieldWriteBeforeFieldReadTest.java
@@ -24,22 +24,20 @@
 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 FieldWriteBeforeFieldReadTest extends TestBase {
 
-  private final TestParameters parameters;
+  @Parameter(0)
+  public TestParameters parameters;
 
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
     return getTestParameters().withAllRuntimesAndApiLevels().build();
   }
 
-  public FieldWriteBeforeFieldReadTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
   @Test
   public void test() throws Exception {
     testForR8(parameters.getBackend())
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/reflection/ForNameInterfaceTest.java b/src/test/java/com/android/tools/r8/ir/optimize/reflection/ForNameInterfaceTest.java
index 817463a..1c3626f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/reflection/ForNameInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/reflection/ForNameInterfaceTest.java
@@ -50,7 +50,7 @@
     testForR8(parameters.getBackend())
         .addInnerClasses(ForNameInterfaceTest.class)
         .addKeepMainRule(Main.class)
-        .minification(false)
+        .addDontObfuscate()
         .setMinApi(parameters)
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetNameInClassInitializerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetNameInClassInitializerTest.java
index 45b83f4..d4c23d5 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetNameInClassInitializerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetNameInClassInitializerTest.java
@@ -67,7 +67,7 @@
         .enableInliningAnnotations()
         .addKeepMainRule(MAIN)
         .addKeepRules("-keep class **.GetNameClinit*")
-        .minification(enableMinification)
+        .addDontObfuscateUnless(enableMinification)
         .setMinApi(parameters)
         .addOptionsModification(this::configure)
         .run(parameters.getRuntime(), MAIN)
@@ -83,7 +83,7 @@
             .enableInliningAnnotations()
             .addKeepMainRule(MAIN)
             .addKeepRules("-keep,allowobfuscation class **.GetNameClinit*")
-            .minification(enableMinification)
+            .addDontObfuscateUnless(enableMinification)
             .setMinApi(parameters)
             .addOptionsModification(this::configure)
             .compile();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetNameTest.java b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetNameTest.java
index e322f8d..dbee197 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetNameTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetNameTest.java
@@ -271,7 +271,7 @@
             .addKeepRules("-keep class **.GetName0*")
             .addKeepRules("-keepattributes InnerClasses,EnclosingMethod")
             .addKeepRules("-printmapping " + createNewMappingPath().toAbsolutePath().toString())
-            .minification(enableMinification)
+            .addDontObfuscateUnless(enableMinification)
             .setMinApi(parameters)
             .addOptionsModification(this::configure)
             .compile()
@@ -298,7 +298,7 @@
             .addKeepRules("-keep,allowobfuscation class **.GetName0*")
             .addKeepRules("-keepattributes InnerClasses,EnclosingMethod")
             .addKeepRules("-printmapping " + createNewMappingPath().toAbsolutePath().toString())
-            .minification(enableMinification)
+            .addDontObfuscateUnless(enableMinification)
             .setMinApi(parameters)
             .addOptionsModification(this::configure)
             .compile()
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetSimpleNameTest.java b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetSimpleNameTest.java
index 533c75f..aa4ae93 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetSimpleNameTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/reflection/GetSimpleNameTest.java
@@ -206,7 +206,7 @@
         .enableInliningAnnotations()
         .addKeepAllClassesRule()
         .addKeepAttributeInnerClassesAndEnclosingMethod()
-        .minification(enableMinification)
+        .addDontObfuscateUnless(enableMinification)
         .setMinApi(parameters)
         .addOptionsModification(this::configure)
         .run(parameters.getRuntime(), MAIN)
@@ -224,7 +224,7 @@
         .addKeepRules("-keep class **.ClassGetSimpleName*")
         .addKeepRules("-keep class **.Outer*")
         .addKeepAttributeInnerClassesAndEnclosingMethod()
-        .minification(enableMinification)
+        .addDontObfuscateUnless(enableMinification)
         .setMinApi(parameters)
         .addOptionsModification(this::configure)
         .run(parameters.getRuntime(), MAIN)
@@ -245,7 +245,7 @@
         // then use OUTPUT_WITH_SHRUNK_ATTRIBUTES
         .addKeepRules("-keep,allowobfuscation class **.Outer*")
         .addKeepAttributeInnerClassesAndEnclosingMethod()
-        .minification(enableMinification)
+        .addDontObfuscateUnless(enableMinification)
         .setMinApi(parameters)
         .addOptionsModification(this::configure)
         .run(parameters.getRuntime(), MAIN)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/reflection/InnerClassNameTestRunner.java b/src/test/java/com/android/tools/r8/ir/optimize/reflection/InnerClassNameTestRunner.java
index e88fb06..61ea74d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/reflection/InnerClassNameTestRunner.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/reflection/InnerClassNameTestRunner.java
@@ -229,7 +229,7 @@
             .addKeepAttributeInnerClassesAndEnclosingMethod()
             .addProgramClassFileData(InnerClassNameTestDump.dump(config, parameters))
             .allowDiagnosticInfoMessages(hasMalformedInnerClassAttribute())
-            .minification(minify)
+            .addDontObfuscateUnless(minify)
             .addOptionsModification(
                 options -> {
                   options.disableInnerClassSeparatorValidationWhenRepackaging = true;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/PrivateInstanceMethodCollisionTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/PrivateInstanceMethodCollisionTest.java
index eff87f7..d45d543 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/PrivateInstanceMethodCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/PrivateInstanceMethodCollisionTest.java
@@ -67,7 +67,7 @@
         .enableNeverClassInliningAnnotations()
         .enableNoHorizontalClassMergingAnnotations()
         .enableNoMethodStaticizingAnnotations()
-        .minification(minification)
+        .addDontObfuscateUnless(minification)
         .allowAccessModification(allowAccessModification)
         .applyIf(
             allowAccessModification,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/UninstantiatedAnnotatedArgumentsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/UninstantiatedAnnotatedArgumentsTest.java
index e5c56c7..798002a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/UninstantiatedAnnotatedArgumentsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/uninstantiatedtypes/UninstantiatedAnnotatedArgumentsTest.java
@@ -72,7 +72,7 @@
         .enableNoParameterReorderingAnnotations()
         .enableUnusedArgumentAnnotations()
         // TODO(b/123060011): Mapping not working in presence of argument removal.
-        .minification(keepUninstantiatedArguments)
+        .addDontObfuscateUnless(keepUninstantiatedArguments)
         .setMinApi(parameters)
         .compile()
         .inspect(this::verifyOutput)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/CollisionWithLibraryMethodsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/CollisionWithLibraryMethodsTest.java
index 44fd6bc..3f2cd87 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/CollisionWithLibraryMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/CollisionWithLibraryMethodsTest.java
@@ -53,7 +53,7 @@
         .enableNeverClassInliningAnnotations()
         .enableNoMethodStaticizingAnnotations()
         .enableInliningAnnotations()
-        .minification(minification)
+        .addDontObfuscateUnless(minification)
         .setMinApi(parameters)
         .compile()
         .inspect(this::verify)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/PrivateInstanceMethodCollisionTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/PrivateInstanceMethodCollisionTest.java
index ccfb422..c55bb32 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/PrivateInstanceMethodCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/PrivateInstanceMethodCollisionTest.java
@@ -67,7 +67,7 @@
         .enableInliningAnnotations()
         .enableNeverClassInliningAnnotations()
         .enableNoMethodStaticizingAnnotations()
-        .minification(minification)
+        .addDontObfuscateUnless(minification)
         .allowAccessModification(allowAccessModification)
         .applyIf(
             allowAccessModification,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedAnnotatedArgumentsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedAnnotatedArgumentsTest.java
index 764d4f8..c4cef26 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedAnnotatedArgumentsTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedAnnotatedArgumentsTest.java
@@ -70,7 +70,7 @@
         .enableConstantArgumentAnnotations()
         .enableUnusedArgumentAnnotations(keepUnusedArguments)
         // TODO(b/123060011): Mapping not working in presence of unused argument removal.
-        .minification(keepUnusedArguments)
+        .addDontObfuscateUnless(keepUnusedArguments)
         .setMinApi(parameters)
         .compile()
         .inspect(this::verifyOutput)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java
index 9a844ac..b07f468 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentRemovalWithOverridingTest.java
@@ -50,7 +50,7 @@
         .enableNeverClassInliningAnnotations()
         .enableInliningAnnotations()
         .enableNoVerticalClassMergingAnnotations()
-        .minification(minification)
+        .addDontObfuscateUnless(minification)
         .setMinApi(parameters)
         .compile()
         .inspect(this::verify)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java
index d772b8f..ba233be 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsCollisionTest.java
@@ -62,7 +62,7 @@
         .enableNeverClassInliningAnnotations()
         .enableNoMethodStaticizingAnnotations()
         .enableNoVerticalClassMergingAnnotations()
-        .minification(minification)
+        .addDontObfuscateUnless(minification)
         .setMinApi(parameters)
         .compile()
         .inspect(this::verifyUnusedArgumentsRemovedAndNoCollisions)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsTestBase.java b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsTestBase.java
index 49efe19..2cd91b2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsTestBase.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/unusedarguments/UnusedArgumentsTestBase.java
@@ -75,7 +75,7 @@
         .addProgramClasses(getTestClass())
         .addProgramClasses(getAdditionalClasses())
         .addKeepMainRule(getTestClass())
-        .minification(minification)
+        .addDontObfuscateUnless(minification)
         .addOptionsModification(options -> options.enableSideEffectAnalysis = false)
         .apply(this::configure)
         .run(parameters.getRuntime(), getTestClass())
diff --git a/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java b/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java
index 9dc6503..ed272e7 100644
--- a/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java
@@ -211,15 +211,6 @@
     }
 
     @Override
-    public BasicBlock addThrowingInstructionToPossiblyThrowingBlock(
-        IRCode code,
-        ListIterator<BasicBlock> blockIterator,
-        Instruction instruction,
-        InternalOptions options) {
-      throw new Unimplemented();
-    }
-
-    @Override
     public BasicBlock split(
         IRCode code, ListIterator<BasicBlock> blockIterator, boolean keepCatchHandlers) {
       throw new Unimplemented();
diff --git a/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinReflectionLibTest.java b/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinReflectionLibTest.java
index ede0d93..52ee123 100644
--- a/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinReflectionLibTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinReflectionLibTest.java
@@ -67,31 +67,29 @@
 
   @Test
   public void testAsIs() throws Exception {
-    test(builder -> builder.addDontObfuscate().addDontOptimize().noTreeShaking());
+    test(builder -> builder.addDontObfuscate().addDontOptimize().addDontShrink());
   }
 
   @Test
   public void testDontShrinkAndDontOptimize() throws Exception {
-    test(builder -> builder.addDontOptimize().noTreeShaking());
+    test(builder -> builder.addDontOptimize().addDontShrink());
   }
 
   @Test
   public void testDontShrinkAndDontObfuscate() throws Exception {
-    test(builder -> builder.addDontObfuscate().noTreeShaking());
+    test(builder -> builder.addDontObfuscate().addDontShrink());
   }
 
   @Test
   public void testDontShrink() throws Exception {
-    test(TestShrinkerBuilder::noTreeShaking);
+    test(TestShrinkerBuilder::addDontShrink);
   }
 
   @Test
   public void testDontShrinkDifferently() throws Exception {
     test(
         builder ->
-            builder
-                .addKeepRules("-keep,allowobfuscation class **.*KClasses*")
-                .noTreeShaking());
+            builder.addKeepRules("-keep,allowobfuscation class **.*KClasses*").addDontShrink());
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
index 5bc57ba..4de0f57 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListOutputTest.java
@@ -99,7 +99,7 @@
     Path mainDexListOutput = temp.getRoot().toPath().resolve("main-dex-output.txt");
     testForR8(Backend.DEX)
         .addProgramClasses(HelloWorldMain.class)
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .setMinApi(AndroidApiLevel.K)
         .addMainDexRuleFiles(mainDexRules)
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
index 19db97f..9eea1c5 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexTracingTest.java
@@ -396,7 +396,7 @@
         .assumeAllMethodsMayHaveSideEffects()
         .setMinApi(minSdk)
         .addDontObfuscate()
-        .noTreeShaking()
+        .addDontShrink()
         .addDontOptimize()
         .setMainDexListConsumer(ToolHelper.consumeString(r8MainDexListOutput::set))
         .allowDiagnosticMessages()
diff --git a/src/test/java/com/android/tools/r8/maindexlist/checkdiscard/MainDexListCheckDiscard.java b/src/test/java/com/android/tools/r8/maindexlist/checkdiscard/MainDexListCheckDiscard.java
index 3f1fb69..db968c1 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/checkdiscard/MainDexListCheckDiscard.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/checkdiscard/MainDexListCheckDiscard.java
@@ -54,7 +54,7 @@
         .setMinApi(AndroidApiLevel.K)
         .addMainDexRules(keepMainProguardConfiguration(HelloWorldMain.class))
         .addMainDexRules(checkDiscardRule)
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .compile();
   }
diff --git a/src/test/java/com/android/tools/r8/maindexlist/whyareyoukeeping/MainDexListWhyAreYouKeeping.java b/src/test/java/com/android/tools/r8/maindexlist/whyareyoukeeping/MainDexListWhyAreYouKeeping.java
index 0aafb8d..c8a267a 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/whyareyoukeeping/MainDexListWhyAreYouKeeping.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/whyareyoukeeping/MainDexListWhyAreYouKeeping.java
@@ -85,7 +85,7 @@
   public void runTestWithR8(GraphConsumer consumer, String rule) throws Exception {
     R8FullTestBuilder builder =
         testForR8(Backend.DEX)
-            .noTreeShaking()
+            .addDontShrink()
             .addDontObfuscate()
             .setMinApi(AndroidApiLevel.K)
             .addProgramClasses(CLASSES)
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 6ed1857..15d91c2 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingTest.java
@@ -6,32 +6,23 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.R8Command;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.TestDescriptionWatcher;
+import com.android.tools.r8.utils.ThrowingConsumer;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.FieldAccessInstructionSubject;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
 import com.android.tools.r8.utils.codeinspector.InvokeInstructionSubject;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
 import com.google.common.collect.ImmutableList;
-import java.io.File;
-import java.io.IOException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.Arrays;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.Iterator;
-import java.util.List;
-import java.util.function.Consumer;
-import java.util.stream.Collectors;
-import org.junit.Assume;
-import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -49,7 +40,7 @@
   private final Backend backend;
   private final String keepRuleFile;
   private final Path programFile;
-  private final Consumer<CodeInspector> inspection;
+  private final ThrowingConsumer<CodeInspector, Exception> inspection;
   private final int minApiLevel;
 
   @Rule
@@ -64,34 +55,6 @@
     this.minApiLevel = configuration.getMinApiLevel();
   }
 
-  @Before
-  public void runR8() throws Exception {
-    // Generate R8 processed version without library option.
-    String out = temp.getRoot().getCanonicalPath();
-    // NOTE: It is important to turn off inlining to ensure
-    // dex inspection of invokes is predictable.
-    R8Command.Builder builder =
-        R8Command.builder()
-            .setOutput(Paths.get(out), TestBase.outputMode(backend))
-            .addLibraryFiles(JAR_LIBRARY, TestBase.runtimeJar(backend))
-            .setDisableTreeShaking(true)
-            .setDisableMinification(true);
-    if (backend == Backend.DEX) {
-      builder.setMinApiLevel(minApiLevel);
-    }
-    if (keepRuleFile != null) {
-      builder.addProguardConfigurationFiles(Paths.get(ToolHelper.EXAMPLES_DIR, name, keepRuleFile));
-      ToolHelper.allowTestProguardOptions(builder);
-    }
-    ToolHelper.getAppBuilder(builder).addProgramFiles(programFile);
-    ToolHelper.runR8(
-        builder.build(),
-        options -> {
-          options.inlinerOptions().enableInlining = false;
-          options.enableRedundantFieldLoadElimination = false;
-        });
-  }
-
   private static boolean coolInvokes(InstructionSubject instruction) {
     if (!instruction.isInvokeVirtual() && !instruction.isInvokeInterface() &&
         !instruction.isInvokeStatic()) {
@@ -185,14 +148,14 @@
     final Backend backend;
     final String keepRuleFile;
     final AndroidVersion version;
-    final Consumer<CodeInspector> processedInspection;
+    final ThrowingConsumer<CodeInspector, Exception> processedInspection;
 
     private TestConfiguration(
         String name,
         Backend backend,
         String keepRuleFile,
         AndroidVersion version,
-        Consumer<CodeInspector> processedInspection) {
+        ThrowingConsumer<CodeInspector, Exception> processedInspection) {
       this.name = name;
       this.backend = backend;
       this.keepRuleFile = keepRuleFile;
@@ -206,14 +169,10 @@
         Backend backend,
         String keepRuleFile,
         AndroidVersion version,
-        Consumer<CodeInspector> processedInspection) {
+        ThrowingConsumer<CodeInspector, Exception> processedInspection) {
       builder.add(new TestConfiguration(name, backend, keepRuleFile, version, processedInspection));
     }
 
-    public Path getDexPath() {
-      return getBuildPath().resolve(name).resolve("classes.dex");
-    }
-
     public Path getJarPath() {
       return getBuildPath().resolve(name + ".jar");
     }
@@ -267,7 +226,7 @@
           builder,
           "memberrebinding3",
           backend,
-          null,
+          "keep-rules.txt",
           TestConfiguration.AndroidVersion.PRE_N,
           MemberRebindingTest::inspect3);
       TestConfiguration.add(
@@ -282,23 +241,24 @@
   }
 
   @Test
-  public void memberRebindingTest() throws IOException {
-    Assume.assumeTrue(ToolHelper.artSupported() || ToolHelper.compareAgaintsGoldenFiles());
-
-    Path out = Paths.get(temp.getRoot().getCanonicalPath());
-    List<Path> processed;
-    if (backend == Backend.DEX) {
-      processed = Collections.singletonList(out.resolve("classes.dex"));
-    } else {
-      assert backend == Backend.CF;
-      processed =
-          Arrays.stream(out.resolve(name).toFile().listFiles(f -> f.toString().endsWith(".class")))
-              .map(File::toPath)
-              .collect(Collectors.toList());
-    }
-
-    CodeInspector inspector = new CodeInspector(processed);
-    inspection.accept(inspector);
-
+  public void memberRebindingTest() throws Exception {
+    testForR8(backend)
+        .addProgramFiles(programFile)
+        .addClasspathFiles(JAR_LIBRARY)
+        .applyIf(
+            keepRuleFile != null,
+            b -> b.addKeepRuleFiles(Paths.get(ToolHelper.EXAMPLES_DIR, name, keepRuleFile)))
+        .applyIf(backend.isDex(), b -> b.setMinApi(minApiLevel))
+        .addDontObfuscate()
+        .addDontShrink()
+        .addKeepRules("-neverpropagatevalue class * { *; }")
+        .addOptionsModification(
+            options -> {
+              options.enableRedundantFieldLoadElimination = false;
+              options.inlinerOptions().enableInlining = false;
+            })
+        .enableProguardTestOptions()
+        .compile()
+        .inspect(inspection);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseWithNoShrinkingTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseWithNoShrinkingTest.java
index 7542952..8cece91 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseWithNoShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseWithNoShrinkingTest.java
@@ -51,7 +51,7 @@
                   .transform());
           b.enableInliningAnnotations();
           b.addKeepClassAndMembersRules(DescriptorUtils.descriptorToJavaType(NEW_A_DESCRIPTOR));
-          b.noTreeShaking();
+          b.addDontShrink();
         });
   }
 
diff --git a/src/test/java/com/android/tools/r8/naming/AvoidRTest.java b/src/test/java/com/android/tools/r8/naming/AvoidRTest.java
index 4a35018..38e2e99 100644
--- a/src/test/java/com/android/tools/r8/naming/AvoidRTest.java
+++ b/src/test/java/com/android/tools/r8/naming/AvoidRTest.java
@@ -61,7 +61,7 @@
     builder.addProgramClassFileData(jasminBuilder.buildClasses());
     Set<String> usedDescriptors = new HashSet<>();
     builder
-        .noTreeShaking()
+        .addDontShrink()
         .addKeepRules("-classobfuscationdictionary " + dictionary)
         .compile()
         .inspect(
@@ -89,7 +89,7 @@
     builder.addProgramClassFileData(jasminBuilder.buildClasses());
     Set<String> usedNames = new HashSet<>();
     builder
-        .noTreeShaking()
+        .addDontShrink()
         .compile()
         .inspect(
             codeInspector -> {
@@ -122,7 +122,7 @@
     builder.addProgramClassFileData(jasminBuilder.buildClasses());
     Set<String> usedDescriptors = new HashSet<>();
     builder
-        .noTreeShaking()
+        .addDontShrink()
         .addKeepRules(keepRule)
         .compile()
         .inspect(
diff --git a/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeTest.java b/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeTest.java
index 5d11b24..9c28fa1 100644
--- a/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeTest.java
+++ b/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeTest.java
@@ -63,7 +63,7 @@
             .addKeepMainRule("package.TestClass")
             .addKeepRules("-keepconstantarguments class * { *; }")
             .enableProguardTestOptions()
-            .noTreeShaking()
+            .addDontShrink()
             .compile()
             .inspector();
 
diff --git a/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java b/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
index 8bca773..af2865a 100644
--- a/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
@@ -59,7 +59,7 @@
             .addKeepMainRule(MAIN_CLASS_NAME)
             .addKeepClassRulesWithAllowObfuscation(ENUM_CLASS_NAME)
             .allowDiagnosticWarningMessages()
-            .minification(minify)
+            .addDontObfuscateUnless(minify)
             .setMinApi(parameters)
             .compile()
             .assertAllWarningMessagesMatch(
diff --git a/src/test/java/com/android/tools/r8/naming/FieldMinificationObfuscationDictionaryDuplicateTest.java b/src/test/java/com/android/tools/r8/naming/FieldMinificationObfuscationDictionaryDuplicateTest.java
index 60208a1c..28a0ba9 100644
--- a/src/test/java/com/android/tools/r8/naming/FieldMinificationObfuscationDictionaryDuplicateTest.java
+++ b/src/test/java/com/android/tools/r8/naming/FieldMinificationObfuscationDictionaryDuplicateTest.java
@@ -45,7 +45,7 @@
     FileUtils.writeTextFile(dictionary, "a");
     testForR8(parameters.getBackend())
         .addProgramClasses(A.class)
-        .noTreeShaking()
+        .addDontShrink()
         .addKeepRules("-obfuscationdictionary " + dictionary.toString())
         .addKeepMainRule(A.class)
         .setMinApi(parameters)
diff --git a/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java b/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
index b89cc49..0c52a0e 100644
--- a/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
+++ b/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
@@ -102,7 +102,7 @@
                 "}")
             .allowDiagnosticWarningMessages()
             .enableProguardTestOptions()
-            .minification(minification)
+            .addDontObfuscateUnless(minification)
             .compile()
             .assertAllWarningMessagesMatch(
                 equalTo("Resource 'META-INF/MANIFEST.MF' already exists."));
@@ -172,7 +172,7 @@
                     "}"))
             .addNeverSingleCallerInlineAnnotations()
             .allowDiagnosticWarningMessages()
-            .minification(minification)
+            .addDontObfuscateUnless(minification)
             .compile()
             .assertAllWarningMessagesMatch(
                 equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
diff --git a/src/test/java/com/android/tools/r8/naming/MinificationMixedCaseAndNumbersTest.java b/src/test/java/com/android/tools/r8/naming/MinificationMixedCaseAndNumbersTest.java
index fd8b808..b6c69c2 100644
--- a/src/test/java/com/android/tools/r8/naming/MinificationMixedCaseAndNumbersTest.java
+++ b/src/test/java/com/android/tools/r8/naming/MinificationMixedCaseAndNumbersTest.java
@@ -54,7 +54,7 @@
     testForR8(parameters.getBackend())
         .addInnerClasses(MinificationMixedCaseAndNumbersTest.class)
         .addKeepMainRule(Main.class)
-        .noTreeShaking()
+        .addDontShrink()
         .addKeepRules(
             "-dontusemixedcaseclassnames", "-keeppackagenames com.android.tools.r8.naming")
         .setMinApi(parameters)
diff --git a/src/test/java/com/android/tools/r8/naming/PackageObfuscationDictionaryDuplicateTest.java b/src/test/java/com/android/tools/r8/naming/PackageObfuscationDictionaryDuplicateTest.java
index a3936e0..a769120 100644
--- a/src/test/java/com/android/tools/r8/naming/PackageObfuscationDictionaryDuplicateTest.java
+++ b/src/test/java/com/android/tools/r8/naming/PackageObfuscationDictionaryDuplicateTest.java
@@ -46,7 +46,7 @@
     FileUtils.writeTextFile(dictionary, "a");
     testForR8(parameters.getBackend())
         .addProgramClassesAndInnerClasses(Top.class, A.class, C.class)
-        .noTreeShaking()
+        .addDontShrink()
         .addKeepRules("-packageobfuscationdictionary " + dictionary.toString())
         .addKeepMainRule(C.class)
         .setMinApi(parameters)
diff --git a/src/test/java/com/android/tools/r8/naming/PackagePrivateOverrideSameMethodNameTest.java b/src/test/java/com/android/tools/r8/naming/PackagePrivateOverrideSameMethodNameTest.java
index a5687f1..aa311d4 100644
--- a/src/test/java/com/android/tools/r8/naming/PackagePrivateOverrideSameMethodNameTest.java
+++ b/src/test/java/com/android/tools/r8/naming/PackagePrivateOverrideSameMethodNameTest.java
@@ -63,7 +63,7 @@
             .setMinApi(parameters)
             .enableInliningAnnotations()
             .enableNeverClassInliningAnnotations()
-            .minification(minification)
+            .addDontObfuscateUnless(minification)
             .run(parameters.getRuntime(), Main.class)
             .apply(this::assertSuccessOutput);
     if (parameters.isDexRuntime() && parameters.getDexRuntimeVersion().isDalvik()) {
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterDevirtualizationTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterDevirtualizationTest.java
index 1219836..319c4e8 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterDevirtualizationTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterDevirtualizationTest.java
@@ -125,7 +125,7 @@
     assertThat(inspector.clazz(LibInterfaceB.class), not(isPresent()));
 
     testForR8(parameters.getBackend())
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .addProgramClasses(PROGRAM_CLASSES)
         .addApplyMapping(libraryResult.getProguardMap())
@@ -158,7 +158,7 @@
     assertThat(inspector.clazz(LibInterfaceB.class), not(isPresent()));
 
     testForR8(parameters.getBackend())
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .addProgramClasses(PROGRAM_CLASSES)
         .addApplyMapping(libraryResult.getProguardMap())
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterHorizontalMergingFieldTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterHorizontalMergingFieldTest.java
index 22a0643..1e11234 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterHorizontalMergingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterHorizontalMergingFieldTest.java
@@ -102,7 +102,7 @@
         != inspector.clazz(LibraryB.class).isPresent());
 
     testForR8(parameters.getBackend())
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .addProgramClasses(PROGRAM_CLASSES)
         .addApplyMapping(libraryResult.getProguardMap())
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterHorizontalMergingMethodTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterHorizontalMergingMethodTest.java
index 1c19a2e..38b04ec 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterHorizontalMergingMethodTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterHorizontalMergingMethodTest.java
@@ -110,7 +110,7 @@
         != inspector.clazz(LibraryB.class).isPresent());
 
     testForR8(parameters.getBackend())
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .addProgramClasses(PROGRAM_CLASSES)
         .addApplyMapping(libraryResult.getProguardMap())
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterVerticalMergingFieldTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterVerticalMergingFieldTest.java
index 3b08988..139eae6 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterVerticalMergingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterVerticalMergingFieldTest.java
@@ -90,7 +90,7 @@
     assertThat(inspector.clazz(LibrarySubclass.class), isPresent());
 
     testForR8(parameters.getBackend())
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .addProgramClasses(PROGRAM_CLASSES)
         .addApplyMapping(libraryResult.getProguardMap())
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterVerticalMergingMethodTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterVerticalMergingMethodTest.java
index c5817de..80bc496 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterVerticalMergingMethodTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterVerticalMergingMethodTest.java
@@ -127,7 +127,7 @@
   private static R8TestCompileResult compileProgram(Backend backend, String proguardMap)
       throws CompilationFailedException {
     return testForR8(getStaticTemp(), backend)
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .addProgramClasses(PROGRAM_CLASSES)
         .addApplyMapping(proguardMap)
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInnerClassesPreserveTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInnerClassesPreserveTest.java
index bf3d004..4db3cd8 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInnerClassesPreserveTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInnerClassesPreserveTest.java
@@ -50,7 +50,7 @@
         .addApplyMapping(libraryCompileResult.getProguardMap())
         .addKeepAttributes("EnclosingMethod", "InnerClasses")
         .setMinApi(parameters)
-        .noTreeShaking()
+        .addDontShrink()
         .compile()
         .addRunClasspathFiles(libraryCompileResult.writeToZip())
         .run(parameters.getRuntime(), ProgramClassWithSimpleLibraryReference.class)
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInterfaceInvokeTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInterfaceInvokeTest.java
index da531ea..c8bb6e6 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInterfaceInvokeTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInterfaceInvokeTest.java
@@ -74,7 +74,7 @@
         .addClasspathClasses(classPathClasses)
         .addProgramClasses(TestApp.class)
         .addDontObfuscate()
-        .noTreeShaking()
+        .addDontShrink()
         .addApplyMapping(libraryResult.getProguardMap())
         .setMinApi(parameters)
         .compile()
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInterfaceTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInterfaceTest.java
index ff6de98..db2a10b 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingInterfaceTest.java
@@ -86,7 +86,7 @@
         .addKeepAllClassesRule()
         .addApplyMapping(libraryCompileResult.getProguardMap())
         .setMinApi(parameters)
-        .noTreeShaking()
+        .addDontShrink()
         .compile()
         .addRunClasspathFiles(libraryCompileResult.writeToZip())
         .run(parameters.getRuntime(), testClass)
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingReservationTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingReservationTest.java
index 278caf6..8b9c128 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingReservationTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingReservationTest.java
@@ -48,7 +48,7 @@
         .addKeepMainRule(Runner.class)
         .addApplyMapping(R.class.getTypeName() + " -> " + R.class.getTypeName() + ":")
         .setMinApi(parameters)
-        .noTreeShaking()
+        .addDontShrink()
         .compile()
         .addRunClasspathFiles(libraryCompileResult.writeToZip())
         .run(parameters.getRuntime(), Runner.class)
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingRotateNameClashTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingRotateNameClashTest.java
index a0ce1ee..81ba247 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingRotateNameClashTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingRotateNameClashTest.java
@@ -45,7 +45,7 @@
         .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
         .addProgramClasses(C.class)
         .addKeepMainRule(C.class)
-        .noTreeShaking()
+        .addDontShrink()
         .addApplyMapping(
             StringUtils.lines(
                 A.class.getTypeName() + " -> " + B.class.getTypeName() + ":",
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingSameStaticNameTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingSameStaticNameTest.java
index 168cf97..71e101a 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingSameStaticNameTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingSameStaticNameTest.java
@@ -59,7 +59,7 @@
   @Test
   public void test_b131532229() throws Exception {
     testForR8(parameters.getBackend())
-        .noTreeShaking()
+        .addDontShrink()
         .addLibraryClasses(A.class, B.class)
         .addLibraryFiles(parameters.getDefaultRuntimeLibrary())
         .addProgramClasses(C.class)
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingVirtualInvokeTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingVirtualInvokeTest.java
index a72ff12..3e4723a 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingVirtualInvokeTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingVirtualInvokeTest.java
@@ -152,7 +152,7 @@
       throws ExecutionException, IOException, CompilationFailedException {
     R8TestCompileResult libraryCompileResult = compilationResults.apply(parameters);
     testForR8(parameters.getBackend())
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .addProgramClasses(PROGRAM_CLASSES)
         .addApplyMapping(libraryCompileResult.getProguardMap())
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/desugar/DefaultInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/desugar/DefaultInterfaceMethodTest.java
index 37f2b71..3521a29 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/desugar/DefaultInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/desugar/DefaultInterfaceMethodTest.java
@@ -89,7 +89,7 @@
     }
 
     testForR8(parameters.getBackend())
-        .noTreeShaking()
+        .addDontShrink()
         .addProgramClasses(ProgramClass.class)
         .addClasspathClasses(LibraryInterface.class)
         .addApplyMapping(libraryResult.getProguardMap())
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/desugar/StaticInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/desugar/StaticInterfaceMethodTest.java
index d42b085..45d0a3b 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/desugar/StaticInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/desugar/StaticInterfaceMethodTest.java
@@ -95,7 +95,7 @@
     }
 
     testForR8(parameters.getBackend())
-        .noTreeShaking()
+        .addDontShrink()
         .addProgramClasses(ProgramClass.class)
         .addClasspathClasses(LibraryInterface.class)
         .addApplyMapping(libraryResult.getProguardMap())
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/shared/NameClashTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/shared/NameClashTest.java
index 4a2c79e..97f2633 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/shared/NameClashTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/shared/NameClashTest.java
@@ -120,7 +120,7 @@
         .addProgramFiles(prgJarThatUsesOriginalLib)
         .addKeepMainRule(MAIN)
         .addKeepRules("-applymapping " + mappingFile)
-        .noTreeShaking()
+        .addDontShrink()
         .compile()
         .run(MAIN)
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
@@ -133,7 +133,7 @@
         .addProgramFiles(prgJarThatUsesOriginalLib)
         .addKeepMainRule(MAIN)
         .addKeepRules("-applymapping " + mappingFile)
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .compile()
         .run(MAIN)
@@ -146,7 +146,7 @@
         .addProgramFiles(prgJarThatUsesOriginalLib)
         .addKeepMainRule(MAIN)
         .addKeepRules("-applymapping " + mappingFile)
-        .noTreeShaking()
+        .addDontShrink()
         .compile()
         .run(MAIN)
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
@@ -158,7 +158,7 @@
         .addProgramFiles(prgJarThatUsesOriginalLib)
         .addKeepMainRule(MAIN)
         .addKeepRules("-applymapping " + mappingFile)
-        .noTreeShaking()
+        .addDontShrink()
         .compile()
         .run(MAIN)
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
@@ -170,7 +170,7 @@
         .addProgramFiles(prgJarThatUsesMinifiedLib)
         .addKeepMainRule(MAIN)
         .addKeepRules("-applymapping " + mappingFile)
-        .noTreeShaking()
+        .addDontShrink()
         .compile()
         .run(MAIN)
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/ApplyMappingTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/ApplyMappingTest.java
index e0d32a3..223b45c 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/ApplyMappingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/ApplyMappingTest.java
@@ -144,7 +144,8 @@
         testForR8(parameters.getBackend())
             .addProgramFiles(NAMING001_JAR)
             .addKeepRuleFiles(Paths.get(ToolHelper.EXAMPLES_DIR, "naming001", "keep-rules-106.txt"))
-            .noTreeShaking()
+            .addDontOptimize()
+            .addDontShrink()
             .setMinApi(parameters)
             .compile()
             .inspector();
diff --git a/src/test/java/com/android/tools/r8/naming/arraytypes/ArrayTypesTest.java b/src/test/java/com/android/tools/r8/naming/arraytypes/ArrayTypesTest.java
index 74d750d..fb4f3ef6 100644
--- a/src/test/java/com/android/tools/r8/naming/arraytypes/ArrayTypesTest.java
+++ b/src/test/java/com/android/tools/r8/naming/arraytypes/ArrayTypesTest.java
@@ -68,7 +68,7 @@
 
   private void runR8Test(boolean enableMinification) throws Exception {
     testForR8(parameters.getBackend())
-        .minification(enableMinification)
+        .addDontObfuscateUnless(enableMinification)
         .addProgramClasses(Main.class, A.class)
         .addProgramClassFileData(generateTestClass())
         .addKeepMainRule(Main.class)
@@ -103,7 +103,7 @@
         .addKeepMainRule(Main.class)
         .addKeepRules("-applymapping " + mappingFile.toAbsolutePath())
         .addDontObfuscate()
-        .noTreeShaking()
+        .addDontShrink()
         .setMinApi(parameters)
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutput(expectedOutput);
diff --git a/src/test/java/com/android/tools/r8/naming/b124357885/B124357885Test.java b/src/test/java/com/android/tools/r8/naming/b124357885/B124357885Test.java
index 4b3c35f..50b9bc5 100644
--- a/src/test/java/com/android/tools/r8/naming/b124357885/B124357885Test.java
+++ b/src/test/java/com/android/tools/r8/naming/b124357885/B124357885Test.java
@@ -70,7 +70,7 @@
                             + " { *** test(); }"))
             .enableInliningAnnotations()
             .enableKeepUnusedReturnValueAnnotations()
-            .minification(minification)
+            .addDontObfuscateUnless(minification)
             .setMinApi(parameters)
             .compile()
             .inspect(
diff --git a/src/test/java/com/android/tools/r8/naming/b126592786/B126592786.java b/src/test/java/com/android/tools/r8/naming/b126592786/B126592786.java
index ce1faf5..adc08a2 100644
--- a/src/test/java/com/android/tools/r8/naming/b126592786/B126592786.java
+++ b/src/test/java/com/android/tools/r8/naming/b126592786/B126592786.java
@@ -42,7 +42,7 @@
   public void runTest(boolean genericTypeLive) throws Exception {
     Class<?> mainClass = genericTypeLive ? MainGenericTypeLive.class : MainGenericTypeNotLive.class;
     testForR8(parameters.getBackend())
-        .minification(minify)
+        .addDontObfuscateUnless(minify)
         .addProgramClasses(GetClassUtil.class, A.class, GenericType.class, mainClass, Marker.class)
         .addKeepMainRule(mainClass)
         .addKeepRules(
diff --git a/src/test/java/com/android/tools/r8/naming/b131810441/AnonymousClassRenamingTest.java b/src/test/java/com/android/tools/r8/naming/b131810441/AnonymousClassRenamingTest.java
index bc4f872..2adbaec 100644
--- a/src/test/java/com/android/tools/r8/naming/b131810441/AnonymousClassRenamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/b131810441/AnonymousClassRenamingTest.java
@@ -50,7 +50,7 @@
         .addKeepMainRule(TestMain.class)
         .addKeepAttributes("InnerClasses", "EnclosingMethod")
         .enableInliningAnnotations()
-        .minification(enableMinification)
+        .addDontObfuscateUnless(enableMinification)
         .setMinApi(parameters)
         .run(parameters.getRuntime(), TestMain.class)
         .assertSuccessWithOutput(EXPECTED_OUTPUT)
diff --git a/src/test/java/com/android/tools/r8/naming/b132460884/LocalClassRenamingTest.java b/src/test/java/com/android/tools/r8/naming/b132460884/LocalClassRenamingTest.java
index 8be4f0b..1c18921 100644
--- a/src/test/java/com/android/tools/r8/naming/b132460884/LocalClassRenamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/b132460884/LocalClassRenamingTest.java
@@ -83,8 +83,8 @@
         .addProgramClasses(TestMain.class)
         .addKeepMainRule(TestMain.class)
         .addKeepAttributes("Signature", "InnerClasses")
-        .noTreeShaking()
-        .minification(enableMinification)
+        .addDontShrink()
+        .addDontObfuscateUnless(enableMinification)
         .setMinApi(parameters)
         .compile()
         .inspect(
diff --git a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderClassLoaderRewritingTest.java b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderClassLoaderRewritingTest.java
index 1df6b3a..9695e90 100644
--- a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderClassLoaderRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderClassLoaderRewritingTest.java
@@ -4,25 +4,17 @@
 
 package com.android.tools.r8.optimize.serviceloader;
 
-import static junit.framework.TestCase.assertNull;
-
-import com.android.tools.r8.DataEntryResource;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.StringUtils;
-import java.nio.file.Path;
 import java.util.ServiceLoader;
-import java.util.zip.ZipFile;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
 @RunWith(Parameterized.class)
 public class ServiceLoaderClassLoaderRewritingTest extends ServiceLoaderTestBase {
-
-  private final TestParameters parameters;
   private final String EXPECTED_OUTPUT = StringUtils.lines("Hello World!");
 
   public interface Service {
@@ -67,30 +59,17 @@
   }
 
   public ServiceLoaderClassLoaderRewritingTest(TestParameters parameters) {
-    this.parameters = parameters;
+    super(parameters);
   }
 
   @Test
   public void testRewritings() throws Exception {
-    Path path = temp.newFile("out.zip").toPath();
-    testForR8(parameters.getBackend())
-        .addInnerClasses(ServiceLoaderClassLoaderRewritingTest.class)
+    serviceLoaderTest(Service.class, ServiceImpl.class)
         .addKeepMainRule(MainRunner.class)
-        .setMinApi(parameters)
         .enableInliningAnnotations()
-        .addDataEntryResources(
-            DataEntryResource.fromBytes(
-                StringUtils.lines(ServiceImpl.class.getTypeName()).getBytes(),
-                "META-INF/services/" + Service.class.getTypeName(),
-                Origin.unknown()))
         .compile()
-        .writeToZip(path)
         .inspect(inspector -> verifyNoServiceLoaderLoads(inspector.clazz(MainRunner.class)))
         .run(parameters.getRuntime(), MainRunner.class)
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
-
-    // Check that we have removed the service configuration from META-INF/services.
-    ZipFile zip = new ZipFile(path.toFile());
-    assertNull(zip.getEntry("META-INF/services/" + Service.class.getTypeName()));
   }
 }
diff --git a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderConstClassFromCalleeTest.java b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderConstClassFromCalleeTest.java
index da90e4a..a6556a2 100644
--- a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderConstClassFromCalleeTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderConstClassFromCalleeTest.java
@@ -5,41 +5,30 @@
 
 import static junit.framework.TestCase.assertEquals;
 
-import com.android.tools.r8.DataEntryResource;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.utils.StringUtils;
 import java.util.ServiceLoader;
 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 ServiceLoaderConstClassFromCalleeTest extends ServiceLoaderTestBase {
 
-  @Parameter(0)
-  public TestParameters parameters;
-
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
     return getTestParameters().withAllRuntimesAndApiLevels().build();
   }
 
+  public ServiceLoaderConstClassFromCalleeTest(TestParameters parameters) {
+    super(parameters);
+  }
+
   @Test
   public void test() throws Exception {
-    testForR8(parameters.getBackend())
-        .addInnerClasses(getClass())
+    serviceLoaderTest(Service.class, ServiceImpl.class, ServiceImpl2.class)
         .addKeepMainRule(Main.class)
-        .setMinApi(parameters)
-        .addDataEntryResources(
-            DataEntryResource.fromBytes(
-                StringUtils.lines(ServiceImpl.class.getTypeName(), ServiceImpl2.class.getTypeName())
-                    .getBytes(),
-                "META-INF/services/" + Service.class.getTypeName(),
-                Origin.unknown()))
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("Hello, world!")
         // Check that the call to ServiceLoader.load is removed.
diff --git a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderMultipleCallsSameMethodTest.java b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderMultipleCallsSameMethodTest.java
index 149fd33..5cd038d 100644
--- a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderMultipleCallsSameMethodTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderMultipleCallsSameMethodTest.java
@@ -5,31 +5,24 @@
 package com.android.tools.r8.optimize.serviceloader;
 
 import static junit.framework.TestCase.assertEquals;
-import static junit.framework.TestCase.assertNull;
 import static junit.framework.TestCase.assertTrue;
 import static org.junit.Assert.assertFalse;
 
 import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.DataEntryResource;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
 import java.io.IOException;
-import java.nio.file.Path;
 import java.util.ServiceLoader;
 import java.util.concurrent.ExecutionException;
-import java.util.zip.ZipFile;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
 @RunWith(Parameterized.class)
 public class ServiceLoaderMultipleCallsSameMethodTest extends ServiceLoaderTestBase {
-
-  private final TestParameters parameters;
   private final String EXPECTED_OUTPUT = StringUtils.lines("Hello World!", "Hello World!");
 
   public interface Service {
@@ -45,13 +38,6 @@
     }
   }
 
-  public static class ServiceImpl2 implements Service {
-
-    @Override
-    public void print() {
-      System.out.println("Hello World 2!");
-    }
-  }
 
   public static class MainRunner {
 
@@ -77,32 +63,23 @@
   }
 
   public ServiceLoaderMultipleCallsSameMethodTest(TestParameters parameters) {
-    this.parameters = parameters;
+    super(parameters);
   }
 
   @Test
   public void testRewritings() throws IOException, CompilationFailedException, ExecutionException {
-    Path path = temp.newFile("out.zip").toPath();
-    testForR8(parameters.getBackend())
-        .addInnerClasses(ServiceLoaderMultipleCallsSameMethodTest.class)
+    serviceLoaderTest(Service.class, ServiceImpl.class)
         .addKeepMainRule(MainRunner.class)
-        .setMinApi(parameters)
         .enableInliningAnnotations()
-        .addDataEntryResources(
-            DataEntryResource.fromBytes(
-                StringUtils.lines(ServiceImpl.class.getTypeName()).getBytes(),
-                "META-INF/services/" + Service.class.getTypeName(),
-                Origin.unknown()))
         .compile()
-        .writeToZip(path)
         .run(parameters.getRuntime(), MainRunner.class)
         .assertSuccessWithOutput(EXPECTED_OUTPUT)
-        // Check that we have actually rewritten the calls to ServiceLoader.load.
-        .inspect(this::verifyNoServiceLoaderLoads)
-        .inspect(this::verifyNoClassLoaders)
         .inspect(
             inspector -> {
-              // Check the synthesize service loader method is a single shared method.
+              verifyNoServiceLoaderLoads(inspector.clazz(MainRunner.class));
+              verifyNoClassLoaders(inspector);
+              verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+              // Check the synthesized service loader method is a single shared method.
               // Due to minification we just check there is only a single synthetic class with a
               // single static method.
               boolean found = false;
@@ -115,9 +92,5 @@
                 }
               }
             });
-
-    // Check that we have removed the service configuration from META-INF/services.
-    ZipFile zip = new ZipFile(path.toFile());
-    assertNull(zip.getEntry("META-INF/services/" + Service.class.getTypeName()));
   }
 }
diff --git a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderMultipleCallsTest.java b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderMultipleCallsTest.java
index c688bd4..5b2d452 100644
--- a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderMultipleCallsTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderMultipleCallsTest.java
@@ -5,31 +5,24 @@
 package com.android.tools.r8.optimize.serviceloader;
 
 import static junit.framework.TestCase.assertEquals;
-import static junit.framework.TestCase.assertNull;
 import static junit.framework.TestCase.assertTrue;
 import static org.junit.Assert.assertFalse;
 
 import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.DataEntryResource;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
 import java.io.IOException;
-import java.nio.file.Path;
 import java.util.ServiceLoader;
 import java.util.concurrent.ExecutionException;
-import java.util.zip.ZipFile;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
 @RunWith(Parameterized.class)
 public class ServiceLoaderMultipleCallsTest extends ServiceLoaderTestBase {
-
-  private final TestParameters parameters;
   private final String EXPECTED_OUTPUT = StringUtils.lines("Hello World!", "Hello World!");
 
   public interface Service {
@@ -45,14 +38,6 @@
     }
   }
 
-  public static class ServiceImpl2 implements Service {
-
-    @Override
-    public void print() {
-      System.out.println("Hello World 2!");
-    }
-  }
-
   public static class MainRunner {
 
     public static void main(String[] args) {
@@ -81,31 +66,22 @@
   }
 
   public ServiceLoaderMultipleCallsTest(TestParameters parameters) {
-    this.parameters = parameters;
+    super(parameters);
   }
 
   @Test
   public void testRewritings() throws IOException, CompilationFailedException, ExecutionException {
-    Path path = temp.newFile("out.zip").toPath();
-    testForR8(parameters.getBackend())
-        .addInnerClasses(ServiceLoaderMultipleCallsTest.class)
+    serviceLoaderTest(Service.class, ServiceImpl.class)
         .addKeepMainRule(MainRunner.class)
-        .setMinApi(parameters)
         .enableInliningAnnotations()
-        .addDataEntryResources(
-            DataEntryResource.fromBytes(
-                StringUtils.lines(ServiceImpl.class.getTypeName()).getBytes(),
-                "META-INF/services/" + Service.class.getTypeName(),
-                Origin.unknown()))
         .compile()
-        .writeToZip(path)
         .run(parameters.getRuntime(), MainRunner.class)
         .assertSuccessWithOutput(EXPECTED_OUTPUT)
         .inspect(
             inspector -> {
               // Check that we have actually rewritten the calls to ServiceLoader.load.
               assertEquals(0, getServiceLoaderLoads(inspector));
-              // Check the synthesize service loader method is a single shared method.
+              // Check the synthesized service loader method is a single shared method.
               // Due to minification we just check there is only a single synthetic class with a
               // single static method.
               boolean found = false;
@@ -118,9 +94,5 @@
                 }
               }
             });
-
-    // Check that we have removed the service configuration from META-INF/services.
-    ZipFile zip = new ZipFile(path.toFile());
-    assertNull(zip.getEntry("META-INF/services/" + Service.class.getTypeName()));
   }
 }
diff --git a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderRewritingLineSeparatorTest.java b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderRewritingLineSeparatorTest.java
index 7610575..c142442 100644
--- a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderRewritingLineSeparatorTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderRewritingLineSeparatorTest.java
@@ -5,7 +5,6 @@
 package com.android.tools.r8.optimize.serviceloader;
 
 import static junit.framework.TestCase.assertEquals;
-import static junit.framework.TestCase.assertNull;
 
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.DataEntryResource;
@@ -13,10 +12,8 @@
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.StringUtils;
 import java.io.IOException;
-import java.nio.file.Path;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
-import java.util.zip.ZipFile;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -24,8 +21,6 @@
 
 @RunWith(Parameterized.class)
 public class ServiceLoaderRewritingLineSeparatorTest extends ServiceLoaderTestBase {
-
-  private final TestParameters parameters;
   private final Separator lineSeparator;
 
   private final String EXPECTED_OUTPUT =
@@ -55,18 +50,16 @@
   }
 
   public ServiceLoaderRewritingLineSeparatorTest(TestParameters parameters, Separator separator) {
-    this.parameters = parameters;
+    super(parameters);
     this.lineSeparator = separator;
   }
 
   @Test
   public void testRewritingWithMultipleWithLineSeparator()
       throws IOException, CompilationFailedException, ExecutionException {
-    Path path = temp.newFile("out.zip").toPath();
-    testForR8(parameters.getBackend())
+    serviceLoaderTest(null)
         .addInnerClasses(ServiceLoaderRewritingTest.class)
         .addKeepMainRule(ServiceLoaderRewritingTest.MainRunner.class)
-        .setMinApi(parameters)
         .addDataEntryResources(
             DataEntryResource.fromBytes(
                 StringUtils.join(
@@ -77,14 +70,17 @@
                 "META-INF/services/" + ServiceLoaderRewritingTest.Service.class.getTypeName(),
                 Origin.unknown()))
         .compile()
-        .writeToZip(path)
         .run(parameters.getRuntime(), ServiceLoaderRewritingTest.MainRunner.class)
         .assertSuccessWithOutput(EXPECTED_OUTPUT + StringUtils.lines("Hello World 2!"))
         // Check that we have actually rewritten the calls to ServiceLoader.load.
-        .inspect(inspector -> assertEquals(0, getServiceLoaderLoads(inspector)));
-
-    // Check that we have removed the service configuration from META-INF/services.
-    ZipFile zip = new ZipFile(path.toFile());
-    assertNull(zip.getEntry("META-INF/services"));
+        .inspect(
+            inspector -> {
+              assertEquals(0, getServiceLoaderLoads(inspector));
+              verifyServiceMetaInf(
+                  inspector,
+                  ServiceLoaderRewritingTest.Service.class,
+                  ServiceLoaderRewritingTest.ServiceImpl.class,
+                  ServiceLoaderRewritingTest.ServiceImpl2.class);
+            });
   }
 }
diff --git a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderRewritingTest.java b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderRewritingTest.java
index 1483561..18f4a79 100644
--- a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderRewritingTest.java
@@ -4,30 +4,23 @@
 
 package com.android.tools.r8.optimize.serviceloader;
 
-import static com.android.tools.r8.TestBase.getTestParameters;
-import static junit.framework.Assert.assertNotNull;
-import static junit.framework.TestCase.assertEquals;
-import static junit.framework.TestCase.assertNull;
-import static junit.framework.TestCase.assertTrue;
+import static com.android.tools.r8.ToolHelper.DexVm.Version.V7_0_0;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assume.assumeTrue;
 
 import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.DataEntryResource;
-import com.android.tools.r8.DiagnosticsMatcher;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.ToolHelper.DexVm.Version;
-import com.android.tools.r8.ir.optimize.ServiceLoaderRewriterDiagnostic;
-import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import java.io.IOException;
-import java.nio.file.Path;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.ServiceConfigurationError;
 import java.util.ServiceLoader;
 import java.util.concurrent.ExecutionException;
-import java.util.zip.ZipFile;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -35,7 +28,6 @@
 @RunWith(Parameterized.class)
 public class ServiceLoaderRewritingTest extends ServiceLoaderTestBase {
 
-  private final TestParameters parameters;
   private final String EXPECTED_OUTPUT =
       StringUtils.lines("Hello World!", "Hello World!", "Hello World!");
 
@@ -60,6 +52,14 @@
     }
   }
 
+  public static class ServiceImplNoDefaultConstructor extends ServiceImpl {
+    public ServiceImplNoDefaultConstructor(int unused) {}
+  }
+
+  public static class ServiceImplNonPublicConstructor extends ServiceImpl {
+    ServiceImplNonPublicConstructor() {}
+  }
+
   public static class MainRunner {
 
     public static void main(String[] args) {
@@ -150,208 +150,183 @@
     }
   }
 
-  @Parameterized.Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  @Parameterized.Parameters(name = "{0}, enableRewriting: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.values());
   }
 
-  public ServiceLoaderRewritingTest(TestParameters parameters) {
-    this.parameters = parameters;
+  public ServiceLoaderRewritingTest(TestParameters parameters, boolean enableRewriting) {
+    super(parameters, enableRewriting);
+  }
+
+  private void expectRewritten(CodeInspector inspector) {
+    long found = getServiceLoaderLoads(inspector);
+    if (enableRewriting) {
+      assertEquals(0, found);
+    } else {
+      assertNotEquals(0, found);
+    }
+  }
+
+  private boolean isDexV7() {
+    // Runtime uses boot classloader rather than system classloader on this version.
+    return parameters.isDexRuntime() && parameters.getDexRuntimeVersion() == V7_0_0;
   }
 
   @Test
-  public void testRewritings() throws IOException, CompilationFailedException, ExecutionException {
-    Path path = temp.newFile("out.zip").toPath();
-    testForR8(parameters.getBackend())
-        .addInnerClasses(ServiceLoaderRewritingTest.class)
-        .addKeepMainRule(MainRunner.class)
-        .setMinApi(parameters)
-        .addDataEntryResources(
-            DataEntryResource.fromBytes(
-                StringUtils.lines(ServiceImpl.class.getTypeName()).getBytes(),
-                "META-INF/services/" + Service.class.getTypeName(),
-                Origin.unknown()))
-        .compile()
-        .writeToZip(path)
-        .run(parameters.getRuntime(), MainRunner.class)
-        .assertSuccessWithOutput(EXPECTED_OUTPUT)
-        // Check that we have actually rewritten the calls to ServiceLoader.load.
-        .inspect(inspector -> assertEquals(0, getServiceLoaderLoads(inspector)));
-
-    // Check that we have removed the service configuration from META-INF/services.
-    ZipFile zip = new ZipFile(path.toFile());
-    assertNull(zip.getEntry("META-INF/services/" + Service.class.getTypeName()));
-  }
-
-  @Test
-  public void testRewritingWithMultiple()
+  public void testRewritingWithNoImpls()
       throws IOException, CompilationFailedException, ExecutionException {
-    Path path = temp.newFile("out.zip").toPath();
-    testForR8(parameters.getBackend())
-        .addInnerClasses(ServiceLoaderRewritingTest.class)
+    serviceLoaderTest(null)
         .addKeepMainRule(MainRunner.class)
-        .setMinApi(parameters)
-        .addDataEntryResources(
-            DataEntryResource.fromBytes(
-                StringUtils.lines(ServiceImpl.class.getTypeName(), ServiceImpl2.class.getTypeName())
-                    .getBytes(),
-                "META-INF/services/" + Service.class.getTypeName(),
-                Origin.unknown()))
         .compile()
-        .writeToZip(path)
         .run(parameters.getRuntime(), MainRunner.class)
-        .assertSuccessWithOutput(EXPECTED_OUTPUT + StringUtils.lines("Hello World 2!"))
-        // Check that we have actually rewritten the calls to ServiceLoader.load.
-        .inspect(inspector -> assertEquals(0, getServiceLoaderLoads(inspector)));
+        .assertFailureWithErrorThatThrows(NoSuchElementException.class)
+        .inspectFailure(this::expectRewritten);
+  }
 
-    // Check that we have removed the service configuration from META-INF/services.
-    ZipFile zip = new ZipFile(path.toFile());
-    assertNull(zip.getEntry("META-INF/services/" + Service.class.getTypeName()));
+  @Test
+  public void testRewritings() throws Exception {
+    serviceLoaderTest(Service.class, ServiceImpl.class)
+        .addKeepMainRule(MainRunner.class)
+        .compile()
+        .run(parameters.getRuntime(), MainRunner.class)
+        .applyIf(
+            isDexV7() && !enableRewriting,
+            runResult ->
+                runResult.assertFailureWithErrorThatThrows(ServiceConfigurationError.class),
+            runResult ->
+                runResult
+                    .assertSuccessWithOutput(EXPECTED_OUTPUT)
+                    .inspect(
+                        inspector -> {
+                          expectRewritten(inspector);
+                          verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+                        }));
+  }
+
+  @Test
+  public void testRewritingWithMultiple() throws Exception {
+    serviceLoaderTest(Service.class, ServiceImpl.class, ServiceImpl2.class)
+        .addKeepMainRule(MainRunner.class)
+        .compile()
+        .run(parameters.getRuntime(), MainRunner.class)
+        .applyIf(
+            isDexV7() && !enableRewriting,
+            runResult ->
+                runResult.assertFailureWithErrorThatThrows(ServiceConfigurationError.class),
+            runResult ->
+                runResult
+                    .assertSuccessWithOutput(EXPECTED_OUTPUT + StringUtils.lines("Hello World 2!"))
+                    .inspect(
+                        inspector -> {
+                          expectRewritten(inspector);
+                          verifyServiceMetaInf(
+                              inspector, Service.class, ServiceImpl.class, ServiceImpl2.class);
+                        }));
   }
 
   @Test
   public void testRewritingsWithCatchHandlers()
       throws IOException, CompilationFailedException, ExecutionException {
-    Path path = temp.newFile("out.zip").toPath();
-    testForR8(parameters.getBackend())
-        .addInnerClasses(ServiceLoaderRewritingTest.class)
+    serviceLoaderTest(Service.class, ServiceImpl.class, ServiceImpl2.class)
         .addKeepMainRule(MainWithTryCatchRunner.class)
-        .setMinApi(parameters)
-        .addDataEntryResources(
-            DataEntryResource.fromBytes(
-                StringUtils.lines(ServiceImpl.class.getTypeName(), ServiceImpl2.class.getTypeName())
-                    .getBytes(),
-                "META-INF/services/" + Service.class.getTypeName(),
-                Origin.unknown()))
         .compile()
-        .writeToZip(path)
         .run(parameters.getRuntime(), MainWithTryCatchRunner.class)
         .assertSuccessWithOutput(StringUtils.lines("Hello World!"))
-        // Check that we have actually rewritten the calls to ServiceLoader.load.
-        .inspect(inspector -> assertEquals(0, getServiceLoaderLoads(inspector)));
-
-    // Check that we have removed the service configuration from META-INF/services.
-    ZipFile zip = new ZipFile(path.toFile());
-    assertNull(zip.getEntry("META-INF/services/" + Service.class.getTypeName()));
+        .inspect(
+            inspector -> {
+              expectRewritten(inspector);
+              verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class, ServiceImpl2.class);
+            });
   }
 
   @Test
   public void testDoNoRewrite() throws IOException, CompilationFailedException, ExecutionException {
-    Path path = temp.newFile("out.zip").toPath();
-    CodeInspector inspector =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(ServiceLoaderRewritingTest.class)
-            .addKeepMainRule(OtherRunner.class)
-            .setMinApi(parameters)
-            .addKeepRules(
-                "-whyareyounotinlining class "
-                    + ServiceLoader.class.getTypeName()
-                    + " { *** load(...); }")
-            .enableExperimentalWhyAreYouNotInlining()
-            .addDataEntryResources(
-                DataEntryResource.fromBytes(
-                    StringUtils.lines(ServiceImpl.class.getTypeName()).getBytes(),
-                    "META-INF/services/" + Service.class.getTypeName(),
-                    Origin.unknown()))
-            .allowDiagnosticInfoMessages()
-            .compile()
-            .assertAllInfosMatch(
-                DiagnosticsMatcher.diagnosticType(ServiceLoaderRewriterDiagnostic.class))
-            .assertAtLeastOneInfoMessage()
-            .writeToZip(path)
-            .run(parameters.getRuntime(), OtherRunner.class)
-            .assertSuccessWithOutput(EXPECTED_OUTPUT)
-            .inspector();
+    serviceLoaderTest(Service.class, ServiceImpl.class)
+        .addKeepMainRule(OtherRunner.class)
+        .allowDiagnosticInfoMessages(enableRewriting)
+        .compileWithExpectedDiagnostics(expectedDiagnostics)
+        .run(parameters.getRuntime(), OtherRunner.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT)
+        .inspect(
+            inspector -> {
+              assertEquals(3, getServiceLoaderLoads(inspector));
+              verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+            });
+  }
 
-    // Check that we have not rewritten the calls to ServiceLoader.load.
-    assertEquals(3, getServiceLoaderLoads(inspector));
+  @Test
+  public void testDoNoRewriteNoDefaultConstructor()
+      throws IOException, CompilationFailedException, ExecutionException {
+    serviceLoaderTest(Service.class, ServiceImplNoDefaultConstructor.class)
+        .addKeepMainRule(MainRunner.class)
+        .allowDiagnosticInfoMessages(enableRewriting)
+        .compileWithExpectedDiagnostics(expectedDiagnostics)
+        .run(parameters.getRuntime(), MainRunner.class)
+        .assertFailureWithErrorThatThrows(ServiceConfigurationError.class);
+  }
 
-    // Check that we have not removed the service configuration from META-INF/services.
-    ZipFile zip = new ZipFile(path.toFile());
-    ClassSubject serviceImpl = inspector.clazz(ServiceImpl.class);
-    assertTrue(serviceImpl.isPresent());
-    assertNotNull(zip.getEntry("META-INF/services/" + serviceImpl.getFinalName()));
+  @Test
+  public void testDoNoRewriteNonSubclass()
+      throws IOException, CompilationFailedException, ExecutionException {
+    serviceLoaderTest(Service.class, MainRunner.class)
+        .addKeepMainRule(MainRunner.class)
+        .allowDiagnosticInfoMessages(enableRewriting)
+        .compileWithExpectedDiagnostics(expectedDiagnostics)
+        .run(parameters.getRuntime(), MainRunner.class)
+        .assertFailureWithErrorThatThrows(ServiceConfigurationError.class);
+  }
+
+  @Test
+  public void testDoNoRewriteNonPublicConstructor()
+      throws IOException, CompilationFailedException, ExecutionException {
+    // This throws a ServiceConfigurationError only on Android 7.
+    serviceLoaderTest(Service.class, ServiceImplNonPublicConstructor.class)
+        .addKeepMainRule(MainRunner.class)
+        .allowDiagnosticInfoMessages(enableRewriting)
+        .compileWithExpectedDiagnostics(expectedDiagnostics)
+        .run(parameters.getRuntime(), MainRunner.class)
+        .applyIf(
+            !isDexV7(),
+            runResult -> runResult.assertSuccessWithOutput(EXPECTED_OUTPUT),
+            runResult ->
+                runResult.assertFailureWithErrorThatThrows(ServiceConfigurationError.class));
   }
 
   @Test
   public void testDoNoRewriteWhenEscaping()
       throws IOException, CompilationFailedException, ExecutionException {
-    Path path = temp.newFile("out.zip").toPath();
-    CodeInspector inspector =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(ServiceLoaderRewritingTest.class)
-            .addKeepMainRule(EscapingRunner.class)
-            .enableInliningAnnotations()
-            .setMinApi(parameters)
-            .addKeepRules(
-                "-whyareyounotinlining class "
-                    + ServiceLoader.class.getTypeName()
-                    + " { *** load(...); }")
-            .enableExperimentalWhyAreYouNotInlining()
-            .addDontObfuscate()
-            .addDataEntryResources(
-                DataEntryResource.fromBytes(
-                    StringUtils.lines(ServiceImpl.class.getTypeName()).getBytes(),
-                    "META-INF/services/" + Service.class.getTypeName(),
-                    Origin.unknown()))
-            .allowDiagnosticInfoMessages()
-            .compile()
-            .assertAllInfosMatch(
-                DiagnosticsMatcher.diagnosticType(ServiceLoaderRewriterDiagnostic.class))
-            .assertAtLeastOneInfoMessage()
-            .writeToZip(path)
-            .run(parameters.getRuntime(), EscapingRunner.class)
-            .assertSuccessWithOutput(EXPECTED_OUTPUT)
-            .inspector();
-
-    // Check that we have not rewritten the calls to ServiceLoader.load.
-    assertEquals(3, getServiceLoaderLoads(inspector));
-
-    // Check that we have not removed the service configuration from META-INF/services.
-    ZipFile zip = new ZipFile(path.toFile());
-    ClassSubject serviceImpl = inspector.clazz(ServiceImpl.class);
-    assertTrue(serviceImpl.isPresent());
-    assertNotNull(zip.getEntry("META-INF/services/" + serviceImpl.getFinalName()));
+    serviceLoaderTest(Service.class, ServiceImpl.class)
+        .addKeepMainRule(EscapingRunner.class)
+        .enableInliningAnnotations()
+        .addDontObfuscate()
+        .allowDiagnosticInfoMessages(enableRewriting)
+        .compileWithExpectedDiagnostics(expectedDiagnostics)
+        .run(parameters.getRuntime(), EscapingRunner.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT)
+        .inspect(
+            inspector -> {
+              assertEquals(3, getServiceLoaderLoads(inspector));
+              verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+            });
   }
 
   @Test
   public void testDoNoRewriteWhenClassLoaderIsPhi()
       throws IOException, CompilationFailedException, ExecutionException {
-    Path path = temp.newFile("out.zip").toPath();
-    CodeInspector inspector =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(ServiceLoaderRewritingTest.class)
-            .addKeepMainRule(LoadWhereClassLoaderIsPhi.class)
-            .enableInliningAnnotations()
-            .setMinApi(parameters)
-            .addKeepRules(
-                "-whyareyounotinlining class "
-                    + ServiceLoader.class.getTypeName()
-                    + " { *** load(...); }")
-            .enableExperimentalWhyAreYouNotInlining()
-            .addDataEntryResources(
-                DataEntryResource.fromBytes(
-                    StringUtils.lines(ServiceImpl.class.getTypeName()).getBytes(),
-                    "META-INF/services/" + Service.class.getTypeName(),
-                    Origin.unknown()))
-            .allowDiagnosticInfoMessages()
-            .compile()
-            .assertAllInfosMatch(
-                DiagnosticsMatcher.diagnosticType(ServiceLoaderRewriterDiagnostic.class))
-            .assertAtLeastOneInfoMessage()
-            .writeToZip(path)
-            .run(parameters.getRuntime(), LoadWhereClassLoaderIsPhi.class)
-            .assertSuccessWithOutputLines("Hello World!")
-            .inspector();
-
-    // Check that we have not rewritten the calls to ServiceLoader.load.
-    assertEquals(1, getServiceLoaderLoads(inspector));
-
-    // Check that we have not removed the service configuration from META-INF/services.
-    ZipFile zip = new ZipFile(path.toFile());
-    ClassSubject serviceImpl = inspector.clazz(ServiceImpl.class);
-    assertTrue(serviceImpl.isPresent());
-    assertNotNull(zip.getEntry("META-INF/services/" + serviceImpl.getFinalName()));
+    serviceLoaderTest(Service.class, ServiceImpl.class)
+        .addKeepMainRule(LoadWhereClassLoaderIsPhi.class)
+        .enableInliningAnnotations()
+        .allowDiagnosticInfoMessages(enableRewriting)
+        .compileWithExpectedDiagnostics(expectedDiagnostics)
+        .run(parameters.getRuntime(), LoadWhereClassLoaderIsPhi.class)
+        .assertSuccessWithOutputLines("Hello World!")
+        .inspect(
+            inspector -> {
+              assertEquals(1, getServiceLoaderLoads(inspector));
+              verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+            });
   }
 
   @Test
@@ -361,41 +336,18 @@
     // https://android-review.googlesource.com/c/platform/libcore/+/273135
     assumeTrue(
         parameters.getRuntime().isCf()
-            || !parameters.getRuntime().asDex().getVm().getVersion().equals(Version.V7_0_0));
-    Path path = temp.newFile("out.zip").toPath();
-    CodeInspector inspector =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(ServiceLoaderRewritingTest.class)
-            .addKeepMainRule(MainRunner.class)
-            .addKeepClassRules(Service.class)
-            .setMinApi(parameters)
-            .addKeepRules(
-                "-whyareyounotinlining class "
-                    + ServiceLoader.class.getTypeName()
-                    + " { *** load(...); }")
-            .enableExperimentalWhyAreYouNotInlining()
-            .addDataEntryResources(
-                DataEntryResource.fromBytes(
-                    StringUtils.lines(ServiceImpl.class.getTypeName()).getBytes(),
-                    "META-INF/services/" + Service.class.getTypeName(),
-                    Origin.unknown()))
-            .allowDiagnosticInfoMessages()
-            .compile()
-            .assertAllInfosMatch(
-                DiagnosticsMatcher.diagnosticType(ServiceLoaderRewriterDiagnostic.class))
-            .assertAtLeastOneInfoMessage()
-            .writeToZip(path)
-            .run(parameters.getRuntime(), MainRunner.class)
-            .assertSuccessWithOutput(EXPECTED_OUTPUT)
-            .inspector();
-
-    // Check that we have not rewritten the calls to ServiceLoader.load.
-    assertEquals(3, getServiceLoaderLoads(inspector));
-
-    // Check that we have not removed the service configuration from META-INF/services.
-    ZipFile zip = new ZipFile(path.toFile());
-    ClassSubject service = inspector.clazz(Service.class);
-    assertTrue(service.isPresent());
-    assertNotNull(zip.getEntry("META-INF/services/" + service.getFinalName()));
+            || !parameters.getRuntime().asDex().getVm().getVersion().equals(V7_0_0));
+    serviceLoaderTest(Service.class, ServiceImpl.class)
+        .addKeepMainRule(MainRunner.class)
+        .addKeepClassRules(Service.class)
+        .allowDiagnosticInfoMessages(enableRewriting)
+        .compileWithExpectedDiagnostics(expectedDiagnostics)
+        .run(parameters.getRuntime(), MainRunner.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT)
+        .inspect(
+            inspector -> {
+              assertEquals(3, getServiceLoaderLoads(inspector));
+              verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+            });
   }
 }
diff --git a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderRewritingWithAssumeNoSideEffectsTest.java b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderRewritingWithAssumeNoSideEffectsTest.java
new file mode 100644
index 0000000..c57f579
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderRewritingWithAssumeNoSideEffectsTest.java
@@ -0,0 +1,278 @@
+// 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.serviceloader;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.ServiceLoader;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ServiceLoaderRewritingWithAssumeNoSideEffectsTest extends ServiceLoaderTestBase {
+  private final String EXPECTED_OUTPUT = StringUtils.lines("Hello World!");
+
+  public interface Service {
+
+    void print();
+  }
+
+  public static class ServiceImpl implements Service {
+
+    @Override
+    public void print() {
+      System.out.println("Hello World!");
+    }
+  }
+
+  public static class ServiceImpl2 implements Service {
+
+    @Override
+    public void print() {
+      System.out.println("Hello World 2!");
+    }
+  }
+
+  public static class MainRunner {
+    public static void main(String[] args) {
+      ServiceLoader.load(Service.class, Service.class.getClassLoader()).iterator().next().print();
+    }
+  }
+
+  public static class HasNextRunner {
+    public static void main(String[] args) {
+      Iterator<Service> iterator =
+          ServiceLoader.load(Service.class, Service.class.getClassLoader()).iterator();
+      if (iterator.hasNext()) {
+        iterator.next().print();
+      }
+    }
+  }
+
+  public static class MultipleCallsRunner {
+    public static void main(String[] args) {
+      Iterator<Service> iterator =
+          ServiceLoader.load(Service.class, Service.class.getClassLoader()).iterator();
+      if (iterator.hasNext() && iterator.hasNext()) {
+        iterator.next().print();
+      }
+    }
+  }
+
+  public static class HasNextAfterNextRunner {
+    public static void main(String[] args) {
+      Iterator<Service> iterator =
+          ServiceLoader.load(Service.class, Service.class.getClassLoader()).iterator();
+
+      iterator.next().print();
+      if (iterator.hasNext()) {
+        System.out.println("not reached");
+      }
+    }
+  }
+
+  public static class HasNextAfterNextWithTryCatch {
+    public static void main(String[] args) {
+      try {
+        Iterator<Service> iterator =
+            ServiceLoader.load(Service.class, Service.class.getClassLoader()).iterator();
+
+        iterator.next().print();
+        if (iterator.hasNext()) {
+          System.out.println("not reached");
+        }
+      } catch (Throwable t) {
+        System.out.println("unreachable");
+      }
+    }
+  }
+
+  public static class LoopingRunner {
+    public static void main(String[] args) {
+      Iterator<Service> iterator =
+          ServiceLoader.load(Service.class, Service.class.getClassLoader()).iterator();
+      // Loop without a call to hasNext().
+      for (int i = System.currentTimeMillis() > 0 ? 0 : 1; i < 1; ++i) {
+        iterator.next().print();
+      }
+    }
+  }
+
+  public static class PhiRunner {
+    public static void main(String[] args) {
+      Iterator<Service> iterator =
+          System.currentTimeMillis() > 0
+              ? ServiceLoader.load(Service.class, Service.class.getClassLoader()).iterator()
+              : null;
+      iterator.next().print();
+    }
+  }
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public ServiceLoaderRewritingWithAssumeNoSideEffectsTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  private static void assertIteratorPresent(CodeInspector inspector, boolean expected) {
+    assertEquals(0, getServiceLoaderLoads(inspector));
+
+    boolean hasIteratorCall =
+        inspector
+            .streamInstructions()
+            .anyMatch(ins -> ins.isInvoke() && ins.getMethod().name.toString().equals("iterator"));
+    assertEquals(expected, hasIteratorCall);
+  }
+
+  private R8FullTestBuilder doTest(Class<?>... implClasses) throws IOException {
+    return serviceLoaderTest(Service.class, implClasses)
+        .addKeepRules("-assumenosideeffects class java.util.ServiceLoader { *** load(...); }");
+  }
+
+  @Test
+  public void testRewritingWithNoImplsHasNext()
+      throws IOException, CompilationFailedException, ExecutionException {
+    doTest()
+        .addKeepMainRule(HasNextRunner.class)
+        .compile()
+        .run(parameters.getRuntime(), HasNextRunner.class)
+        .assertSuccessWithOutput("")
+        .inspect(inspector -> assertIteratorPresent(inspector, false));
+  }
+
+  @Test
+  public void testRewritingWithMultiple()
+      throws IOException, CompilationFailedException, ExecutionException {
+    doTest(ServiceImpl.class, ServiceImpl2.class)
+        .addKeepMainRule(MainRunner.class)
+        .compile()
+        .run(parameters.getRuntime(), MainRunner.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT)
+        .inspect(
+            inspector -> {
+              assertIteratorPresent(inspector, false);
+              // ServiceImpl2 gets removed since next() is called only once.
+              verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+            });
+  }
+
+  @Test
+  public void testRewritingWithHasNext()
+      throws IOException, CompilationFailedException, ExecutionException {
+    doTest(ServiceImpl.class)
+        .addKeepMainRule(HasNextRunner.class)
+        .compile()
+        .run(parameters.getRuntime(), HasNextRunner.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT)
+        .inspect(
+            inspector -> {
+              assertIteratorPresent(inspector, false);
+              verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+            });
+  }
+
+  @Test
+  public void testDoNotRewriteMultipleCalls()
+      throws IOException, CompilationFailedException, ExecutionException {
+    doTest(ServiceImpl.class)
+        .addKeepMainRule(MultipleCallsRunner.class)
+        .compile()
+        .run(parameters.getRuntime(), MultipleCallsRunner.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT)
+        .inspect(
+            inspector -> {
+              assertIteratorPresent(inspector, true);
+              verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+            });
+  }
+
+  @Test
+  public void testDoNotRewriteHasNextAfterNext()
+      throws IOException, CompilationFailedException, ExecutionException {
+    doTest(ServiceImpl.class)
+        .addKeepMainRule(HasNextAfterNextRunner.class)
+        .compile()
+        .run(parameters.getRuntime(), HasNextAfterNextRunner.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT)
+        .inspect(
+            inspector -> {
+              assertIteratorPresent(inspector, true);
+              verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+            });
+  }
+
+  @Test
+  public void testDoNotRewriteHasNextAfterNextWithTryCatch()
+      throws IOException, CompilationFailedException, ExecutionException {
+    doTest(ServiceImpl.class)
+        .addKeepMainRule(HasNextAfterNextWithTryCatch.class)
+        .compile()
+        .run(parameters.getRuntime(), HasNextAfterNextWithTryCatch.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT)
+        .inspect(
+            inspector -> {
+              assertIteratorPresent(inspector, true);
+              verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+            });
+  }
+
+  @Test
+  public void testDoNotRewriteHasNextAfterNextBlocks()
+      throws IOException, CompilationFailedException, ExecutionException {
+    doTest(ServiceImpl.class)
+        .addKeepMainRule(HasNextAfterNextRunner.class)
+        .compile()
+        .run(parameters.getRuntime(), HasNextAfterNextRunner.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT)
+        .inspect(
+            inspector -> {
+              assertIteratorPresent(inspector, true);
+              verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+            });
+  }
+
+  @Test
+  public void testDoNotRewriteLoop()
+      throws IOException, CompilationFailedException, ExecutionException {
+    doTest(ServiceImpl.class)
+        .addKeepMainRule(LoopingRunner.class)
+        .compile()
+        .run(parameters.getRuntime(), LoopingRunner.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT)
+        .inspect(
+            inspector -> {
+              assertIteratorPresent(inspector, true);
+              verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+            });
+  }
+
+  @Test
+  public void testDoNotRewritePhiUser()
+      throws IOException, CompilationFailedException, ExecutionException {
+    doTest(ServiceImpl.class)
+        .addKeepMainRule(PhiRunner.class)
+        .compile()
+        .run(parameters.getRuntime(), PhiRunner.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT)
+        .inspect(
+            inspector -> {
+              assertIteratorPresent(inspector, true);
+              verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+            });
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderTestBase.java b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderTestBase.java
index 21276a2..809f782 100644
--- a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderTestBase.java
+++ b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceLoaderTestBase.java
@@ -4,38 +4,65 @@
 package com.android.tools.r8.optimize.serviceloader;
 
 import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethodWithName;
-import static junit.framework.TestCase.assertTrue;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.DataEntryResource;
+import com.android.tools.r8.DiagnosticsMatcher;
+import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestCompilerBuilder.DiagnosticsConsumer;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.graph.AppServices;
+import com.android.tools.r8.ir.optimize.ServiceLoaderRewriterDiagnostic;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.DataResourceConsumerForTesting;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
-import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.ImmutableMap;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 public class ServiceLoaderTestBase extends TestBase {
+  private static final DiagnosticsConsumer<CompilationFailedException> REWRITER_DIAGNOSTICS =
+      diagnostics ->
+          diagnostics
+              .assertOnlyInfos()
+              .assertAllInfosMatch(
+                  DiagnosticsMatcher.diagnosticType(ServiceLoaderRewriterDiagnostic.class));
+
+  protected final TestParameters parameters;
+  protected final boolean enableRewriting;
+  protected DataResourceConsumerForTesting dataResourceConsumer;
+  protected final DiagnosticsConsumer<CompilationFailedException> expectedDiagnostics;
+
+  public ServiceLoaderTestBase(TestParameters parameters) {
+    this(parameters, true);
+  }
+
+  public ServiceLoaderTestBase(TestParameters parameters, boolean enableRewriting) {
+    this.parameters = parameters;
+    this.enableRewriting = enableRewriting;
+    if (enableRewriting) {
+      expectedDiagnostics = REWRITER_DIAGNOSTICS;
+    } else {
+      expectedDiagnostics = diagnostics -> diagnostics.assertNoInfos();
+    }
+  }
 
   public static long getServiceLoaderLoads(CodeInspector inspector) {
-    return inspector.allClasses().stream()
-        .mapToLong(ServiceLoaderTestBase::getServiceLoaderLoads)
-        .reduce(0, Long::sum);
-  }
-
-  public static long getServiceLoaderLoads(CodeInspector inspector, Class<?> clazz) {
-    return getServiceLoaderLoads(inspector.clazz(clazz));
-  }
-
-  public static long getServiceLoaderLoads(ClassSubject classSubject) {
-    assertTrue(classSubject.isPresent());
-    return classSubject.allMethods(MethodSubject::hasCode).stream()
-        .mapToLong(
-            method ->
-                method
-                    .streamInstructions()
-                    .filter(ServiceLoaderTestBase::isServiceLoaderLoad)
-                    .count())
-        .sum();
+    return inspector
+        .streamInstructions()
+        .filter(ServiceLoaderTestBase::isServiceLoaderLoad)
+        .count();
   }
 
   private static boolean isServiceLoaderLoad(InstructionSubject instruction) {
@@ -43,22 +70,89 @@
         && instruction.getMethod().qualifiedName().contains("ServiceLoader.load");
   }
 
-  public void verifyNoClassLoaders(CodeInspector inspector) {
-    inspector.allClasses().forEach(this::verifyNoClassLoaders);
+  public static void verifyNoClassLoaders(CodeInspector inspector) {
+    inspector.allClasses().forEach(ServiceLoaderTestBase::verifyNoClassLoaders);
   }
 
-  public void verifyNoClassLoaders(ClassSubject classSubject) {
+  public static void verifyNoClassLoaders(ClassSubject classSubject) {
     assertTrue(classSubject.isPresent());
     classSubject.forAllMethods(
         method -> assertThat(method, not(invokesMethodWithName("getClassLoader"))));
   }
 
-  public void verifyNoServiceLoaderLoads(CodeInspector inspector) {
-    inspector.allClasses().forEach(this::verifyNoServiceLoaderLoads);
-  }
-
-  public void verifyNoServiceLoaderLoads(ClassSubject classSubject) {
+  public static void verifyNoServiceLoaderLoads(ClassSubject classSubject) {
     assertTrue(classSubject.isPresent());
     classSubject.forAllMethods(method -> assertThat(method, not(invokesMethodWithName("load"))));
   }
+
+  public Map<String, List<String>> getServiceMappings() {
+    return dataResourceConsumer.getAll().entrySet().stream()
+        .filter(e -> e.getKey().startsWith(AppServices.SERVICE_DIRECTORY_NAME))
+        .collect(
+            Collectors.toMap(
+                e -> e.getKey().substring(AppServices.SERVICE_DIRECTORY_NAME.length()),
+                e -> e.getValue()));
+  }
+
+  public void verifyServiceMetaInf(
+      CodeInspector inspector, Class<?> serviceClass, Class<?> serviceImplClass) {
+    // Account for renaming, and for the impl to be merged with the interface.
+    String finalServiceName = inspector.clazz(serviceClass).getFinalName();
+    String finalImplName = inspector.clazz(serviceImplClass).getFinalName();
+    if (finalServiceName == null) {
+      finalServiceName = finalImplName;
+    }
+    Map<String, List<String>> actual = getServiceMappings();
+    Map<String, List<String>> expected =
+        ImmutableMap.of(finalServiceName, Collections.singletonList(finalImplName));
+    assertEquals(expected, actual);
+  }
+
+  public void verifyServiceMetaInf(
+      CodeInspector inspector,
+      Class<?> serviceClass,
+      Class<?> serviceImplClass1,
+      Class<?> serviceImplClass2) {
+    // Account for renaming. No class merging should happen.
+    String finalServiceName = inspector.clazz(serviceClass).getFinalName();
+    String finalImplName1 = inspector.clazz(serviceImplClass1).getFinalName();
+    String finalImplName2 = inspector.clazz(serviceImplClass2).getFinalName();
+    Map<String, List<String>> actual = getServiceMappings();
+    Map<String, List<String>> expected =
+        ImmutableMap.of(finalServiceName, Arrays.asList(finalImplName1, finalImplName2));
+    assertEquals(expected, actual);
+  }
+
+  protected R8FullTestBuilder serviceLoaderTest(Class<?> serviceClass, Class<?>... implClasses)
+      throws IOException {
+    return serviceLoaderTestNoClasses(serviceClass, implClasses).addInnerClasses(getClass());
+  }
+
+  protected R8FullTestBuilder serviceLoaderTestNoClasses(
+      Class<?> serviceClass, Class<?>... implClasses) throws IOException {
+    R8FullTestBuilder ret =
+        testForR8(parameters.getBackend())
+            .setMinApi(parameters)
+            .addOptionsModification(
+                o -> {
+                  dataResourceConsumer = new DataResourceConsumerForTesting(o.dataResourceConsumer);
+                  o.dataResourceConsumer = dataResourceConsumer;
+                  o.enableServiceLoaderRewriting = enableRewriting;
+                })
+            // Enables ServiceLoader optimization failure diagnostics.
+            .enableExperimentalWhyAreYouNotInlining()
+            .addKeepRules("-whyareyounotinlining class java.util.ServiceLoader { *** load(...); }");
+    if (implClasses.length > 0) {
+      String implLines =
+          Arrays.stream(implClasses)
+              .map(c -> c.getTypeName() + "\n")
+              .collect(Collectors.joining(""));
+      ret.addDataEntryResources(
+          DataEntryResource.fromBytes(
+              implLines.getBytes(),
+              AppServices.SERVICE_DIRECTORY_NAME + serviceClass.getTypeName(),
+              Origin.unknown()));
+    }
+    return ret;
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceWithFeatureNullClassLoaderTest.java b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceWithFeatureNullClassLoaderTest.java
new file mode 100644
index 0000000..a815899
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceWithFeatureNullClassLoaderTest.java
@@ -0,0 +1,80 @@
+// 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.serviceloader;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.util.ServiceLoader;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ServiceWithFeatureNullClassLoaderTest extends ServiceLoaderTestBase {
+
+  public interface Service {
+
+    void print();
+  }
+
+  public static class ServiceImpl implements Service {
+
+    @Override
+    public void print() {
+      System.out.println("Hello World!");
+    }
+  }
+
+  public static class MainRunner {
+
+    public static void main(String[] args) {
+      run1();
+    }
+
+    @NeverInline
+    public static void run1() {
+      for (Service x : ServiceLoader.load(Service.class, null)) {
+        x.print();
+      }
+    }
+
+    @NeverInline
+    public static void checkNotNull(ClassLoader classLoader) {
+      if (classLoader == null) {
+        throw new NullPointerException("ClassLoader should not be null");
+      }
+    }
+  }
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+  }
+
+  public ServiceWithFeatureNullClassLoaderTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test
+  public void testNoRewritings() throws Exception {
+    R8TestCompileResult result =
+        serviceLoaderTestNoClasses(Service.class, ServiceImpl.class)
+            .addFeatureSplit(MainRunner.class, Service.class, ServiceImpl.class)
+            .enableInliningAnnotations()
+            .addKeepMainRule(MainRunner.class)
+            .allowDiagnosticInfoMessages()
+            .compileWithExpectedDiagnostics(expectedDiagnostics);
+
+    CodeInspector inspector = result.featureInspector();
+    assertEquals(getServiceLoaderLoads(inspector), 1);
+    // Check that we have not removed the service configuration from META-INF/services.
+    verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceWithFeatureTest.java b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceWithFeatureTest.java
new file mode 100644
index 0000000..34237e1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/optimize/serviceloader/ServiceWithFeatureTest.java
@@ -0,0 +1,77 @@
+// 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.serviceloader;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.util.ServiceLoader;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ServiceWithFeatureTest extends ServiceLoaderTestBase {
+
+  public interface Service {
+
+    void print();
+  }
+
+  public static class ServiceImpl implements Service {
+
+    @Override
+    public void print() {
+      System.out.println("Hello World!");
+    }
+  }
+
+  public static class MainRunner {
+
+    public static void main(String[] args) {
+      run1();
+    }
+
+    @NeverInline
+    public static void run1() {
+      ClassLoader classLoader = Service.class.getClassLoader();
+      checkNotNull(classLoader);
+      for (Service x : ServiceLoader.load(Service.class, classLoader)) {
+        x.print();
+      }
+    }
+
+    @NeverInline
+    public static void checkNotNull(ClassLoader classLoader) {
+      if (classLoader == null) {
+        throw new NullPointerException("ClassLoader should not be null");
+      }
+    }
+  }
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+  }
+
+  public ServiceWithFeatureTest(TestParameters parameters) {
+    super(parameters);
+  }
+
+  @Test
+  public void testRewritings() throws Exception {
+    serviceLoaderTestNoClasses(Service.class, ServiceImpl.class)
+        .addFeatureSplit(MainRunner.class, Service.class, ServiceImpl.class)
+        .enableInliningAnnotations()
+        .addKeepMainRule(MainRunner.class)
+        .compile()
+        .inspect(
+            inspector -> {},
+            inspector -> {
+              verifyNoServiceLoaderLoads(inspector.clazz(MainRunner.class));
+              verifyServiceMetaInf(inspector, Service.class, ServiceImpl.class);
+            });
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/regress/b165825758/Regress165825758Test.java b/src/test/java/com/android/tools/r8/regress/b165825758/Regress165825758Test.java
index 8f93035..4034d59 100644
--- a/src/test/java/com/android/tools/r8/regress/b165825758/Regress165825758Test.java
+++ b/src/test/java/com/android/tools/r8/regress/b165825758/Regress165825758Test.java
@@ -26,23 +26,22 @@
 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 Regress165825758Test extends TestBase {
 
-  static final String EXPECTED = StringUtils.lines("Hello, world");
+  private static final String EXPECTED = StringUtils.lines("Hello, world");
 
-  private final TestParameters parameters;
+  @Parameter(0)
+  public TestParameters parameters;
 
-  @Parameterized.Parameters(name = "{0}")
+  @Parameters(name = "{0}")
   public static TestParametersCollection data() {
     return getTestParameters().withAllRuntimesAndApiLevels().build();
   }
 
-  public Regress165825758Test(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
   @Test
   public void testReference() throws Exception {
     testForRuntime(parameters)
diff --git a/src/test/java/com/android/tools/r8/regress/b78493232/Regress78493232_WithPhi.java b/src/test/java/com/android/tools/r8/regress/b78493232/Regress78493232_WithPhi.java
index d052107..07b52af 100644
--- a/src/test/java/com/android/tools/r8/regress/b78493232/Regress78493232_WithPhi.java
+++ b/src/test/java/com/android/tools/r8/regress/b78493232/Regress78493232_WithPhi.java
@@ -10,6 +10,7 @@
 
 import com.android.tools.r8.AsmTestBase;
 import com.android.tools.r8.D8TestRunResult;
+import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
@@ -88,7 +89,7 @@
             .addProgramClasses(CLASSES)
             .addProgramClassFileData(CLASS_BYTES)
             .allowDiagnosticWarningMessages()
-            .treeShaking(treeShake)
+            .applyIf(!treeShake, R8FullTestBuilder::addDontShrink)
             .addDontObfuscate()
             .setMinApi(parameters)
             .addOptionsModification(options -> options.testing.readInputStackMaps = false)
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceLambdaTest.java b/src/test/java/com/android/tools/r8/retrace/RetraceLambdaTest.java
index eb871a6..e78aece 100644
--- a/src/test/java/com/android/tools/r8/retrace/RetraceLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceLambdaTest.java
@@ -98,7 +98,7 @@
         .addInnerClasses(getClass())
         .addKeepMainRule(Main.class)
         .addKeepPackageNamesRule(getClass().getPackage())
-        .noTreeShaking()
+        .addDontShrink()
         .addDontOptimize()
         .addKeepAttributeSourceFile()
         .addKeepAttributeLineNumberTable()
diff --git a/src/test/java/com/android/tools/r8/retrace/StackTraceWithPcAndJumboStringTestRunner.java b/src/test/java/com/android/tools/r8/retrace/StackTraceWithPcAndJumboStringTestRunner.java
index 25e7cc8..655a095 100644
--- a/src/test/java/com/android/tools/r8/retrace/StackTraceWithPcAndJumboStringTestRunner.java
+++ b/src/test/java/com/android/tools/r8/retrace/StackTraceWithPcAndJumboStringTestRunner.java
@@ -46,7 +46,7 @@
   public void testR8() throws Exception {
     testForR8(parameters.getBackend())
         .addProgramClasses(getTestClass())
-        .noTreeShaking()
+        .addDontShrink()
         .addKeepAttributeLineNumberTable()
         .addKeepMainRule(getTestClass())
         .setMinApi(parameters)
diff --git a/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTest.java b/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTest.java
index 045cc76..e954b79 100644
--- a/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTest.java
@@ -89,7 +89,7 @@
             // TODO(b/136633154): This should work both with and without -dontobfuscate.
             .addDontObfuscate()
             // TODO(b/136633154): This should work both with and without -dontshrink.
-            .noTreeShaking()
+            .addDontShrink()
             .compile()
             .applyIf(
                 parameters.isDexRuntime(),
diff --git a/src/test/java/com/android/tools/r8/rewrite/assertions/RemoveAssertionsTest.java b/src/test/java/com/android/tools/r8/rewrite/assertions/RemoveAssertionsTest.java
index e8bfc88..04a1132 100644
--- a/src/test/java/com/android/tools/r8/rewrite/assertions/RemoveAssertionsTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/assertions/RemoveAssertionsTest.java
@@ -197,7 +197,7 @@
     return testForR8(getStaticTemp(), Backend.CF)
         .addProgramClasses(ClassWithAssertions.class)
         .debug()
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .addAssertionsConfiguration(transformation)
         .compile();
@@ -221,7 +221,7 @@
         .addProgramClasses(ChromuimAssertionHookMock.class)
         .setMinApi(AndroidApiLevel.B)
         .debug()
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .setMinApi(minApi)
         .compile();
@@ -350,7 +350,7 @@
             .addProgramClasses(ClassWithAssertions.class)
             .debug()
             .setMinApi(minApi)
-            .noTreeShaking()
+            .addDontShrink()
             .addDontObfuscate()
             .compile()
             .writeToZip();
diff --git a/src/test/java/com/android/tools/r8/rewrite/staticvalues/inlibraries/StaticLibraryValuesChangeTest.java b/src/test/java/com/android/tools/r8/rewrite/staticvalues/inlibraries/StaticLibraryValuesChangeTest.java
index 7d2c4bc..906d8e4 100644
--- a/src/test/java/com/android/tools/r8/rewrite/staticvalues/inlibraries/StaticLibraryValuesChangeTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/staticvalues/inlibraries/StaticLibraryValuesChangeTest.java
@@ -85,7 +85,7 @@
             PreloadedClassFileProvider.fromClassData(
                 DescriptorUtils.javaTypeToDescriptor(LibraryClass.class.getName()),
                 compileTimeLibrary.buildClasses().get(0)))
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .compile()
         // Merge the compiled TestMain with the runtime version of LibraryClass.
diff --git a/src/test/java/com/android/tools/r8/shaking/FunctionTest.java b/src/test/java/com/android/tools/r8/shaking/FunctionTest.java
index eda629d..a5c498a 100644
--- a/src/test/java/com/android/tools/r8/shaking/FunctionTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/FunctionTest.java
@@ -42,7 +42,7 @@
   public void testR8Working() throws Exception {
     testForR8(parameters.getBackend())
         .addKeepMainRule(TestClass.class)
-        .noTreeShaking()
+        .addDontShrink()
         .addDontObfuscate()
         .enableInliningAnnotations()
         .addInnerClasses(FunctionTest.class)
diff --git a/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java b/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java
index 6ae395d..023b120 100644
--- a/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java
@@ -166,7 +166,7 @@
                     ToolHelper.getAppBuilder(b.getBuilder())
                         .addProgramFiles(Paths.get(programFile)))
             .enableProguardTestOptions()
-            .minification(minify.isMinify())
+            .addDontObfuscateUnless(minify.isMinify())
             .setMinApi(parameters)
             .addKeepRuleFiles(
                 ListUtils.map(
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
index 6af8bd4..82e9f74 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
@@ -102,7 +102,7 @@
             .addKeepRules(KEEP_ANNOTATIONS)
             .addKeepRules("-keep @interface " + ANNOTATION_NAME + " {", "  *;", "}")
             .allowDiagnosticWarningMessages()
-            .minification(minify)
+            .addDontObfuscateUnless(minify)
             .setMinApi(parameters)
             .compile()
             .assertAllWarningMessagesMatch(
@@ -143,7 +143,7 @@
                 "  java.lang.String *f2();",
                 "}")
             .allowDiagnosticWarningMessages()
-            .minification(minify)
+            .addDontObfuscateUnless(minify)
             .setMinApi(parameters)
             .compile()
             .assertAllWarningMessagesMatch(
@@ -181,7 +181,7 @@
             .addKeepMainRule(MAIN_CLASS_NAME)
             .addKeepRules(KEEP_ANNOTATIONS)
             .allowDiagnosticWarningMessages()
-            .minification(minify)
+            .addDontObfuscateUnless(minify)
             .setMinApi(parameters)
             .compile()
             .assertAllWarningMessagesMatch(
@@ -218,7 +218,7 @@
             .addProgramFiles(getJavaJarFile(FOLDER))
             .addKeepMainRule(MAIN_CLASS_NAME)
             .allowDiagnosticWarningMessages()
-            .minification(minify)
+            .addDontObfuscateUnless(minify)
             .setMinApi(parameters)
             .compile()
             .assertAllWarningMessagesMatch(
diff --git a/src/test/java/com/android/tools/r8/shaking/attributes/EnclosingMethodTest.java b/src/test/java/com/android/tools/r8/shaking/attributes/EnclosingMethodTest.java
index d93c615..971b408 100644
--- a/src/test/java/com/android/tools/r8/shaking/attributes/EnclosingMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/attributes/EnclosingMethodTest.java
@@ -95,7 +95,7 @@
         .addKeepMainRule(MAIN)
         .addKeepRules("-keep class **.GetName*")
         .addKeepRules("-keepattributes InnerClasses,EnclosingMethod")
-        .minification(enableMinification)
+        .addDontObfuscateUnless(enableMinification)
         .setMinApi(parameters)
         .run(parameters.getRuntime(), MAIN)
         .assertSuccessWithOutput(OUTPUT_WITH_SHRUNK_ATTRIBUTES);
diff --git a/src/test/java/com/android/tools/r8/shaking/attributes/InnerClassesSimpleTest.java b/src/test/java/com/android/tools/r8/shaking/attributes/InnerClassesSimpleTest.java
index 41de889..0af92c9 100644
--- a/src/test/java/com/android/tools/r8/shaking/attributes/InnerClassesSimpleTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/attributes/InnerClassesSimpleTest.java
@@ -40,7 +40,7 @@
             .addInnerClasses(getClass())
             .addKeepMainRule(Main.class)
             .addKeepPackageNamesRule(getClass().getPackage())
-            .noTreeShaking()
+            .addDontShrink()
             .applyIf(!minify, TestShrinkerBuilder::addDontObfuscate)
             .compile()
             .writeToZip();
diff --git a/src/test/java/com/android/tools/r8/shaking/attributes/MissingEnclosingMethodTest.java b/src/test/java/com/android/tools/r8/shaking/attributes/MissingEnclosingMethodTest.java
index 06e43a0..615f9cf 100644
--- a/src/test/java/com/android/tools/r8/shaking/attributes/MissingEnclosingMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/attributes/MissingEnclosingMethodTest.java
@@ -116,7 +116,7 @@
         .apply(config::addInnerClasses)
         .addKeepMainRule(DataClassUser.class)
         .addKeepAttributes("Signature", "InnerClasses", "EnclosingMethod")
-        .minification(enableMinification)
+        .addDontObfuscateUnless(enableMinification)
         .setMinApi(parameters)
         .run(parameters.getRuntime(), DataClassUser.class)
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/IfRuleWithFieldAnnotation.java b/src/test/java/com/android/tools/r8/shaking/ifrule/IfRuleWithFieldAnnotation.java
index 18d41dd..aff5d9d 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/IfRuleWithFieldAnnotation.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/IfRuleWithFieldAnnotation.java
@@ -94,7 +94,7 @@
         .addProgramClasses(Foo.class, Bar.class, SerializedName.class, FooNotCallingBar.class)
         .addDontWarn(getClass())
         .addKeepMainRule(FooNotCallingBar.class)
-        .noMinification()
+        .addDontObfuscate()
         .addKeepRules(CONDITIONAL_KEEP_RULE)
         .compile()
         .inspect(
@@ -113,7 +113,7 @@
         .addProgramClasses(Foo.class, Bar.class, SerializedName.class, FooNotCallingBar.class)
         .addDontWarn(getClass())
         .addKeepMainRule(FooNotCallingBar.class)
-        .noMinification()
+        .addDontObfuscate()
         .compile()
         .inspect(
             codeInspector -> {
diff --git a/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java
index 41f3dcc..2dd2b3f 100644
--- a/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java
@@ -178,7 +178,7 @@
         .enableInliningAnnotations()
         .enableNeverClassInliningAnnotations()
         .enableUnusedArgumentAnnotations()
-        .minification(enableMinification)
+        .addDontObfuscateUnless(enableMinification)
         .apply(this::configureKeepParameterNames)
         .compile()
         .inspect(this::checkLocalVariableTable)
@@ -217,7 +217,7 @@
         .enableUnusedArgumentAnnotations()
         .addInnerClasses(KeepParameterNamesTest.class)
         .addKeepMainRule(TestClass.class)
-        .minification(enableMinification)
+        .addDontObfuscateUnless(enableMinification)
         .apply(this::configureKeepParameterNames)
         .compile()
         .inspect(this::checkLocalVariableTableNotKept)
diff --git a/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java b/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java
index 1b75532..0865b95 100644
--- a/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/proxy/MockitoTest.java
@@ -52,7 +52,7 @@
             .addProgramFiles(MOCKITO_INTERFACE_JAR)
             .addKeepRuleFiles(flagToKeepTestRunner)
             .addDontWarn("org.mockito.**")
-            .minification(minify)
+            .addDontObfuscateUnless(minify)
             .setMinApi(parameters)
             .compile()
             .inspector();
@@ -71,7 +71,7 @@
             .addProgramFiles(MOCKITO_INTERFACE_JAR)
             .addKeepRuleFiles(flagToKeepInterfaceConditionally)
             .addDontWarn("org.mockito.**")
-            .minification(minify)
+            .addDontObfuscateUnless(minify)
             .setMinApi(parameters)
             .compile()
             .inspector();
diff --git a/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingOverriddenMethodTest.java b/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingOverriddenMethodTest.java
index 79c5edc..ba197fb 100644
--- a/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingOverriddenMethodTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/whyareyoukeeping/WhyAreYouKeepingOverriddenMethodTest.java
@@ -54,7 +54,7 @@
         .enableNeverClassInliningAnnotations()
         .enableInliningAnnotations()
         .enableNoVerticalClassMergingAnnotations()
-        .minification(minification)
+        .addDontObfuscateUnless(minification)
         .setMinApi(AndroidApiLevel.B)
         // Redirect the compilers stdout to intercept the '-whyareyoukeeping' output
         .collectStdout()
@@ -72,7 +72,7 @@
         .enableNeverClassInliningAnnotations()
         .enableInliningAnnotations()
         .enableNoVerticalClassMergingAnnotations()
-        .minification(minification)
+        .addDontObfuscateUnless(minification)
         .setMinApi(AndroidApiLevel.B)
         .setKeptGraphConsumer(graphConsumer)
         .compile();
diff --git a/src/test/java/com/android/tools/r8/utils/DataResourceConsumerForTesting.java b/src/test/java/com/android/tools/r8/utils/DataResourceConsumerForTesting.java
index 77274e6..dc2dfe8 100644
--- a/src/test/java/com/android/tools/r8/utils/DataResourceConsumerForTesting.java
+++ b/src/test/java/com/android/tools/r8/utils/DataResourceConsumerForTesting.java
@@ -54,6 +54,10 @@
   @Override
   public void finished(DiagnosticsHandler handler) {}
 
+  public Map<String, ImmutableList<String>> getAll() {
+    return resources;
+  }
+
   public ImmutableList<String> get(String name) {
     return resources.get(name);
   }
diff --git a/src/test/testbase/java/com/android/tools/r8/ProguardTestBuilder.java b/src/test/testbase/java/com/android/tools/r8/ProguardTestBuilder.java
index 758f1cf..275592f 100644
--- a/src/test/testbase/java/com/android/tools/r8/ProguardTestBuilder.java
+++ b/src/test/testbase/java/com/android/tools/r8/ProguardTestBuilder.java
@@ -110,12 +110,6 @@
       command.add(outJar.toString());
       command.add("-printmapping");
       command.add(mapFile.toString());
-      if (enableTreeShaking.isFalse()) {
-        command.add("-dontshrink");
-      }
-      if (enableMinification.isFalse()) {
-        command.add("-dontobfuscate");
-      }
       ProcessBuilder pbuilder = new ProcessBuilder(command);
       ProcessResult result = ToolHelper.runProcess(pbuilder, getStdoutForTesting());
       if (result.exitCode != 0) {
diff --git a/src/test/testbase/java/com/android/tools/r8/R8TestBuilder.java b/src/test/testbase/java/com/android/tools/r8/R8TestBuilder.java
index ecd1ea7..bf3998d 100644
--- a/src/test/testbase/java/com/android/tools/r8/R8TestBuilder.java
+++ b/src/test/testbase/java/com/android/tools/r8/R8TestBuilder.java
@@ -114,12 +114,6 @@
       builder.addProguardConfiguration(keepRules, Origin.unknown());
     }
     builder.addMainDexRulesFiles(mainDexRulesFiles);
-    if (enableTreeShaking.isFalse()) {
-      builder.setDisableTreeShaking(true);
-    }
-    if (enableMinification.isFalse()) {
-      builder.setDisableMinification(true);
-    }
     StringBuilder proguardMapBuilder = wrapProguardMapConsumer(builder);
     if (!applyMappingMaps.isEmpty()) {
       try {
diff --git a/src/test/testbase/java/com/android/tools/r8/R8TestCompileResult.java b/src/test/testbase/java/com/android/tools/r8/R8TestCompileResult.java
index f9db531..942cc92 100644
--- a/src/test/testbase/java/com/android/tools/r8/R8TestCompileResult.java
+++ b/src/test/testbase/java/com/android/tools/r8/R8TestCompileResult.java
@@ -140,6 +140,11 @@
         AndroidApp.builder().addProgramFile(feature).setProguardMapOutputData(proguardMap).build());
   }
 
+  public CodeInspector featureInspector() throws IOException {
+    assert features.size() == 1;
+    return featureInspector(features.get(0));
+  }
+
   @SafeVarargs
   public final <E extends Throwable> R8TestCompileResult inspect(
       ThrowingConsumer<CodeInspector, E>... consumers) throws IOException, E {
diff --git a/src/test/testbase/java/com/android/tools/r8/TestShrinkerBuilder.java b/src/test/testbase/java/com/android/tools/r8/TestShrinkerBuilder.java
index 57d2137..2dbe0e2 100644
--- a/src/test/testbase/java/com/android/tools/r8/TestShrinkerBuilder.java
+++ b/src/test/testbase/java/com/android/tools/r8/TestShrinkerBuilder.java
@@ -15,7 +15,6 @@
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.FileUtils;
-import com.android.tools.r8.utils.OptionalBool;
 import com.android.tools.r8.utils.StringUtils;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Sets;
@@ -35,9 +34,6 @@
         T extends TestShrinkerBuilder<C, B, CR, RR, T>>
     extends TestCompilerBuilder<C, B, CR, RR, T> {
 
-  protected OptionalBool enableTreeShaking = OptionalBool.UNKNOWN;
-  protected OptionalBool enableMinification = OptionalBool.UNKNOWN;
-
   private final Set<Class<? extends Annotation>> addedTestingAnnotations =
       Sets.newIdentityHashSet();
 
@@ -49,10 +45,6 @@
     return false;
   }
 
-  public boolean isR8TestBuilder() {
-    return false;
-  }
-
   public boolean isR8CompatTestBuilder() {
     return false;
   }
@@ -90,25 +82,6 @@
     return backend == Backend.DEX ? super.getMinApiLevel() : -1;
   }
 
-  public T treeShaking(boolean enable) {
-    enableTreeShaking = OptionalBool.of(enable);
-    return self();
-  }
-
-  public T noTreeShaking() {
-    return treeShaking(false);
-  }
-
-  public T minification(boolean enable) {
-    enableMinification = OptionalBool.of(enable);
-    return self();
-  }
-
-  @Deprecated
-  public T noMinification() {
-    return minification(false);
-  }
-
   public T addClassObfuscationDictionary(String... names) throws IOException {
     Path path = getState().getNewTempFolder().resolve("classobfuscationdictionary.txt");
     FileUtils.writeTextFile(path, StringUtils.join(" ", names));
@@ -140,6 +113,13 @@
             + clazz.getTypeName());
   }
 
+  public T addDontObfuscateUnless(boolean enableMinification) {
+    if (!enableMinification) {
+      return addDontObfuscate();
+    }
+    return self();
+  }
+
   public T addDontOptimize() {
     return addKeepRules("-dontoptimize");
   }
diff --git a/src/test/testbase/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java b/src/test/testbase/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
index 74bdc47..7c06d42 100644
--- a/src/test/testbase/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
+++ b/src/test/testbase/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
@@ -67,6 +67,7 @@
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class CodeInspector {
 
@@ -401,6 +402,12 @@
     return builder.build();
   }
 
+  public Stream<InstructionSubject> streamInstructions() {
+    return allClasses().stream()
+        .flatMap(cls -> cls.allMethods(MethodSubject::hasCode).stream())
+        .flatMap(MethodSubject::streamInstructions);
+  }
+
   public FieldSubject field(Field field) {
     return field(Reference.fieldFromField(field));
   }
diff --git a/src/test/testbase/java/com/android/tools/r8/utils/codeinspector/TypeSubject.java b/src/test/testbase/java/com/android/tools/r8/utils/codeinspector/TypeSubject.java
index efa2c30..1140771 100644
--- a/src/test/testbase/java/com/android/tools/r8/utils/codeinspector/TypeSubject.java
+++ b/src/test/testbase/java/com/android/tools/r8/utils/codeinspector/TypeSubject.java
@@ -41,6 +41,10 @@
     throw new Unreachable("Cannot determine if a type is synthetic");
   }
 
+  public boolean is(Class<?> clazz) {
+    return is(clazz.getTypeName());
+  }
+
   public boolean is(String type) {
     return dexType.equals(codeInspector.toDexType(type));
   }
diff --git a/tools/r8_release.py b/tools/r8_release.py
index 6090377..5e0f695 100755
--- a/tools/r8_release.py
+++ b/tools/r8_release.py
@@ -358,8 +358,9 @@
         message = f'DO NOT SUBMIT: {message}'
     if commit_info:
         message += f'\n\n{commit_info}'
+    message = message.replace("'", r"\'")
     return subprocess.check_output(
-        f"g4 change --desc '{message}\n'",
+        f"g4 change --desc $'{message}\n'",
         shell=True).decode('utf-8')