diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index a7d57b1..c56ea8a 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -821,7 +821,7 @@
     if (whyAreYouKeepingConsumer != null) {
       for (DexReference reference : rootSet.reasonAsked) {
         whyAreYouKeepingConsumer.printWhyAreYouKeeping(
-            enqueuer.getGraphNode(reference), System.out);
+            enqueuer.getGraphReporter().getGraphNode(reference), System.out);
       }
     }
     if (rootSet.checkDiscarded.isEmpty()
@@ -851,7 +851,8 @@
       if (!failed.isEmpty()) {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         whyAreYouKeepingConsumer.printWhyAreYouKeeping(
-            enqueuer.getGraphNode(definition.toReference()), new PrintStream(baos));
+            enqueuer.getGraphReporter().getGraphNode(definition.toReference()),
+            new PrintStream(baos));
         options.reporter.info(
             new StringDiagnostic(
                 "Item " + definition.toSourceString() + " was not discarded.\n" + baos.toString()));
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 57ed2d3..fd9a75f 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -12,17 +12,8 @@
 
 import com.android.tools.r8.Diagnostic;
 import com.android.tools.r8.dex.IndexedItemCollection;
-import com.android.tools.r8.errors.Unimplemented;
 import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.experimental.graphinfo.AnnotationGraphNode;
-import com.android.tools.r8.experimental.graphinfo.ClassGraphNode;
-import com.android.tools.r8.experimental.graphinfo.FieldGraphNode;
 import com.android.tools.r8.experimental.graphinfo.GraphConsumer;
-import com.android.tools.r8.experimental.graphinfo.GraphEdgeInfo;
-import com.android.tools.r8.experimental.graphinfo.GraphEdgeInfo.EdgeKind;
-import com.android.tools.r8.experimental.graphinfo.GraphNode;
-import com.android.tools.r8.experimental.graphinfo.KeepRuleGraphNode;
-import com.android.tools.r8.experimental.graphinfo.MethodGraphNode;
 import com.android.tools.r8.graph.AppInfoWithSubtyping;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.Descriptor;
@@ -58,24 +49,19 @@
 import com.android.tools.r8.ir.code.InvokeMethod;
 import com.android.tools.r8.ir.code.InvokeVirtual;
 import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
 import com.android.tools.r8.ir.desugar.LambdaDescriptor;
 import com.android.tools.r8.logging.Log;
 import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.references.TypeReference;
 import com.android.tools.r8.shaking.EnqueuerWorklist.Action;
+import com.android.tools.r8.shaking.GraphReporter.KeepReasonWitness;
 import com.android.tools.r8.shaking.RootSetBuilder.ConsequentRootSet;
 import com.android.tools.r8.shaking.RootSetBuilder.RootSet;
 import com.android.tools.r8.shaking.ScopedDexMethodSet.AddMethodIfMoreVisibleResult;
-import com.android.tools.r8.utils.DequeUtils;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.SetUtils;
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.android.tools.r8.utils.Timing;
 import com.google.common.base.Equivalence.Wrapper;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableList.Builder;
 import com.google.common.collect.ImmutableSortedSet;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
@@ -84,7 +70,6 @@
 import it.unimi.dsi.fastutil.objects.Object2BooleanMap;
 import java.lang.reflect.InvocationHandler;
 import java.util.ArrayDeque;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.Deque;
 import java.util.HashMap;
@@ -164,14 +149,6 @@
 
   private final Set<DexReference> identifierNameStrings = Sets.newIdentityHashSet();
 
-  // Canonicalization of external graph-nodes and edge info.
-  private final Map<DexItem, AnnotationGraphNode> annotationNodes = new IdentityHashMap<>();
-  private final Map<DexType, ClassGraphNode> classNodes = new IdentityHashMap<>();
-  private final Map<DexMethod, MethodGraphNode> methodNodes = new IdentityHashMap<>();
-  private final Map<DexField, FieldGraphNode> fieldNodes = new IdentityHashMap<>();
-  private final Map<ProguardKeepRuleBase, KeepRuleGraphNode> ruleNodes = new IdentityHashMap<>();
-  private final Map<EdgeKind, GraphEdgeInfo> reasonInfo = new IdentityHashMap<>();
-
   /**
    * Set of method signatures used in invoke-super instructions that either cannot be resolved or
    * resolve to a private method (leading to an IllegalAccessError).
@@ -199,7 +176,7 @@
    * Set of types that are mentioned in the program. We at least need an empty abstract class item
    * for these.
    */
-  private final SetWithReason<DexProgramClass> liveTypes = new SetWithReason<>(this::registerClass);
+  private final SetWithReason<DexProgramClass> liveTypes;
 
   /** Set of live types defined in the library and classpath. Used to avoid duplicate tracing. */
   private final Set<DexClass> liveNonProgramTypes = Sets.newIdentityHashSet();
@@ -213,12 +190,10 @@
   private final Set<DexType> skippedProtoExtensionTypes = Sets.newIdentityHashSet();
 
   /** Set of annotation types that are instantiated. */
-  private final SetWithReason<DexAnnotation> liveAnnotations =
-      new SetWithReason<>(this::registerAnnotation);
+  private final SetWithReason<DexAnnotation> liveAnnotations;
 
   /** Set of types that are actually instantiated. These cannot be abstract. */
-  private final SetWithReason<DexProgramClass> instantiatedTypes =
-      new SetWithReason<>(this::registerClass);
+  private final SetWithReason<DexProgramClass> instantiatedTypes;
 
   /** Set of all types that are instantiated, directly or indirectly, thus may be abstract. */
   private final Set<DexProgramClass> directAndIndirectlyInstantiatedTypes =
@@ -229,8 +204,7 @@
    * are required so that invokes can find the method. If a method is only a target but not live,
    * its implementation may be removed and it may be marked abstract.
    */
-  private final SetWithReason<DexEncodedMethod> targetedMethods =
-      new SetWithReason<>(this::registerMethod);
+  private final SetWithReason<DexEncodedMethod> targetedMethods;
   /**
    * Set of program methods that are used as the bootstrap method for an invoke-dynamic instruction.
    */
@@ -251,14 +225,12 @@
    * Set of methods that belong to live classes and can be reached by invokes. These need to be
    * kept.
    */
-  private final SetWithReason<DexEncodedMethod> liveMethods =
-      new SetWithReason<>(this::registerMethod);
+  private final SetWithReason<DexEncodedMethod> liveMethods;
 
   /**
    * Set of fields that belong to live classes and can be reached by invokes. These need to be kept.
    */
-  private final SetWithReason<DexEncodedField> liveFields =
-      new SetWithReason<>(this::registerField);
+  private final SetWithReason<DexEncodedField> liveFields;
 
   /**
    * Set of service types (from META-INF/services/) that may have been instantiated reflectively via
@@ -270,8 +242,7 @@
    * Set of interface types for which there may be instantiations, such as lambda expressions or
    * explicit keep rules.
    */
-  private final SetWithReason<DexProgramClass> instantiatedInterfaceTypes =
-      new SetWithReason<>(this::registerInterface);
+  private final SetWithReason<DexProgramClass> instantiatedInterfaceTypes;
 
   /** A queue of items that need processing. Different items trigger different actions. */
   private final EnqueuerWorklist workList;
@@ -314,8 +285,6 @@
       new IdentityHashMap<>();
 
   private final GraphReporter graphReporter;
-  private final GraphConsumer keptGraphConsumer;
-  private CollectingGraphConsumer verificationGraphConsumer = null;
 
   Enqueuer(
       AppView<? extends AppInfoWithSubtyping> appView,
@@ -326,8 +295,7 @@
     this.appInfo = appView.appInfo();
     this.appView = appView;
     this.forceProguardCompatibility = options.forceProguardCompatibility;
-    this.graphReporter = new GraphReporter();
-    this.keptGraphConsumer = recordKeptGraph(options, keptGraphConsumer);
+    this.graphReporter = new GraphReporter(appView, keptGraphConsumer);
     this.mode = mode;
     this.options = options;
     this.workList = EnqueuerWorklist.createWorklist(appView);
@@ -335,12 +303,24 @@
     if (options.enableGeneratedMessageLiteShrinking && mode.isInitialOrFinalTreeShaking()) {
       registerAnalysis(new ProtoEnqueuerExtension(appView));
     }
+
+    liveTypes = new SetWithReason<>(graphReporter::registerClass);
+    liveAnnotations = new SetWithReason<>(graphReporter::registerAnnotation);
+    instantiatedTypes = new SetWithReason<>(graphReporter::registerClass);
+    targetedMethods = new SetWithReason<>(graphReporter::registerMethod);
+    liveMethods = new SetWithReason<>(graphReporter::registerMethod);
+    liveFields = new SetWithReason<>(graphReporter::registerField);
+    instantiatedInterfaceTypes = new SetWithReason<>(graphReporter::registerInterface);
   }
 
   public Mode getMode() {
     return mode;
   }
 
+  public GraphReporter getGraphReporter() {
+    return graphReporter;
+  }
+
   public Enqueuer registerAnalysis(EnqueuerAnalysis analysis) {
     this.analyses.add(analysis);
     return this;
@@ -1315,7 +1295,7 @@
 
   private void registerClassInitializer(DexProgramClass definition, KeepReason reason) {
     if (definition.hasClassInitializer()) {
-      registerMethod(definition.getClassInitializer(), reason);
+      graphReporter.registerMethod(definition.getClassInitializer(), reason);
     }
   }
 
@@ -1850,7 +1830,7 @@
     MarkedResolutionTarget resolution = virtualTargetsMarkedAsReachable.get(method);
     if (resolution != null) {
       if (!resolution.isUnresolved()) {
-        registerMethod(resolution.method, reason);
+        graphReporter.registerMethod(resolution.method, reason);
       }
       return;
     }
@@ -2126,47 +2106,15 @@
     return createAppInfo(appInfo);
   }
 
-  private GraphConsumer recordKeptGraph(InternalOptions options, GraphConsumer consumer) {
-    if (options.testing.verifyKeptGraphInfo) {
-      verificationGraphConsumer = new CollectingGraphConsumer(consumer);
-      return verificationGraphConsumer;
-    }
-    return consumer;
-  }
-
-  private boolean verifyKeptGraph() {
-    if (options.testing.verifyKeptGraphInfo) {
-      assert verificationGraphConsumer != null;
-      for (DexProgramClass liveType : liveTypes.items) {
-        assert verifyRootedPath(liveType, verificationGraphConsumer);
+  public boolean verifyKeptGraph() {
+    if (appView.options().testing.verifyKeptGraphInfo) {
+      for (DexProgramClass liveType : liveTypes.getItems()) {
+        assert graphReporter.verifyRootedPath(liveType);
       }
     }
     return true;
   }
 
-  private boolean verifyRootedPath(DexProgramClass liveType, CollectingGraphConsumer graph) {
-    ClassGraphNode node = getClassGraphNode(liveType.type);
-    Set<GraphNode> seen = Sets.newIdentityHashSet();
-    Deque<GraphNode> targets = DequeUtils.newArrayDeque(node);
-    while (!targets.isEmpty()) {
-      GraphNode item = targets.pop();
-      if (item instanceof KeepRuleGraphNode) {
-        KeepRuleGraphNode rule = (KeepRuleGraphNode) item;
-        if (rule.getPreconditions().isEmpty()) {
-          return true;
-        }
-      }
-      if (seen.add(item)) {
-        Map<GraphNode, Set<GraphEdgeInfo>> sources = graph.getSourcesTargeting(item);
-        assert sources != null : "No sources set for " + item;
-        assert !sources.isEmpty() : "Empty sources set for " + item;
-        targets.addAll(sources.keySet());
-      }
-    }
-    assert false : "No rooted path to " + liveType.type;
-    return true;
-  }
-
   private AppInfoWithLiveness createAppInfo(AppInfoWithSubtyping appInfo) {
     ImmutableSortedSet.Builder<DexType> builder =
         ImmutableSortedSet.orderedBy(PresortedComparable::slowCompareTo);
@@ -2921,7 +2869,7 @@
     }
   }
 
-  private static class MarkedResolutionTarget {
+  public static class MarkedResolutionTarget {
 
     private static final MarkedResolutionTarget UNRESOLVED = new MarkedResolutionTarget(null, null);
 
@@ -3120,402 +3068,4 @@
     }
   }
 
-  class GraphReporter {
-
-    private EdgeKind reportPrecondition(KeepRuleGraphNode keepRuleGraphNode) {
-      if (keepRuleGraphNode.getPreconditions().isEmpty()) {
-        return EdgeKind.KeepRule;
-      }
-      for (GraphNode precondition : keepRuleGraphNode.getPreconditions()) {
-        reportEdge(precondition, keepRuleGraphNode, EdgeKind.KeepRulePrecondition);
-      }
-      return EdgeKind.ConditionalKeepRule;
-    }
-
-    KeepReasonWitness reportKeepClass(
-        DexDefinition precondition, ProguardKeepRuleBase rule, DexProgramClass clazz) {
-      if (keptGraphConsumer == null) {
-        return KeepReasonWitness.INSTANCE;
-      }
-      KeepRuleGraphNode ruleNode = getKeepRuleGraphNode(precondition, rule);
-      EdgeKind edgeKind = reportPrecondition(ruleNode);
-      return reportEdge(ruleNode, getClassGraphNode(clazz.type), edgeKind);
-    }
-
-    KeepReasonWitness reportKeepClass(
-        DexDefinition precondition, Collection<ProguardKeepRuleBase> rules, DexProgramClass clazz) {
-      assert !rules.isEmpty();
-      if (keptGraphConsumer != null) {
-        for (ProguardKeepRuleBase rule : rules) {
-          reportKeepClass(precondition, rule, clazz);
-        }
-      }
-      return KeepReasonWitness.INSTANCE;
-    }
-
-    KeepReasonWitness reportKeepMethod(
-        DexDefinition precondition, ProguardKeepRuleBase rule, DexEncodedMethod method) {
-      if (keptGraphConsumer == null) {
-        return KeepReasonWitness.INSTANCE;
-      }
-      KeepRuleGraphNode ruleNode = getKeepRuleGraphNode(precondition, rule);
-      EdgeKind edgeKind = reportPrecondition(ruleNode);
-      return reportEdge(ruleNode, getMethodGraphNode(method.method), edgeKind);
-    }
-
-    KeepReasonWitness reportKeepMethod(
-        DexDefinition precondition,
-        Collection<ProguardKeepRuleBase> rules,
-        DexEncodedMethod method) {
-      assert !rules.isEmpty();
-      if (keptGraphConsumer != null) {
-        for (ProguardKeepRuleBase rule : rules) {
-          reportKeepMethod(precondition, rule, method);
-        }
-      }
-      return KeepReasonWitness.INSTANCE;
-    }
-
-    KeepReasonWitness reportKeepField(
-        DexDefinition precondition, ProguardKeepRuleBase rule, DexEncodedField field) {
-      if (keptGraphConsumer == null) {
-        return KeepReasonWitness.INSTANCE;
-      }
-      KeepRuleGraphNode ruleNode = getKeepRuleGraphNode(precondition, rule);
-      EdgeKind edgeKind = reportPrecondition(ruleNode);
-      return reportEdge(ruleNode, getFieldGraphNode(field.field), edgeKind);
-    }
-
-    KeepReasonWitness reportKeepField(
-        DexDefinition precondition, Collection<ProguardKeepRuleBase> rules, DexEncodedField field) {
-      assert !rules.isEmpty();
-      if (keptGraphConsumer != null) {
-        for (ProguardKeepRuleBase rule : rules) {
-          reportKeepField(precondition, rule, field);
-        }
-      }
-      return KeepReasonWitness.INSTANCE;
-    }
-
-    public KeepReasonWitness reportCompatKeepDefaultInitializer(
-        DexProgramClass holder, DexEncodedMethod defaultInitializer) {
-      assert holder.type == defaultInitializer.method.holder;
-      assert holder.getDefaultInitializer() == defaultInitializer;
-      if (keptGraphConsumer != null) {
-        reportEdge(
-            getClassGraphNode(holder.type),
-            getMethodGraphNode(defaultInitializer.method),
-            EdgeKind.CompatibilityRule);
-      }
-      return KeepReasonWitness.COMPAT_INSTANCE;
-    }
-
-    public KeepReasonWitness reportCompatKeepMethod(
-        DexProgramClass holder, DexEncodedMethod method) {
-      assert holder.type == method.method.holder;
-      // TODO(b/141729349): This compat rule is from the method to itself and has not edge. Fix it.
-      // The rule is stating that if the method is targeted it is live. Since such an edge does
-      // not contribute to additional information in the kept graph as it stands (no distinction
-      // of targeted vs live edges), there is little point in emitting it.
-      return KeepReasonWitness.COMPAT_INSTANCE;
-    }
-
-    public KeepReason reportCompatInstantiated(
-        DexProgramClass instantiated, DexEncodedMethod method) {
-      if (keptGraphConsumer != null) {
-        reportEdge(
-            getMethodGraphNode(method.method),
-            getClassGraphNode(instantiated.type),
-            EdgeKind.CompatibilityRule);
-      }
-      return KeepReasonWitness.COMPAT_INSTANCE;
-    }
-
-    public KeepReasonWitness reportClassReferencedFrom(
-        DexProgramClass clazz, DexEncodedMethod method) {
-      if (keptGraphConsumer != null) {
-        MethodGraphNode source = getMethodGraphNode(method.method);
-        ClassGraphNode target = getClassGraphNode(clazz.type);
-        return reportEdge(source, target, EdgeKind.ReferencedFrom);
-      }
-      return KeepReasonWitness.INSTANCE;
-    }
-
-    public KeepReasonWitness reportClassReferencedFrom(
-        DexProgramClass clazz, DexEncodedField field) {
-      if (keptGraphConsumer != null) {
-        FieldGraphNode source = getFieldGraphNode(field.field);
-        ClassGraphNode target = getClassGraphNode(clazz.type);
-        return reportEdge(source, target, EdgeKind.ReferencedFrom);
-      }
-      return KeepReasonWitness.INSTANCE;
-    }
-
-    public KeepReasonWitness reportReachableMethodAsLive(
-        DexEncodedMethod encodedMethod, MarkedResolutionTarget reason) {
-      if (keptGraphConsumer != null) {
-        return reportEdge(
-            getMethodGraphNode(reason.method.method),
-            getMethodGraphNode(encodedMethod.method),
-            EdgeKind.OverridingMethod);
-      }
-      return KeepReasonWitness.INSTANCE;
-    }
-
-    public KeepReasonWitness reportReachableMethodAsLive(
-        DexEncodedMethod encodedMethod, Set<MarkedResolutionTarget> reasons) {
-      assert !reasons.isEmpty();
-      if (keptGraphConsumer != null) {
-        MethodGraphNode target = getMethodGraphNode(encodedMethod.method);
-        for (MarkedResolutionTarget reason : reasons) {
-          reportEdge(getMethodGraphNode(reason.method.method), target, EdgeKind.OverridingMethod);
-        }
-      }
-      return KeepReasonWitness.INSTANCE;
-    }
-
-    private KeepReason reportCompanionClass(DexProgramClass iface, DexProgramClass companion) {
-      assert iface.isInterface();
-      assert InterfaceMethodRewriter.isCompanionClassType(companion.type);
-      if (keptGraphConsumer == null) {
-        return KeepReasonWitness.INSTANCE;
-      }
-      return reportEdge(
-          getClassGraphNode(iface.type),
-          getClassGraphNode(companion.type),
-          EdgeKind.CompanionClass);
-    }
-
-    private KeepReason reportCompanionMethod(
-        DexEncodedMethod definition, DexEncodedMethod implementation) {
-      assert InterfaceMethodRewriter.isCompanionClassType(implementation.method.holder);
-      if (keptGraphConsumer == null) {
-        return KeepReasonWitness.INSTANCE;
-      }
-      return reportEdge(
-          getMethodGraphNode(definition.method),
-          getMethodGraphNode(implementation.method),
-          EdgeKind.CompanionMethod);
-    }
-
-    private KeepReasonWitness reportEdge(
-        GraphNode source, GraphNode target, GraphEdgeInfo.EdgeKind kind) {
-      assert keptGraphConsumer != null;
-      keptGraphConsumer.acceptEdge(source, target, getEdgeInfo(kind));
-      return KeepReasonWitness.INSTANCE;
-    }
-
-  }
-
-  /**
-   * Sentinel value indicating that a keep reason has been reported.
-   *
-   * <p>Should only ever be returned by the register* function below.
-   */
-  private static class KeepReasonWitness extends KeepReason {
-
-    private static KeepReasonWitness INSTANCE = new KeepReasonWitness();
-    private static KeepReasonWitness COMPAT_INSTANCE =
-        new KeepReasonWitness() {
-          @Override
-          public boolean isDueToProguardCompatibility() {
-            return true;
-          }
-        };
-
-    @Override
-    public EdgeKind edgeKind() {
-      throw new Unreachable();
-    }
-
-    @Override
-    public GraphNode getSourceNode(Enqueuer enqueuer) {
-      throw new Unreachable();
-    }
-  }
-
-  private boolean skipReporting(KeepReason reason) {
-    assert reason != null;
-    if (reason == KeepReasonWitness.INSTANCE || reason == KeepReasonWitness.COMPAT_INSTANCE) {
-      return true;
-    }
-    assert getSourceNode(reason) != null;
-    return keptGraphConsumer == null;
-  }
-
-  private KeepReasonWitness registerType(DexType type, KeepReason reason) {
-    if (skipReporting(reason)) {
-      return KeepReasonWitness.INSTANCE;
-    }
-    return registerEdge(getClassGraphNode(type), reason);
-  }
-
-  private KeepReasonWitness registerInterface(DexProgramClass iface, KeepReason reason) {
-    assert iface.isInterface();
-    if (skipReporting(reason)) {
-      return KeepReasonWitness.INSTANCE;
-    }
-    return registerEdge(getClassGraphNode(iface.type), reason);
-  }
-
-  private KeepReasonWitness registerClass(DexProgramClass clazz, KeepReason reason) {
-    if (skipReporting(reason)) {
-      return KeepReasonWitness.INSTANCE;
-    }
-    return registerEdge(getClassGraphNode(clazz.type), reason);
-  }
-
-  private KeepReasonWitness registerAnnotation(DexAnnotation annotation, KeepReason reason) {
-    if (skipReporting(reason)) {
-      return KeepReasonWitness.INSTANCE;
-    }
-    return registerEdge(getAnnotationGraphNode(annotation.annotation.type), reason);
-  }
-
-  private KeepReasonWitness registerMethod(DexEncodedMethod method, KeepReason reason) {
-    if (skipReporting(reason)) {
-      return KeepReasonWitness.INSTANCE;
-    }
-    if (reason.edgeKind() == EdgeKind.IsLibraryMethod && isNonProgramClass(method.method.holder)) {
-      // Don't report edges to actual library methods.
-      // TODO(b/120959039): This should be dead code once no library classes are ever enqueued.
-      return KeepReasonWitness.INSTANCE;
-    }
-    return registerEdge(getMethodGraphNode(method.method), reason);
-  }
-
-  private KeepReasonWitness registerField(DexEncodedField field, KeepReason reason) {
-    if (skipReporting(reason)) {
-      return KeepReasonWitness.INSTANCE;
-    }
-    return registerEdge(getFieldGraphNode(field.field), reason);
-  }
-
-  private KeepReasonWitness registerEdge(GraphNode target, KeepReason reason) {
-    assert !skipReporting(reason);
-    GraphNode sourceNode = getSourceNode(reason);
-    // TODO(b/120959039): Make sure we do have edges to nodes deriving library nodes!
-    if (!sourceNode.isLibraryNode()) {
-      GraphEdgeInfo edgeInfo = getEdgeInfo(reason);
-      keptGraphConsumer.acceptEdge(sourceNode, target, edgeInfo);
-    }
-    return KeepReasonWitness.INSTANCE;
-  }
-
-  private boolean isNonProgramClass(DexType type) {
-    DexClass clazz = appView.definitionFor(type);
-    return clazz == null || clazz.isNotProgramClass();
-  }
-
-  private GraphNode getSourceNode(KeepReason reason) {
-    return reason.getSourceNode(this);
-  }
-
-  public GraphNode getGraphNode(DexReference reference) {
-    if (reference.isDexType()) {
-      return getClassGraphNode(reference.asDexType());
-    }
-    if (reference.isDexMethod()) {
-      return getMethodGraphNode(reference.asDexMethod());
-    }
-    if (reference.isDexField()) {
-      return getFieldGraphNode(reference.asDexField());
-    }
-    throw new Unreachable();
-  }
-
-  GraphEdgeInfo getEdgeInfo(KeepReason reason) {
-    return getEdgeInfo(reason.edgeKind());
-  }
-
-  GraphEdgeInfo getEdgeInfo(GraphEdgeInfo.EdgeKind kind) {
-    return reasonInfo.computeIfAbsent(kind, k -> new GraphEdgeInfo(k));
-  }
-
-  AnnotationGraphNode getAnnotationGraphNode(DexItem type) {
-    return annotationNodes.computeIfAbsent(type, t -> {
-      if (t instanceof DexType) {
-        return new AnnotationGraphNode(getClassGraphNode(((DexType) t)));
-      }
-      throw new Unimplemented("Incomplete support for annotation node on item: " + type.getClass());
-    });
-  }
-
-  ClassGraphNode getClassGraphNode(DexType type) {
-    return classNodes.computeIfAbsent(
-        type,
-        t -> {
-          DexClass definition = appView.definitionFor(t);
-          return new ClassGraphNode(
-              definition != null && definition.isNotProgramClass(),
-              Reference.classFromDescriptor(t.toDescriptorString()));
-        });
-  }
-
-  MethodGraphNode getMethodGraphNode(DexMethod context) {
-    return methodNodes.computeIfAbsent(
-        context,
-        m -> {
-          DexClass holderDefinition = appView.definitionFor(context.holder);
-          Builder<TypeReference> builder = ImmutableList.builder();
-          for (DexType param : m.proto.parameters.values) {
-            builder.add(Reference.typeFromDescriptor(param.toDescriptorString()));
-          }
-          return new MethodGraphNode(
-              holderDefinition != null && holderDefinition.isNotProgramClass(),
-              Reference.method(
-                  Reference.classFromDescriptor(m.holder.toDescriptorString()),
-                  m.name.toString(),
-                  builder.build(),
-                  m.proto.returnType.isVoidType()
-                      ? null
-                      : Reference.typeFromDescriptor(m.proto.returnType.toDescriptorString())));
-        });
-  }
-
-  FieldGraphNode getFieldGraphNode(DexField context) {
-    return fieldNodes.computeIfAbsent(
-        context,
-        f -> {
-          DexClass holderDefinition = appView.definitionFor(context.holder);
-          return new FieldGraphNode(
-              holderDefinition != null && holderDefinition.isNotProgramClass(),
-              Reference.field(
-                  Reference.classFromDescriptor(f.holder.toDescriptorString()),
-                  f.name.toString(),
-                  Reference.typeFromDescriptor(f.type.toDescriptorString())));
-        });
-  }
-
-  // Due to the combined encoding of dependent rules, ala keepclassmembers and conditional keep
-  // rules the conversion to a keep-rule graph node can be one of three forms:
-  // 1. A non-dependent keep rule. In this case precondtion == null and the rule is not an if-rule.
-  // 2. A dependent keep rule. In this case precondtion != null and rule is not an if-rule.
-  // 3. A conditional keep rule. In this case rule is an if-rule, but precondition may or may not be
-  //    null. In the non-null case, the precondition is the type the consequent may depend on,
-  //    say T for the consequent "-keep T { f; }". It is *not* the precondition of the conditional
-  //    rule.
-  KeepRuleGraphNode getKeepRuleGraphNode(DexDefinition precondition, ProguardKeepRuleBase rule) {
-    if (rule instanceof ProguardKeepRule) {
-      Set<GraphNode> preconditions =
-          precondition != null
-              ? Collections.singleton(getGraphNode(precondition.toReference()))
-              : Collections.emptySet();
-      return ruleNodes.computeIfAbsent(rule, key -> new KeepRuleGraphNode(rule, preconditions));
-    }
-    if (rule instanceof ProguardIfRule) {
-      ProguardIfRule ifRule = (ProguardIfRule) rule;
-      assert !ifRule.getPreconditions().isEmpty();
-      return ruleNodes.computeIfAbsent(
-          ifRule,
-          key -> {
-            Set<GraphNode> preconditions = new HashSet<>(ifRule.getPreconditions().size());
-            for (DexReference condition : ifRule.getPreconditions()) {
-              preconditions.add(getGraphNode(condition));
-            }
-            return new KeepRuleGraphNode(ifRule, preconditions);
-          });
-    }
-    throw new Unreachable("Unexpected type of keep rule: " + rule);
-  }
 }
diff --git a/src/main/java/com/android/tools/r8/shaking/GraphReporter.java b/src/main/java/com/android/tools/r8/shaking/GraphReporter.java
new file mode 100644
index 0000000..e87abf0
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/shaking/GraphReporter.java
@@ -0,0 +1,482 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.shaking;
+
+import com.android.tools.r8.errors.Unimplemented;
+import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.experimental.graphinfo.AnnotationGraphNode;
+import com.android.tools.r8.experimental.graphinfo.ClassGraphNode;
+import com.android.tools.r8.experimental.graphinfo.FieldGraphNode;
+import com.android.tools.r8.experimental.graphinfo.GraphConsumer;
+import com.android.tools.r8.experimental.graphinfo.GraphEdgeInfo;
+import com.android.tools.r8.experimental.graphinfo.GraphEdgeInfo.EdgeKind;
+import com.android.tools.r8.experimental.graphinfo.GraphNode;
+import com.android.tools.r8.experimental.graphinfo.KeepRuleGraphNode;
+import com.android.tools.r8.experimental.graphinfo.MethodGraphNode;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexAnnotation;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexDefinition;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexItem;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexReference;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.shaking.Enqueuer.MarkedResolutionTarget;
+import com.android.tools.r8.utils.DequeUtils;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableList.Builder;
+import com.google.common.collect.Sets;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class GraphReporter {
+
+  private final AppView<?> appView;
+  private final GraphConsumer keptGraphConsumer;
+  private final CollectingGraphConsumer verificationGraphConsumer;
+
+  // Canonicalization of external graph-nodes and edge info.
+  private final Map<DexItem, AnnotationGraphNode> annotationNodes = new IdentityHashMap<>();
+  private final Map<DexType, ClassGraphNode> classNodes = new IdentityHashMap<>();
+  private final Map<DexMethod, MethodGraphNode> methodNodes = new IdentityHashMap<>();
+  private final Map<DexField, FieldGraphNode> fieldNodes = new IdentityHashMap<>();
+  private final Map<ProguardKeepRuleBase, KeepRuleGraphNode> ruleNodes = new IdentityHashMap<>();
+  private final Map<EdgeKind, GraphEdgeInfo> reasonInfo = new IdentityHashMap<>();
+
+  GraphReporter(AppView<?> appView, GraphConsumer keptGraphConsumer) {
+    this.appView = appView;
+    if (appView.options().testing.verifyKeptGraphInfo) {
+      this.verificationGraphConsumer = new CollectingGraphConsumer(keptGraphConsumer);
+      this.keptGraphConsumer = verificationGraphConsumer;
+    } else {
+      this.verificationGraphConsumer = null;
+      this.keptGraphConsumer = keptGraphConsumer;
+    }
+  }
+
+  public boolean verifyRootedPath(DexProgramClass liveType) {
+    assert verificationGraphConsumer != null;
+    ClassGraphNode node = getClassGraphNode(liveType.type);
+    Set<GraphNode> seen = Sets.newIdentityHashSet();
+    Deque<GraphNode> targets = DequeUtils.newArrayDeque(node);
+    while (!targets.isEmpty()) {
+      GraphNode item = targets.pop();
+      if (item instanceof KeepRuleGraphNode) {
+        KeepRuleGraphNode rule = (KeepRuleGraphNode) item;
+        if (rule.getPreconditions().isEmpty()) {
+          return true;
+        }
+      }
+      if (seen.add(item)) {
+        Map<GraphNode, Set<GraphEdgeInfo>> sources =
+            verificationGraphConsumer.getSourcesTargeting(item);
+        assert sources != null : "No sources set for " + item;
+        assert !sources.isEmpty() : "Empty sources set for " + item;
+        targets.addAll(sources.keySet());
+      }
+    }
+    assert false : "No rooted path to " + liveType.type;
+    return false;
+  }
+
+  private EdgeKind reportPrecondition(KeepRuleGraphNode keepRuleGraphNode) {
+    if (keepRuleGraphNode.getPreconditions().isEmpty()) {
+      return EdgeKind.KeepRule;
+    }
+    for (GraphNode precondition : keepRuleGraphNode.getPreconditions()) {
+      reportEdge(precondition, keepRuleGraphNode, EdgeKind.KeepRulePrecondition);
+    }
+    return EdgeKind.ConditionalKeepRule;
+  }
+
+  KeepReasonWitness reportKeepClass(
+      DexDefinition precondition, ProguardKeepRuleBase rule, DexProgramClass clazz) {
+    if (keptGraphConsumer == null) {
+      return KeepReasonWitness.INSTANCE;
+    }
+    KeepRuleGraphNode ruleNode = getKeepRuleGraphNode(precondition, rule);
+    EdgeKind edgeKind = reportPrecondition(ruleNode);
+    return reportEdge(ruleNode, getClassGraphNode(clazz.type), edgeKind);
+  }
+
+  KeepReasonWitness reportKeepClass(
+      DexDefinition precondition, Collection<ProguardKeepRuleBase> rules, DexProgramClass clazz) {
+    assert !rules.isEmpty();
+    if (keptGraphConsumer != null) {
+      for (ProguardKeepRuleBase rule : rules) {
+        reportKeepClass(precondition, rule, clazz);
+      }
+    }
+    return KeepReasonWitness.INSTANCE;
+  }
+
+  KeepReasonWitness reportKeepMethod(
+      DexDefinition precondition, ProguardKeepRuleBase rule, DexEncodedMethod method) {
+    if (keptGraphConsumer == null) {
+      return KeepReasonWitness.INSTANCE;
+    }
+    KeepRuleGraphNode ruleNode = getKeepRuleGraphNode(precondition, rule);
+    EdgeKind edgeKind = reportPrecondition(ruleNode);
+    return reportEdge(ruleNode, getMethodGraphNode(method.method), edgeKind);
+  }
+
+  KeepReasonWitness reportKeepMethod(
+      DexDefinition precondition, Collection<ProguardKeepRuleBase> rules, DexEncodedMethod method) {
+    assert !rules.isEmpty();
+    if (keptGraphConsumer != null) {
+      for (ProguardKeepRuleBase rule : rules) {
+        reportKeepMethod(precondition, rule, method);
+      }
+    }
+    return KeepReasonWitness.INSTANCE;
+  }
+
+  KeepReasonWitness reportKeepField(
+      DexDefinition precondition, ProguardKeepRuleBase rule, DexEncodedField field) {
+    if (keptGraphConsumer == null) {
+      return KeepReasonWitness.INSTANCE;
+    }
+    KeepRuleGraphNode ruleNode = getKeepRuleGraphNode(precondition, rule);
+    EdgeKind edgeKind = reportPrecondition(ruleNode);
+    return reportEdge(ruleNode, getFieldGraphNode(field.field), edgeKind);
+  }
+
+  KeepReasonWitness reportKeepField(
+      DexDefinition precondition, Collection<ProguardKeepRuleBase> rules, DexEncodedField field) {
+    assert !rules.isEmpty();
+    if (keptGraphConsumer != null) {
+      for (ProguardKeepRuleBase rule : rules) {
+        reportKeepField(precondition, rule, field);
+      }
+    }
+    return KeepReasonWitness.INSTANCE;
+  }
+
+  public KeepReasonWitness reportCompatKeepDefaultInitializer(
+      DexProgramClass holder, DexEncodedMethod defaultInitializer) {
+    assert holder.type == defaultInitializer.method.holder;
+    assert holder.getDefaultInitializer() == defaultInitializer;
+    if (keptGraphConsumer != null) {
+      reportEdge(
+          getClassGraphNode(holder.type),
+          getMethodGraphNode(defaultInitializer.method),
+          EdgeKind.CompatibilityRule);
+    }
+    return KeepReasonWitness.COMPAT_INSTANCE;
+  }
+
+  public KeepReasonWitness reportCompatKeepMethod(DexProgramClass holder, DexEncodedMethod method) {
+    assert holder.type == method.method.holder;
+    // TODO(b/141729349): This compat rule is from the method to itself and has not edge. Fix it.
+    // The rule is stating that if the method is targeted it is live. Since such an edge does
+    // not contribute to additional information in the kept graph as it stands (no distinction
+    // of targeted vs live edges), there is little point in emitting it.
+    return KeepReasonWitness.COMPAT_INSTANCE;
+  }
+
+  public KeepReason reportCompatInstantiated(
+      DexProgramClass instantiated, DexEncodedMethod method) {
+    if (keptGraphConsumer != null) {
+      reportEdge(
+          getMethodGraphNode(method.method),
+          getClassGraphNode(instantiated.type),
+          EdgeKind.CompatibilityRule);
+    }
+    return KeepReasonWitness.COMPAT_INSTANCE;
+  }
+
+  public KeepReasonWitness reportClassReferencedFrom(
+      DexProgramClass clazz, DexEncodedMethod method) {
+    if (keptGraphConsumer != null) {
+      MethodGraphNode source = getMethodGraphNode(method.method);
+      ClassGraphNode target = getClassGraphNode(clazz.type);
+      return reportEdge(source, target, EdgeKind.ReferencedFrom);
+    }
+    return KeepReasonWitness.INSTANCE;
+  }
+
+  public KeepReasonWitness reportClassReferencedFrom(DexProgramClass clazz, DexEncodedField field) {
+    if (keptGraphConsumer != null) {
+      FieldGraphNode source = getFieldGraphNode(field.field);
+      ClassGraphNode target = getClassGraphNode(clazz.type);
+      return reportEdge(source, target, EdgeKind.ReferencedFrom);
+    }
+    return KeepReasonWitness.INSTANCE;
+  }
+
+  public KeepReasonWitness reportReachableMethodAsLive(
+      DexEncodedMethod encodedMethod, MarkedResolutionTarget reason) {
+    if (keptGraphConsumer != null) {
+      return reportEdge(
+          getMethodGraphNode(reason.method.method),
+          getMethodGraphNode(encodedMethod.method),
+          EdgeKind.OverridingMethod);
+    }
+    return KeepReasonWitness.INSTANCE;
+  }
+
+  public KeepReasonWitness reportReachableMethodAsLive(
+      DexEncodedMethod encodedMethod, Set<MarkedResolutionTarget> reasons) {
+    assert !reasons.isEmpty();
+    if (keptGraphConsumer != null) {
+      MethodGraphNode target = getMethodGraphNode(encodedMethod.method);
+      for (MarkedResolutionTarget reason : reasons) {
+        reportEdge(getMethodGraphNode(reason.method.method), target, EdgeKind.OverridingMethod);
+      }
+    }
+    return KeepReasonWitness.INSTANCE;
+  }
+
+  public KeepReason reportCompanionClass(DexProgramClass iface, DexProgramClass companion) {
+    assert iface.isInterface();
+    assert InterfaceMethodRewriter.isCompanionClassType(companion.type);
+    if (keptGraphConsumer == null) {
+      return KeepReasonWitness.INSTANCE;
+    }
+    return reportEdge(
+        getClassGraphNode(iface.type), getClassGraphNode(companion.type), EdgeKind.CompanionClass);
+  }
+
+  public KeepReason reportCompanionMethod(
+      DexEncodedMethod definition, DexEncodedMethod implementation) {
+    assert InterfaceMethodRewriter.isCompanionClassType(implementation.method.holder);
+    if (keptGraphConsumer == null) {
+      return KeepReasonWitness.INSTANCE;
+    }
+    return reportEdge(
+        getMethodGraphNode(definition.method),
+        getMethodGraphNode(implementation.method),
+        EdgeKind.CompanionMethod);
+  }
+
+  private KeepReasonWitness reportEdge(GraphNode source, GraphNode target, EdgeKind kind) {
+    assert keptGraphConsumer != null;
+    keptGraphConsumer.acceptEdge(source, target, getEdgeInfo(kind));
+    return KeepReasonWitness.INSTANCE;
+  }
+
+  /**
+   * Sentinel value indicating that a keep reason has been reported.
+   *
+   * <p>Should only ever be returned by the graph reporter functions.
+   */
+  public static class KeepReasonWitness extends KeepReason {
+
+    private static KeepReasonWitness INSTANCE = new KeepReasonWitness();
+    private static KeepReasonWitness COMPAT_INSTANCE =
+        new KeepReasonWitness() {
+          @Override
+          public boolean isDueToProguardCompatibility() {
+            return true;
+          }
+        };
+
+    private KeepReasonWitness() {
+      // Only the reporter may create instances.
+    }
+
+    @Override
+    public EdgeKind edgeKind() {
+      throw new Unreachable();
+    }
+
+    @Override
+    public GraphNode getSourceNode(GraphReporter graphReporter) {
+      throw new Unreachable();
+    }
+  }
+
+  private boolean skipReporting(KeepReason reason) {
+    assert reason != null;
+    if (reason == KeepReasonWitness.INSTANCE || reason == KeepReasonWitness.COMPAT_INSTANCE) {
+      return true;
+    }
+    assert getSourceNode(reason) != null;
+    return keptGraphConsumer == null;
+  }
+
+  public KeepReasonWitness registerInterface(DexProgramClass iface, KeepReason reason) {
+    assert iface.isInterface();
+    if (skipReporting(reason)) {
+      return KeepReasonWitness.INSTANCE;
+    }
+    return registerEdge(getClassGraphNode(iface.type), reason);
+  }
+
+  public KeepReasonWitness registerClass(DexProgramClass clazz, KeepReason reason) {
+    if (skipReporting(reason)) {
+      return KeepReasonWitness.INSTANCE;
+    }
+    return registerEdge(getClassGraphNode(clazz.type), reason);
+  }
+
+  public KeepReasonWitness registerAnnotation(DexAnnotation annotation, KeepReason reason) {
+    if (skipReporting(reason)) {
+      return KeepReasonWitness.INSTANCE;
+    }
+    return registerEdge(getAnnotationGraphNode(annotation.annotation.type), reason);
+  }
+
+  public KeepReasonWitness registerMethod(DexEncodedMethod method, KeepReason reason) {
+    if (skipReporting(reason)) {
+      return KeepReasonWitness.INSTANCE;
+    }
+    if (reason.edgeKind() == EdgeKind.IsLibraryMethod && isNonProgramClass(method.method.holder)) {
+      // Don't report edges to actual library methods.
+      // TODO(b/120959039): This should be dead code once no library classes are ever enqueued.
+      return KeepReasonWitness.INSTANCE;
+    }
+    return registerEdge(getMethodGraphNode(method.method), reason);
+  }
+
+  public KeepReasonWitness registerField(DexEncodedField field, KeepReason reason) {
+    if (skipReporting(reason)) {
+      return KeepReasonWitness.INSTANCE;
+    }
+    return registerEdge(getFieldGraphNode(field.field), reason);
+  }
+
+  private KeepReasonWitness registerEdge(GraphNode target, KeepReason reason) {
+    assert !skipReporting(reason);
+    GraphNode sourceNode = getSourceNode(reason);
+    // TODO(b/120959039): Make sure we do have edges to nodes deriving library nodes!
+    if (!sourceNode.isLibraryNode()) {
+      GraphEdgeInfo edgeInfo = getEdgeInfo(reason);
+      keptGraphConsumer.acceptEdge(sourceNode, target, edgeInfo);
+    }
+    return KeepReasonWitness.INSTANCE;
+  }
+
+  private boolean isNonProgramClass(DexType type) {
+    DexClass clazz = appView.definitionFor(type);
+    return clazz == null || clazz.isNotProgramClass();
+  }
+
+  private GraphNode getSourceNode(KeepReason reason) {
+    return reason.getSourceNode(this);
+  }
+
+  public GraphNode getGraphNode(DexReference reference) {
+    if (reference.isDexType()) {
+      return getClassGraphNode(reference.asDexType());
+    }
+    if (reference.isDexMethod()) {
+      return getMethodGraphNode(reference.asDexMethod());
+    }
+    if (reference.isDexField()) {
+      return getFieldGraphNode(reference.asDexField());
+    }
+    throw new Unreachable();
+  }
+
+  GraphEdgeInfo getEdgeInfo(KeepReason reason) {
+    return getEdgeInfo(reason.edgeKind());
+  }
+
+  GraphEdgeInfo getEdgeInfo(EdgeKind kind) {
+    return reasonInfo.computeIfAbsent(kind, k -> new GraphEdgeInfo(k));
+  }
+
+  AnnotationGraphNode getAnnotationGraphNode(DexItem type) {
+    return annotationNodes.computeIfAbsent(
+        type,
+        t -> {
+          if (t instanceof DexType) {
+            return new AnnotationGraphNode(getClassGraphNode(((DexType) t)));
+          }
+          throw new Unimplemented(
+              "Incomplete support for annotation node on item: " + type.getClass());
+        });
+  }
+
+  ClassGraphNode getClassGraphNode(DexType type) {
+    return classNodes.computeIfAbsent(
+        type,
+        t -> {
+          DexClass definition = appView.definitionFor(t);
+          return new ClassGraphNode(
+              definition != null && definition.isNotProgramClass(),
+              Reference.classFromDescriptor(t.toDescriptorString()));
+        });
+  }
+
+  MethodGraphNode getMethodGraphNode(DexMethod context) {
+    return methodNodes.computeIfAbsent(
+        context,
+        m -> {
+          DexClass holderDefinition = appView.definitionFor(context.holder);
+          Builder<TypeReference> builder = ImmutableList.builder();
+          for (DexType param : m.proto.parameters.values) {
+            builder.add(Reference.typeFromDescriptor(param.toDescriptorString()));
+          }
+          return new MethodGraphNode(
+              holderDefinition != null && holderDefinition.isNotProgramClass(),
+              Reference.method(
+                  Reference.classFromDescriptor(m.holder.toDescriptorString()),
+                  m.name.toString(),
+                  builder.build(),
+                  m.proto.returnType.isVoidType()
+                      ? null
+                      : Reference.typeFromDescriptor(m.proto.returnType.toDescriptorString())));
+        });
+  }
+
+  FieldGraphNode getFieldGraphNode(DexField context) {
+    return fieldNodes.computeIfAbsent(
+        context,
+        f -> {
+          DexClass holderDefinition = appView.definitionFor(context.holder);
+          return new FieldGraphNode(
+              holderDefinition != null && holderDefinition.isNotProgramClass(),
+              Reference.field(
+                  Reference.classFromDescriptor(f.holder.toDescriptorString()),
+                  f.name.toString(),
+                  Reference.typeFromDescriptor(f.type.toDescriptorString())));
+        });
+  }
+
+  // Due to the combined encoding of dependent rules, ala keepclassmembers and conditional keep
+  // rules the conversion to a keep-rule graph node can be one of three forms:
+  // 1. A non-dependent keep rule. In this case precondtion == null and the rule is not an if-rule.
+  // 2. A dependent keep rule. In this case precondtion != null and rule is not an if-rule.
+  // 3. A conditional keep rule. In this case rule is an if-rule, but precondition may or may not be
+  //    null. In the non-null case, the precondition is the type the consequent may depend on,
+  //    say T for the consequent "-keep T { f; }". It is *not* the precondition of the conditional
+  //    rule.
+  KeepRuleGraphNode getKeepRuleGraphNode(DexDefinition precondition, ProguardKeepRuleBase rule) {
+    if (rule instanceof ProguardKeepRule) {
+      Set<GraphNode> preconditions =
+          precondition != null
+              ? Collections.singleton(getGraphNode(precondition.toReference()))
+              : Collections.emptySet();
+      return ruleNodes.computeIfAbsent(rule, key -> new KeepRuleGraphNode(rule, preconditions));
+    }
+    if (rule instanceof ProguardIfRule) {
+      ProguardIfRule ifRule = (ProguardIfRule) rule;
+      assert !ifRule.getPreconditions().isEmpty();
+      return ruleNodes.computeIfAbsent(
+          ifRule,
+          key -> {
+            Set<GraphNode> preconditions = new HashSet<>(ifRule.getPreconditions().size());
+            for (DexReference condition : ifRule.getPreconditions()) {
+              preconditions.add(getGraphNode(condition));
+            }
+            return new KeepRuleGraphNode(ifRule, preconditions);
+          });
+    }
+    throw new Unreachable("Unexpected type of keep rule: " + rule);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/shaking/KeepReason.java b/src/main/java/com/android/tools/r8/shaking/KeepReason.java
index 43b875a..5f5d772 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepReason.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepReason.java
@@ -18,7 +18,7 @@
 
   public abstract GraphEdgeInfo.EdgeKind edgeKind();
 
-  public abstract GraphNode getSourceNode(Enqueuer enqueuer);
+  public abstract GraphNode getSourceNode(GraphReporter graphReporter);
 
   static KeepReason annotatedOn(DexDefinition definition) {
     return new AnnotatedOn(definition);
@@ -103,8 +103,8 @@
     }
 
     @Override
-    public GraphNode getSourceNode(Enqueuer enqueuer) {
-      return enqueuer.getMethodGraphNode(method.method);
+    public GraphNode getSourceNode(GraphReporter graphReporter) {
+      return graphReporter.getMethodGraphNode(method.method);
     }
   }
 
@@ -235,8 +235,8 @@
     }
 
     @Override
-    public GraphNode getSourceNode(Enqueuer enqueuer) {
-      return enqueuer.getClassGraphNode(type);
+    public GraphNode getSourceNode(GraphReporter graphReporter) {
+      return graphReporter.getClassGraphNode(type);
     }
   }
 
@@ -256,8 +256,8 @@
     }
 
     @Override
-    public GraphNode getSourceNode(Enqueuer enqueuer) {
-      return enqueuer.getClassGraphNode(implementer);
+    public GraphNode getSourceNode(GraphReporter graphReporter) {
+      return graphReporter.getClassGraphNode(implementer);
     }
   }
 
@@ -275,8 +275,8 @@
     }
 
     @Override
-    public GraphNode getSourceNode(Enqueuer enqueuer) {
-      return enqueuer.getAnnotationGraphNode(holder);
+    public GraphNode getSourceNode(GraphReporter graphReporter) {
+      return graphReporter.getAnnotationGraphNode(holder);
     }
   }
 
@@ -294,14 +294,14 @@
     }
 
     @Override
-    public GraphNode getSourceNode(Enqueuer enqueuer) {
+    public GraphNode getSourceNode(GraphReporter graphReporter) {
       if (holder.isDexClass()) {
-        return enqueuer.getClassGraphNode(holder.asDexClass().type);
+        return graphReporter.getClassGraphNode(holder.asDexClass().type);
       } else if (holder.isDexEncodedField()) {
-        return enqueuer.getFieldGraphNode(holder.asDexEncodedField().field);
+        return graphReporter.getFieldGraphNode(holder.asDexEncodedField().field);
       } else {
         assert holder.isDexEncodedMethod();
-        return enqueuer.getMethodGraphNode(holder.asDexEncodedMethod().method);
+        return graphReporter.getMethodGraphNode(holder.asDexEncodedMethod().method);
       }
     }
   }