diff --git a/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/AbstractTransferFunction.java b/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/AbstractTransferFunction.java
index af7a836..a3013e3 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/AbstractTransferFunction.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/AbstractTransferFunction.java
@@ -4,19 +4,17 @@
 
 package com.android.tools.r8.ir.analysis.framework.intraprocedural;
 
-import com.android.tools.r8.ir.code.BasicBlock;
-import com.android.tools.r8.ir.code.Instruction;
-
 /**
  * A transfer function that defines the abstract semantics of the instructions in the program
  * according to some abstract state {@link StateType}.
  */
-public interface AbstractTransferFunction<StateType extends AbstractState<StateType>> {
+public interface AbstractTransferFunction<
+    Block, Instruction, StateType extends AbstractState<StateType>> {
 
   TransferFunctionResult<StateType> apply(Instruction instruction, StateType state);
 
   default StateType computeBlockEntryState(
-      BasicBlock block, BasicBlock predecessor, StateType predecessorExitState) {
+      Block block, Block predecessor, StateType predecessorExitState) {
     return predecessorExitState;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/ControlFlowGraph.java b/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/ControlFlowGraph.java
new file mode 100644
index 0000000..41fcd44
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/ControlFlowGraph.java
@@ -0,0 +1,42 @@
+// Copyright (c) 2022, 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.framework.intraprocedural;
+
+import com.android.tools.r8.utils.TraversalContinuation;
+import com.google.common.collect.Iterables;
+import java.util.Collection;
+import java.util.function.BiFunction;
+
+public interface ControlFlowGraph<Block, Instruction> {
+
+  Collection<Block> getPredecessors(Block block);
+
+  Collection<Block> getSuccessors(Block block);
+
+  default boolean hasUniquePredecessor(Block block) {
+    return getPredecessors(block).size() == 1;
+  }
+
+  default Block getUniquePredecessor(Block block) {
+    assert hasUniquePredecessor(block);
+    return Iterables.getOnlyElement(getPredecessors(block));
+  }
+
+  default boolean hasUniqueSuccessor(Block block) {
+    return getSuccessors(block).size() == 1;
+  }
+
+  default boolean hasUniqueSuccessorWithUniquePredecessor(Block block) {
+    return hasUniqueSuccessor(block) && getPredecessors(getUniqueSuccessor(block)).size() == 1;
+  }
+
+  default Block getUniqueSuccessor(Block block) {
+    assert hasUniqueSuccessor(block);
+    return Iterables.getOnlyElement(getSuccessors(block));
+  }
+
+  <T> TraversalContinuation<T> traverseInstructions(
+      Block block, BiFunction<Instruction, T, TraversalContinuation<T>> fn, T initialValue);
+}
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 a8a1832..8974bbf 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
@@ -24,8 +24,8 @@
     return false;
   }
 
-  public <StateType extends AbstractState<StateType>>
-      SuccessfulDataflowAnalysisResult<StateType> asSuccessfulAnalysisResult() {
+  public <Block, StateType extends AbstractState<StateType>>
+      SuccessfulDataflowAnalysisResult<Block, StateType> asSuccessfulAnalysisResult() {
     return null;
   }
 
@@ -33,12 +33,13 @@
     return false;
   }
 
-  public static class SuccessfulDataflowAnalysisResult<StateType extends AbstractState<StateType>>
+  public static class SuccessfulDataflowAnalysisResult<
+          Block, StateType extends AbstractState<StateType>>
       extends DataflowAnalysisResult {
 
-    private final Map<BasicBlock, StateType> blockExitStates;
+    private final Map<Block, StateType> blockExitStates;
 
-    public SuccessfulDataflowAnalysisResult(Map<BasicBlock, StateType> blockExitStates) {
+    public SuccessfulDataflowAnalysisResult(Map<Block, StateType> blockExitStates) {
       this.blockExitStates = blockExitStates;
     }
 
@@ -57,7 +58,7 @@
 
     @SuppressWarnings("unchecked")
     @Override
-    public SuccessfulDataflowAnalysisResult<StateType> asSuccessfulAnalysisResult() {
+    public SuccessfulDataflowAnalysisResult<Block, StateType> asSuccessfulAnalysisResult() {
       return this;
     }
   }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/IntraProceduralDataflowAnalysisBase.java b/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/IntraProceduralDataflowAnalysisBase.java
new file mode 100644
index 0000000..9b015d2
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/IntraProceduralDataflowAnalysisBase.java
@@ -0,0 +1,147 @@
+// Copyright (c) 2022, 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.framework.intraprocedural;
+
+import com.android.tools.r8.ir.analysis.framework.intraprocedural.DataflowAnalysisResult.FailedDataflowAnalysisResult;
+import com.android.tools.r8.ir.analysis.framework.intraprocedural.DataflowAnalysisResult.SuccessfulDataflowAnalysisResult;
+import com.android.tools.r8.utils.Timing;
+import com.android.tools.r8.utils.TraversalContinuation;
+import com.android.tools.r8.utils.WorkList;
+import java.util.IdentityHashMap;
+import java.util.Map;
+
+/**
+ * This defines a simple fixpoint solver for running an intraprocedural dataflow analysis.
+ *
+ * <p>The solver computes an {@link AbstractState} for each {@link Block} using the {@link
+ * AbstractTransferFunction} which defines the abstract semantics for each instruction.
+ *
+ * <p>Once the fixpoint is reached the analysis returns a {@link SuccessfulDataflowAnalysisResult}.
+ * If the supplied {@link AbstractTransferFunction} returns a {@link FailedTransferFunctionResult}
+ * for a given instruction and abstract state, then the analysis return a {@link
+ * FailedDataflowAnalysisResult}.
+ */
+public class IntraProceduralDataflowAnalysisBase<
+    Block, Instruction, StateType extends AbstractState<StateType>> {
+
+  final StateType bottom;
+
+  final ControlFlowGraph<Block, Instruction> cfg;
+
+  // The transfer function that defines the abstract semantics for each instruction.
+  final AbstractTransferFunction<Block, Instruction, StateType> transfer;
+
+  // The state of the analysis.
+  final Map<Block, StateType> blockExitStates = new IdentityHashMap<>();
+
+  // The entry states for each block that satisfies the predicate
+  // shouldCacheBlockEntryStateFor(block). These entry states can be computed from the exit states
+  // of the predecessors, but doing so can be expensive when a block has many predecessors.
+  final Map<Block, StateType> blockEntryStatesCache = new IdentityHashMap<>();
+
+  public IntraProceduralDataflowAnalysisBase(
+      StateType bottom,
+      ControlFlowGraph<Block, Instruction> cfg,
+      AbstractTransferFunction<Block, Instruction, StateType> transfer) {
+    this.bottom = bottom;
+    this.cfg = cfg;
+    this.transfer = transfer;
+  }
+
+  public DataflowAnalysisResult run(Block root) {
+    return run(root, Timing.empty());
+  }
+
+  public DataflowAnalysisResult run(Block root, Timing timing) {
+    return run(WorkList.newIdentityWorkList(root), timing);
+  }
+
+  private DataflowAnalysisResult run(WorkList<Block> worklist, Timing timing) {
+    while (worklist.hasNext()) {
+      Block initialBlock = worklist.next();
+      Block block = initialBlock;
+      Block end = null;
+      // Compute the abstract state upon entry to the basic block, by joining all the predecessor
+      // exit states.
+      StateType state =
+          timing.time("Compute block entry state", () -> computeBlockEntryState(initialBlock));
+
+      timing.begin("Compute transfers");
+      do {
+        TraversalContinuation<StateType> traversalContinuation =
+            cfg.traverseInstructions(
+                block,
+                (instruction, previousState) -> {
+                  TransferFunctionResult<StateType> transferResult =
+                      transfer.apply(instruction, previousState);
+                  if (transferResult.isFailedTransferResult()) {
+                    timing.end();
+                    return TraversalContinuation.doBreak();
+                  }
+                  assert transferResult.isAbstractState();
+                  return TraversalContinuation.doContinue(transferResult.asAbstractState());
+                },
+                state);
+        if (traversalContinuation.isBreak()) {
+          return new FailedDataflowAnalysisResult();
+        }
+        state = traversalContinuation.getValue();
+        if (cfg.hasUniqueSuccessorWithUniquePredecessor(block)) {
+          block = cfg.getUniqueSuccessor(block);
+        } else {
+          end = block;
+          block = null;
+        }
+      } while (block != null);
+      timing.end();
+
+      // Update the block exit state, and re-enqueue all successor blocks if the abstract state
+      // changed.
+      if (setBlockExitState(end, state)) {
+        worklist.addAllIgnoringSeenSet(cfg.getSuccessors(end));
+      }
+
+      // Add the computed exit state to the entry state of each successor that satisfies the
+      // predicate shouldCacheBlockEntryStateFor(successor).
+      updateBlockEntryStateCacheForSuccessors(end, state);
+    }
+    return new SuccessfulDataflowAnalysisResult<>(blockExitStates);
+  }
+
+  StateType computeBlockEntryState(Block block) {
+    if (shouldCacheBlockEntryStateFor(block)) {
+      return blockEntryStatesCache.getOrDefault(block, bottom);
+    }
+    StateType result = bottom;
+    for (Block predecessor : cfg.getPredecessors(block)) {
+      StateType edgeState =
+          transfer.computeBlockEntryState(
+              block, predecessor, blockExitStates.getOrDefault(predecessor, bottom));
+      result = result.join(edgeState);
+    }
+    return result;
+  }
+
+  boolean setBlockExitState(Block block, StateType state) {
+    assert !cfg.hasUniqueSuccessorWithUniquePredecessor(block);
+    StateType previous = blockExitStates.put(block, state);
+    assert previous == null || state.isGreaterThanOrEquals(previous);
+    return !state.equals(previous);
+  }
+
+  void updateBlockEntryStateCacheForSuccessors(Block block, StateType state) {
+    for (Block successor : cfg.getSuccessors(block)) {
+      if (shouldCacheBlockEntryStateFor(successor)) {
+        StateType edgeState = transfer.computeBlockEntryState(successor, block, state);
+        StateType previous = blockEntryStatesCache.getOrDefault(successor, bottom);
+        blockEntryStatesCache.put(successor, previous.join(edgeState));
+      }
+    }
+  }
+
+  boolean shouldCacheBlockEntryStateFor(Block block) {
+    return cfg.getPredecessors(block).size() > 2;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/IntraproceduralDataflowAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/IntraproceduralDataflowAnalysis.java
index 4f00ef0..13a9c42 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/IntraproceduralDataflowAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/framework/intraprocedural/IntraproceduralDataflowAnalysis.java
@@ -4,130 +4,17 @@
 
 package com.android.tools.r8.ir.analysis.framework.intraprocedural;
 
-import com.android.tools.r8.ir.analysis.framework.intraprocedural.DataflowAnalysisResult.FailedDataflowAnalysisResult;
-import com.android.tools.r8.ir.analysis.framework.intraprocedural.DataflowAnalysisResult.SuccessfulDataflowAnalysisResult;
 import com.android.tools.r8.ir.code.BasicBlock;
+import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Instruction;
-import com.android.tools.r8.utils.Timing;
-import com.android.tools.r8.utils.WorkList;
-import java.util.IdentityHashMap;
-import java.util.Map;
 
-/**
- * This defines a simple fixpoint solver for running an intraprocedural dataflow analysis.
- *
- * <p>The solver computes an {@link AbstractState} for each {@link BasicBlock} using the {@link
- * AbstractTransferFunction} which defines the abstract semantics for each instruction.
- *
- * <p>Once the fixpoint is reached the analysis returns a {@link SuccessfulDataflowAnalysisResult}.
- * If the supplied {@link AbstractTransferFunction} returns a {@link FailedTransferFunctionResult}
- * for a given instruction and abstract state, then the analysis return a {@link
- * FailedDataflowAnalysisResult}.
- */
-public class IntraproceduralDataflowAnalysis<StateType extends AbstractState<StateType>> {
-
-  private final StateType bottom;
-
-  // The transfer function that defines the abstract semantics for each instruction.
-  private final AbstractTransferFunction<StateType> transfer;
-
-  // The state of the analysis.
-  private final Map<BasicBlock, StateType> blockExitStates = new IdentityHashMap<>();
-
-  // The entry states for each block that satisfies the predicate
-  // shouldCacheBlockEntryStateFor(block). These entry states can be computed from the exit states
-  // of the predecessors, but doing so can be expensive when a block has many predecessors.
-  private final Map<BasicBlock, StateType> blockEntryStatesCache = new IdentityHashMap<>();
+public class IntraproceduralDataflowAnalysis<StateType extends AbstractState<StateType>>
+    extends IntraProceduralDataflowAnalysisBase<BasicBlock, Instruction, StateType> {
 
   public IntraproceduralDataflowAnalysis(
-      StateType bottom, AbstractTransferFunction<StateType> transfer) {
-    this.bottom = bottom;
-    this.transfer = transfer;
-  }
-
-  public DataflowAnalysisResult run(BasicBlock root) {
-    return run(root, Timing.empty());
-  }
-
-  public DataflowAnalysisResult run(BasicBlock root, Timing timing) {
-    return run(WorkList.newIdentityWorkList(root), timing);
-  }
-
-  private DataflowAnalysisResult run(WorkList<BasicBlock> worklist, Timing timing) {
-    while (worklist.hasNext()) {
-      BasicBlock initialBlock = worklist.next();
-      BasicBlock block = initialBlock;
-      BasicBlock end = null;
-      // Compute the abstract state upon entry to the basic block, by joining all the predecessor
-      // exit states.
-      StateType state =
-          timing.time("Compute block entry state", () -> computeBlockEntryState(initialBlock));
-
-      timing.begin("Compute transfers");
-      do {
-        for (Instruction instruction : block.getInstructions()) {
-          TransferFunctionResult<StateType> transferResult = transfer.apply(instruction, state);
-          if (transferResult.isFailedTransferResult()) {
-            timing.end();
-            return new FailedDataflowAnalysisResult();
-          }
-          assert transferResult.isAbstractState();
-          state = transferResult.asAbstractState();
-        }
-        if (block.hasUniqueSuccessorWithUniquePredecessor()) {
-          block = block.getUniqueSuccessor();
-        } else {
-          end = block;
-          block = null;
-        }
-      } while (block != null);
-      timing.end();
-
-      // Update the block exit state, and re-enqueue all successor blocks if the abstract state
-      // changed.
-      if (setBlockExitState(end, state)) {
-        worklist.addAllIgnoringSeenSet(end.getSuccessors());
-      }
-
-      // Add the computed exit state to the entry state of each successor that satisfies the
-      // predicate shouldCacheBlockEntryStateFor(successor).
-      updateBlockEntryStateCacheForSuccessors(end, state);
-    }
-    return new SuccessfulDataflowAnalysisResult<>(blockExitStates);
-  }
-
-  private StateType computeBlockEntryState(BasicBlock block) {
-    if (shouldCacheBlockEntryStateFor(block)) {
-      return blockEntryStatesCache.getOrDefault(block, bottom);
-    }
-    StateType result = bottom;
-    for (BasicBlock predecessor : block.getPredecessors()) {
-      StateType edgeState =
-          transfer.computeBlockEntryState(
-              block, predecessor, blockExitStates.getOrDefault(predecessor, bottom));
-      result = result.join(edgeState);
-    }
-    return result;
-  }
-
-  private boolean setBlockExitState(BasicBlock block, StateType state) {
-    assert !block.hasUniqueSuccessorWithUniquePredecessor();
-    StateType previous = blockExitStates.put(block, state);
-    assert previous == null || state.isGreaterThanOrEquals(previous);
-    return !state.equals(previous);
-  }
-
-  private void updateBlockEntryStateCacheForSuccessors(BasicBlock block, StateType state) {
-    for (BasicBlock successor : block.getSuccessors()) {
-      if (shouldCacheBlockEntryStateFor(successor)) {
-        StateType edgeState = transfer.computeBlockEntryState(successor, block, state);
-        StateType previous = blockEntryStatesCache.getOrDefault(successor, bottom);
-        blockEntryStatesCache.put(successor, previous.join(edgeState));
-      }
-    }
-  }
-
-  private boolean shouldCacheBlockEntryStateFor(BasicBlock block) {
-    return block.getPredecessors().size() > 2;
+      StateType bottom,
+      IRCode code,
+      AbstractTransferFunction<BasicBlock, Instruction, StateType> transfer) {
+    super(bottom, code, transfer);
   }
 }
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 01b08a8..a67618b 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
@@ -16,6 +16,7 @@
 import com.android.tools.r8.graph.classmerging.MergedClassesCollection;
 import com.android.tools.r8.ir.analysis.TypeChecker;
 import com.android.tools.r8.ir.analysis.VerifyTypesHelper;
+import com.android.tools.r8.ir.analysis.framework.intraprocedural.ControlFlowGraph;
 import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
 import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
@@ -33,6 +34,7 @@
 import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.SetUtils;
 import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.TraversalContinuation;
 import com.android.tools.r8.utils.WorkList;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
@@ -55,13 +57,14 @@
 import java.util.NoSuchElementException;
 import java.util.Queue;
 import java.util.Set;
+import java.util.function.BiFunction;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-public class IRCode implements ValueFactory {
+public class IRCode implements ControlFlowGraph<BasicBlock, Instruction>, ValueFactory {
 
   private static final int MAX_MARKING_COLOR = 0x40000000;
 
@@ -1363,6 +1366,29 @@
     return blocks;
   }
 
+  @Override
+  public Collection<BasicBlock> getPredecessors(BasicBlock block) {
+    return block.getPredecessors();
+  }
+
+  @Override
+  public Collection<BasicBlock> getSuccessors(BasicBlock block) {
+    return block.getSuccessors();
+  }
+
+  @Override
+  public <T> TraversalContinuation<T> traverseInstructions(
+      BasicBlock block, BiFunction<Instruction, T, TraversalContinuation<T>> fn, T initialValue) {
+    TraversalContinuation<T> traversalContinuation = TraversalContinuation.doContinue(initialValue);
+    for (Instruction instruction : block.getInstructions()) {
+      traversalContinuation = fn.apply(instruction, traversalContinuation.getValue());
+      if (traversalContinuation.shouldBreak()) {
+        return traversalContinuation;
+      }
+    }
+    return traversalContinuation;
+  }
+
   /**
    * Returns the set of blocks that are reachable from the given source. The source itself is only
    * included if there is a path from the given block to itself.
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/ClassInlinerMethodConstraintAnalysis.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/ClassInlinerMethodConstraintAnalysis.java
index 854188e..f45344f 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/ClassInlinerMethodConstraintAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/ClassInlinerMethodConstraintAnalysis.java
@@ -26,8 +26,8 @@
     // Analyze code.
     IntraproceduralDataflowAnalysis<ParameterUsages> analysis =
         new IntraproceduralDataflowAnalysis<>(
-            ParameterUsages.bottom(), new TransferFunction(appView, method, code));
-    SuccessfulDataflowAnalysisResult<ParameterUsages> result =
+            ParameterUsages.bottom(), code, new TransferFunction(appView, method, code));
+    SuccessfulDataflowAnalysisResult<?, ParameterUsages> result =
         timing.time(
             "Data flow analysis",
             () -> analysis.run(code.entryBlock(), timing).asSuccessfulAnalysisResult());
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/TransferFunction.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/TransferFunction.java
index 65c05e6..0e4a8dd 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/TransferFunction.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/analysis/TransferFunction.java
@@ -52,7 +52,8 @@
 import com.google.common.collect.Sets;
 import java.util.Set;
 
-class TransferFunction implements AbstractTransferFunction<ParameterUsages> {
+class TransferFunction
+    implements AbstractTransferFunction<BasicBlock, Instruction, ParameterUsages> {
 
   private static final AliasedValueConfiguration aliasedValueConfiguration =
       AssumeAndCheckCastAliasedValueConfiguration.getInstance();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderAppendFlowAnalysis.java b/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderAppendFlowAnalysis.java
index 80066f3..1179c6d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderAppendFlowAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderAppendFlowAnalysis.java
@@ -12,6 +12,7 @@
 import com.android.tools.r8.ir.analysis.framework.intraprocedural.IntraproceduralDataflowAnalysis;
 import com.android.tools.r8.ir.analysis.framework.intraprocedural.TransferFunctionResult;
 import com.android.tools.r8.ir.code.BasicBlock;
+import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InvokeMethod;
 import com.android.tools.r8.ir.code.InvokeVirtual;
@@ -39,10 +40,10 @@
    * loop.
    */
   static boolean hasAppendInstructionInLoop(
-      Value builder, StringBuilderOptimizationConfiguration configuration) {
+      IRCode code, Value builder, StringBuilderOptimizationConfiguration configuration) {
     IntraproceduralDataflowAnalysis<AbstractStateImpl> analysis =
         new IntraproceduralDataflowAnalysis<>(
-            AbstractStateImpl.bottom(), new TransferFunction(builder, configuration));
+            AbstractStateImpl.bottom(), code, new TransferFunction(builder, configuration));
     DataflowAnalysisResult result = analysis.run(builder.definition.getBlock());
     return result.isFailedAnalysisResult();
   }
@@ -121,7 +122,8 @@
    * <p>If a call to {@code toString()} on the builder i seen, then the abstract state is reset to
    * bottom.
    */
-  private static class TransferFunction implements AbstractTransferFunction<AbstractStateImpl> {
+  private static class TransferFunction
+      implements AbstractTransferFunction<BasicBlock, Instruction, AbstractStateImpl> {
 
     private final Value builder;
     private final StringBuilderOptimizationConfiguration configuration;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizer.java
index b851f1e..7e0b884 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizer.java
@@ -722,7 +722,7 @@
         return null;
       }
       if (StringBuilderAppendFlowAnalysis.hasAppendInstructionInLoop(
-          builder, optimizationConfiguration)) {
+          code, builder, optimizationConfiguration)) {
         return null;
       }
       return StringUtils.join("", contents);