diff --git a/src/main/java/com/android/tools/r8/tracereferences/Formatter.java b/src/main/java/com/android/tools/r8/tracereferences/Formatter.java
new file mode 100644
index 0000000..b545e65
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/tracereferences/Formatter.java
@@ -0,0 +1,176 @@
+// Copyright (c) 2020, 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.tracereferences;
+
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.PackageReference;
+import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedClass;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedField;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedMethod;
+import com.android.tools.r8.utils.ListUtils;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.StringUtils.BraceType;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+abstract class Formatter {
+
+  private final StringBuilder output;
+
+  Formatter() {
+    output = new StringBuilder();
+  }
+
+  String get() {
+    return output.toString();
+  }
+
+  protected void append(String string) {
+    output.append(string);
+  }
+
+  protected void appendLine(String string) {
+    output.append(StringUtils.lines(string));
+  }
+
+  protected void appendLine() {
+    appendLine("");
+  }
+
+  protected void printArguments(MethodReference method) {
+    StringUtils.append(
+        output,
+        ListUtils.map(method.getFormalTypes(), TypeReference::getTypeName),
+        ",",
+        BraceType.PARENS);
+  }
+
+  protected abstract void printConstructorName(MethodReference method);
+
+  private void printError(String message) {
+    append("# Error: " + message);
+  }
+
+  protected abstract void printField(TracedField field);
+
+  protected abstract void printMethod(TracedMethod method);
+
+  private void printFieldError(FieldReference field) {
+    appendLine(
+        field.getFieldType().getTypeName()
+            + " "
+            + field.getHolderClass().getTypeName()
+            + "."
+            + field.getFieldName());
+  }
+
+  private void printMethodError(MethodReference method) {
+    printReturn(method);
+    append(" ");
+    append(method.getHolderClass().getTypeName());
+    append(".");
+    append(method.getMethodName());
+    printArguments(method);
+    appendLine();
+  }
+
+  protected abstract void printPackageNames(List<String> packageNames);
+
+  protected void printReturn(MethodReference method) {
+    append(method.getReturnType() != null ? method.getReturnType().getTypeName() : "void");
+  }
+
+  protected void printNameAndReturn(MethodReference method) {
+    if (method.getMethodName().equals("<init>")) {
+      printConstructorName(method);
+    } else {
+      printReturn(method);
+      append(" ");
+      append(method.getMethodName());
+    }
+  }
+
+  protected abstract void printTypeHeader(TracedClass clazz);
+
+  protected abstract void printTypeFooter();
+
+  void format(TraceReferencesResult result) {
+    int errors =
+        print(
+            result.types,
+            result.keepPackageNames,
+            result.fields,
+            result.methods,
+            result.missingDefinition);
+    assert errors == result.missingDefinition.size();
+  }
+
+  private int print(
+      Set<TracedClass> types,
+      Set<PackageReference> keepPackageNames,
+      Map<ClassReference, Set<TracedField>> fields,
+      Map<ClassReference, Set<TracedMethod>> methods,
+      Set<Object> missingDefinition) {
+    int errors = 0;
+    List<TracedClass> sortedTypes = new ArrayList<>(types);
+    sortedTypes.sort(Comparator.comparing(tracedClass -> tracedClass.getReference().getTypeName()));
+    for (TracedClass type : sortedTypes) {
+      if (missingDefinition.contains(type)) {
+        printError("Could not find definition for type " + type.getReference().getTypeName());
+        errors++;
+        continue;
+      }
+      printTypeHeader(type);
+      Set<TracedMethod> methodsForClass = methods.get(type.getReference());
+      if (methodsForClass != null) {
+        List<TracedMethod> sortedMethods = new ArrayList<>(methods.get(type.getReference()).size());
+        for (TracedMethod method : methods.get(type.getReference())) {
+          if (method.isMissingDefinition()) {
+            printError("Could not find definition for method ");
+            printMethodError(method.getReference());
+            errors++;
+            continue;
+          }
+          assert method.getAccessFlags() != null;
+          sortedMethods.add(method);
+        }
+        sortedMethods.sort(
+            Comparator.comparing(tracedMethod -> tracedMethod.getReference().toString()));
+        for (TracedMethod method : sortedMethods) {
+          printMethod(method);
+        }
+      }
+      Set<TracedField> fieldsForClass = fields.get(type.getReference());
+      if (fieldsForClass != null) {
+        List<TracedField> sortedFields = new ArrayList<>(fieldsForClass);
+        sortedFields.sort(
+            Comparator.comparing(tracedField -> tracedField.getReference().toString()));
+        for (TracedField field : sortedFields) {
+          if (field.isMissingDefinition()) {
+            printError("Could not find definition for field ");
+            printFieldError(field.getReference());
+            errors++;
+            continue;
+          }
+          printField(field);
+        }
+      }
+      printTypeFooter();
+    }
+    List<String> packageNamesToKeep =
+        keepPackageNames.stream()
+            .map(PackageReference::getPackageName)
+            .sorted()
+            .collect(Collectors.toList());
+    printPackageNames(packageNamesToKeep);
+    return errors;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/tracereferences/KeepRuleFormatter.java b/src/main/java/com/android/tools/r8/tracereferences/KeepRuleFormatter.java
index f259b01..85352f2 100644
--- a/src/main/java/com/android/tools/r8/tracereferences/KeepRuleFormatter.java
+++ b/src/main/java/com/android/tools/r8/tracereferences/KeepRuleFormatter.java
@@ -3,70 +3,66 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.tracereferences;
 
-import com.android.tools.r8.DiagnosticsHandler;
-import com.android.tools.r8.StringConsumer;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedClass;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedField;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedMethod;
 import com.android.tools.r8.utils.StringUtils;
 import java.util.List;
 
-class KeepRuleFormatter extends ResultFormatter {
+class KeepRuleFormatter extends Formatter {
   final boolean allowObfuscation;
 
-  KeepRuleFormatter(
-      StringConsumer output, DiagnosticsHandler diagnosticsHandler, boolean allowObfuscation) {
-    super(output, diagnosticsHandler);
+  KeepRuleFormatter(boolean allowObfuscation) {
     this.allowObfuscation = allowObfuscation;
   }
 
   @Override
-  protected void printTypeHeader(DexClass dexClass) {
+  protected void printTypeHeader(TracedClass tracedClass) {
     append(allowObfuscation ? "-keep,allowobfuscation" : "-keep");
-    if (dexClass.isInterface()) {
-      append(" interface " + dexClass.type.toSourceString() + " {" + System.lineSeparator());
-    } else if (dexClass.accessFlags.isEnum()) {
-      append(" enum " + dexClass.type.toSourceString() + " {" + System.lineSeparator());
+    if (tracedClass.getAccessFlags().isInterface()) {
+      appendLine(" interface " + tracedClass.getReference().getTypeName() + " {");
+    } else if (tracedClass.getAccessFlags().isEnum()) {
+      appendLine(" enum " + tracedClass.getReference().getTypeName() + " {");
     } else {
-      append(" class " + dexClass.type.toSourceString() + " {" + System.lineSeparator());
+      appendLine(" class " + tracedClass.getReference().getTypeName() + " {");
     }
   }
 
   @Override
-  protected void printConstructorName(DexEncodedMethod encodedMethod) {
+  protected void printConstructorName(MethodReference method) {
     append("<init>");
   }
 
   @Override
-  protected void printField(DexClass dexClass, DexField field) {
+  protected void printField(TracedField field) {
     append(
         "  "
-            + field.type.toSourceString()
+            + field.getReference().getFieldType().getTypeName()
             + " "
-            + field.name.toString()
+            + field.getReference().getFieldName()
             + ";"
             + System.lineSeparator());
   }
 
   @Override
-  protected void printMethod(DexEncodedMethod encodedMethod, String typeName) {
-    // Static initializers do not require keep rules - it is kept by keeping the class.
-    if (encodedMethod.accessFlags.isConstructor() && encodedMethod.accessFlags.isStatic()) {
+  protected void printMethod(TracedMethod tracedMethod) {
+    if (tracedMethod.getReference().getMethodName().equals("<clinit>")) {
       return;
     }
     append("  ");
-    if (encodedMethod.isPublicMethod()) {
+    if (tracedMethod.getAccessFlags().isPublic()) {
       append("public ");
-    } else if (encodedMethod.isPrivateMethod()) {
+    } else if (tracedMethod.getAccessFlags().isPrivate()) {
       append("private ");
-    } else if (encodedMethod.isProtectedMethod()) {
+    } else if (tracedMethod.getAccessFlags().isProtected()) {
       append("protected ");
     }
-    if (encodedMethod.isStatic()) {
+    if (tracedMethod.getAccessFlags().isStatic()) {
       append("static ");
     }
-    printNameAndReturn(encodedMethod);
-    printArguments(encodedMethod.method);
+    printNameAndReturn(tracedMethod.getReference());
+    printArguments(tracedMethod.getReference());
     appendLine(";");
   }
 
diff --git a/src/main/java/com/android/tools/r8/tracereferences/PrintUsesFormatter.java b/src/main/java/com/android/tools/r8/tracereferences/PrintUsesFormatter.java
index 12b2e6b..a29fdb5 100644
--- a/src/main/java/com/android/tools/r8/tracereferences/PrintUsesFormatter.java
+++ b/src/main/java/com/android/tools/r8/tracereferences/PrintUsesFormatter.java
@@ -3,35 +3,30 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.tracereferences;
 
-import com.android.tools.r8.DiagnosticsHandler;
-import com.android.tools.r8.StringConsumer;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedClass;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedField;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedMethod;
 import java.util.List;
 
-class PrintUsesFormatter extends ResultFormatter {
-
-  PrintUsesFormatter(StringConsumer output, DiagnosticsHandler diagnosticsHandler) {
-    super(output, diagnosticsHandler);
-  }
+class PrintUsesFormatter extends Formatter {
 
   @Override
-  protected void printConstructorName(DexEncodedMethod encodedMethod) {
-    if (encodedMethod.accessFlags.isStatic()) {
+  protected void printConstructorName(MethodReference method) {
+    if (method.getMethodName().equals("<clinit>")) {
       append("<clinit>");
     } else {
-      String holderName = encodedMethod.holder().toSourceString();
+      String holderName = method.getHolderClass().getTypeName();
       String constructorName = holderName.substring(holderName.lastIndexOf('.') + 1);
       append(constructorName);
     }
   }
 
   @Override
-  protected void printMethod(DexEncodedMethod encodedMethod, String typeName) {
-    append(typeName + ": ");
-    printNameAndReturn(encodedMethod);
-    printArguments(encodedMethod.method);
+  protected void printMethod(TracedMethod method) {
+    append(method.getReference().getHolderClass().getTypeName() + ": ");
+    printNameAndReturn(method.getReference());
+    printArguments(method.getReference());
     appendLine("");
   }
 
@@ -41,20 +36,20 @@
   }
 
   @Override
-  protected void printTypeHeader(DexClass dexClass) {
-    appendLine(dexClass.type.toSourceString());
+  protected void printTypeHeader(TracedClass type) {
+    appendLine(type.getReference().getTypeName());
   }
 
   @Override
   protected void printTypeFooter() {}
 
   @Override
-  protected void printField(DexClass dexClass, DexField field) {
+  protected void printField(TracedField field) {
     appendLine(
-        dexClass.type.toSourceString()
+        field.getReference().getHolderClass().getTypeName()
             + ": "
-            + field.type.toSourceString()
+            + field.getReference().getFieldType().getTypeName()
             + " "
-            + field.name.toString());
+            + field.getReference().getFieldName());
   }
 }
diff --git a/src/main/java/com/android/tools/r8/tracereferences/Result.java b/src/main/java/com/android/tools/r8/tracereferences/Result.java
deleted file mode 100644
index 6889f0c..0000000
--- a/src/main/java/com/android/tools/r8/tracereferences/Result.java
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright (c) 2020, 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.tracereferences;
-
-import com.android.tools.r8.graph.DexApplication;
-import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexReference;
-import com.android.tools.r8.graph.DexType;
-import java.util.Map;
-import java.util.Set;
-
-class Result {
-  final DexApplication application;
-  final Set<DexType> types;
-  final Set<String> keepPackageNames;
-  final Map<DexType, Set<DexField>> fields;
-  final Map<DexType, Set<DexMethod>> methods;
-  final Set<DexReference> missingDefinition;
-
-  Result(
-      DexApplication application,
-      Set<DexType> types,
-      Set<String> keepPackageNames,
-      Map<DexType, Set<DexField>> fields,
-      Map<DexType, Set<DexMethod>> methods,
-      Set<DexReference> missingDefinition) {
-    this.application = application;
-    this.types = types;
-    this.keepPackageNames = keepPackageNames;
-    this.fields = fields;
-    this.methods = methods;
-    this.missingDefinition = missingDefinition;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/tracereferences/ResultFormatter.java b/src/main/java/com/android/tools/r8/tracereferences/ResultFormatter.java
deleted file mode 100644
index 2fd8934..0000000
--- a/src/main/java/com/android/tools/r8/tracereferences/ResultFormatter.java
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright (c) 2020, 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.tracereferences;
-
-import com.android.tools.r8.DiagnosticsHandler;
-import com.android.tools.r8.StringConsumer;
-import com.android.tools.r8.graph.DexApplication;
-import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexReference;
-import com.android.tools.r8.graph.DexType;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-abstract class ResultFormatter {
-
-  private final StringConsumer output;
-  private final DiagnosticsHandler diagnosticsHandler;
-
-  ResultFormatter(StringConsumer output, DiagnosticsHandler diagnosticsHandler) {
-    this.output = output;
-    this.diagnosticsHandler = diagnosticsHandler;
-  }
-
-  protected void append(String string) {
-    output.accept(string, diagnosticsHandler);
-  }
-
-  protected void appendLine(String string) {
-    output.accept(string + System.lineSeparator(), diagnosticsHandler);
-  }
-
-  protected void printArguments(DexMethod method) {
-    append("(");
-    for (int i = 0; i < method.getArity(); i++) {
-      if (i != 0) {
-        append(",");
-      }
-      append(method.proto.parameters.values[i].toSourceString());
-    }
-    append(")");
-  }
-
-  protected abstract void printConstructorName(DexEncodedMethod encodedMethod);
-
-  private void printError(String message) {
-    appendLine("# Error: " + message);
-  }
-
-  protected abstract void printField(DexClass dexClass, DexField field);
-
-  protected abstract void printMethod(DexEncodedMethod encodedMethod, String typeName);
-
-  protected abstract void printPackageNames(List<String> packageNames);
-
-  protected void printNameAndReturn(DexEncodedMethod encodedMethod) {
-    if (encodedMethod.accessFlags.isConstructor()) {
-      printConstructorName(encodedMethod);
-    } else {
-      DexMethod method = encodedMethod.method;
-      append(method.proto.returnType.toSourceString());
-      append(" ");
-      append(method.name.toSourceString());
-    }
-  }
-
-  protected abstract void printTypeHeader(DexClass dexClass);
-
-  protected abstract void printTypeFooter();
-
-  void format(Result result) {
-    int errors =
-        print(
-            result.application,
-            result.types,
-            result.keepPackageNames,
-            result.fields,
-            result.methods,
-            result.missingDefinition);
-    output.finished(diagnosticsHandler);
-    assert errors == result.missingDefinition.size();
-  }
-
-  private int print(
-      DexApplication application,
-      Set<DexType> types,
-      Set<String> keepPackageNames,
-      Map<DexType, Set<DexField>> fields,
-      Map<DexType, Set<DexMethod>> methods,
-      Set<DexReference> missingDefinition) {
-    int errors = 0;
-    List<DexType> sortedTypes = new ArrayList<>(types);
-    sortedTypes.sort(Comparator.comparing(DexType::toSourceString));
-    for (DexType type : sortedTypes) {
-      DexClass dexClass = application.definitionFor(type);
-      if (missingDefinition.contains(type)) {
-        assert dexClass == null;
-        printError("Could not find definition for type " + type.toSourceString());
-        errors++;
-        continue;
-      }
-      printTypeHeader(dexClass);
-      List<DexEncodedMethod> methodDefinitions = new ArrayList<>(methods.size());
-      for (DexMethod method : methods.get(type)) {
-        DexEncodedMethod encodedMethod = dexClass.lookupMethod(method);
-        if (missingDefinition.contains(method)) {
-          assert encodedMethod == null;
-          printError("Could not find definition for method " + method.toSourceString());
-          errors++;
-          continue;
-        }
-        methodDefinitions.add(encodedMethod);
-      }
-      methodDefinitions.sort(Comparator.comparing(x -> x.method.name.toSourceString()));
-      for (DexEncodedMethod encodedMethod : methodDefinitions) {
-        printMethod(encodedMethod, dexClass.type.toSourceString());
-      }
-      List<DexField> sortedFields = new ArrayList<>(fields.get(type));
-      sortedFields.sort(Comparator.comparing(DexField::toSourceString));
-      for (DexField field : sortedFields) {
-        if (missingDefinition.contains(field)) {
-          printError("Could not find definition for field " + field.toSourceString());
-          errors++;
-          continue;
-        }
-        printField(dexClass, field);
-      }
-      printTypeFooter();
-    }
-    ArrayList<String> packageNamesToKeep = new ArrayList<>(keepPackageNames);
-    Collections.sort(packageNamesToKeep);
-    printPackageNames(packageNamesToKeep);
-    return errors;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/tracereferences/TraceReferences.java b/src/main/java/com/android/tools/r8/tracereferences/TraceReferences.java
index d0ec93e..acc2cb6 100644
--- a/src/main/java/com/android/tools/r8/tracereferences/TraceReferences.java
+++ b/src/main/java/com/android/tools/r8/tracereferences/TraceReferences.java
@@ -32,7 +32,7 @@
       throw new CompilationFailedException();
     } catch (Exception e) {
       command.getDiagnosticsHandler().error(new ExceptionDiagnostic(e));
-      throw new CompilationFailedException();
+      throw new CompilationFailedException(e);
     }
   }
 
@@ -46,8 +46,8 @@
     if (command.getSource().isEmpty()) {
       throw new TraceReferencesException("No source specified");
     }
-    if (command.getOutput() == null) {
-      throw new TraceReferencesException("No output specified");
+    if (command.getConsumer() == null) {
+      throw new TraceReferencesException("No consumer specified");
     }
     AndroidApp.Builder builder = AndroidApp.builder();
     command.getLibrary().forEach(builder::addLibraryResourceProvider);
@@ -80,25 +80,8 @@
         }
       }
     }
-    Tracer tracer = new Tracer(tagetDescriptors, builder.build());
-    Result result = tracer.run();
-    ResultFormatter formatter;
-    switch (command.getOutputFormat()) {
-      case PRINTUSAGE:
-        formatter = new PrintUsesFormatter(command.getOutput(), command.getDiagnosticsHandler());
-        break;
-      case KEEP_RULES:
-        formatter =
-            new KeepRuleFormatter(command.getOutput(), command.getDiagnosticsHandler(), false);
-        break;
-      case KEEP_RULES_WITH_ALLOWOBFUSCATION:
-        formatter =
-            new KeepRuleFormatter(command.getOutput(), command.getDiagnosticsHandler(), true);
-        break;
-      default:
-        throw new TraceReferencesException("Unexpected format " + command.getOutputFormat().name());
-    }
-    formatter.format(result);
+    Tracer tracer = new Tracer(tagetDescriptors, builder.build(), command.getDiagnosticsHandler());
+    tracer.run(command.getConsumer());
   }
 
   public static void run(String... args) throws CompilationFailedException {
diff --git a/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesCommand.java b/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesCommand.java
index f6fcb69..ae0ee57 100644
--- a/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesCommand.java
+++ b/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesCommand.java
@@ -11,10 +11,8 @@
 import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.Keep;
 import com.android.tools.r8.ProgramResourceProvider;
-import com.android.tools.r8.StringConsumer;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.origin.PathOrigin;
-import com.android.tools.r8.tracereferences.TraceReferencesCommandParser.OutputFormat;
 import com.android.tools.r8.utils.ArchiveResourceProvider;
 import com.android.tools.r8.utils.ExceptionDiagnostic;
 import com.android.tools.r8.utils.StringDiagnostic;
@@ -35,8 +33,7 @@
   private final ImmutableList<ClassFileResourceProvider> library;
   private final ImmutableList<ClassFileResourceProvider> traceTarget;
   private final ImmutableList<ProgramResourceProvider> traceSource;
-  private final StringConsumer output;
-  private final OutputFormat outputFormat;
+  private final TraceReferencesConsumer consumer;
 
   TraceReferencesCommand(
       boolean printHelp,
@@ -45,16 +42,14 @@
       ImmutableList<ClassFileResourceProvider> library,
       ImmutableList<ClassFileResourceProvider> traceTarget,
       ImmutableList<ProgramResourceProvider> traceSource,
-      StringConsumer output,
-      OutputFormat outputFormat) {
+      TraceReferencesConsumer consumer) {
     this.printHelp = printHelp;
     this.printVersion = printVersion;
     this.diagnosticsHandler = diagnosticsHandler;
     this.library = library;
     this.traceTarget = traceTarget;
     this.traceSource = traceSource;
-    this.output = output;
-    this.outputFormat = outputFormat;
+    this.consumer = consumer;
   }
 
   /**
@@ -101,8 +96,7 @@
         ImmutableList.builder();
     private final ImmutableList.Builder<ProgramResourceProvider> traceSourceBuilder =
         ImmutableList.builder();
-    private StringConsumer output;
-    private OutputFormat outputFormat = TraceReferencesCommandParser.OutputFormat.PRINTUSAGE;
+    private TraceReferencesConsumer consumer;
 
     private Builder(DiagnosticsHandler diagnosticsHandler) {
       this.diagnosticsHandler = diagnosticsHandler;
@@ -197,13 +191,8 @@
       return this;
     }
 
-    Builder setOutputPath(Path output) {
-      this.output = new StringConsumer.FileConsumer(output);
-      return this;
-    }
-
-    Builder setOutputFormat(OutputFormat outputFormat) {
-      this.outputFormat = outputFormat;
+    Builder setConsumer(TraceReferencesConsumer consumer) {
+      this.consumer = consumer;
       return this;
     }
 
@@ -217,8 +206,7 @@
           libraryBuilder.build(),
           traceTarget,
           traceSource,
-          output,
-          outputFormat);
+          consumer);
     }
 
     void error(Diagnostic diagnostic) {
@@ -244,11 +232,7 @@
     return traceSource;
   }
 
-  StringConsumer getOutput() {
-    return output;
-  }
-
-  OutputFormat getOutputFormat() {
-    return outputFormat;
+  TraceReferencesConsumer getConsumer() {
+    return consumer;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesCommandParser.java b/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesCommandParser.java
index 79de8e2..476d0d4 100644
--- a/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesCommandParser.java
+++ b/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesCommandParser.java
@@ -6,11 +6,13 @@
 import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.JdkClassFileProvider;
 import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.tracereferences.TraceReferencesFormattingConsumer.OutputFormat;
 import com.android.tools.r8.utils.ExceptionDiagnostic;
 import com.android.tools.r8.utils.FlagFile;
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.google.common.collect.ImmutableSet;
 import java.io.IOException;
+import java.io.PrintStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -19,17 +21,6 @@
 
 class TraceReferencesCommandParser {
 
-  enum OutputFormat {
-    /** Format used with the -printusage flag */
-    PRINTUSAGE,
-    /** Keep rules keeping each of the traced references */
-    KEEP_RULES,
-    /**
-     * Keep rules with <code>allowobfuscation</code> modifier keeping each of the traced references
-     */
-    KEEP_RULES_WITH_ALLOWOBFUSCATION
-  }
-
   private static final Set<String> OPTIONS_WITH_PARAMETER =
       ImmutableSet.of("--lib", "--target", "--source", "--format", "--output");
 
@@ -78,6 +69,8 @@
   private TraceReferencesCommand.Builder parse(
       String[] args, Origin origin, TraceReferencesCommand.Builder builder) {
     String[] expandedArgs = FlagFile.expandFlagFiles(args, builder::error);
+    Path output = null;
+    OutputFormat format = TraceReferencesFormattingConsumer.OutputFormat.PRINTUSAGE;
     for (int i = 0; i < expandedArgs.length; i++) {
       String arg = expandedArgs[i].trim();
       String nextArg = null;
@@ -103,28 +96,42 @@
       } else if (arg.equals("--source")) {
         builder.addSourceFiles(Paths.get(nextArg));
       } else if (arg.equals("--format")) {
-        OutputFormat format = null;
         if (nextArg.equals("printuses")) {
-          format = OutputFormat.PRINTUSAGE;
+          format = TraceReferencesFormattingConsumer.OutputFormat.PRINTUSAGE;
         }
         if (nextArg.equals("keep")) {
-          format = OutputFormat.KEEP_RULES;
+          format = TraceReferencesFormattingConsumer.OutputFormat.KEEP_RULES;
         }
         if (nextArg.equals("keepallowobfuscation")) {
-          format = OutputFormat.KEEP_RULES_WITH_ALLOWOBFUSCATION;
+          format = TraceReferencesFormattingConsumer.OutputFormat.KEEP_RULES_WITH_ALLOWOBFUSCATION;
         }
         if (format == null) {
           builder.error(new StringDiagnostic("Unsupported format '" + nextArg + "'"));
         }
-        builder.setOutputFormat(format);
       } else if (arg.equals("--output")) {
-        builder.setOutputPath(Paths.get(nextArg));
+        output = Paths.get(nextArg);
       } else if (arg.startsWith("@")) {
         builder.error(new StringDiagnostic("Recursive @argfiles are not supported: ", origin));
       } else {
         builder.error(new StringDiagnostic("Unsupported argument '" + arg + "'"));
       }
     }
+    final Path finalOutput = output;
+    builder.setConsumer(
+        new TraceReferencesFormattingConsumer(format) {
+          @Override
+          public void finished() {
+            PrintStream out = System.out;
+            if (finalOutput != null) {
+              try {
+                out = new PrintStream(Files.newOutputStream(finalOutput));
+              } catch (IOException e) {
+                builder.error(new ExceptionDiagnostic(e));
+              }
+            }
+            out.print(get());
+          }
+        });
     return builder;
   }
 
diff --git a/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesConsumer.java b/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesConsumer.java
new file mode 100644
index 0000000..38b8086
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesConsumer.java
@@ -0,0 +1,90 @@
+// Copyright (c) 2020, 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.tracereferences;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.KeepForSubclassing;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.PackageReference;
+
+/** Consumer interface for recording references */
+@KeepForSubclassing
+public interface TraceReferencesConsumer {
+
+  /**
+   * Interface for asking for the access flags for a traced reference when the definition is present
+   */
+  @Keep
+  interface AccessFlags {
+    boolean isStatic();
+
+    boolean isPublic();
+
+    boolean isProtected();
+
+    boolean isPrivate();
+  }
+
+  /**
+   * Interface for asking for additional class information for a traced class when the definition is
+   * found.
+   */
+  @Keep
+  interface ClassAccessFlags extends AccessFlags {
+    boolean isInterface();
+
+    boolean isEnum();
+  }
+
+  @Keep
+  interface FieldAccessFlags extends AccessFlags {}
+
+  @Keep
+  interface MethodAccessFlags extends AccessFlags {}
+
+  /** Interface implemented by all references reported */
+  @Keep
+  interface TracedReference<T, F> {
+    /** Returns if the reference does not have a definition in the program traced. */
+    boolean isMissingDefinition();
+
+    /** Returns the reference traced. */
+    T getReference();
+
+    /**
+     * Returns the access flags for the reference traced. If the definition is not found (<code>
+     * isMissingDefinition()</code> returns <code>true</code>) the access flags are not known and
+     * this returns <code>null</code>.
+     */
+    F getAccessFlags();
+  }
+
+  @Keep
+  interface TracedClass extends TracedReference<ClassReference, ClassAccessFlags> {}
+
+  @Keep
+  interface TracedField extends TracedReference<FieldReference, FieldAccessFlags> {}
+
+  @Keep
+  interface TracedMethod extends TracedReference<MethodReference, MethodAccessFlags> {}
+
+  /** Class has been traced. */
+  void acceptType(TracedClass tracedClazz);
+
+  /** Field has been traced. */
+  void acceptField(TracedField tracedField);
+
+  /** Method has been traced. */
+  void acceptMethod(TracedMethod tracedMethod);
+
+  /** Package which is required for package privatge access has been traced. */
+  void acceptPackage(PackageReference pkg);
+
+  /**
+   * Tracing has finished. There will be no more calls to any of the <code>acceptXXX</code> methods.
+   */
+  void finished();
+}
diff --git a/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesFormattingConsumer.java b/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesFormattingConsumer.java
new file mode 100644
index 0000000..67167c4
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesFormattingConsumer.java
@@ -0,0 +1,79 @@
+// Copyright (c) 2020, 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.tracereferences;
+
+import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.references.PackageReference;
+
+class TraceReferencesFormattingConsumer implements TraceReferencesConsumer {
+
+  public enum OutputFormat {
+    /** Format used with the -printusage flag */
+    PRINTUSAGE,
+    /** Keep rules keeping each of the traced references */
+    KEEP_RULES,
+    /**
+     * Keep rules with <code>allowobfuscation</code> modifier keeping each of the traced references
+     */
+    KEEP_RULES_WITH_ALLOWOBFUSCATION
+  }
+
+  private final OutputFormat format;
+  private final TraceReferencesResult.Builder builder = TraceReferencesResult.builder();
+  private boolean finishedCalled = false;
+
+  public TraceReferencesFormattingConsumer(OutputFormat format) {
+    this.format = format;
+  }
+
+  @Override
+  public void acceptType(TracedClass type) {
+    assert !finishedCalled;
+    builder.acceptType(type);
+  }
+
+  @Override
+  public void acceptField(TracedField field) {
+    assert !finishedCalled;
+    builder.acceptField(field);
+  }
+
+  @Override
+  public void acceptMethod(TracedMethod method) {
+    assert !finishedCalled;
+    builder.acceptMethod(method);
+  }
+
+  @Override
+  public void acceptPackage(PackageReference pkg) {
+    assert !finishedCalled;
+    builder.acceptPackage(pkg);
+  }
+
+  @Override
+  public void finished() {
+    assert !finishedCalled;
+    finishedCalled = true;
+  }
+
+  public String get() {
+    TraceReferencesResult result = builder.build();
+    Formatter formatter;
+    switch (format) {
+      case PRINTUSAGE:
+        formatter = new PrintUsesFormatter();
+        break;
+      case KEEP_RULES:
+        formatter = new KeepRuleFormatter(false);
+        break;
+      case KEEP_RULES_WITH_ALLOWOBFUSCATION:
+        formatter = new KeepRuleFormatter(true);
+        break;
+      default:
+        throw new Unreachable();
+    }
+    formatter.format(result);
+    return formatter.get();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesResult.java b/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesResult.java
new file mode 100644
index 0000000..f8dab44
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesResult.java
@@ -0,0 +1,94 @@
+// Copyright (c) 2020, 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.tracereferences;
+
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.PackageReference;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedClass;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedField;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedMethod;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+class TraceReferencesResult {
+
+  final Set<TracedClass> types;
+  final Map<ClassReference, Set<TracedField>> fields;
+  final Map<ClassReference, Set<TracedMethod>> methods;
+  final Set<PackageReference> keepPackageNames;
+  final Set<Object> missingDefinition;
+
+  TraceReferencesResult(
+      Set<TracedClass> types,
+      Map<ClassReference, Set<TracedField>> fields,
+      Map<ClassReference, Set<TracedMethod>> methods,
+      Set<PackageReference> keepPackageNames,
+      Set<Object> missingDefinition) {
+    this.types = types;
+    this.fields = fields;
+    this.methods = methods;
+    this.keepPackageNames = keepPackageNames;
+    this.missingDefinition = missingDefinition;
+  }
+
+  static Builder builder() {
+    return new Builder();
+  }
+
+  static class Builder implements TraceReferencesConsumer {
+    private final Set<TracedClass> types = new HashSet<>();
+    private final Map<ClassReference, Set<TracedField>> fields = new HashMap<>();
+    private final Map<ClassReference, Set<TracedMethod>> methods = new HashMap<>();
+    private final Set<Object> missingDefinition = new HashSet<>();
+    private final Set<PackageReference> keepPackageNames = new HashSet<>();
+
+    @Override
+    public void acceptType(TracedClass tracedClass) {
+      types.add(tracedClass);
+      if (tracedClass.isMissingDefinition()) {
+        this.missingDefinition.add(tracedClass.getReference());
+      }
+    }
+
+    @Override
+    public void acceptField(TracedField tracedField) {
+      FieldReference field = tracedField.getReference();
+      fields.computeIfAbsent(field.getHolderClass(), k -> new HashSet<>()).add(tracedField);
+      if (tracedField.isMissingDefinition()) {
+        this.missingDefinition.add(field);
+      }
+    }
+
+    @Override
+    public void acceptMethod(TracedMethod tracedMethod) {
+      MethodReference method = tracedMethod.getReference();
+      methods.computeIfAbsent(method.getHolderClass(), k -> new HashSet<>()).add(tracedMethod);
+      if (tracedMethod.isMissingDefinition()) {
+        this.missingDefinition.add(method);
+      }
+    }
+
+    @Override
+    public void acceptPackage(PackageReference pkg) {
+      keepPackageNames.add(pkg);
+    }
+
+    @Override
+    public void finished() {}
+
+    TraceReferencesResult build() {
+      missingDefinition.forEach(
+          missingDefinition -> {
+            assert missingDefinition instanceof ClassReference
+                || missingDefinition instanceof FieldReference
+                || missingDefinition instanceof MethodReference;
+          });
+      return new TraceReferencesResult(types, fields, methods, keepPackageNames, missingDefinition);
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/tracereferences/Tracer.java b/src/main/java/com/android/tools/r8/tracereferences/Tracer.java
index 5ad1cfa..d30158b 100644
--- a/src/main/java/com/android/tools/r8/tracereferences/Tracer.java
+++ b/src/main/java/com/android/tools/r8/tracereferences/Tracer.java
@@ -5,6 +5,7 @@
 
 import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
 
+import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.dex.ApplicationReader;
 import com.android.tools.r8.features.ClassToFeatureSplitMap;
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
@@ -17,7 +18,6 @@
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProgramClass;
-import com.android.tools.r8.graph.DexReference;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.DexValue;
 import com.android.tools.r8.graph.DexValue.DexValueArray;
@@ -26,29 +26,209 @@
 import com.android.tools.r8.graph.ResolutionResult;
 import com.android.tools.r8.graph.UseRegistry;
 import com.android.tools.r8.ir.desugar.LambdaDescriptor;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.shaking.MainDexClasses;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.AccessFlags;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.ClassAccessFlags;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.FieldAccessFlags;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.MethodAccessFlags;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedClass;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedField;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedMethod;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedReference;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.StringDiagnostic;
 import com.android.tools.r8.utils.Timing;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
+import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 
 class Tracer {
 
+  static class AccessFlagsImpl<T extends com.android.tools.r8.graph.AccessFlags<T>>
+      implements AccessFlags {
+    T accessFlags;
+
+    AccessFlagsImpl(T accessFlags) {
+      this.accessFlags = accessFlags;
+    }
+
+    @Override
+    public boolean isStatic() {
+      return accessFlags.isStatic();
+    }
+
+    @Override
+    public boolean isPublic() {
+      return accessFlags.isPublic();
+    }
+
+    @Override
+    public boolean isProtected() {
+      return accessFlags.isProtected();
+    }
+
+    @Override
+    public boolean isPrivate() {
+      return accessFlags.isPrivate();
+    }
+  }
+
+  static class ClassAccessFlagsImpl
+      extends AccessFlagsImpl<com.android.tools.r8.graph.ClassAccessFlags>
+      implements ClassAccessFlags {
+    ClassAccessFlagsImpl(com.android.tools.r8.graph.ClassAccessFlags accessFlags) {
+      super(accessFlags);
+    }
+
+    @Override
+    public boolean isInterface() {
+      return accessFlags.isInterface();
+    }
+
+    @Override
+    public boolean isEnum() {
+      return accessFlags.isEnum();
+    }
+  }
+
+  static class FieldAccessFlagsImpl
+      extends AccessFlagsImpl<com.android.tools.r8.graph.FieldAccessFlags>
+      implements FieldAccessFlags {
+    FieldAccessFlagsImpl(com.android.tools.r8.graph.FieldAccessFlags accessFlags) {
+      super(accessFlags);
+    }
+  }
+
+  static class MethodAccessFlagsImpl
+      extends AccessFlagsImpl<com.android.tools.r8.graph.MethodAccessFlags>
+      implements MethodAccessFlags {
+    MethodAccessFlagsImpl(com.android.tools.r8.graph.MethodAccessFlags accessFlags) {
+      super(accessFlags);
+    }
+  }
+
+  abstract static class TracedReferenceBase<T, F> implements TracedReference<T, F> {
+    private final T reference;
+    private final F accessFlags;
+    private final boolean missingDefinition;
+
+    private TracedReferenceBase(T reference, F accessFlags, boolean missingDefinition) {
+      assert accessFlags != null || missingDefinition;
+      this.reference = reference;
+      this.accessFlags = accessFlags;
+      this.missingDefinition = missingDefinition;
+    }
+
+    @Override
+    public T getReference() {
+      return reference;
+    }
+
+    @Override
+    public boolean isMissingDefinition() {
+      return missingDefinition;
+    }
+
+    @Override
+    public F getAccessFlags() {
+      return accessFlags;
+    }
+
+    @Override
+    public int hashCode() {
+      // Equality is only based on the reference.
+      return reference.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object other) {
+      // Equality is only based on the reference.
+      if (!(other instanceof TracedReferenceBase)) {
+        return false;
+      }
+      return reference.equals(((TracedReferenceBase<?, ?>) other).reference);
+    }
+
+    public abstract String getKindName();
+  }
+
+  static class TracedClassImpl extends TracedReferenceBase<ClassReference, ClassAccessFlags>
+      implements TracedClass {
+    private TracedClassImpl(DexType reference, DexClass definition) {
+      super(
+          Reference.classFromDescriptor(reference.toDescriptorString()),
+          definition != null ? new ClassAccessFlagsImpl(definition.getAccessFlags()) : null,
+          definition == null);
+    }
+
+    @Override
+    public String getKindName() {
+      return "type";
+    }
+
+    @Override
+    public String toString() {
+      return getReference().getTypeName();
+    }
+  }
+
+  static class TracedFieldImpl extends TracedReferenceBase<FieldReference, FieldAccessFlags>
+      implements TracedField {
+    private TracedFieldImpl(DexField reference, DexEncodedField definition) {
+      super(
+          Reference.field(
+              Reference.classFromDescriptor(reference.holder.toDescriptorString()),
+              reference.name.toString(),
+              Reference.typeFromDescriptor(reference.type.toDescriptorString())),
+          definition != null ? new FieldAccessFlagsImpl(definition.getAccessFlags()) : null,
+          definition == null);
+    }
+
+    @Override
+    public String getKindName() {
+      return "field";
+    }
+
+    @Override
+    public String toString() {
+      return getReference().toString();
+    }
+  }
+
+  static class TracedMethodImpl extends TracedReferenceBase<MethodReference, MethodAccessFlags>
+      implements TracedMethod {
+    private TracedMethodImpl(DexMethod reference, DexEncodedMethod definition) {
+      super(
+          reference.asMethodReference(),
+          definition != null ? new MethodAccessFlagsImpl(definition.getAccessFlags()) : null,
+          definition == null);
+    }
+
+    @Override
+    public String getKindName() {
+      return "method";
+    }
+
+    @Override
+    public String toString() {
+      return getReference().toString();
+    }
+  }
+
   private final Set<String> descriptors;
-  private Set<DexType> types = Sets.newIdentityHashSet();
-  private Map<DexType, Set<DexMethod>> methods = Maps.newIdentityHashMap();
-  private Map<DexType, Set<DexField>> fields = Maps.newIdentityHashMap();
-  private Set<String> keepPackageNames = Sets.newHashSet();
-  private Set<DexReference> missingDefinitions = Sets.newHashSet();
+  private final DiagnosticsHandler diagnostics;
   private final DirectMappedDexApplication application;
   private final AppInfoWithClassHierarchy appInfo;
 
-  Tracer(Set<String> descriptors, AndroidApp inputApp) throws Exception {
+  Tracer(Set<String> descriptors, AndroidApp inputApp, DiagnosticsHandler diagnostics)
+      throws Exception {
     this.descriptors = descriptors;
+    this.diagnostics = diagnostics;
     InternalOptions options = new InternalOptions();
     application =
         new ApplicationReader(inputApp, options, new Timing("ReferenceTrace")).read().toDirect();
@@ -59,8 +239,8 @@
             MainDexClasses.createEmptyMainDexClasses());
   }
 
-  Result run() {
-    UseCollector useCollector = new UseCollector(appInfo.dexItemFactory());
+  void run(TraceReferencesConsumer consumer) {
+    UseCollector useCollector = new UseCollector(appInfo.dexItemFactory(), consumer, diagnostics);
     for (DexProgramClass clazz : application.classes()) {
       useCollector.setContext(clazz);
       useCollector.registerSuperType(clazz, clazz.superType);
@@ -70,74 +250,80 @@
       clazz.forEachProgramMethod(useCollector::registerMethod);
       clazz.forEachField(useCollector::registerField);
     }
-
-    return new Result(application, types, keepPackageNames, fields, methods, missingDefinitions);
-  }
-
-  private boolean isTargetType(DexType type) {
-    return descriptors.contains(type.toDescriptorString());
-  }
-
-  private void addType(DexType type) {
-    if (isTargetType(type) && types.add(type)) {
-      DexClass clazz = appInfo.definitionFor(type);
-      if (clazz != null && clazz.accessFlags.isVisibilityDependingOnPackage()) {
-        keepPackageNames.add(clazz.type.getPackageName());
-      }
-      methods.put(type, Sets.newIdentityHashSet());
-      fields.put(type, Sets.newIdentityHashSet());
-    }
-  }
-
-  private void addField(DexField field) {
-    addType(field.type);
-    DexEncodedField baseField = appInfo.resolveField(field).getResolvedField();
-    if (baseField != null && baseField.holder() != field.holder) {
-      field = baseField.field;
-    }
-    addType(field.holder);
-    if (isTargetType(field.holder)) {
-      Set<DexField> typeFields = fields.get(field.holder);
-      assert typeFields != null;
-      if (baseField != null) {
-        if (baseField.accessFlags.isVisibilityDependingOnPackage()) {
-          keepPackageNames.add(baseField.holder().getPackageName());
-        }
-      } else {
-        missingDefinitions.add(field);
-      }
-      typeFields.add(field);
-    }
-  }
-
-  private void addMethod(DexMethod method) {
-    addType(method.holder);
-    for (DexType parameterType : method.proto.parameters.values) {
-      addType(parameterType);
-    }
-    addType(method.proto.returnType);
-    if (isTargetType(method.holder)) {
-      Set<DexMethod> typeMethods = methods.get(method.holder);
-      assert typeMethods != null;
-      DexClass holder = appInfo.definitionForHolder(method);
-      DexEncodedMethod definition = method.lookupOnClass(holder);
-      if (definition != null) {
-        if (definition.accessFlags.isVisibilityDependingOnPackage()) {
-          keepPackageNames.add(definition.holder().getPackageName());
-        }
-      } else {
-        missingDefinitions.add(method);
-      }
-      typeMethods.add(method);
-    }
+    consumer.finished();
   }
 
   class UseCollector extends UseRegistry {
 
+    private final TraceReferencesConsumer consumer;
     private DexProgramClass context;
+    private final DiagnosticsHandler diagnostics;
+    private Set<TracedReference<?, ?>> missingDefinitionReported = new HashSet<>();
 
-    UseCollector(DexItemFactory factory) {
+    UseCollector(
+        DexItemFactory factory, TraceReferencesConsumer consumer, DiagnosticsHandler diagnostics) {
       super(factory);
+      this.consumer = consumer;
+      this.diagnostics = diagnostics;
+    }
+
+    private boolean isTargetType(DexType type) {
+      return descriptors.contains(type.toDescriptorString());
+    }
+
+    private void addType(DexType type) {
+      if (isTargetType(type)) {
+        DexClass clazz = appInfo.definitionFor(type);
+        TracedClassImpl tracedClass = new TracedClassImpl(type, clazz);
+        consumer.acceptType(tracedClass);
+        checkDiagnostics(tracedClass);
+        if (clazz != null && clazz.accessFlags.isVisibilityDependingOnPackage()) {
+          consumer.acceptPackage(Reference.packageFromString(clazz.type.getPackageName()));
+        }
+      }
+    }
+
+    private void addField(DexField field) {
+      addType(field.type);
+      DexEncodedField baseField = appInfo.resolveField(field).getResolvedField();
+      if (baseField != null && baseField.holder() != field.holder) {
+        field = baseField.field;
+      }
+      addType(field.holder);
+      if (isTargetType(field.holder)) {
+        TracedFieldImpl tracedField = new TracedFieldImpl(field, baseField);
+        consumer.acceptField(tracedField);
+        checkDiagnostics(tracedField);
+        if (baseField != null && baseField.accessFlags.isVisibilityDependingOnPackage()) {
+          consumer.acceptPackage(Reference.packageFromString(baseField.holder().getPackageName()));
+        }
+      }
+    }
+
+    private void addMethod(DexMethod method) {
+      addType(method.holder);
+      for (DexType parameterType : method.proto.parameters.values) {
+        addType(parameterType);
+      }
+      addType(method.proto.returnType);
+      if (isTargetType(method.holder)) {
+        DexClass holder = appInfo.definitionForHolder(method);
+        DexEncodedMethod definition = method.lookupOnClass(holder);
+        TracedMethodImpl tracedMethod = new TracedMethodImpl(method, definition);
+        consumer.acceptMethod(tracedMethod);
+        checkDiagnostics(tracedMethod);
+        if (definition != null && definition.accessFlags.isVisibilityDependingOnPackage()) {
+          consumer.acceptPackage(Reference.packageFromString(definition.holder().getPackageName()));
+        }
+      }
+    }
+
+    private void checkDiagnostics(TracedReferenceBase<?, ?> tracedReference) {
+      if (tracedReference.isMissingDefinition() && missingDefinitionReported.add(tracedReference)) {
+        diagnostics.warning(
+            new StringDiagnostic(
+                "Missing definition of " + tracedReference.getKindName() + " " + tracedReference));
+      }
     }
 
     public void setContext(DexProgramClass context) {
diff --git a/src/test/java/com/android/tools/r8/tracereferences/TraceReferencesCommandTest.java b/src/test/java/com/android/tools/r8/tracereferences/TraceReferencesCommandTest.java
index 489d8b2..88ec578 100644
--- a/src/test/java/com/android/tools/r8/tracereferences/TraceReferencesCommandTest.java
+++ b/src/test/java/com/android/tools/r8/tracereferences/TraceReferencesCommandTest.java
@@ -14,7 +14,7 @@
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.tracereferences.TraceReferencesCommandParser.OutputFormat;
+import com.android.tools.r8.tracereferences.TraceReferencesFormattingConsumer.OutputFormat;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.FileUtils;
@@ -26,6 +26,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
+import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;
@@ -53,8 +54,7 @@
     assertEquals(0, command.getLibrary().size());
     assertEquals(0, command.getTarget().size());
     assertEquals(0, command.getSource().size());
-    assertEquals(TraceReferencesCommandParser.OutputFormat.PRINTUSAGE, command.getOutputFormat());
-    assertNull(command.getOutput());
+    assertNull(command.getConsumer());
   }
 
   @Test(expected = CompilationFailedException.class)
@@ -105,29 +105,48 @@
   }
 
   private String formatName(OutputFormat format) {
-    if (format == TraceReferencesCommandParser.OutputFormat.PRINTUSAGE) {
+    if (format == TraceReferencesFormattingConsumer.OutputFormat.PRINTUSAGE) {
       return "printuses";
     }
-    if (format == TraceReferencesCommandParser.OutputFormat.KEEP_RULES) {
+    if (format == TraceReferencesFormattingConsumer.OutputFormat.KEEP_RULES) {
       return "keep";
     }
-    assertSame(format, TraceReferencesCommandParser.OutputFormat.KEEP_RULES_WITH_ALLOWOBFUSCATION);
+    assertSame(
+        format, TraceReferencesFormattingConsumer.OutputFormat.KEEP_RULES_WITH_ALLOWOBFUSCATION);
     return "keepallowobfuscation";
   }
 
   public void runAndCheckOutput(
       Path targetJar, Path sourceJar, OutputFormat format, String expected) throws Throwable {
+    runAndCheckOutput(targetJar, sourceJar, format, expected, null);
+  }
+
+  public void runAndCheckOutput(
+      Path targetJar,
+      Path sourceJar,
+      OutputFormat format,
+      String expected,
+      Consumer<DiagnosticsChecker> diagnosticsCheckerConsumer)
+      throws Throwable {
     Path dir = temp.newFolder().toPath();
     Path output = dir.resolve("output.txt");
+    DiagnosticsChecker diagnosticsChecker = new DiagnosticsChecker();
+    TraceReferencesFormattingConsumer consumer = new TraceReferencesFormattingConsumer(format);
     TraceReferences.run(
-        TraceReferencesCommand.builder()
+        TraceReferencesCommand.builder(diagnosticsChecker)
             .addLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.P))
             .addTargetFiles(targetJar)
             .addSourceFiles(sourceJar)
-            .setOutputPath(output)
-            .setOutputFormat(format)
+            .setConsumer(consumer)
             .build());
-    assertEquals(expected, FileUtils.readTextFile(output, Charsets.UTF_8));
+    assertEquals(expected, consumer.get());
+    if (diagnosticsCheckerConsumer != null) {
+      diagnosticsCheckerConsumer.accept(diagnosticsChecker);
+    } else {
+      assertEquals(0, diagnosticsChecker.errors.size());
+      assertEquals(0, diagnosticsChecker.warnings.size());
+      assertEquals(0, diagnosticsChecker.infos.size());
+    }
 
     TraceReferences.run(
         TraceReferencesCommand.parse(
@@ -172,7 +191,7 @@
     runAndCheckOutput(
         ImmutableList.of(Target.class),
         ImmutableList.of(Source.class),
-        TraceReferencesCommandParser.OutputFormat.PRINTUSAGE,
+        TraceReferencesFormattingConsumer.OutputFormat.PRINTUSAGE,
         StringUtils.lines(
             ImmutableList.of(
                 "com.android.tools.r8.tracereferences.TraceReferencesCommandTest$Target",
@@ -187,7 +206,7 @@
     runAndCheckOutput(
         ImmutableList.of(Target.class),
         ImmutableList.of(Source.class),
-        TraceReferencesCommandParser.OutputFormat.KEEP_RULES,
+        TraceReferencesFormattingConsumer.OutputFormat.KEEP_RULES,
         StringUtils.lines(
             ImmutableList.of(
                 "-keep class com.android.tools.r8.tracereferences.TraceReferencesCommandTest$Target"
@@ -203,7 +222,7 @@
     runAndCheckOutput(
         ImmutableList.of(Target.class),
         ImmutableList.of(Source.class),
-        TraceReferencesCommandParser.OutputFormat.KEEP_RULES_WITH_ALLOWOBFUSCATION,
+        TraceReferencesFormattingConsumer.OutputFormat.KEEP_RULES_WITH_ALLOWOBFUSCATION,
         StringUtils.lines(
             ImmutableList.of(
                 "-keep,allowobfuscation class"
@@ -219,7 +238,7 @@
     runAndCheckOutput(
         ImmutableList.of(OtherTarget.class),
         ImmutableList.of(Source.class),
-        TraceReferencesCommandParser.OutputFormat.PRINTUSAGE,
+        TraceReferencesFormattingConsumer.OutputFormat.PRINTUSAGE,
         StringUtils.lines(ImmutableList.of()));
   }
 
@@ -228,7 +247,7 @@
     runAndCheckOutput(
         ImmutableList.of(OtherTarget.class),
         ImmutableList.of(Source.class),
-        TraceReferencesCommandParser.OutputFormat.KEEP_RULES,
+        TraceReferencesFormattingConsumer.OutputFormat.KEEP_RULES,
         StringUtils.lines(ImmutableList.of()));
   }
 
@@ -237,7 +256,7 @@
     runAndCheckOutput(
         ImmutableList.of(OtherTarget.class),
         ImmutableList.of(Source.class),
-        TraceReferencesCommandParser.OutputFormat.KEEP_RULES_WITH_ALLOWOBFUSCATION,
+        TraceReferencesFormattingConsumer.OutputFormat.KEEP_RULES_WITH_ALLOWOBFUSCATION,
         StringUtils.lines(ImmutableList.of()));
   }
 
@@ -264,7 +283,7 @@
     runAndCheckOutput(
         targetJar,
         sourceJar,
-        TraceReferencesCommandParser.OutputFormat.PRINTUSAGE,
+        TraceReferencesFormattingConsumer.OutputFormat.PRINTUSAGE,
         StringUtils.lines(
             ImmutableList.of(
                 "com.android.tools.r8.tracereferences.TraceReferencesCommandTest$Target",
@@ -273,7 +292,12 @@
                     + ".target(int)",
                 "# Error: Could not find definition for field int"
                     + " com.android.tools.r8.tracereferences.TraceReferencesCommandTest$Target"
-                    + ".field")));
+                    + ".field")),
+        diagnosticsChecker -> {
+          assertEquals(0, diagnosticsChecker.errors.size());
+          assertEquals(2, diagnosticsChecker.warnings.size());
+          assertEquals(0, diagnosticsChecker.infos.size());
+        });
   }
 
   @Test
@@ -289,7 +313,7 @@
     runAndCheckOutput(
         targetJar,
         sourceJar,
-        TraceReferencesCommandParser.OutputFormat.KEEP_RULES,
+        TraceReferencesFormattingConsumer.OutputFormat.KEEP_RULES,
         StringUtils.lines(
             ImmutableList.of(
                 "-keep class com.android.tools.r8.tracereferences.TraceReferencesCommandTest$Target"
@@ -301,7 +325,12 @@
                     + " com.android.tools.r8.tracereferences.TraceReferencesCommandTest$Target"
                     + ".field",
                 "}",
-                "-keeppackagenames com.android.tools.r8.tracereferences")));
+                "-keeppackagenames com.android.tools.r8.tracereferences")),
+        diagnosticsChecker -> {
+          assertEquals(0, diagnosticsChecker.errors.size());
+          assertEquals(2, diagnosticsChecker.warnings.size());
+          assertEquals(0, diagnosticsChecker.infos.size());
+        });
   }
 
   @Test
@@ -317,7 +346,7 @@
     runAndCheckOutput(
         targetJar,
         sourceJar,
-        TraceReferencesCommandParser.OutputFormat.KEEP_RULES_WITH_ALLOWOBFUSCATION,
+        TraceReferencesFormattingConsumer.OutputFormat.KEEP_RULES_WITH_ALLOWOBFUSCATION,
         StringUtils.lines(
             ImmutableList.of(
                 "-keep,allowobfuscation class"
@@ -327,7 +356,12 @@
                 "# Error: Could not find definition for field int"
                     + " com.android.tools.r8.tracereferences.TraceReferencesCommandTest$Target.field",
                 "}",
-                "-keeppackagenames com.android.tools.r8.tracereferences")));
+                "-keeppackagenames com.android.tools.r8.tracereferences")),
+        diagnosticsChecker -> {
+          assertEquals(0, diagnosticsChecker.errors.size());
+          assertEquals(2, diagnosticsChecker.warnings.size());
+          assertEquals(0, diagnosticsChecker.infos.size());
+        });
   }
 
   private byte[] getClassWithTargetRemoved() throws IOException {