diff --git a/src/main/java/com/android/tools/r8/BaseCompilerCommand.java b/src/main/java/com/android/tools/r8/BaseCompilerCommand.java
index 8323666..1431a9a 100644
--- a/src/main/java/com/android/tools/r8/BaseCompilerCommand.java
+++ b/src/main/java/com/android/tools/r8/BaseCompilerCommand.java
@@ -6,6 +6,7 @@
 import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.inspector.Inspector;
 import com.android.tools.r8.ir.desugar.DesugaredLibraryConfiguration;
 import com.android.tools.r8.ir.desugar.DesugaredLibraryConfigurationParser;
 import com.android.tools.r8.origin.Origin;
@@ -16,8 +17,11 @@
 import com.android.tools.r8.utils.Reporter;
 import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.function.BiPredicate;
+import java.util.function.Consumer;
 import java.util.function.Function;
 
 /**
@@ -41,6 +45,7 @@
   private final boolean optimizeMultidexForLinearAlloc;
   private final BiPredicate<String, Long> dexClassChecksumFilter;
   private final List<AssertionsConfiguration> assertionsConfiguration;
+  private final List<Consumer<Inspector>> outputInspections;
 
   BaseCompilerCommand(boolean printHelp, boolean printVersion) {
     super(printHelp, printVersion);
@@ -54,6 +59,7 @@
     optimizeMultidexForLinearAlloc = false;
     dexClassChecksumFilter = (name, checksum) -> true;
     assertionsConfiguration = new ArrayList<>();
+    outputInspections = null;
   }
 
   BaseCompilerCommand(
@@ -67,7 +73,8 @@
       boolean optimizeMultidexForLinearAlloc,
       boolean includeClassesChecksum,
       BiPredicate<String, Long> dexClassChecksumFilter,
-      List<AssertionsConfiguration> assertionsConfiguration) {
+      List<AssertionsConfiguration> assertionsConfiguration,
+      List<Consumer<Inspector>> outputInspections) {
     super(app);
     assert minApiLevel > 0;
     assert mode != null;
@@ -81,6 +88,7 @@
     this.includeClassesChecksum = includeClassesChecksum;
     this.dexClassChecksumFilter = dexClassChecksumFilter;
     this.assertionsConfiguration = assertionsConfiguration;
+    this.outputInspections = outputInspections;
   }
 
   /**
@@ -140,7 +148,11 @@
   }
 
   public List<AssertionsConfiguration> getAssertionsConfiguration() {
-    return assertionsConfiguration;
+    return Collections.unmodifiableList(assertionsConfiguration);
+  }
+
+  public Collection<Consumer<Inspector>> getOutputInspections() {
+    return Collections.unmodifiableList(outputInspections);
   }
 
   Reporter getReporter() {
@@ -173,6 +185,7 @@
     private boolean optimizeMultidexForLinearAlloc = false;
     private BiPredicate<String, Long> dexClassChecksumFilter = (name, checksum) -> true;
     private List<AssertionsConfiguration> assertionsConfiguration = new ArrayList<>();
+    private List<Consumer<Inspector>> outputInspections = new ArrayList<>();
 
     abstract CompilationMode defaultCompilationMode();
 
@@ -552,5 +565,31 @@
       }
       super.validate();
     }
+
+    /**
+     * Add an inspection of the output program.
+     *
+     * <p>On a successful compilation the inspection is guaranteed to be called with inspectors that
+     * combined cover all of the output program. The inspections may be called multiple times with
+     * inspectors that have overlapping content (eg, classes synthesized based on multiple inputs
+     * can lead to this). Any overlapping content will be consistent, e.g., the inspection of type T
+     * will be the same (equality, not identify) as any other inspection of type T.
+     *
+     * <p>There is no guarantee of the order inspections are called or on which thread they are
+     * called.
+     *
+     * <p>The validity of an {@code Inspector} and all of its sub-inspectors, eg,
+     * {@MethodInspector}, is that of the callback. If any inspector object escapes the scope of the
+     * callback, the behavior of that inspector is undefined.
+     *
+     * @param inspection Inspection callback receiving inspectors denoting parts of the output.
+     */
+    public void addOutputInspection(Consumer<Inspector> inspection) {
+      outputInspections.add(inspection);
+    }
+
+    List<Consumer<Inspector>> getOutputInspections() {
+      return outputInspections;
+    }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/D8.java b/src/main/java/com/android/tools/r8/D8.java
index 93387f0..1ce0024 100644
--- a/src/main/java/com/android/tools/r8/D8.java
+++ b/src/main/java/com/android/tools/r8/D8.java
@@ -18,6 +18,7 @@
 import com.android.tools.r8.graph.GraphLense;
 import com.android.tools.r8.graph.InitClassLens;
 import com.android.tools.r8.graph.analysis.ClassInitializerAssertionEnablingAnalysis;
+import com.android.tools.r8.inspector.internal.InspectorImpl;
 import com.android.tools.r8.ir.conversion.IRConverter;
 import com.android.tools.r8.ir.desugar.PrefixRewritingMapper;
 import com.android.tools.r8.ir.optimize.AssertionsRewriter;
@@ -221,6 +222,7 @@
         markers.add(marker);
       }
 
+      InspectorImpl.runInspections(options.outputInspections, app);
       if (options.isGeneratingClassFiles()) {
         new CfApplicationWriter(
                 app,
diff --git a/src/main/java/com/android/tools/r8/D8Command.java b/src/main/java/com/android/tools/r8/D8Command.java
index b7c9347..32e653c 100644
--- a/src/main/java/com/android/tools/r8/D8Command.java
+++ b/src/main/java/com/android/tools/r8/D8Command.java
@@ -6,6 +6,8 @@
 import com.android.tools.r8.AssertionsConfiguration.AssertionTransformation;
 import com.android.tools.r8.errors.DexFileOverflowDiagnostic;
 import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.inspector.Inspector;
+import com.android.tools.r8.inspector.internal.InspectorImpl;
 import com.android.tools.r8.ir.desugar.DesugaredLibraryConfiguration;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.AndroidApiLevel;
@@ -19,6 +21,7 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.function.BiPredicate;
+import java.util.function.Consumer;
 
 /**
  * Immutable command structure for an invocation of the {@link D8} compiler.
@@ -36,13 +39,6 @@
 @Keep
 public final class D8Command extends BaseCompilerCommand {
 
-  private static class ClasspathInputOrigin extends InputFileOrigin {
-
-    public ClasspathInputOrigin(Path file) {
-      super("classpath input", file);
-    }
-  }
-
   private static class DefaultD8DiagnosticsHandler implements DiagnosticsHandler {
 
     @Override
@@ -229,6 +225,7 @@
           desugaredLibraryKeepRuleConsumer,
           libraryConfiguration,
           getAssertionsConfiguration(),
+          getOutputInspections(),
           factory);
     }
   }
@@ -297,6 +294,7 @@
       StringConsumer desugaredLibraryKeepRuleConsumer,
       DesugaredLibraryConfiguration libraryConfiguration,
       List<AssertionsConfiguration> assertionsConfiguration,
+      List<Consumer<Inspector>> outputInspections,
       DexItemFactory factory) {
     super(
         inputApp,
@@ -309,7 +307,8 @@
         optimizeMultidexForLinearAlloc,
         encodeChecksum,
         dexClassChecksumFilter,
-        assertionsConfiguration);
+        assertionsConfiguration,
+        outputInspections);
     this.intermediate = intermediate;
     this.desugarGraphConsumer = desugarGraphConsumer;
     this.desugaredLibraryKeepRuleConsumer = desugaredLibraryKeepRuleConsumer;
@@ -379,6 +378,8 @@
         new AssertionConfigurationWithDefault(
             AssertionTransformation.DISABLE, getAssertionsConfiguration());
 
+    internal.outputInspections = InspectorImpl.wrapInspections(getOutputInspections());
+
     return internal;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/L8Command.java b/src/main/java/com/android/tools/r8/L8Command.java
index 9db1c33..c863fe6 100644
--- a/src/main/java/com/android/tools/r8/L8Command.java
+++ b/src/main/java/com/android/tools/r8/L8Command.java
@@ -7,6 +7,7 @@
 import com.android.tools.r8.ProgramResource.Kind;
 import com.android.tools.r8.errors.DexFileOverflowDiagnostic;
 import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.inspector.Inspector;
 import com.android.tools.r8.ir.desugar.DesugaredLibraryConfiguration;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.AndroidApp;
@@ -21,6 +22,7 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.function.Consumer;
 
 /** Immutable command structure for an invocation of the {@link L8} library compiler. */
 @Keep
@@ -83,6 +85,7 @@
       Reporter diagnosticsHandler,
       DesugaredLibraryConfiguration libraryConfiguration,
       List<AssertionsConfiguration> assertionsConfiguration,
+      List<Consumer<Inspector>> outputInspections,
       DexItemFactory factory) {
     super(
         inputApp,
@@ -95,7 +98,8 @@
         false,
         false,
         (name, checksum) -> true,
-        assertionsConfiguration);
+        assertionsConfiguration,
+        outputInspections);
     this.d8Command = d8Command;
     this.r8Command = r8Command;
     this.libraryConfiguration = libraryConfiguration;
@@ -317,6 +321,7 @@
           getReporter(),
           libraryConfiguration,
           getAssertionsConfiguration(),
+          getOutputInspections(),
           factory);
     }
   }
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index eb5ba8e..4961a3e 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -31,6 +31,7 @@
 import com.android.tools.r8.graph.InitClassLens;
 import com.android.tools.r8.graph.analysis.ClassInitializerAssertionEnablingAnalysis;
 import com.android.tools.r8.graph.analysis.InitializedClassesInInstanceMethodsAnalysis;
+import com.android.tools.r8.inspector.internal.InspectorImpl;
 import com.android.tools.r8.ir.analysis.proto.GeneratedExtensionRegistryShrinker;
 import com.android.tools.r8.ir.conversion.IRConverter;
 import com.android.tools.r8.ir.desugar.BackportedMethodRewriter;
@@ -201,6 +202,7 @@
       InternalOptions options,
       ProguardMapSupplier proguardMapSupplier)
       throws ExecutionException {
+    InspectorImpl.runInspections(options.outputInspections, application);
     try {
       Marker marker = options.getMarker(Tool.R8);
       assert marker != null;
diff --git a/src/main/java/com/android/tools/r8/R8Command.java b/src/main/java/com/android/tools/r8/R8Command.java
index 4051f9c..a9c92d2 100644
--- a/src/main/java/com/android/tools/r8/R8Command.java
+++ b/src/main/java/com/android/tools/r8/R8Command.java
@@ -9,6 +9,8 @@
 import com.android.tools.r8.experimental.graphinfo.GraphConsumer;
 import com.android.tools.r8.features.FeatureSplitConfiguration;
 import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.inspector.Inspector;
+import com.android.tools.r8.inspector.internal.InspectorImpl;
 import com.android.tools.r8.ir.desugar.DesugaredLibraryConfiguration;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.origin.PathOrigin;
@@ -567,7 +569,8 @@
               desugaredLibraryKeepRuleConsumer,
               libraryConfiguration,
               featureSplitConfiguration,
-              getAssertionsConfiguration());
+              getAssertionsConfiguration(),
+              getOutputInspections());
 
       return command;
     }
@@ -724,7 +727,8 @@
       StringConsumer desugaredLibraryKeepRuleConsumer,
       DesugaredLibraryConfiguration libraryConfiguration,
       FeatureSplitConfiguration featureSplitConfiguration,
-      List<AssertionsConfiguration> assertionsConfiguration) {
+      List<AssertionsConfiguration> assertionsConfiguration,
+      List<Consumer<Inspector>> outputInspections) {
     super(
         inputApp,
         mode,
@@ -736,7 +740,8 @@
         optimizeMultidexForLinearAlloc,
         encodeChecksum,
         dexClassChecksumFilter,
-        assertionsConfiguration);
+        assertionsConfiguration,
+        outputInspections);
     assert proguardConfiguration != null;
     assert mainDexKeepRules != null;
     this.mainDexKeepRules = mainDexKeepRules;
@@ -874,6 +879,8 @@
 
     internal.syntheticProguardRulesConsumer = syntheticProguardRulesConsumer;
 
+    internal.outputInspections = InspectorImpl.wrapInspections(getOutputInspections());
+
     // Default is to remove all javac generated assertion code when generating dex.
     assert internal.assertionsConfiguration == null;
     internal.assertionsConfiguration =
diff --git a/src/main/java/com/android/tools/r8/inspector/BooleanValueInspector.java b/src/main/java/com/android/tools/r8/inspector/BooleanValueInspector.java
new file mode 100644
index 0000000..1fba365
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/BooleanValueInspector.java
@@ -0,0 +1,8 @@
+// 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.inspector;
+
+public interface BooleanValueInspector extends ValueInspector {
+  boolean getBooleanValue();
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/ByteValueInspector.java b/src/main/java/com/android/tools/r8/inspector/ByteValueInspector.java
new file mode 100644
index 0000000..718183e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/ByteValueInspector.java
@@ -0,0 +1,8 @@
+// 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.inspector;
+
+public interface ByteValueInspector extends ValueInspector {
+  byte getByteValue();
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/CharValueInspector.java b/src/main/java/com/android/tools/r8/inspector/CharValueInspector.java
new file mode 100644
index 0000000..d79ee9c
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/CharValueInspector.java
@@ -0,0 +1,8 @@
+// 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.inspector;
+
+public interface CharValueInspector extends ValueInspector {
+  char getCharValue();
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/ClassInspector.java b/src/main/java/com/android/tools/r8/inspector/ClassInspector.java
new file mode 100644
index 0000000..b18dd26
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/ClassInspector.java
@@ -0,0 +1,22 @@
+// 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.inspector;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.references.ClassReference;
+import java.util.function.Consumer;
+
+/** Inspector for a class or interface definition. */
+@Keep
+public interface ClassInspector {
+
+  /** Get the class reference for the class of this inspector. */
+  ClassReference getClassReference();
+
+  /** Iterate all fields declared in the class/interface (unspecified order). */
+  void forEachField(Consumer<FieldInspector> inspection);
+
+  /** Iterate all methods declared in the class/interface (unspecified order). */
+  void forEachMethod(Consumer<MethodInspector> inspection);
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/DoubleValueInspector.java b/src/main/java/com/android/tools/r8/inspector/DoubleValueInspector.java
new file mode 100644
index 0000000..334f7ac
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/DoubleValueInspector.java
@@ -0,0 +1,8 @@
+// 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.inspector;
+
+public interface DoubleValueInspector extends ValueInspector {
+  double getDoubleValue();
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/FieldInspector.java b/src/main/java/com/android/tools/r8/inspector/FieldInspector.java
new file mode 100644
index 0000000..5d2e656
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/FieldInspector.java
@@ -0,0 +1,30 @@
+// 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.inspector;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.references.FieldReference;
+import java.util.Optional;
+
+/** Inspector for a field definition. */
+@Keep
+public interface FieldInspector {
+
+  /** Get the field reference for the field of this inspector. */
+  FieldReference getFieldReference();
+
+  /** True if the field is declared static. */
+  boolean isStatic();
+
+  /** True if the field is declared final. */
+  boolean isFinal();
+
+  /**
+   * Returns an inspector for the initial value if it is known by the compiler.
+   *
+   * <p>Note that the determination of the value is best effort, often the value will simply be the
+   * default value for the given type.
+   */
+  Optional<ValueInspector> getInitialValue();
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/FloatValueInspector.java b/src/main/java/com/android/tools/r8/inspector/FloatValueInspector.java
new file mode 100644
index 0000000..cb4c12d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/FloatValueInspector.java
@@ -0,0 +1,8 @@
+// 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.inspector;
+
+public interface FloatValueInspector extends ValueInspector {
+  float getFloatValue();
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/Inspector.java b/src/main/java/com/android/tools/r8/inspector/Inspector.java
new file mode 100644
index 0000000..880b450
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/Inspector.java
@@ -0,0 +1,15 @@
+// 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.inspector;
+
+import com.android.tools.r8.Keep;
+import java.util.function.Consumer;
+
+/** Inspector providing access to various parts of an application. */
+@Keep
+public interface Inspector {
+
+  /** Iterate all classes and interfaces defined by the program (order unspecified). */
+  void forEachClass(Consumer<ClassInspector> inspection);
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/IntValueInspector.java b/src/main/java/com/android/tools/r8/inspector/IntValueInspector.java
new file mode 100644
index 0000000..38376c2
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/IntValueInspector.java
@@ -0,0 +1,8 @@
+// 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.inspector;
+
+public interface IntValueInspector extends ValueInspector {
+  int getIntValue();
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/LongValueInspector.java b/src/main/java/com/android/tools/r8/inspector/LongValueInspector.java
new file mode 100644
index 0000000..177a885
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/LongValueInspector.java
@@ -0,0 +1,8 @@
+// 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.inspector;
+
+public interface LongValueInspector extends ValueInspector {
+  long getLongValue();
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/MethodInspector.java b/src/main/java/com/android/tools/r8/inspector/MethodInspector.java
new file mode 100644
index 0000000..41cc8de
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/MethodInspector.java
@@ -0,0 +1,15 @@
+// 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.inspector;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.references.MethodReference;
+
+/** Inspector for a method definition. */
+@Keep
+public interface MethodInspector {
+
+  /** Get the method reference for the method of this inspector. */
+  MethodReference getMethodReference();
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/ShortValueInspector.java b/src/main/java/com/android/tools/r8/inspector/ShortValueInspector.java
new file mode 100644
index 0000000..fb1d823
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/ShortValueInspector.java
@@ -0,0 +1,8 @@
+// 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.inspector;
+
+public interface ShortValueInspector extends ValueInspector {
+  short getShortValue();
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/StringValueInspector.java b/src/main/java/com/android/tools/r8/inspector/StringValueInspector.java
new file mode 100644
index 0000000..c0b78c4
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/StringValueInspector.java
@@ -0,0 +1,8 @@
+// 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.inspector;
+
+public interface StringValueInspector extends ValueInspector {
+  String getStringValue();
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/ValueInspector.java b/src/main/java/com/android/tools/r8/inspector/ValueInspector.java
new file mode 100644
index 0000000..84f1fe0
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/ValueInspector.java
@@ -0,0 +1,53 @@
+// 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.inspector;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.references.TypeReference;
+
+/** Inspector for a JVM representable value. */
+@Keep
+public interface ValueInspector {
+
+  /** Get the type reference describing the type of the value. */
+  TypeReference getTypeReference();
+
+  boolean isPrimitive();
+
+  boolean isBooleanValue();
+
+  boolean isByteValue();
+
+  boolean isCharValue();
+
+  boolean isShortValue();
+
+  boolean isIntValue();
+
+  boolean isLongValue();
+
+  boolean isFloatValue();
+
+  boolean isDoubleValue();
+
+  boolean isStringValue();
+
+  BooleanValueInspector asBooleanValue();
+
+  ByteValueInspector asByteValue();
+
+  CharValueInspector asCharValue();
+
+  ShortValueInspector asShortValue();
+
+  IntValueInspector asIntValue();
+
+  LongValueInspector asLongValue();
+
+  FloatValueInspector asFloatValue();
+
+  DoubleValueInspector asDoubleValue();
+
+  StringValueInspector asStringValue();
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/internal/ClassInspectorImpl.java b/src/main/java/com/android/tools/r8/inspector/internal/ClassInspectorImpl.java
new file mode 100644
index 0000000..c2ebc8e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/internal/ClassInspectorImpl.java
@@ -0,0 +1,40 @@
+// 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.inspector.internal;
+
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.inspector.ClassInspector;
+import com.android.tools.r8.inspector.FieldInspector;
+import com.android.tools.r8.inspector.MethodInspector;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import java.util.function.Consumer;
+
+public class ClassInspectorImpl implements ClassInspector {
+
+  private final DexClass clazz;
+  private ClassReference reference = null;
+
+  ClassInspectorImpl(DexClass clazz) {
+    this.clazz = clazz;
+  }
+
+  @Override
+  public ClassReference getClassReference() {
+    if (reference == null) {
+      reference = Reference.classFromDescriptor(clazz.type.toDescriptorString());
+    }
+    return reference;
+  }
+
+  @Override
+  public void forEachField(Consumer<FieldInspector> inspection) {
+    clazz.forEachField(field -> inspection.accept(new FieldInspectorImpl(this, field)));
+  }
+
+  @Override
+  public void forEachMethod(Consumer<MethodInspector> inspection) {
+    clazz.forEachMethod(method -> inspection.accept(new MethodInspectorImpl(this, method)));
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/internal/FieldInspectorImpl.java b/src/main/java/com/android/tools/r8/inspector/internal/FieldInspectorImpl.java
new file mode 100644
index 0000000..056d652e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/internal/FieldInspectorImpl.java
@@ -0,0 +1,52 @@
+// 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.inspector.internal;
+
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.inspector.FieldInspector;
+import com.android.tools.r8.inspector.ValueInspector;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.Reference;
+import java.util.Optional;
+
+public class FieldInspectorImpl implements FieldInspector {
+  private final ClassInspectorImpl parent;
+  private final DexEncodedField field;
+  private FieldReference reference = null;
+
+  public FieldInspectorImpl(ClassInspectorImpl parent, DexEncodedField field) {
+    this.parent = parent;
+    this.field = field;
+  }
+
+  @Override
+  public FieldReference getFieldReference() {
+    if (reference == null) {
+      reference =
+          Reference.field(
+              parent.getClassReference(),
+              field.field.name.toString(),
+              Reference.typeFromDescriptor(field.field.type.toDescriptorString()));
+    }
+    return reference;
+  }
+
+  @Override
+  public boolean isStatic() {
+    return field.accessFlags.isStatic();
+  }
+
+  @Override
+  public boolean isFinal() {
+    return field.accessFlags.isFinal();
+  }
+
+  @Override
+  public Optional<ValueInspector> getInitialValue() {
+    if (field.isStatic() && field.getStaticValue() != null) {
+      return Optional.of(new ValueInspectorImpl(field.getStaticValue(), field.field.type));
+    }
+    return Optional.empty();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/internal/InspectorImpl.java b/src/main/java/com/android/tools/r8/inspector/internal/InspectorImpl.java
new file mode 100644
index 0000000..c3d8a64
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/internal/InspectorImpl.java
@@ -0,0 +1,54 @@
+// 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.inspector.internal;
+
+import com.android.tools.r8.graph.DexApplication;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.inspector.ClassInspector;
+import com.android.tools.r8.inspector.Inspector;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+
+public class InspectorImpl implements Inspector {
+
+  // This wrapping appears odd, but allows hooking in inspections on the impl type from tests.
+  public static List<Consumer<InspectorImpl>> wrapInspections(
+      Collection<Consumer<Inspector>> inspections) {
+    if (inspections == null || inspections.isEmpty()) {
+      return Collections.emptyList();
+    }
+    List<Consumer<InspectorImpl>> wrapped = new ArrayList<>(inspections.size());
+    for (Consumer<Inspector> inspection : inspections) {
+      wrapped.add(inspection::accept);
+    }
+    return wrapped;
+  }
+
+  public static void runInspections(
+      List<Consumer<InspectorImpl>> inspections, DexApplication application) {
+    if (inspections == null || inspections.isEmpty()) {
+      return;
+    }
+    InspectorImpl inspector = new InspectorImpl(application);
+    for (Consumer<InspectorImpl> inspection : inspections) {
+      inspection.accept(inspector);
+    }
+  }
+
+  private final DexApplication application;
+
+  public InspectorImpl(DexApplication application) {
+    this.application = application;
+  }
+
+  @Override
+  public void forEachClass(Consumer<ClassInspector> inspection) {
+    for (DexProgramClass clazz : application.classes()) {
+      inspection.accept(new ClassInspectorImpl(clazz));
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/internal/MethodInspectorImpl.java b/src/main/java/com/android/tools/r8/inspector/internal/MethodInspectorImpl.java
new file mode 100644
index 0000000..1d868be
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/internal/MethodInspectorImpl.java
@@ -0,0 +1,41 @@
+// 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.inspector.internal;
+
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.inspector.MethodInspector;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.ListUtils;
+import java.util.Arrays;
+
+public class MethodInspectorImpl implements MethodInspector {
+
+  private final ClassInspectorImpl parent;
+  private final DexEncodedMethod method;
+  private MethodReference reference;
+
+  public MethodInspectorImpl(ClassInspectorImpl parent, DexEncodedMethod method) {
+    this.parent = parent;
+    this.method = method;
+  }
+
+  @Override
+  public MethodReference getMethodReference() {
+    if (reference == null) {
+      reference =
+          Reference.method(
+              parent.getClassReference(),
+              method.method.name.toString(),
+              ListUtils.map(
+                  Arrays.asList(method.method.proto.parameters.values),
+                  param -> Reference.typeFromDescriptor(param.toDescriptorString())),
+              method.method.proto.returnType.isVoidType()
+                  ? null
+                  : Reference.typeFromDescriptor(
+                      method.method.proto.returnType.toDescriptorString()));
+    }
+    return reference;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/inspector/internal/ValueInspectorImpl.java b/src/main/java/com/android/tools/r8/inspector/internal/ValueInspectorImpl.java
new file mode 100644
index 0000000..8f269d7
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/inspector/internal/ValueInspectorImpl.java
@@ -0,0 +1,198 @@
+// 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.inspector.internal;
+
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexValue;
+import com.android.tools.r8.inspector.BooleanValueInspector;
+import com.android.tools.r8.inspector.ByteValueInspector;
+import com.android.tools.r8.inspector.CharValueInspector;
+import com.android.tools.r8.inspector.DoubleValueInspector;
+import com.android.tools.r8.inspector.FloatValueInspector;
+import com.android.tools.r8.inspector.IntValueInspector;
+import com.android.tools.r8.inspector.LongValueInspector;
+import com.android.tools.r8.inspector.ShortValueInspector;
+import com.android.tools.r8.inspector.StringValueInspector;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.references.TypeReference;
+
+public class ValueInspectorImpl
+    implements BooleanValueInspector,
+        ByteValueInspector,
+        CharValueInspector,
+        ShortValueInspector,
+        IntValueInspector,
+        LongValueInspector,
+        FloatValueInspector,
+        DoubleValueInspector,
+        StringValueInspector {
+
+  private final DexValue value;
+  private final DexType type;
+
+  public ValueInspectorImpl(DexValue value, DexType type) {
+    this.value = value;
+    this.type = type;
+  }
+
+  @Override
+  public TypeReference getTypeReference() {
+    return Reference.typeFromDescriptor(type.toDescriptorString());
+  }
+
+  @Override
+  public boolean isPrimitive() {
+    return type.isPrimitiveType();
+  }
+
+  @Override
+  public boolean isBooleanValue() {
+    return type.isBooleanType();
+  }
+
+  @Override
+  public BooleanValueInspector asBooleanValue() {
+    return isBooleanValue() ? this : null;
+  }
+
+  @Override
+  public boolean getBooleanValue() {
+    guard(isBooleanValue());
+    return value.asDexValueBoolean().getValue();
+  }
+
+  @Override
+  public boolean isByteValue() {
+    return type.isByteType();
+  }
+
+  @Override
+  public ByteValueInspector asByteValue() {
+    return isByteValue() ? this : null;
+  }
+
+  @Override
+  public byte getByteValue() {
+    guard(isByteValue());
+    return value.asDexValueByte().getValue();
+  }
+
+  @Override
+  public boolean isCharValue() {
+    return type.isCharType();
+  }
+
+  @Override
+  public CharValueInspector asCharValue() {
+    return isCharValue() ? this : null;
+  }
+
+  @Override
+  public char getCharValue() {
+    guard(isCharValue());
+    return value.asDexValueChar().getValue();
+  }
+
+  @Override
+  public boolean isShortValue() {
+    return type.isShortType();
+  }
+
+  @Override
+  public ShortValueInspector asShortValue() {
+    return isShortValue() ? this : null;
+  }
+
+  @Override
+  public short getShortValue() {
+    guard(isShortValue());
+    return value.asDexValueShort().getValue();
+  }
+
+  @Override
+  public boolean isIntValue() {
+    return type.isIntType();
+  }
+
+  @Override
+  public IntValueInspector asIntValue() {
+    return isIntValue() ? this : null;
+  }
+
+  @Override
+  public int getIntValue() {
+    guard(isIntValue());
+    return value.asDexValueInt().value;
+  }
+
+  @Override
+  public boolean isLongValue() {
+    return type.isLongType();
+  }
+
+  @Override
+  public LongValueInspector asLongValue() {
+    return isLongValue() ? this : null;
+  }
+
+  @Override
+  public long getLongValue() {
+    guard(isLongValue());
+    return value.asDexValueLong().getValue();
+  }
+
+  @Override
+  public boolean isFloatValue() {
+    return type.isFloatType();
+  }
+
+  @Override
+  public FloatValueInspector asFloatValue() {
+    return isFloatValue() ? this : null;
+  }
+
+  @Override
+  public float getFloatValue() {
+    guard(isFloatValue());
+    return value.asDexValueFloat().getValue();
+  }
+
+  @Override
+  public boolean isDoubleValue() {
+    return type.isDoubleType();
+  }
+
+  @Override
+  public DoubleValueInspector asDoubleValue() {
+    return isDoubleValue() ? this : null;
+  }
+
+  @Override
+  public double getDoubleValue() {
+    guard(isDoubleValue());
+    return value.asDexValueDouble().getValue();
+  }
+
+  @Override
+  public boolean isStringValue() {
+    return type.isClassType() && value.isDexValueString();
+  }
+
+  @Override
+  public StringValueInspector asStringValue() {
+    return isStringValue() ? this : null;
+  }
+
+  @Override
+  public String getStringValue() {
+    guard(isStringValue());
+    return value.asDexValueString().getValue().toString();
+  }
+
+  private static void guard(boolean precondition) {
+    if (!precondition) {
+      throw new IllegalStateException("Invalid call on ValueInspector");
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index 3e44783..7ff5ff4 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -32,6 +32,7 @@
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.inspector.internal.InspectorImpl;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.desugar.DesugaredLibraryConfiguration;
 import com.android.tools.r8.ir.optimize.Inliner;
@@ -58,6 +59,7 @@
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.Deque;
 import java.util.HashMap;
@@ -113,6 +115,8 @@
   public DataResourceConsumer dataResourceConsumer;
   public FeatureSplitConfiguration featureSplitConfiguration;
 
+  public List<Consumer<InspectorImpl>> outputInspections = Collections.emptyList();
+
   // Constructor for testing and/or other utilities.
   public InternalOptions() {
     reporter = new Reporter();
diff --git a/src/test/java/com/android/tools/r8/inspection/FieldFlagsAndValueInspectionTest.java b/src/test/java/com/android/tools/r8/inspection/FieldFlagsAndValueInspectionTest.java
new file mode 100644
index 0000000..d64be27
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/inspection/FieldFlagsAndValueInspectionTest.java
@@ -0,0 +1,112 @@
+// 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.inspection;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.inspector.Inspector;
+import com.android.tools.r8.inspector.ValueInspector;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.StringUtils;
+import java.util.Optional;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class FieldFlagsAndValueInspectionTest extends TestBase {
+
+  static final String EXPECTED = StringUtils.lines("30");
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public FieldFlagsAndValueInspectionTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    if (parameters.isCfRuntime()) {
+      testForJvm()
+          .addProgramClasses(TestClass.class)
+          .run(parameters.getRuntime(), TestClass.class)
+          .assertSuccessWithOutput(EXPECTED);
+      return;
+    }
+    testForD8()
+        .addProgramClasses(TestClass.class)
+        .setMinApi(parameters.getApiLevel())
+        .apply(b -> b.getBuilder().addOutputInspection(inspector -> inspection(inspector, false)))
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED);
+    assertFound();
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(TestClass.class)
+        .addKeepClassAndMembersRules(TestClass.class)
+        .setMinApi(parameters.getApiLevel())
+        .apply(b -> b.getBuilder().addOutputInspection(inspector -> inspection(inspector, true)))
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED);
+    assertFound();
+  }
+
+  private int foundFields = 0;
+
+  private void inspection(Inspector inspector, boolean isR8) {
+    inspector.forEachClass(
+        classInspector -> {
+          classInspector.forEachField(
+              fieldInspector -> {
+                foundFields++;
+                String name = fieldInspector.getFieldReference().getFieldName();
+                assertEquals(name.contains("s"), fieldInspector.isStatic());
+                assertEquals(name.contains("f"), fieldInspector.isFinal());
+                assertEquals(Reference.INT, fieldInspector.getFieldReference().getFieldType());
+                Optional<ValueInspector> value = fieldInspector.getInitialValue();
+                if (fieldInspector.isStatic() && fieldInspector.isFinal()) {
+                  // The static final 'sfi' is static initialized to 2.
+                  assertTrue(value.isPresent());
+                  assertEquals(2, value.get().asIntValue().getIntValue());
+                } else if (fieldInspector.isStatic()) {
+                  // The static 'si' is default initialized to 0 and clinit sets it to 4.
+                  // R8 optimizes that to directly set 4.
+                  assertTrue(value.isPresent());
+                  assertEquals(isR8 ? 4 : 0, value.get().asIntValue().getIntValue());
+                } else {
+                  assertFalse(value.isPresent());
+                }
+              });
+        });
+  }
+
+  private void assertFound() {
+    assertEquals(4, foundFields);
+  }
+
+  static class TestClass {
+    public static final int sfi = 2;
+    public static int si = 4;
+    public final int fi = 8;
+    public int i = 16;
+
+    public static void main(String[] args) {
+      TestClass obj = new TestClass();
+      System.out.println(obj.sfi + obj.si + obj.fi + obj.i);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/inspection/FieldValueTypesInspectionTest.java b/src/test/java/com/android/tools/r8/inspection/FieldValueTypesInspectionTest.java
new file mode 100644
index 0000000..0031885
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/inspection/FieldValueTypesInspectionTest.java
@@ -0,0 +1,196 @@
+// 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.inspection;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.inspector.Inspector;
+import com.android.tools.r8.inspector.ValueInspector;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.StringUtils;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class FieldValueTypesInspectionTest extends TestBase {
+
+  static final String EXPECTED =
+      StringUtils.lines(
+          "" + TestClass.z,
+          "" + TestClass.b,
+          "" + TestClass.c,
+          "" + TestClass.s,
+          "" + TestClass.i,
+          "" + TestClass.j,
+          "" + TestClass.f,
+          "" + TestClass.d,
+          "foo");
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public FieldValueTypesInspectionTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    if (parameters.isCfRuntime()) {
+      testForJvm()
+          .addProgramClasses(TestClass.class)
+          .run(parameters.getRuntime(), TestClass.class)
+          .assertSuccessWithOutput(EXPECTED);
+      return;
+    }
+    testForD8()
+        .addProgramClasses(TestClass.class)
+        .setMinApi(parameters.getApiLevel())
+        .apply(b -> b.getBuilder().addOutputInspection(this::inspection))
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED);
+    assertFound();
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(TestClass.class)
+        .addKeepClassAndMembersRules(TestClass.class)
+        .setMinApi(parameters.getApiLevel())
+        .apply(b -> b.getBuilder().addOutputInspection(this::inspection))
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED);
+    assertFound();
+  }
+
+  private int foundFields = 0;
+
+  private void inspection(Inspector inspector) {
+    inspector.forEachClass(
+        classInspector -> {
+          classInspector.forEachField(
+              fieldInspector -> {
+                foundFields++;
+                FieldReference reference = fieldInspector.getFieldReference();
+                ValueInspector value = fieldInspector.getInitialValue().get();
+                assertEquals(reference.getFieldType(), value.getTypeReference());
+                String name = reference.getFieldName();
+                boolean isBoolean = name.equals("z");
+                boolean isByte = name.equals("b");
+                boolean isChar = name.equals("c");
+                boolean isShort = name.equals("s");
+                boolean isInt = name.equals("i");
+                boolean isLong = name.equals("j");
+                boolean isFloat = name.equals("f");
+                boolean isDouble = name.equals("d");
+                boolean isString = name.equals("str");
+                assertEquals(isBoolean, value.isBooleanValue());
+                assertEquals(isByte, value.isByteValue());
+                assertEquals(isChar, value.isCharValue());
+                assertEquals(isShort, value.isShortValue());
+                assertEquals(isInt, value.isIntValue());
+                assertEquals(isLong, value.isLongValue());
+                assertEquals(isFloat, value.isFloatValue());
+                assertEquals(isDouble, value.isDoubleValue());
+                assertEquals(isString, value.isStringValue());
+                if (isBoolean) {
+                  assertEquals(Reference.BOOL, reference.getFieldType());
+                  assertEquals(TestClass.z, value.asBooleanValue().getBooleanValue());
+                } else {
+                  assertNull(value.asBooleanValue());
+                }
+                if (isByte) {
+                  assertEquals(Reference.BYTE, reference.getFieldType());
+                  assertEquals(TestClass.b, value.asByteValue().getByteValue());
+                } else {
+                  assertNull(value.asByteValue());
+                }
+                if (isChar) {
+                  assertEquals(Reference.CHAR, reference.getFieldType());
+                  assertEquals(TestClass.c, value.asCharValue().getCharValue());
+                } else {
+                  assertNull(value.asCharValue());
+                }
+                if (isShort) {
+                  assertEquals(Reference.SHORT, reference.getFieldType());
+                  assertEquals(TestClass.s, value.asShortValue().getShortValue());
+                } else {
+                  assertNull(value.asShortValue());
+                }
+                if (isInt) {
+                  assertEquals(Reference.INT, reference.getFieldType());
+                  assertEquals(TestClass.i, value.asIntValue().getIntValue());
+                } else {
+                  assertNull(value.asIntValue());
+                }
+                if (isLong) {
+                  assertEquals(Reference.LONG, reference.getFieldType());
+                  assertEquals(TestClass.j, value.asLongValue().getLongValue());
+                } else {
+                  assertNull(value.asLongValue());
+                }
+                if (isFloat) {
+                  assertEquals(Reference.FLOAT, reference.getFieldType());
+                  assertEquals(
+                      Float.floatToRawIntBits(TestClass.f),
+                      Float.floatToRawIntBits(value.asFloatValue().getFloatValue()));
+                } else {
+                  assertNull(value.asFloatValue());
+                }
+                if (isDouble) {
+                  assertEquals(Reference.DOUBLE, reference.getFieldType());
+                  assertEquals(
+                      Double.doubleToRawLongBits(TestClass.d),
+                      Double.doubleToRawLongBits(value.asDoubleValue().getDoubleValue()));
+                } else {
+                  assertNull(value.asDoubleValue());
+                }
+                if (isString) {
+                  assertEquals(Reference.classFromClass(String.class), reference.getFieldType());
+                  assertEquals(TestClass.str, value.asStringValue().getStringValue());
+                } else {
+                  assertNull(value.asStringValue());
+                }
+              });
+        });
+  }
+
+  private void assertFound() {
+    assertEquals(9, foundFields);
+  }
+
+  static class TestClass {
+    public static final boolean z = true;
+    public static final byte b = 2;
+    public static final char c = 4;
+    public static final short s = 8;
+    public static final int i = 16;
+    public static final long j = 32L;
+    public static final float f = 64.1F;
+    public static final double d = 128.1D;
+    public static final String str = "foo";
+
+    public static void main(String[] args) {
+      System.out.println(z);
+      System.out.println(b);
+      System.out.println(c);
+      System.out.println(s);
+      System.out.println(i);
+      System.out.println(j);
+      System.out.println(f);
+      System.out.println(d);
+      System.out.println(str);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/inspection/InspectionApiTest.java b/src/test/java/com/android/tools/r8/inspection/InspectionApiTest.java
new file mode 100644
index 0000000..5c5a6e3
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/inspection/InspectionApiTest.java
@@ -0,0 +1,104 @@
+// 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.inspection;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.inspector.Inspector;
+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.utils.StringUtils;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class InspectionApiTest extends TestBase {
+
+  static final String EXPECTED = StringUtils.lines("Hello, world");
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public InspectionApiTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    if (parameters.isCfRuntime()) {
+      testForJvm()
+          .addProgramClasses(TestClass.class)
+          .run(parameters.getRuntime(), TestClass.class)
+          .assertSuccessWithOutput(EXPECTED);
+      return;
+    }
+    testForD8()
+        .addProgramClasses(TestClass.class)
+        .setMinApi(parameters.getApiLevel())
+        .apply(b -> b.getBuilder().addOutputInspection(this::inspection))
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED);
+    assertFound();
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(TestClass.class)
+        .addKeepClassAndMembersRules(TestClass.class)
+        .setMinApi(parameters.getApiLevel())
+        .apply(b -> b.getBuilder().addOutputInspection(this::inspection))
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(EXPECTED);
+    assertFound();
+  }
+
+  ClassReference foundClass = null;
+  FieldReference foundField = null;
+  MethodReference foundMethod = null;
+
+  private void inspection(Inspector inspector) {
+    inspector.forEachClass(
+        classInspector -> {
+          foundClass = classInspector.getClassReference();
+          classInspector.forEachField(
+              fieldInspector -> {
+                foundField = fieldInspector.getFieldReference();
+              });
+          classInspector.forEachMethod(
+              methodInspector -> {
+                // Ignore clinit (which is removed in R8).
+                if (!methodInspector.getMethodReference().getMethodName().equals("<clinit>")) {
+                  foundMethod = methodInspector.getMethodReference();
+                }
+              });
+        });
+  }
+
+  private void assertFound() throws Exception {
+    assertEquals(Reference.classFromClass(TestClass.class), foundClass);
+    assertEquals(Reference.fieldFromField(TestClass.class.getDeclaredField("foo")), foundField);
+    assertEquals(
+        Reference.methodFromMethod(TestClass.class.getDeclaredMethod("main", String[].class)),
+        foundMethod);
+  }
+
+  static class TestClass {
+    public static int foo = 42;
+
+    public static void main(String[] args) {
+      System.out.println("Hello, world");
+    }
+  }
+}