diff --git a/src/main/java/com/android/tools/r8/features/IsolatedFeatureSplitsChecker.java b/src/main/java/com/android/tools/r8/features/IsolatedFeatureSplitsChecker.java
new file mode 100644
index 0000000..ee3e64f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/features/IsolatedFeatureSplitsChecker.java
@@ -0,0 +1,174 @@
+// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.features;
+
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.FieldResolutionResult;
+import com.android.tools.r8.graph.FieldResolutionResult.SingleFieldResolutionResult;
+import com.android.tools.r8.graph.MethodResolutionResult;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.analysis.EnqueuerFieldAccessAnalysis;
+import com.android.tools.r8.graph.analysis.EnqueuerInvokeAnalysis;
+import com.android.tools.r8.graph.analysis.EnqueuerTypeAccessAnalysis;
+import com.android.tools.r8.shaking.Enqueuer;
+import com.android.tools.r8.shaking.EnqueuerWorklist;
+import com.android.tools.r8.utils.InternalOptions;
+
+// TODO(b/300247439): Also trace types referenced from new-array instructions, call sites, etc.
+public class IsolatedFeatureSplitsChecker
+    implements EnqueuerFieldAccessAnalysis, EnqueuerInvokeAnalysis, EnqueuerTypeAccessAnalysis {
+
+  @SuppressWarnings("UnusedVariable")
+  private final AppView<? extends AppInfoWithClassHierarchy> appView;
+
+  @SuppressWarnings("UnusedVariable")
+  private final Enqueuer enqueuer;
+
+  private IsolatedFeatureSplitsChecker(
+      AppView<? extends AppInfoWithClassHierarchy> appView, Enqueuer enqueuer) {
+    this.appView = appView;
+    this.enqueuer = enqueuer;
+  }
+
+  public static void register(
+      AppView<? extends AppInfoWithClassHierarchy> appView, Enqueuer enqueuer) {
+    if (enabled(appView, enqueuer)) {
+      IsolatedFeatureSplitsChecker checker = new IsolatedFeatureSplitsChecker(appView, enqueuer);
+      enqueuer
+          .registerFieldAccessAnalysis(checker)
+          .registerInvokeAnalysis(checker)
+          .registerTypeAccessAnalysis(checker);
+    }
+  }
+
+  private static boolean enabled(
+      AppView<? extends AppInfoWithClassHierarchy> appView, Enqueuer enqueuer) {
+    InternalOptions options = appView.options();
+    return options.hasFeatureSplitConfiguration()
+        && options.getFeatureSplitConfiguration().isIsolatedSplitsEnabled()
+        && enqueuer.getMode().isInitialTreeShaking();
+  }
+
+  @SuppressWarnings("UnusedVariable")
+  private void traceFieldAccess(FieldResolutionResult resolutionResult, ProgramMethod context) {
+    // TODO(b/300247439): Check access.
+  }
+
+  @SuppressWarnings("UnusedVariable")
+  private void traceMethodInvoke(MethodResolutionResult resolutionResult, ProgramMethod context) {
+    // TODO(b/300247439): Check access.
+  }
+
+  @SuppressWarnings("UnusedVariable")
+  private void traceTypeAccess(DexClass clazz, ProgramMethod context) {
+    // TODO(b/300247439): Check access.
+  }
+
+  // Field accesses.
+
+  @Override
+  public void traceInstanceFieldRead(
+      DexField field,
+      FieldResolutionResult resolutionResult,
+      ProgramMethod context,
+      EnqueuerWorklist worklist) {
+    traceFieldAccess(resolutionResult, context);
+  }
+
+  @Override
+  public void traceInstanceFieldWrite(
+      DexField field,
+      FieldResolutionResult resolutionResult,
+      ProgramMethod context,
+      EnqueuerWorklist worklist) {
+    traceFieldAccess(resolutionResult, context);
+  }
+
+  @Override
+  public void traceStaticFieldRead(
+      DexField field,
+      SingleFieldResolutionResult<?> resolutionResult,
+      ProgramMethod context,
+      EnqueuerWorklist worklist) {
+    traceFieldAccess(resolutionResult, context);
+  }
+
+  @Override
+  public void traceStaticFieldWrite(
+      DexField field,
+      FieldResolutionResult resolutionResult,
+      ProgramMethod context,
+      EnqueuerWorklist worklist) {
+    traceFieldAccess(resolutionResult, context);
+  }
+
+  // Method invokes.
+
+  @Override
+  public void traceInvokeStatic(
+      DexMethod invokedMethod, MethodResolutionResult resolutionResult, ProgramMethod context) {
+    traceMethodInvoke(resolutionResult, context);
+  }
+
+  @Override
+  public void traceInvokeDirect(
+      DexMethod invokedMethod, MethodResolutionResult resolutionResult, ProgramMethod context) {
+    traceMethodInvoke(resolutionResult, context);
+  }
+
+  @Override
+  public void traceInvokeInterface(
+      DexMethod invokedMethod, MethodResolutionResult resolutionResult, ProgramMethod context) {
+    traceMethodInvoke(resolutionResult, context);
+  }
+
+  @Override
+  public void traceInvokeSuper(
+      DexMethod invokedMethod, MethodResolutionResult resolutionResult, ProgramMethod context) {
+    traceMethodInvoke(resolutionResult, context);
+  }
+
+  @Override
+  public void traceInvokeVirtual(
+      DexMethod invokedMethod, MethodResolutionResult resolutionResult, ProgramMethod context) {
+    traceMethodInvoke(resolutionResult, context);
+  }
+
+  // Type accesses.
+
+  @Override
+  public void traceCheckCast(DexType type, DexClass clazz, ProgramMethod context) {
+    traceTypeAccess(clazz, context);
+  }
+
+  @Override
+  public void traceSafeCheckCast(DexType type, DexClass clazz, ProgramMethod context) {
+    traceTypeAccess(clazz, context);
+  }
+
+  @Override
+  public void traceConstClass(DexType type, DexClass clazz, ProgramMethod context) {
+    traceTypeAccess(clazz, context);
+  }
+
+  @Override
+  public void traceExceptionGuard(DexType type, DexClass clazz, ProgramMethod context) {
+    traceTypeAccess(clazz, context);
+  }
+
+  @Override
+  public void traceInstanceOf(DexType type, DexClass clazz, ProgramMethod context) {
+    traceTypeAccess(clazz, context);
+  }
+
+  @Override
+  public void traceNewInstance(DexType type, DexClass clazz, ProgramMethod context) {
+    traceTypeAccess(clazz, context);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerCheckCastAnalysis.java b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerCheckCastAnalysis.java
index ad0dcbf..1ff19a6 100644
--- a/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerCheckCastAnalysis.java
+++ b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerCheckCastAnalysis.java
@@ -4,12 +4,13 @@
 
 package com.android.tools.r8.graph.analysis;
 
+import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
 
 public interface EnqueuerCheckCastAnalysis {
 
-  void traceCheckCast(DexType type, ProgramMethod context);
+  void traceCheckCast(DexType type, DexClass clazz, ProgramMethod context);
 
-  void traceSafeCheckCast(DexType type, ProgramMethod context);
+  void traceSafeCheckCast(DexType type, DexClass clazz, ProgramMethod context);
 }
diff --git a/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerConstClassAnalysis.java b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerConstClassAnalysis.java
new file mode 100644
index 0000000..61f127a
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerConstClassAnalysis.java
@@ -0,0 +1,13 @@
+// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.graph.analysis;
+
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramMethod;
+
+public interface EnqueuerConstClassAnalysis {
+
+  void traceConstClass(DexType type, DexClass clazz, ProgramMethod context);
+}
diff --git a/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerExceptionGuardAnalysis.java b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerExceptionGuardAnalysis.java
index 1bf392e..752e4a5 100644
--- a/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerExceptionGuardAnalysis.java
+++ b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerExceptionGuardAnalysis.java
@@ -4,9 +4,10 @@
 
 package com.android.tools.r8.graph.analysis;
 
+import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
 
 public interface EnqueuerExceptionGuardAnalysis {
-  void traceExceptionGuard(DexType guard, ProgramMethod context);
+  void traceExceptionGuard(DexType guard, DexClass clazz, ProgramMethod context);
 }
diff --git a/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerFieldAccessAnalysis.java b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerFieldAccessAnalysis.java
index 0642216..69eb560 100644
--- a/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerFieldAccessAnalysis.java
+++ b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerFieldAccessAnalysis.java
@@ -18,28 +18,24 @@
       FieldResolutionResult resolutionResult,
       ProgramMethod context,
       EnqueuerWorklist worklist) {}
-  ;
 
   default void traceInstanceFieldWrite(
       DexField field,
       FieldResolutionResult resolutionResult,
       ProgramMethod context,
       EnqueuerWorklist worklist) {}
-  ;
 
   default void traceStaticFieldRead(
       DexField field,
       SingleFieldResolutionResult<?> resolutionResult,
       ProgramMethod context,
       EnqueuerWorklist worklist) {}
-  ;
 
   default void traceStaticFieldWrite(
       DexField field,
       FieldResolutionResult resolutionResult,
       ProgramMethod context,
       EnqueuerWorklist worklist) {}
-  ;
 
   /**
    * Called when the Enqueuer has reached the final fixpoint. Each analysis may use this callback to
diff --git a/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerInstanceOfAnalysis.java b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerInstanceOfAnalysis.java
index abda4d1..485a311 100644
--- a/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerInstanceOfAnalysis.java
+++ b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerInstanceOfAnalysis.java
@@ -4,9 +4,10 @@
 
 package com.android.tools.r8.graph.analysis;
 
+import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.ProgramMethod;
 
 public interface EnqueuerInstanceOfAnalysis {
-  void traceInstanceOf(DexType type, ProgramMethod context);
+  void traceInstanceOf(DexType type, DexClass clazz, ProgramMethod context);
 }
diff --git a/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerInvokeAnalysis.java b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerInvokeAnalysis.java
index d0a39b3..d2ca27d 100644
--- a/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerInvokeAnalysis.java
+++ b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerInvokeAnalysis.java
@@ -4,6 +4,7 @@
 package com.android.tools.r8.graph.analysis;
 
 import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.MethodResolutionResult;
 import com.android.tools.r8.graph.ProgramMethod;
 
 public interface EnqueuerInvokeAnalysis {
@@ -12,13 +13,18 @@
    * Each traceInvokeXX method is called when a corresponding invoke is found while tracing a live
    * method.
    */
-  void traceInvokeStatic(DexMethod invokedMethod, ProgramMethod context);
+  void traceInvokeStatic(
+      DexMethod invokedMethod, MethodResolutionResult resolutionResult, ProgramMethod context);
 
-  void traceInvokeDirect(DexMethod invokedMethod, ProgramMethod context);
+  void traceInvokeDirect(
+      DexMethod invokedMethod, MethodResolutionResult resolutionResult, ProgramMethod context);
 
-  void traceInvokeInterface(DexMethod invokedMethod, ProgramMethod context);
+  void traceInvokeInterface(
+      DexMethod invokedMethod, MethodResolutionResult resolutionResult, ProgramMethod context);
 
-  void traceInvokeSuper(DexMethod invokedMethod, ProgramMethod context);
+  void traceInvokeSuper(
+      DexMethod invokedMethod, MethodResolutionResult resolutionResult, ProgramMethod context);
 
-  void traceInvokeVirtual(DexMethod invokedMethod, ProgramMethod context);
+  void traceInvokeVirtual(
+      DexMethod invokedMethod, MethodResolutionResult resolutionResult, ProgramMethod context);
 }
diff --git a/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerNewInstanceAnalysis.java b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerNewInstanceAnalysis.java
new file mode 100644
index 0000000..880c91a
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerNewInstanceAnalysis.java
@@ -0,0 +1,13 @@
+// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.graph.analysis;
+
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramMethod;
+
+public interface EnqueuerNewInstanceAnalysis {
+
+  void traceNewInstance(DexType type, DexClass clazz, ProgramMethod context);
+}
diff --git a/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerTypeAccessAnalysis.java b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerTypeAccessAnalysis.java
new file mode 100644
index 0000000..3d44ef1
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/analysis/EnqueuerTypeAccessAnalysis.java
@@ -0,0 +1,11 @@
+// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.graph.analysis;
+
+public interface EnqueuerTypeAccessAnalysis
+    extends EnqueuerCheckCastAnalysis,
+        EnqueuerConstClassAnalysis,
+        EnqueuerExceptionGuardAnalysis,
+        EnqueuerInstanceOfAnalysis,
+        EnqueuerNewInstanceAnalysis {}
diff --git a/src/main/java/com/android/tools/r8/graph/analysis/InvokeVirtualToInterfaceVerifyErrorWorkaround.java b/src/main/java/com/android/tools/r8/graph/analysis/InvokeVirtualToInterfaceVerifyErrorWorkaround.java
index 94bf7ce..70fca76 100644
--- a/src/main/java/com/android/tools/r8/graph/analysis/InvokeVirtualToInterfaceVerifyErrorWorkaround.java
+++ b/src/main/java/com/android/tools/r8/graph/analysis/InvokeVirtualToInterfaceVerifyErrorWorkaround.java
@@ -8,6 +8,7 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.MethodResolutionResult;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.shaking.Enqueuer;
 import com.android.tools.r8.shaking.KeepInfo.Joiner;
@@ -53,7 +54,8 @@
   }
 
   @Override
-  public void traceInvokeVirtual(DexMethod invokedMethod, ProgramMethod context) {
+  public void traceInvokeVirtual(
+      DexMethod invokedMethod, MethodResolutionResult resolutionResult, ProgramMethod context) {
     if (isInterfaceInSomeApiLevel(invokedMethod.getHolderType())) {
       enqueuer.getKeepInfo().joinMethod(context, Joiner::disallowOptimization);
     }
@@ -69,22 +71,26 @@
   }
 
   @Override
-  public void traceInvokeDirect(DexMethod invokedMethod, ProgramMethod context) {
+  public void traceInvokeDirect(
+      DexMethod invokedMethod, MethodResolutionResult resolutionResult, ProgramMethod context) {
     // Intentionally empty.
   }
 
   @Override
-  public void traceInvokeInterface(DexMethod invokedMethod, ProgramMethod context) {
+  public void traceInvokeInterface(
+      DexMethod invokedMethod, MethodResolutionResult resolutionResult, ProgramMethod context) {
     // Intentionally empty.
   }
 
   @Override
-  public void traceInvokeStatic(DexMethod invokedMethod, ProgramMethod context) {
+  public void traceInvokeStatic(
+      DexMethod invokedMethod, MethodResolutionResult resolutionResult, ProgramMethod context) {
     // Intentionally empty.
   }
 
   @Override
-  public void traceInvokeSuper(DexMethod invokedMethod, ProgramMethod context) {
+  public void traceInvokeSuper(
+      DexMethod invokedMethod, MethodResolutionResult resolutionResult, ProgramMethod context) {
     // Intentionally empty.
   }
 }
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 ea7cbf5..b4f643a 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -27,6 +27,7 @@
 import com.android.tools.r8.errors.InterfaceDesugarMissingTypeDiagnostic;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.experimental.graphinfo.GraphConsumer;
+import com.android.tools.r8.features.IsolatedFeatureSplitsChecker;
 import com.android.tools.r8.graph.AccessControl;
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
@@ -90,10 +91,13 @@
 import com.android.tools.r8.graph.analysis.ApiModelAnalysis;
 import com.android.tools.r8.graph.analysis.EnqueuerAnalysis;
 import com.android.tools.r8.graph.analysis.EnqueuerCheckCastAnalysis;
+import com.android.tools.r8.graph.analysis.EnqueuerConstClassAnalysis;
 import com.android.tools.r8.graph.analysis.EnqueuerExceptionGuardAnalysis;
 import com.android.tools.r8.graph.analysis.EnqueuerFieldAccessAnalysis;
 import com.android.tools.r8.graph.analysis.EnqueuerInstanceOfAnalysis;
 import com.android.tools.r8.graph.analysis.EnqueuerInvokeAnalysis;
+import com.android.tools.r8.graph.analysis.EnqueuerNewInstanceAnalysis;
+import com.android.tools.r8.graph.analysis.EnqueuerTypeAccessAnalysis;
 import com.android.tools.r8.graph.analysis.GetArrayOfMissingTypeVerifyErrorWorkaround;
 import com.android.tools.r8.graph.analysis.InvokeVirtualToInterfaceVerifyErrorWorkaround;
 import com.android.tools.r8.graph.analysis.ResourceAccessAnalysis;
@@ -256,6 +260,8 @@
   private final Set<EnqueuerInstanceOfAnalysis> instanceOfAnalyses = new LinkedHashSet<>();
   private final Set<EnqueuerExceptionGuardAnalysis> exceptionGuardAnalyses = new LinkedHashSet<>();
   private final Set<EnqueuerCheckCastAnalysis> checkCastAnalyses = new LinkedHashSet<>();
+  private final Set<EnqueuerConstClassAnalysis> constClassAnalyses = new LinkedHashSet<>();
+  private final Set<EnqueuerNewInstanceAnalysis> newInstanceAnalyses = new LinkedHashSet<>();
 
   // Don't hold a direct pointer to app info (use appView).
   private AppInfoWithClassHierarchy appInfo;
@@ -508,6 +514,7 @@
       }
       appView.withGeneratedMessageLiteBuilderShrinker(
           shrinker -> registerAnalysis(shrinker.createEnqueuerAnalysis()));
+      IsolatedFeatureSplitsChecker.register(appView, this);
       ResourceAccessAnalysis.register(appView, this);
     }
 
@@ -585,11 +592,29 @@
     return this;
   }
 
+  public Enqueuer registerConstClassAnalysis(EnqueuerConstClassAnalysis analysis) {
+    constClassAnalyses.add(analysis);
+    return this;
+  }
+
   public Enqueuer registerExceptionGuardAnalysis(EnqueuerExceptionGuardAnalysis analysis) {
     exceptionGuardAnalyses.add(analysis);
     return this;
   }
 
+  public Enqueuer registerNewInstanceAnalysis(EnqueuerNewInstanceAnalysis analysis) {
+    newInstanceAnalyses.add(analysis);
+    return this;
+  }
+
+  public Enqueuer registerTypeAccessAnalysis(EnqueuerTypeAccessAnalysis analysis) {
+    return registerCheckCastAnalysis(analysis)
+        .registerConstClassAnalysis(analysis)
+        .registerExceptionGuardAnalysis(analysis)
+        .registerInstanceOfAnalysis(analysis)
+        .registerNewInstanceAnalysis(analysis);
+  }
+
   public void setAnnotationRemoverBuilder(AnnotationRemover.Builder annotationRemoverBuilder) {
     this.annotationRemoverBuilder = annotationRemoverBuilder;
   }
@@ -1227,23 +1252,23 @@
   }
 
   void traceCheckCast(DexType type, ProgramMethod currentMethod, boolean ignoreCompatRules) {
-    checkCastAnalyses.forEach(analysis -> analysis.traceCheckCast(type, currentMethod));
-    internalTraceConstClassOrCheckCast(type, currentMethod, ignoreCompatRules);
+    DexClass clazz = internalTraceConstClassOrCheckCast(type, currentMethod, ignoreCompatRules);
+    checkCastAnalyses.forEach(analysis -> analysis.traceCheckCast(type, clazz, currentMethod));
   }
 
   void traceSafeCheckCast(DexType type, ProgramMethod currentMethod) {
-    checkCastAnalyses.forEach(analysis -> analysis.traceSafeCheckCast(type, currentMethod));
-    internalTraceConstClassOrCheckCast(type, currentMethod, true);
+    DexClass clazz = internalTraceConstClassOrCheckCast(type, currentMethod, true);
+    checkCastAnalyses.forEach(analysis -> analysis.traceSafeCheckCast(type, clazz, currentMethod));
   }
 
-  @SuppressWarnings("ReferenceEquality")
   void traceConstClass(
       DexType type,
       ProgramMethod currentMethod,
       ListIterator<? extends CfOrDexInstruction> iterator,
       boolean ignoreCompatRules) {
     handleLockCandidate(type, currentMethod, iterator);
-    internalTraceConstClassOrCheckCast(type, currentMethod, ignoreCompatRules);
+    DexClass clazz = internalTraceConstClassOrCheckCast(type, currentMethod, ignoreCompatRules);
+    constClassAnalyses.forEach(analysis -> analysis.traceConstClass(type, clazz, currentMethod));
   }
 
   private void handleLockCandidate(
@@ -1298,18 +1323,21 @@
     return result;
   }
 
-  private void internalTraceConstClassOrCheckCast(
+  private DexClass internalTraceConstClassOrCheckCast(
       DexType type, ProgramMethod currentMethod, boolean ignoreCompatRules) {
-    DexProgramClass baseClass = resolveBaseType(type, currentMethod);
+    DexClass baseClass = resolveBaseType(type, currentMethod);
     traceTypeReference(type, currentMethod);
     if (!forceProguardCompatibility || ignoreCompatRules) {
-      return;
+      return baseClass;
     }
-    if (baseClass != null) {
+    if (baseClass != null && baseClass.isProgramClass()) {
       // Don't require any constructor, see b/112386012.
+      DexProgramClass baseProgramClass = baseClass.asProgramClass();
       markClassAsInstantiatedWithCompatRule(
-          baseClass, () -> graphReporter.reportCompatInstantiated(baseClass, currentMethod));
+          baseProgramClass,
+          () -> graphReporter.reportCompatInstantiated(baseProgramClass, currentMethod));
     }
+    return baseClass;
   }
 
   void traceRecordFieldValues(DexField[] fields, ProgramMethod currentMethod) {
@@ -1401,14 +1429,16 @@
   }
 
   void traceInstanceOf(DexType type, ProgramMethod currentMethod) {
-    instanceOfAnalyses.forEach(analysis -> analysis.traceInstanceOf(type, currentMethod));
-    resolveBaseType(type, currentMethod);
+    DexClass clazz = resolveBaseType(type, currentMethod);
     traceTypeReference(type, currentMethod);
+    instanceOfAnalyses.forEach(analysis -> analysis.traceInstanceOf(type, clazz, currentMethod));
   }
 
-  void traceExceptionGuard(DexType guard, ProgramMethod currentMethod) {
-    exceptionGuardAnalyses.forEach(analysis -> analysis.traceExceptionGuard(guard, currentMethod));
-    traceTypeReference(guard, currentMethod);
+  void traceExceptionGuard(DexType type, ProgramMethod currentMethod) {
+    DexClass clazz = resolveBaseType(type, currentMethod);
+    traceTypeReference(type, currentMethod);
+    exceptionGuardAnalyses.forEach(
+        analysis -> analysis.traceExceptionGuard(type, clazz, currentMethod));
   }
 
   void traceInvokeDirect(DexMethod invokedMethod, ProgramMethod context) {
@@ -1449,8 +1479,10 @@
         methodAccessInfoCollection::registerInvokeDirectInContext, invokedMethod, context)) {
       return;
     }
-    handleInvokeOfDirectTarget(invokedMethod, context, reason);
-    invokeAnalyses.forEach(analysis -> analysis.traceInvokeDirect(invokedMethod, context));
+    MethodResolutionResult resolutionResult =
+        handleInvokeOfDirectTarget(invokedMethod, context, reason);
+    invokeAnalyses.forEach(
+        analysis -> analysis.traceInvokeDirect(invokedMethod, resolutionResult, context));
   }
 
   void traceInvokeInterface(DexMethod invokedMethod, ProgramMethod context) {
@@ -1467,8 +1499,8 @@
         methodAccessInfoCollection::registerInvokeInterfaceInContext, method, context)) {
       return;
     }
-    markVirtualMethodAsReachable(method, true, context, keepReason);
-    invokeAnalyses.forEach(analysis -> analysis.traceInvokeInterface(method, context));
+    MethodResolutionResult result = markVirtualMethodAsReachable(method, true, context, keepReason);
+    invokeAnalyses.forEach(analysis -> analysis.traceInvokeInterface(method, result, context));
   }
 
   void traceInvokeStatic(DexMethod invokedMethod, ProgramMethod context) {
@@ -1505,8 +1537,10 @@
         methodAccessInfoCollection::registerInvokeStaticInContext, invokedMethod, context)) {
       return;
     }
-    handleInvokeOfStaticTarget(invokedMethod, context, reason);
-    invokeAnalyses.forEach(analysis -> analysis.traceInvokeStatic(invokedMethod, context));
+    MethodResolutionResult resolutionResult =
+        handleInvokeOfStaticTarget(invokedMethod, context, reason);
+    invokeAnalyses.forEach(
+        analysis -> analysis.traceInvokeStatic(invokedMethod, resolutionResult, context));
   }
 
   void traceInvokeSuper(DexMethod invokedMethod, ProgramMethod context) {
@@ -1517,7 +1551,6 @@
       return;
     }
     worklist.enqueueMarkReachableSuperAction(invokedMethod, context);
-    invokeAnalyses.forEach(analysis -> analysis.traceInvokeSuper(invokedMethod, context));
   }
 
   void traceInvokeVirtual(DexMethod invokedMethod, ProgramMethod context) {
@@ -1544,8 +1577,10 @@
         methodAccessInfoCollection::registerInvokeVirtualInContext, invokedMethod, context)) {
       return;
     }
-    markVirtualMethodAsReachable(invokedMethod, false, context, reason);
-    invokeAnalyses.forEach(analysis -> analysis.traceInvokeVirtual(invokedMethod, context));
+    MethodResolutionResult resolutionResult =
+        markVirtualMethodAsReachable(invokedMethod, false, context, reason);
+    invokeAnalyses.forEach(
+        analysis -> analysis.traceInvokeVirtual(invokedMethod, resolutionResult, context));
   }
 
   void traceNewInstance(DexType type, ProgramMethod context) {
@@ -1557,11 +1592,13 @@
       return;
     }
 
-    traceNewInstance(
-        type,
-        context,
-        InstantiationReason.NEW_INSTANCE_INSTRUCTION,
-        KeepReason.instantiatedIn(context));
+    DexClass clazz =
+        traceNewInstance(
+            type,
+            context,
+            InstantiationReason.NEW_INSTANCE_INSTRUCTION,
+            KeepReason.instantiatedIn(context));
+    newInstanceAnalyses.forEach(analysis -> analysis.traceNewInstance(type, clazz, context));
   }
 
   void traceNewInstanceFromLambda(DexType type, ProgramMethod context) {
@@ -1569,19 +1606,22 @@
         type, context, InstantiationReason.LAMBDA, KeepReason.invokedFromLambdaCreatedIn(context));
   }
 
-  private void traceNewInstance(
+  private DexClass traceNewInstance(
       DexType type,
       ProgramMethod context,
       InstantiationReason instantiationReason,
       KeepReason keepReason) {
-    DexProgramClass clazz = getProgramClassOrNull(type, context);
-    if (clazz != null) {
+    DexClass clazz = resolveBaseType(type, context);
+    if (clazz != null && clazz.isProgramClass()) {
+      DexProgramClass programClass = clazz.asProgramClass();
       if (clazz.isAnnotation() || clazz.isInterface()) {
-        markTypeAsLive(clazz, graphReporter.registerClass(clazz, keepReason));
+        markTypeAsLive(programClass, graphReporter.registerClass(programClass, keepReason));
       } else {
-        worklist.enqueueMarkInstantiatedAction(clazz, context, instantiationReason, keepReason);
+        worklist.enqueueMarkInstantiatedAction(
+            programClass, context, instantiationReason, keepReason);
       }
     }
+    return clazz;
   }
 
   void traceInstanceFieldRead(DexField field, ProgramMethod currentMethod) {
@@ -2347,13 +2387,12 @@
         appView, annotatedItem, annotation, isLive, annotatedKind, mode);
   }
 
-  private DexProgramClass resolveBaseType(DexType type, ProgramDefinition context) {
+  private DexClass resolveBaseType(DexType type, ProgramDefinition context) {
     if (type.isArrayType()) {
       return resolveBaseType(type.toBaseType(appView.dexItemFactory()), context);
     }
     if (type.isClassType()) {
-      DexProgramClass clazz =
-          asProgramClassOrNull(appView.definitionFor(type, context.getContextClass()));
+      DexClass clazz = appView.definitionFor(type, context.getContextClass());
       if (clazz != null) {
         checkAccess(clazz, context);
       }
@@ -2403,9 +2442,11 @@
         appInfo.resolveMethodLegacy(method, interfaceInvoke);
     methodResolutionResult.visitMethodResolutionResults(
         resolutionResult -> {
-          checkAccess(resolutionResult, context);
-          recordMethodReference(
-              method, resolutionResult.getResolutionPair().asProgramDerivedContext(context));
+          if (!resolutionResult.isArrayCloneMethodResult()) {
+            checkAccess(resolutionResult, context);
+            recordMethodReference(
+                method, resolutionResult.getResolutionPair().asProgramDerivedContext(context));
+          }
         },
         failedResolutionResult -> {
           markFailedMethodResolutionTargets(method, failedResolutionResult, context, reason);
@@ -2414,32 +2455,33 @@
     return methodResolutionResult;
   }
 
-  private void handleInvokeOfStaticTarget(
+  private MethodResolutionResult handleInvokeOfStaticTarget(
       DexMethod reference, ProgramDefinition context, KeepReason reason) {
-    resolveMethod(reference, context, reason)
-        .forEachMethodResolutionResult(
-            resolutionResult -> {
-              if (!resolutionResult.isSingleResolution()) {
-                return;
-              }
-              SingleResolutionResult<?> resolution = resolutionResult.asSingleResolution();
-              if (resolution.getResolvedHolder().isNotProgramClass()) {
-                return;
-              }
-              DexProgramClass clazz = resolution.getResolvedHolder().asProgramClass();
-              DexEncodedMethod encodedMethod = resolution.getResolvedMethod();
+    MethodResolutionResult resolutionResults = resolveMethod(reference, context, reason);
+    resolutionResults.forEachMethodResolutionResult(
+        resolutionResult -> {
+          if (!resolutionResult.isSingleResolution()) {
+            return;
+          }
+          SingleResolutionResult<?> resolution = resolutionResult.asSingleResolution();
+          if (resolution.getResolvedHolder().isNotProgramClass()) {
+            return;
+          }
+          DexProgramClass clazz = resolution.getResolvedHolder().asProgramClass();
+          DexEncodedMethod encodedMethod = resolution.getResolvedMethod();
 
-              // We have to mark the resolved method as targeted even if it cannot actually be
-              // invoked to make sure the invocation will keep failing in the appropriate way.
-              ProgramMethod method = new ProgramMethod(clazz, encodedMethod);
-              markMethodAsTargeted(method, reason);
+          // We have to mark the resolved method as targeted even if it cannot actually be
+          // invoked to make sure the invocation will keep failing in the appropriate way.
+          ProgramMethod method = new ProgramMethod(clazz, encodedMethod);
+          markMethodAsTargeted(method, reason);
 
-              // Only mark methods for which invocation will succeed at runtime live.
-              if (encodedMethod.isStatic()) {
-                markDirectAndIndirectClassInitializersAsLive(clazz);
-                markDirectStaticOrConstructorMethodAsLive(method, reason);
-              }
-            });
+          // Only mark methods for which invocation will succeed at runtime live.
+          if (encodedMethod.isStatic()) {
+            markDirectAndIndirectClassInitializersAsLive(clazz);
+            markDirectStaticOrConstructorMethodAsLive(method, reason);
+          }
+        });
+    return resolutionResults;
   }
 
   void markDirectAndIndirectClassInitializersAsLive(DexProgramClass clazz) {
@@ -2543,43 +2585,44 @@
     handleInvokeOfDirectTarget(method, context, reason);
   }
 
-  private void handleInvokeOfDirectTarget(
+  private MethodResolutionResult handleInvokeOfDirectTarget(
       DexMethod reference, ProgramDefinition context, KeepReason reason) {
-    resolveMethod(reference, context, reason)
-        .forEachMethodResolutionResult(
-            resolutionResult -> {
-              if (resolutionResult.isFailedResolution()) {
-                failedMethodResolutionTargets.add(reference);
-                return;
-              }
+    MethodResolutionResult resolutionResults = resolveMethod(reference, context, reason);
+    resolutionResults.forEachMethodResolutionResult(
+        resolutionResult -> {
+          if (resolutionResult.isFailedResolution()) {
+            failedMethodResolutionTargets.add(reference);
+            return;
+          }
 
-              if (!resolutionResult.isSingleResolution()
-                  || !resolutionResult.getResolvedHolder().isProgramClass()) {
-                return;
-              }
+          if (!resolutionResult.isSingleResolution()
+              || !resolutionResult.getResolvedHolder().isProgramClass()) {
+            return;
+          }
 
-              ProgramMethod resolvedMethod =
-                  resolutionResult.asSingleResolution().getResolvedProgramMethod();
+          ProgramMethod resolvedMethod =
+              resolutionResult.asSingleResolution().getResolvedProgramMethod();
 
-              // We have to mark the resolved method as targeted even if it cannot actually be
-              // invoked to make sure the invocation will keep failing in the appropriate way.
-              markMethodAsTargeted(resolvedMethod, reason);
+          // We have to mark the resolved method as targeted even if it cannot actually be
+          // invoked to make sure the invocation will keep failing in the appropriate way.
+          markMethodAsTargeted(resolvedMethod, reason);
 
-              // Only mark methods for which invocation will succeed at runtime live.
-              if (resolvedMethod.getAccessFlags().isStatic()) {
-                return;
-              }
+          // Only mark methods for which invocation will succeed at runtime live.
+          if (resolvedMethod.getAccessFlags().isStatic()) {
+            return;
+          }
 
-              markDirectStaticOrConstructorMethodAsLive(resolvedMethod, reason);
+          markDirectStaticOrConstructorMethodAsLive(resolvedMethod, reason);
 
-              // It is valid to have an invoke-direct instruction in a default interface method that
-              // targets another default method in the same interface. In a class, that would lead
-              // to a verification error. See also testInvokeSpecialToDefaultMethod.
-              if (resolvedMethod.getDefinition().isNonPrivateVirtualMethod()
-                  && virtualMethodsTargetedByInvokeDirect.add(resolvedMethod.getReference())) {
-                worklist.enqueueMarkMethodLiveAction(resolvedMethod, context, reason);
-              }
-            });
+          // It is valid to have an invoke-direct instruction in a default interface method that
+          // targets another default method in the same interface. In a class, that would lead
+          // to a verification error. See also testInvokeSpecialToDefaultMethod.
+          if (resolvedMethod.getDefinition().isNonPrivateVirtualMethod()
+              && virtualMethodsTargetedByInvokeDirect.add(resolvedMethod.getReference())) {
+            worklist.enqueueMarkMethodLiveAction(resolvedMethod, context, reason);
+          }
+        });
+    return resolutionResults;
   }
 
   private void ensureFromLibraryOrThrow(DexType type, DexLibraryClass context) {
@@ -3343,89 +3386,91 @@
     liveTypes.getItems().forEach(consumer);
   }
 
-  private void markVirtualMethodAsReachable(
+  private MethodResolutionResult markVirtualMethodAsReachable(
       DexMethod method, boolean interfaceInvoke, ProgramMethod context, KeepReason reason) {
-    if (method.holder.isArrayType()) {
+    MethodResolutionResult resolutionResults =
+        resolveMethod(method, context, reason, interfaceInvoke);
+    if (method.getHolderType().isArrayType()) {
       // This is an array type, so the actual class will be generated at runtime. We treat this
       // like an invoke on a direct subtype of java.lang.Object that has no further subtypes.
       // As it has no subtypes, it cannot affect liveness of the program we are processing.
       // Ergo, we can ignore it. We need to make sure that the element type is available, though.
-      markTypeAsLive(method.holder, context, reason);
-      return;
+      markTypeAsLive(method.getHolderType(), context, reason);
+      return resolutionResults;
     }
 
-    resolveMethod(method, context, reason, interfaceInvoke)
-        .forEachMethodResolutionResult(
-            resolutionResult -> {
-              if (!resolutionResult.isSingleResolution()) {
-                return;
-              }
-              SingleResolutionResult<?> resolution = resolutionResult.asSingleResolution();
-              // Note that all virtual methods derived from library methods are kept regardless of
-              // being reachable, so the following only needs to consider reachable targets in the
-              // program.
-              // TODO(b/70160030): Revise this to support tree shaking library methods on
-              //  non-escaping types.
-              DexProgramClass initialResolutionHolder =
-                  resolution.getInitialResolutionHolder().asProgramClass();
-              if (initialResolutionHolder == null) {
-                recordMethodReference(method, context);
-                return;
-              }
+    resolutionResults.forEachMethodResolutionResult(
+        resolutionResult -> {
+          if (!resolutionResult.isSingleResolution()) {
+            return;
+          }
+          SingleResolutionResult<?> resolution = resolutionResult.asSingleResolution();
+          // Note that all virtual methods derived from library methods are kept regardless of
+          // being reachable, so the following only needs to consider reachable targets in the
+          // program.
+          // TODO(b/70160030): Revise this to support tree shaking library methods on
+          //  non-escaping types.
+          DexProgramClass initialResolutionHolder =
+              resolution.getInitialResolutionHolder().asProgramClass();
+          if (initialResolutionHolder == null) {
+            recordMethodReference(method, context);
+            return;
+          }
 
-              if (resolution.getResolvedHolder().isNotProgramClass()) {
-                // TODO(b/70160030): If the resolution is on a library method, then the keep edge
-                //  needs to go directly to the target method in the program. Thus this method will
-                //  need to ensure that 'reason' is not already reported (eg, must be delayed /
-                //  non-witness) and report that for each possible target edge below.
-                return;
-              }
+          if (resolution.getResolvedHolder().isNotProgramClass()) {
+            // TODO(b/70160030): If the resolution is on a library method, then the keep edge
+            //  needs to go directly to the target method in the program. Thus this method will
+            //  need to ensure that 'reason' is not already reported (eg, must be delayed /
+            //  non-witness) and report that for each possible target edge below.
+            return;
+          }
 
-              DexProgramClass contextHolder = context.getContextClass();
-              // If the method has already been marked, just report the new reason for the resolved
-              // target and save the context to ensure correct lookup of virtual dispatch targets.
-              ResolutionSearchKey resolutionSearchKey =
-                  new ResolutionSearchKey(method, interfaceInvoke);
-              ProgramMethodSet seenContexts =
-                  getReachableVirtualTargets(initialResolutionHolder).get(resolutionSearchKey);
-              if (seenContexts != null) {
-                seenContexts.add(context);
-                graphReporter.registerMethod(resolution.getResolvedMethod(), reason);
-                return;
-              }
+          DexProgramClass contextHolder = context.getContextClass();
+          // If the method has already been marked, just report the new reason for the resolved
+          // target and save the context to ensure correct lookup of virtual dispatch targets.
+          ResolutionSearchKey resolutionSearchKey =
+              new ResolutionSearchKey(method, interfaceInvoke);
+          ProgramMethodSet seenContexts =
+              getReachableVirtualTargets(initialResolutionHolder).get(resolutionSearchKey);
+          if (seenContexts != null) {
+            seenContexts.add(context);
+            graphReporter.registerMethod(resolution.getResolvedMethod(), reason);
+            return;
+          }
 
-              // We have to mark the resolution targeted, even if it does not become live, we
-              // need at least an abstract version of it so that it can be targeted.
-              DexProgramClass resolvedHolder = resolution.getResolvedHolder().asProgramClass();
-              DexEncodedMethod resolvedMethod = resolution.getResolvedMethod();
-              markMethodAsTargeted(new ProgramMethod(resolvedHolder, resolvedMethod), reason);
-              if (resolution.isAccessibleForVirtualDispatchFrom(contextHolder, appView).isFalse()) {
-                // Not accessible from this context, so this call will cause a runtime exception.
-                return;
-              }
+          // We have to mark the resolution targeted, even if it does not become live, we
+          // need at least an abstract version of it so that it can be targeted.
+          DexProgramClass resolvedHolder = resolution.getResolvedHolder().asProgramClass();
+          DexEncodedMethod resolvedMethod = resolution.getResolvedMethod();
+          markMethodAsTargeted(new ProgramMethod(resolvedHolder, resolvedMethod), reason);
+          if (resolution.isAccessibleForVirtualDispatchFrom(contextHolder, appView).isFalse()) {
+            // Not accessible from this context, so this call will cause a runtime exception.
+            return;
+          }
 
-              // The method resolved and is accessible, so currently live overrides become live.
-              reachableVirtualTargets
-                  .computeIfAbsent(initialResolutionHolder, ignoreArgument(HashMap::new))
-                  .computeIfAbsent(resolutionSearchKey, ignoreArgument(ProgramMethodSet::create))
-                  .add(context);
+          // The method resolved and is accessible, so currently live overrides become live.
+          reachableVirtualTargets
+              .computeIfAbsent(initialResolutionHolder, ignoreArgument(HashMap::new))
+              .computeIfAbsent(resolutionSearchKey, ignoreArgument(ProgramMethodSet::create))
+              .add(context);
 
-              resolution
-                  .lookupVirtualDispatchTargets(
-                      contextHolder,
-                      appView,
-                      (type, subTypeConsumer, lambdaConsumer) ->
-                          objectAllocationInfoCollection.forEachInstantiatedSubType(
-                              type, subTypeConsumer, lambdaConsumer, appInfo),
-                      definition -> keepInfo.isPinned(definition, options, appInfo))
-                  .forEach(
-                      target ->
-                          markVirtualDispatchTargetAsLive(
-                              target,
-                              programMethod ->
-                                  graphReporter.reportReachableMethodAsLive(
-                                      resolvedMethod.getReference(), programMethod)));
-            });
+          resolution
+              .lookupVirtualDispatchTargets(
+                  contextHolder,
+                  appView,
+                  (type, subTypeConsumer, lambdaConsumer) ->
+                      objectAllocationInfoCollection.forEachInstantiatedSubType(
+                          type, subTypeConsumer, lambdaConsumer, appInfo),
+                  definition -> keepInfo.isPinned(definition, options, appInfo))
+              .forEach(
+                  target ->
+                      markVirtualDispatchTargetAsLive(
+                          target,
+                          programMethod ->
+                              graphReporter.reportReachableMethodAsLive(
+                                  resolvedMethod.getReference(), programMethod)));
+        });
+    return resolutionResults;
   }
 
   private void markVirtualDispatchTargetAsLive(
@@ -3542,54 +3587,56 @@
   }
 
   // Package protected due to entry point from worklist.
-  void markSuperMethodAsReachable(DexMethod reference, ProgramMethod from) {
-    KeepReason reason = KeepReason.targetedBySuperFrom(from);
-    resolveMethod(reference, from, reason)
-        .forEachMethodResolutionResult(
-            resolutionResult -> {
-              if (!resolutionResult.isSingleResolution()) {
-                return;
-              }
-              SingleResolutionResult<?> resolution = resolutionResult.asSingleResolution();
-              // If the resolution is in the program, mark it targeted.
-              if (resolution.getResolvedHolder().isProgramClass()) {
-                markMethodAsTargeted(
-                    new ProgramMethod(
-                        resolution.getResolvedHolder().asProgramClass(),
-                        resolution.getResolvedMethod()),
-                    reason);
-              }
-              // If invoke target is invalid (inaccessible or not an instance-method) record it and
-              // stop.
-              DexClassAndMethod target =
-                  resolution.lookupInvokeSuperTarget(from.getHolder(), appView);
-              if (target == null) {
-                failedMethodResolutionTargets.add(resolution.getResolvedMethod().getReference());
-                analyses.forEach(
-                    analyses ->
-                        analyses.notifyFailedMethodResolutionTarget(
-                            resolution.getResolvedMethod(), worklist));
-                return;
-              }
+  void markSuperMethodAsReachable(DexMethod reference, ProgramMethod context) {
+    KeepReason reason = KeepReason.targetedBySuperFrom(context);
+    MethodResolutionResult resolutionResults = resolveMethod(reference, context, reason);
+    resolutionResults.forEachMethodResolutionResult(
+        resolutionResult -> {
+          if (!resolutionResult.isSingleResolution()) {
+            return;
+          }
+          SingleResolutionResult<?> resolution = resolutionResult.asSingleResolution();
+          // If the resolution is in the program, mark it targeted.
+          if (resolution.getResolvedHolder().isProgramClass()) {
+            markMethodAsTargeted(
+                new ProgramMethod(
+                    resolution.getResolvedHolder().asProgramClass(),
+                    resolution.getResolvedMethod()),
+                reason);
+          }
+          // If invoke target is invalid (inaccessible or not an instance-method) record it and
+          // stop.
+          DexClassAndMethod target =
+              resolution.lookupInvokeSuperTarget(context.getHolder(), appView);
+          if (target == null) {
+            failedMethodResolutionTargets.add(resolution.getResolvedMethod().getReference());
+            analyses.forEach(
+                analyses ->
+                    analyses.notifyFailedMethodResolutionTarget(
+                        resolution.getResolvedMethod(), worklist));
+            return;
+          }
 
-              DexProgramClass clazz = target.getHolder().asProgramClass();
-              if (clazz == null) {
-                return;
-              }
+          DexProgramClass clazz = target.getHolder().asProgramClass();
+          if (clazz == null) {
+            return;
+          }
 
-              ProgramMethod method = target.asProgramMethod();
+          ProgramMethod method = target.asProgramMethod();
 
-              if (superInvokeDependencies
-                  .computeIfAbsent(from.getDefinition(), ignore -> ProgramMethodSet.create())
-                  .add(method)) {
-                if (liveMethods.contains(from)) {
-                  markMethodAsTargeted(method, KeepReason.invokedViaSuperFrom(from));
-                  if (!target.getAccessFlags().isAbstract()) {
-                    markVirtualMethodAsLive(method, KeepReason.invokedViaSuperFrom(from));
-                  }
-                }
+          if (superInvokeDependencies
+              .computeIfAbsent(context.getDefinition(), ignore -> ProgramMethodSet.create())
+              .add(method)) {
+            if (liveMethods.contains(context)) {
+              markMethodAsTargeted(method, KeepReason.invokedViaSuperFrom(context));
+              if (!target.getAccessFlags().isAbstract()) {
+                markVirtualMethodAsLive(method, KeepReason.invokedViaSuperFrom(context));
               }
-            });
+            }
+          }
+        });
+    invokeAnalyses.forEach(
+        analysis -> analysis.traceInvokeSuper(reference, resolutionResults, context));
   }
 
   // Returns the set of live types.
diff --git a/src/main/java/com/android/tools/r8/shaking/RuntimeTypeCheckInfo.java b/src/main/java/com/android/tools/r8/shaking/RuntimeTypeCheckInfo.java
index 5b6511d..045227d 100644
--- a/src/main/java/com/android/tools/r8/shaking/RuntimeTypeCheckInfo.java
+++ b/src/main/java/com/android/tools/r8/shaking/RuntimeTypeCheckInfo.java
@@ -5,6 +5,7 @@
 package com.android.tools.r8.shaking;
 
 import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
@@ -83,22 +84,22 @@
     }
 
     @Override
-    public void traceCheckCast(DexType type, ProgramMethod context) {
+    public void traceCheckCast(DexType type, DexClass clazz, ProgramMethod context) {
       add(type, checkCastTypes);
     }
 
     @Override
-    public void traceSafeCheckCast(DexType type, ProgramMethod context) {
+    public void traceSafeCheckCast(DexType type, DexClass clazz, ProgramMethod context) {
       // Intentionally empty.
     }
 
     @Override
-    public void traceInstanceOf(DexType type, ProgramMethod context) {
+    public void traceInstanceOf(DexType type, DexClass clazz, ProgramMethod context) {
       add(type, instanceOfTypes);
     }
 
     @Override
-    public void traceExceptionGuard(DexType guard, ProgramMethod context) {
+    public void traceExceptionGuard(DexType guard, DexClass clazz, ProgramMethod context) {
       add(guard, exceptionGuardTypes);
     }
 
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 b71ad68..40b2d19 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -223,6 +223,14 @@
     return false;
   }
 
+  public boolean hasFeatureSplitConfiguration() {
+    return featureSplitConfiguration != null;
+  }
+
+  public FeatureSplitConfiguration getFeatureSplitConfiguration() {
+    return featureSplitConfiguration;
+  }
+
   public boolean hasProguardConfiguration() {
     return proguardConfiguration != null;
   }