diff --git a/build.gradle b/build.gradle
index 041431e..c65df58e 100644
--- a/build.gradle
+++ b/build.gradle
@@ -2047,6 +2047,12 @@
 def numberOfTestTimesToPrint = 40
 
 test { task ->
+
+    dependsOn buildLibraryDesugarConversions
+    dependsOn getJarsFromSupportLibs
+    // R8.jar is required for running bootstrap tests.
+    dependsOn r8
+
     def newTestingReport = project.hasProperty('testing-report')
     if (newTestingReport) {
         setUpNewTestReporting(task)
@@ -2064,6 +2070,7 @@
         systemProperty 'test_git_HEAD_sha1', project.property('HEAD_sha1')
     }
 
+
     if (!newTestingReport) {
         testLogging.exceptionFormat = 'full'
         if (project.hasProperty('print_test_stdout')) {
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 8a4c9cc..d814466 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -8,6 +8,7 @@
 
 import com.android.tools.r8.cf.code.CfInstruction;
 import com.android.tools.r8.cf.code.CfPosition;
+import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryKeepRuleGenerator;
 import com.android.tools.r8.dex.ApplicationReader;
 import com.android.tools.r8.dex.ApplicationWriter;
 import com.android.tools.r8.dex.Marker;
@@ -799,6 +800,9 @@
       new GenericSignatureRewriter(appView, prefixRewritingNamingLens)
           .run(appView.appInfo().classes(), executorService);
 
+      new DesugaredLibraryKeepRuleGenerator(appView, prefixRewritingNamingLens)
+          .runIfNecessary(timing);
+
       // Generate the resulting application resources.
       // TODO(b/165783399): Apply the graph lens to all instructions in the CF and DEX backends.
       writeApplication(
diff --git a/src/main/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryKeepRuleGenerator.java b/src/main/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryKeepRuleGenerator.java
new file mode 100644
index 0000000..fb4b86e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryKeepRuleGenerator.java
@@ -0,0 +1,304 @@
+// Copyright (c) 2021, 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.desugar.desugaredlibrary;
+
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProto;
+import com.android.tools.r8.graph.DexString;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.desugar.DesugaredLibraryConfiguration;
+import com.android.tools.r8.naming.NamingLens;
+import com.android.tools.r8.references.ArrayReference;
+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.Reference;
+import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer;
+import com.android.tools.r8.tracereferences.TraceReferencesKeepRules;
+import com.android.tools.r8.tracereferences.Tracer;
+import com.android.tools.r8.tracereferences.internal.TracedClassImpl;
+import com.android.tools.r8.tracereferences.internal.TracedFieldImpl;
+import com.android.tools.r8.tracereferences.internal.TracedMethodImpl;
+import com.android.tools.r8.utils.ClassReferenceUtils;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.ListUtils;
+import com.android.tools.r8.utils.NopDiagnosticsHandler;
+import com.android.tools.r8.utils.SetUtils;
+import com.android.tools.r8.utils.Timing;
+import com.android.tools.r8.utils.TypeReferenceUtils;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Predicate;
+
+/** Generates keep rules for L8 using trace references. */
+public class DesugaredLibraryKeepRuleGenerator {
+
+  private final AppView<AppInfoWithClassHierarchy> appView;
+  private final NamingLens namingLens;
+  private final InternalOptions options;
+
+  public DesugaredLibraryKeepRuleGenerator(
+      AppView<AppInfoWithClassHierarchy> appView, NamingLens namingLens) {
+    this.appView = appView;
+    this.namingLens = namingLens;
+    this.options = appView.options();
+  }
+
+  public void runIfNecessary(Timing timing) {
+    if (shouldRun()) {
+      timing.begin("Desugared library keep rule generator");
+      run();
+      timing.end();
+    }
+  }
+
+  private boolean shouldRun() {
+    if (options.isDesugaredLibraryCompilation()
+        || options.desugaredLibraryKeepRuleConsumer == null
+        || !options.testing.enableExperimentalDesugaredLibraryKeepRuleGenerator) {
+      return false;
+    }
+    return namingLens.hasPrefixRewritingLogic()
+        || options.desugaredLibraryConfiguration.hasEmulatedLibraryInterfaces();
+  }
+
+  private void run() {
+    Tracer tracer = new Tracer(appView, new NopDiagnosticsHandler(), createTargetPredicate());
+    tracer.run(createTraceReferencesConsumer());
+  }
+
+  private Predicate<DexType> createTargetPredicate() {
+    DesugaredLibraryConfiguration desugaredLibraryConfiguration =
+        options.desugaredLibraryConfiguration;
+    Set<DexType> potentialTypesToKeep =
+        SetUtils.newIdentityHashSet(
+            desugaredLibraryConfiguration.getCustomConversions().values(),
+            desugaredLibraryConfiguration.getEmulateLibraryInterface().values());
+    byte[] synthesizedLibraryClassesPackageDescriptorPrefix =
+        DexString.encodeToMutf8(
+            "L" + desugaredLibraryConfiguration.getSynthesizedLibraryClassesPackagePrefix());
+    return type ->
+        namingLens.prefixRewrittenType(type) != null
+            || potentialTypesToKeep.contains(type)
+            || type.getDescriptor().startsWith(synthesizedLibraryClassesPackageDescriptorPrefix);
+  }
+
+  private KeepRuleGenerator createTraceReferencesConsumer() {
+    return new KeepRuleGenerator(appView, namingLens);
+  }
+
+  private static class KeepRuleGenerator extends TraceReferencesConsumer.ForwardingConsumer {
+
+    private final DexItemFactory factory;
+    private final NamingLens namingLens;
+
+    // May receive concurrent callbacks from trace references.
+    private final Map<ClassReference, ClassReference> classRewritingCache =
+        new ConcurrentHashMap<>();
+    private final Map<FieldReference, FieldReference> fieldRewritingCache =
+        new ConcurrentHashMap<>();
+    private final Map<MethodReference, MethodReference> methodRewritingCache =
+        new ConcurrentHashMap<>();
+
+    // We currently cache the conversion from TypeReference to DexType, but not conversions from
+    // ArrayReference to DexType, nor conversions from (formal types, return type) to DexProto.
+    private final Map<TypeReference, DexType> typeConversionCache = new ConcurrentHashMap<>();
+
+    private KeepRuleGenerator(
+        AppView<? extends AppInfoWithClassHierarchy> appView, NamingLens namingLens) {
+      super(
+          TraceReferencesKeepRules.builder()
+              .setOutputConsumer(appView.options().desugaredLibraryKeepRuleConsumer)
+              .build());
+      this.factory = appView.dexItemFactory();
+      this.namingLens = namingLens;
+    }
+
+    @Override
+    public void acceptType(TracedClass tracedClass, DiagnosticsHandler handler) {
+      ClassReference rewrittenReference = rewrittenWithLens(tracedClass.getReference());
+      super.acceptType(
+          rewrittenReference != tracedClass.getReference()
+              ? new TracedClassImpl(rewrittenReference, tracedClass.getAccessFlags())
+              : tracedClass,
+          handler);
+    }
+
+    @Override
+    public void acceptField(TracedField tracedField, DiagnosticsHandler handler) {
+      FieldReference rewrittenReference = rewrittenWithLens(tracedField.getReference());
+      super.acceptField(
+          rewrittenReference != tracedField.getReference()
+              ? new TracedFieldImpl(rewrittenReference, tracedField.getAccessFlags())
+              : tracedField,
+          handler);
+    }
+
+    @Override
+    public void acceptMethod(TracedMethod tracedMethod, DiagnosticsHandler handler) {
+      MethodReference rewrittenReference = rewrittenWithLens(tracedMethod.getReference());
+      super.acceptMethod(
+          rewrittenReference != tracedMethod.getReference()
+              ? new TracedMethodImpl(rewrittenReference, tracedMethod.getAccessFlags())
+              : tracedMethod,
+          handler);
+    }
+
+    @Override
+    public void acceptPackage(PackageReference pkg, DiagnosticsHandler handler) {
+      super.acceptPackage(pkg, handler);
+    }
+
+    private DexType convertClassReference(ClassReference classReference) {
+      return typeConversionCache.computeIfAbsent(
+          classReference, key -> ClassReferenceUtils.toDexType(key.asClass(), factory));
+    }
+
+    private DexProto convertProto(List<TypeReference> formalTypes, TypeReference returnType) {
+      return TypeReferenceUtils.toDexProto(
+          formalTypes, returnType, factory, this::convertClassReference);
+    }
+
+    private DexType convertTypeReference(TypeReference typeReference) {
+      return typeConversionCache.computeIfAbsent(
+          typeReference,
+          key -> TypeReferenceUtils.toDexType(key, factory, this::convertClassReference));
+    }
+
+    private ClassReference rewrittenWithLens(ClassReference classReference) {
+      // First check if we have the result.
+      ClassReference cached = classRewritingCache.get(classReference);
+      if (cached != null) {
+        return cached;
+      }
+      // Otherwise, convert to DexType, apply the naming lens, and cache the result.
+      return internalRewrittenWithLens(classReference, convertClassReference(classReference));
+    }
+
+    private ClassReference rewrittenWithLens(ClassReference classReference, DexType type) {
+      // First check if we have the result.
+      ClassReference cached = classRewritingCache.get(classReference);
+      if (cached != null) {
+        return cached;
+      }
+      // Otherwise, apply the naming lens and cache the result.
+      return internalRewrittenWithLens(classReference, type);
+    }
+
+    private ClassReference internalRewrittenWithLens(ClassReference classReference, DexType type) {
+      DexString rewrittenDescriptor = namingLens.lookupClassDescriptor(type);
+      return addCacheEntry(
+          classReference,
+          rewrittenDescriptor != type.getDescriptor()
+              ? Reference.classFromDescriptor(rewrittenDescriptor.toString())
+              : classReference,
+          classRewritingCache);
+    }
+
+    private FieldReference rewrittenWithLens(FieldReference fieldReference) {
+      // First check if we have the result.
+      FieldReference cached = fieldRewritingCache.get(fieldReference);
+      if (cached != null) {
+        return cached;
+      }
+      // Convert to DexField, using the typeConversionCache.
+      DexField field =
+          factory.createField(
+              convertClassReference(fieldReference.getHolderClass()),
+              convertTypeReference(fieldReference.getFieldType()),
+              fieldReference.getFieldName());
+      // Rewrite the field components, using the classRewritingCache.
+      ClassReference rewrittenFieldHolder =
+          rewrittenWithLens(fieldReference.getHolderClass(), field.getHolderType());
+      String rewrittenFieldName = namingLens.lookupName(field).toString();
+      TypeReference rewrittenFieldType =
+          rewrittenWithLens(fieldReference.getFieldType(), field.getType());
+      // Cache the result.
+      FieldReference rewrittenFieldReference =
+          Reference.field(rewrittenFieldHolder, rewrittenFieldName, rewrittenFieldType);
+      return addCacheEntry(
+          fieldReference,
+          rewrittenFieldReference.equals(fieldReference) ? fieldReference : rewrittenFieldReference,
+          fieldRewritingCache);
+    }
+
+    private MethodReference rewrittenWithLens(MethodReference methodReference) {
+      // First check if we have the result.
+      MethodReference cached = methodRewritingCache.get(methodReference);
+      if (cached != null) {
+        return cached;
+      }
+      // Convert to DexMethod, using the typeConversionCache.
+      DexMethod method =
+          factory.createMethod(
+              convertClassReference(methodReference.getHolderClass()),
+              convertProto(methodReference.getFormalTypes(), methodReference.getReturnType()),
+              methodReference.getMethodName());
+      // Rewrite the method components, using the classRewritingCache.
+      ClassReference rewrittenMethodHolder =
+          rewrittenWithLens(methodReference.getHolderClass(), method.getHolderType());
+      String rewrittenMethodName = namingLens.lookupName(method).toString();
+      Iterator<DexType> parameterIterator = method.getParameters().iterator();
+      List<TypeReference> rewrittenMethodFormalTypes =
+          ListUtils.mapOrElse(
+              methodReference.getFormalTypes(),
+              formalType -> rewrittenWithLens(formalType, parameterIterator.next()),
+              methodReference.getFormalTypes());
+      TypeReference rewrittenMethodReturnType =
+          rewrittenWithLens(methodReference.getReturnType(), method.getReturnType());
+      // Cache the result.
+      MethodReference rewrittenMethodReference =
+          Reference.method(
+              rewrittenMethodHolder,
+              rewrittenMethodName,
+              rewrittenMethodFormalTypes,
+              rewrittenMethodReturnType);
+      return addCacheEntry(
+          methodReference,
+          rewrittenMethodReference.equals(methodReference)
+              ? methodReference
+              : rewrittenMethodReference,
+          methodRewritingCache);
+    }
+
+    private TypeReference rewrittenWithLens(TypeReference typeReference, DexType type) {
+      // The naming lens does not impact 'void' and primitives.
+      if (typeReference == null || typeReference.isPrimitive()) {
+        return typeReference;
+      }
+      // For array types we only cache the result for the base type.
+      if (typeReference.isArray()) {
+        ArrayReference arrayReference = typeReference.asArray();
+        TypeReference baseType = arrayReference.getBaseType();
+        if (baseType.isPrimitive()) {
+          return typeReference;
+        }
+        assert baseType.isClass();
+        ClassReference rewrittenBaseType = rewrittenWithLens(baseType.asClass());
+        return rewrittenBaseType != baseType
+            ? Reference.array(rewrittenBaseType, arrayReference.getDimensions())
+            : typeReference;
+      }
+      // Rewrite the class type using classRewritingCache.
+      assert typeReference.isClass();
+      return rewrittenWithLens(typeReference.asClass(), type);
+    }
+
+    private <T> T addCacheEntry(T reference, T rewrittenReference, Map<T, T> rewritingCache) {
+      rewritingCache.put(reference, rewrittenReference);
+      return rewrittenReference;
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/dex/CodeToKeep.java b/src/main/java/com/android/tools/r8/dex/CodeToKeep.java
index 2261228..7595a40 100644
--- a/src/main/java/com/android/tools/r8/dex/CodeToKeep.java
+++ b/src/main/java/com/android/tools/r8/dex/CodeToKeep.java
@@ -22,8 +22,9 @@
 
   static CodeToKeep createCodeToKeep(InternalOptions options, NamingLens namingLens) {
     if ((!namingLens.hasPrefixRewritingLogic()
-            && options.desugaredLibraryConfiguration.getEmulateLibraryInterface().isEmpty())
-        || options.isDesugaredLibraryCompilation()) {
+            && !options.desugaredLibraryConfiguration.hasEmulatedLibraryInterfaces())
+        || options.isDesugaredLibraryCompilation()
+        || options.testing.enableExperimentalDesugaredLibraryKeepRuleGenerator) {
       return new NopCodeToKeep();
     }
     return new DesugaredLibraryCodeToKeep(namingLens, options);
diff --git a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionClassContext.java b/src/main/java/com/android/tools/r8/diagnostic/DefinitionClassContext.java
similarity index 79%
rename from src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionClassContext.java
rename to src/main/java/com/android/tools/r8/diagnostic/DefinitionClassContext.java
index 1b73b9f..e1530bf 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionClassContext.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/DefinitionClassContext.java
@@ -8,7 +8,7 @@
 import com.android.tools.r8.references.ClassReference;
 
 @Keep
-public interface MissingDefinitionClassContext extends MissingDefinitionContext {
+public interface DefinitionClassContext extends DefinitionContext {
 
   /** Returns the reference of the class context. */
   ClassReference getClassReference();
@@ -19,7 +19,7 @@
   }
 
   @Override
-  default MissingDefinitionClassContext asClassContext() {
+  default DefinitionClassContext asClassContext() {
     return this;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/diagnostic/DefinitionContext.java b/src/main/java/com/android/tools/r8/diagnostic/DefinitionContext.java
new file mode 100644
index 0000000..d05e123
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/DefinitionContext.java
@@ -0,0 +1,61 @@
+// Copyright (c) 2021, 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.diagnostic;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.origin.Origin;
+
+/** A context that references a missing definition in the program, classpath, or library. */
+@Keep
+public interface DefinitionContext {
+
+  /** The origin of the context. */
+  Origin getOrigin();
+
+  /** Predicate that is true iff this is an instance of {@link DefinitionClassContext}. */
+  default boolean isClassContext() {
+    return false;
+  }
+
+  /** Predicate that is true iff this is an instance of {@link DefinitionFieldContext}. */
+  default boolean isFieldContext() {
+    return false;
+  }
+
+  /** Predicate that is true iff this is an instance of {@link DefinitionMethodContext}. */
+  default boolean isMethodContext() {
+    return false;
+  }
+
+  /**
+   * Return a non-null {@link DefinitionClassContext} if this type is {@link
+   * DefinitionClassContext}.
+   *
+   * @return this with static type of {@link DefinitionClassContext}.
+   */
+  default DefinitionClassContext asClassContext() {
+    return null;
+  }
+
+  /**
+   * Return a non-null {@link DefinitionFieldContext} if this type is {@link
+   * DefinitionFieldContext}.
+   *
+   * @return this with static type of {@link DefinitionFieldContext}.
+   */
+  default DefinitionFieldContext asFieldContext() {
+    return null;
+  }
+
+  /**
+   * Return a non-null {@link DefinitionMethodContext} if this type is {@link
+   * DefinitionMethodContext}.
+   *
+   * @return this with static type of {@link DefinitionMethodContext}.
+   */
+  default DefinitionMethodContext asMethodContext() {
+    return null;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionFieldContext.java b/src/main/java/com/android/tools/r8/diagnostic/DefinitionFieldContext.java
similarity index 79%
rename from src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionFieldContext.java
rename to src/main/java/com/android/tools/r8/diagnostic/DefinitionFieldContext.java
index 7564f5a..b3c4981 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionFieldContext.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/DefinitionFieldContext.java
@@ -8,7 +8,7 @@
 import com.android.tools.r8.references.FieldReference;
 
 @Keep
-public interface MissingDefinitionFieldContext extends MissingDefinitionContext {
+public interface DefinitionFieldContext extends DefinitionContext {
 
   /** Returns the reference of the field context. */
   FieldReference getFieldReference();
@@ -19,7 +19,7 @@
   }
 
   @Override
-  default MissingDefinitionFieldContext asFieldContext() {
+  default DefinitionFieldContext asFieldContext() {
     return this;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionMethodContext.java b/src/main/java/com/android/tools/r8/diagnostic/DefinitionMethodContext.java
similarity index 79%
rename from src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionMethodContext.java
rename to src/main/java/com/android/tools/r8/diagnostic/DefinitionMethodContext.java
index 315a29c..86742db 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionMethodContext.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/DefinitionMethodContext.java
@@ -8,7 +8,7 @@
 import com.android.tools.r8.references.MethodReference;
 
 @Keep
-public interface MissingDefinitionMethodContext extends MissingDefinitionContext {
+public interface DefinitionMethodContext extends DefinitionContext {
 
   /** Returns the reference of the method context. */
   MethodReference getMethodReference();
@@ -19,7 +19,7 @@
   }
 
   @Override
-  default MissingDefinitionMethodContext asMethodContext() {
+  default DefinitionMethodContext asMethodContext() {
     return this;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionContext.java b/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionContext.java
deleted file mode 100644
index cb5d3b4..0000000
--- a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionContext.java
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright (c) 2021, 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.diagnostic;
-
-import com.android.tools.r8.Keep;
-import com.android.tools.r8.origin.Origin;
-
-/** A context that references a missing definition in the program, classpath, or library. */
-@Keep
-public interface MissingDefinitionContext {
-
-  /** The origin of the context. */
-  Origin getOrigin();
-
-  /** Predicate that is true iff this is an instance of {@link MissingDefinitionClassContext}. */
-  default boolean isClassContext() {
-    return false;
-  }
-
-  /** Predicate that is true iff this is an instance of {@link MissingDefinitionFieldContext}. */
-  default boolean isFieldContext() {
-    return false;
-  }
-
-  /** Predicate that is true iff this is an instance of {@link MissingDefinitionMethodContext}. */
-  default boolean isMethodContext() {
-    return false;
-  }
-
-  /**
-   * Return a non-null {@link MissingDefinitionClassContext} if this type is {@link
-   * MissingDefinitionClassContext}.
-   *
-   * @return this with static type of {@link MissingDefinitionClassContext}.
-   */
-  default MissingDefinitionClassContext asClassContext() {
-    return null;
-  }
-
-  /**
-   * Return a non-null {@link MissingDefinitionFieldContext} if this type is {@link
-   * MissingDefinitionFieldContext}.
-   *
-   * @return this with static type of {@link MissingDefinitionFieldContext}.
-   */
-  default MissingDefinitionFieldContext asFieldContext() {
-    return null;
-  }
-
-  /**
-   * Return a non-null {@link MissingDefinitionMethodContext} if this type is {@link
-   * MissingDefinitionMethodContext}.
-   *
-   * @return this with static type of {@link MissingDefinitionMethodContext}.
-   */
-  default MissingDefinitionMethodContext asMethodContext() {
-    return null;
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionInfo.java b/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionInfo.java
index ec486de..03fe322 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionInfo.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionInfo.java
@@ -68,5 +68,5 @@
   String getDiagnosticMessage();
 
   /** The contexts from which this missing definition was referenced. */
-  Collection<MissingDefinitionContext> getReferencedFromContexts();
+  Collection<DefinitionContext> getReferencedFromContexts();
 }
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionClassContextImpl.java b/src/main/java/com/android/tools/r8/diagnostic/internal/DefinitionClassContextImpl.java
similarity index 68%
rename from src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionClassContextImpl.java
rename to src/main/java/com/android/tools/r8/diagnostic/internal/DefinitionClassContextImpl.java
index 7944a1e..b632519 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionClassContextImpl.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/DefinitionClassContextImpl.java
@@ -4,16 +4,16 @@
 
 package com.android.tools.r8.diagnostic.internal;
 
-import com.android.tools.r8.diagnostic.MissingDefinitionClassContext;
+import com.android.tools.r8.diagnostic.DefinitionClassContext;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.references.ClassReference;
 
-public class MissingDefinitionClassContextImpl extends MissingDefinitionContextBase
-    implements MissingDefinitionClassContext {
+public class DefinitionClassContextImpl extends DefinitionContextBase
+    implements DefinitionClassContext {
 
   private final ClassReference classReference;
 
-  private MissingDefinitionClassContextImpl(ClassReference classReference, Origin origin) {
+  private DefinitionClassContextImpl(ClassReference classReference, Origin origin) {
     super(origin);
     this.classReference = classReference;
   }
@@ -27,7 +27,7 @@
     return classReference;
   }
 
-  public static class Builder extends MissingDefinitionContextBase.Builder<Builder> {
+  public static class Builder extends DefinitionContextBase.Builder<Builder> {
 
     private ClassReference classReference;
 
@@ -44,9 +44,9 @@
     }
 
     @Override
-    public MissingDefinitionClassContextImpl build() {
+    public DefinitionClassContextImpl build() {
       assert validate();
-      return new MissingDefinitionClassContextImpl(classReference, origin);
+      return new DefinitionClassContextImpl(classReference, origin);
     }
 
     @Override
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionContextBase.java b/src/main/java/com/android/tools/r8/diagnostic/internal/DefinitionContextBase.java
similarity index 74%
rename from src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionContextBase.java
rename to src/main/java/com/android/tools/r8/diagnostic/internal/DefinitionContextBase.java
index cf6a0d1..44bd042 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionContextBase.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/DefinitionContextBase.java
@@ -4,14 +4,14 @@
 
 package com.android.tools.r8.diagnostic.internal;
 
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.DefinitionContext;
 import com.android.tools.r8.origin.Origin;
 
-public abstract class MissingDefinitionContextBase implements MissingDefinitionContext {
+public abstract class DefinitionContextBase implements DefinitionContext {
 
   private final Origin origin;
 
-  MissingDefinitionContextBase(Origin origin) {
+  DefinitionContextBase(Origin origin) {
     this.origin = origin;
   }
 
@@ -31,7 +31,7 @@
 
     abstract B self();
 
-    public abstract MissingDefinitionContext build();
+    public abstract DefinitionContext build();
 
     public boolean validate() {
       assert origin != null;
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/DefinitionContextUtils.java b/src/main/java/com/android/tools/r8/diagnostic/internal/DefinitionContextUtils.java
new file mode 100644
index 0000000..1703738
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/DefinitionContextUtils.java
@@ -0,0 +1,79 @@
+// Copyright (c) 2021, 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.diagnostic.internal;
+
+import com.android.tools.r8.diagnostic.DefinitionClassContext;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.DefinitionFieldContext;
+import com.android.tools.r8.diagnostic.DefinitionMethodContext;
+import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.Definition;
+import com.android.tools.r8.graph.ProgramDerivedContext;
+import com.android.tools.r8.utils.FieldReferenceUtils;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public class DefinitionContextUtils {
+
+  public static void accept(
+      DefinitionContext definitionContext,
+      Consumer<DefinitionClassContext> definitionClassContextConsumer,
+      Consumer<DefinitionFieldContext> definitionFieldContextConsumer,
+      Consumer<DefinitionMethodContext> definitionMethodContextConsumer) {
+    if (definitionContext.isClassContext()) {
+      definitionClassContextConsumer.accept(definitionContext.asClassContext());
+    } else if (definitionContext.isFieldContext()) {
+      definitionFieldContextConsumer.accept(definitionContext.asFieldContext());
+    } else {
+      assert definitionContext.isMethodContext();
+      definitionMethodContextConsumer.accept(definitionContext.asMethodContext());
+    }
+  }
+
+  public static <T> T apply(
+      DefinitionContext definitionContext,
+      Function<DefinitionClassContext, T> definitionClassContextFn,
+      Function<DefinitionFieldContext, T> definitionFieldContextFn,
+      Function<DefinitionMethodContext, T> definitionMethodContextFn) {
+    if (definitionContext.isClassContext()) {
+      return definitionClassContextFn.apply(definitionContext.asClassContext());
+    } else if (definitionContext.isFieldContext()) {
+      return definitionFieldContextFn.apply(definitionContext.asFieldContext());
+    } else {
+      assert definitionContext.isMethodContext();
+      return definitionMethodContextFn.apply(definitionContext.asMethodContext());
+    }
+  }
+
+  public static DefinitionContext create(ProgramDerivedContext programDerivedContext) {
+    Definition context = programDerivedContext.getContext();
+    DefinitionContextBase.Builder<?> builder;
+    if (context.isClass()) {
+      builder =
+          DefinitionClassContextImpl.builder()
+              .setClassContext(context.asClass().getClassReference());
+    } else if (context.isField()) {
+      builder =
+          DefinitionFieldContextImpl.builder()
+              .setFieldContext(context.asField().getFieldReference());
+    } else if (context.isMethod()) {
+      builder =
+          DefinitionMethodContextImpl.builder()
+              .setMethodContext(context.asMethod().getMethodReference());
+    } else {
+      throw new Unreachable();
+    }
+    return builder.setOrigin(context.getOrigin()).build();
+  }
+
+  public static String toSourceString(DefinitionContext definitionContext) {
+    return DefinitionContextUtils.apply(
+        definitionContext,
+        classContext -> classContext.getClassReference().getTypeName(),
+        fieldContext -> FieldReferenceUtils.toSourceString(fieldContext.getFieldReference()),
+        methodContext -> MethodReferenceUtils.toSourceString(methodContext.getMethodReference()));
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionFieldContextImpl.java b/src/main/java/com/android/tools/r8/diagnostic/internal/DefinitionFieldContextImpl.java
similarity index 68%
rename from src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionFieldContextImpl.java
rename to src/main/java/com/android/tools/r8/diagnostic/internal/DefinitionFieldContextImpl.java
index b9ecf41..888f401 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionFieldContextImpl.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/DefinitionFieldContextImpl.java
@@ -4,16 +4,16 @@
 
 package com.android.tools.r8.diagnostic.internal;
 
-import com.android.tools.r8.diagnostic.MissingDefinitionFieldContext;
+import com.android.tools.r8.diagnostic.DefinitionFieldContext;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.references.FieldReference;
 
-public class MissingDefinitionFieldContextImpl extends MissingDefinitionContextBase
-    implements MissingDefinitionFieldContext {
+public class DefinitionFieldContextImpl extends DefinitionContextBase
+    implements DefinitionFieldContext {
 
   private final FieldReference fieldReference;
 
-  private MissingDefinitionFieldContextImpl(FieldReference fieldReference, Origin origin) {
+  private DefinitionFieldContextImpl(FieldReference fieldReference, Origin origin) {
     super(origin);
     this.fieldReference = fieldReference;
   }
@@ -27,7 +27,7 @@
     return fieldReference;
   }
 
-  public static class Builder extends MissingDefinitionContextBase.Builder<Builder> {
+  public static class Builder extends DefinitionContextBase.Builder<Builder> {
 
     private FieldReference fieldReference;
 
@@ -44,9 +44,9 @@
     }
 
     @Override
-    public MissingDefinitionFieldContextImpl build() {
+    public DefinitionFieldContextImpl build() {
       assert validate();
-      return new MissingDefinitionFieldContextImpl(fieldReference, origin);
+      return new DefinitionFieldContextImpl(fieldReference, origin);
     }
 
     @Override
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionMethodContextImpl.java b/src/main/java/com/android/tools/r8/diagnostic/internal/DefinitionMethodContextImpl.java
similarity index 68%
rename from src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionMethodContextImpl.java
rename to src/main/java/com/android/tools/r8/diagnostic/internal/DefinitionMethodContextImpl.java
index eba8719..5c35d3b 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionMethodContextImpl.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/DefinitionMethodContextImpl.java
@@ -4,16 +4,16 @@
 
 package com.android.tools.r8.diagnostic.internal;
 
-import com.android.tools.r8.diagnostic.MissingDefinitionMethodContext;
+import com.android.tools.r8.diagnostic.DefinitionMethodContext;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.references.MethodReference;
 
-public class MissingDefinitionMethodContextImpl extends MissingDefinitionContextBase
-    implements MissingDefinitionMethodContext {
+public class DefinitionMethodContextImpl extends DefinitionContextBase
+    implements DefinitionMethodContext {
 
   private final MethodReference methodReference;
 
-  private MissingDefinitionMethodContextImpl(MethodReference methodReference, Origin origin) {
+  private DefinitionMethodContextImpl(MethodReference methodReference, Origin origin) {
     super(origin);
     this.methodReference = methodReference;
   }
@@ -27,7 +27,7 @@
     return methodReference;
   }
 
-  public static class Builder extends MissingDefinitionContextBase.Builder<Builder> {
+  public static class Builder extends DefinitionContextBase.Builder<Builder> {
 
     private MethodReference methodReference;
 
@@ -44,9 +44,9 @@
     }
 
     @Override
-    public MissingDefinitionMethodContextImpl build() {
+    public DefinitionMethodContextImpl build() {
       assert validate();
-      return new MissingDefinitionMethodContextImpl(methodReference, origin);
+      return new DefinitionMethodContextImpl(methodReference, origin);
     }
 
     @Override
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingClassInfoImpl.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingClassInfoImpl.java
index b240279..82d5a35 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingClassInfoImpl.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingClassInfoImpl.java
@@ -4,8 +4,8 @@
 
 package com.android.tools.r8.diagnostic.internal;
 
+import com.android.tools.r8.diagnostic.DefinitionContext;
 import com.android.tools.r8.diagnostic.MissingClassInfo;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
 import com.android.tools.r8.diagnostic.MissingDefinitionInfo;
 import com.android.tools.r8.references.ClassReference;
 import java.util.Collection;
@@ -15,7 +15,7 @@
   private final ClassReference classReference;
 
   private MissingClassInfoImpl(
-      ClassReference classReference, Collection<MissingDefinitionContext> referencedFromContexts) {
+      ClassReference classReference, Collection<DefinitionContext> referencedFromContexts) {
     super(referencedFromContexts);
     this.classReference = classReference;
   }
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionContextUtils.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionContextUtils.java
deleted file mode 100644
index 74b48c5..0000000
--- a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionContextUtils.java
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright (c) 2021, 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.diagnostic.internal;
-
-import com.android.tools.r8.diagnostic.MissingDefinitionClassContext;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.MissingDefinitionFieldContext;
-import com.android.tools.r8.diagnostic.MissingDefinitionMethodContext;
-import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.graph.Definition;
-import com.android.tools.r8.graph.ProgramDerivedContext;
-import com.android.tools.r8.utils.FieldReferenceUtils;
-import com.android.tools.r8.utils.MethodReferenceUtils;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-public class MissingDefinitionContextUtils {
-
-  public static void accept(
-      MissingDefinitionContext missingDefinitionContext,
-      Consumer<MissingDefinitionClassContext> missingDefinitionClassContextConsumer,
-      Consumer<MissingDefinitionFieldContext> missingDefinitionFieldContextConsumer,
-      Consumer<MissingDefinitionMethodContext> missingDefinitionMethodContextConsumer) {
-    if (missingDefinitionContext.isClassContext()) {
-      missingDefinitionClassContextConsumer.accept(missingDefinitionContext.asClassContext());
-    } else if (missingDefinitionContext.isFieldContext()) {
-      missingDefinitionFieldContextConsumer.accept(missingDefinitionContext.asFieldContext());
-    } else {
-      assert missingDefinitionContext.isMethodContext();
-      missingDefinitionMethodContextConsumer.accept(missingDefinitionContext.asMethodContext());
-    }
-  }
-
-  public static <T> T apply(
-      MissingDefinitionContext missingDefinitionContext,
-      Function<MissingDefinitionClassContext, T> missingDefinitionClassContextFn,
-      Function<MissingDefinitionFieldContext, T> missingDefinitionFieldContextFn,
-      Function<MissingDefinitionMethodContext, T> missingDefinitionMethodContextFn) {
-    if (missingDefinitionContext.isClassContext()) {
-      return missingDefinitionClassContextFn.apply(missingDefinitionContext.asClassContext());
-    } else if (missingDefinitionContext.isFieldContext()) {
-      return missingDefinitionFieldContextFn.apply(missingDefinitionContext.asFieldContext());
-    } else {
-      assert missingDefinitionContext.isMethodContext();
-      return missingDefinitionMethodContextFn.apply(missingDefinitionContext.asMethodContext());
-    }
-  }
-
-  public static MissingDefinitionContext create(ProgramDerivedContext programDerivedContext) {
-    Definition context = programDerivedContext.getContext();
-    MissingDefinitionContextBase.Builder<?> builder;
-    if (context.isClass()) {
-      builder =
-          MissingDefinitionClassContextImpl.builder()
-              .setClassContext(context.asClass().getClassReference());
-    } else if (context.isField()) {
-      builder =
-          MissingDefinitionFieldContextImpl.builder()
-              .setFieldContext(context.asField().getFieldReference());
-    } else if (context.isMethod()) {
-      builder =
-          MissingDefinitionMethodContextImpl.builder()
-              .setMethodContext(context.asMethod().getMethodReference());
-    } else {
-      throw new Unreachable();
-    }
-    return builder.setOrigin(context.getOrigin()).build();
-  }
-
-  public static String toSourceString(MissingDefinitionContext missingDefinitionContext) {
-    return MissingDefinitionContextUtils.apply(
-        missingDefinitionContext,
-        classContext -> classContext.getClassReference().getTypeName(),
-        fieldContext -> FieldReferenceUtils.toSourceString(fieldContext.getFieldReference()),
-        methodContext -> MethodReferenceUtils.toSourceString(methodContext.getMethodReference()));
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionInfoBase.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionInfoBase.java
index b3d2872..8d90a92 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionInfoBase.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionInfoBase.java
@@ -4,16 +4,16 @@
 
 package com.android.tools.r8.diagnostic.internal;
 
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.DefinitionContext;
 import com.android.tools.r8.diagnostic.MissingDefinitionInfo;
 import com.google.common.collect.ImmutableList;
 import java.util.Collection;
 
 public abstract class MissingDefinitionInfoBase implements MissingDefinitionInfo {
 
-  final Collection<MissingDefinitionContext> referencedFromContexts;
+  final Collection<DefinitionContext> referencedFromContexts;
 
-  MissingDefinitionInfoBase(Collection<MissingDefinitionContext> referencedFromContexts) {
+  MissingDefinitionInfoBase(Collection<DefinitionContext> referencedFromContexts) {
     this.referencedFromContexts = referencedFromContexts;
   }
 
@@ -25,18 +25,18 @@
   }
 
   @Override
-  public final Collection<MissingDefinitionContext> getReferencedFromContexts() {
+  public final Collection<DefinitionContext> getReferencedFromContexts() {
     return referencedFromContexts;
   }
 
   public abstract static class Builder {
 
-    final ImmutableList.Builder<MissingDefinitionContext> referencedFromContextsBuilder =
+    final ImmutableList.Builder<DefinitionContext> referencedFromContextsBuilder =
         ImmutableList.builder();
 
     Builder() {}
 
-    public Builder addReferencedFromContext(MissingDefinitionContext missingDefinitionContext) {
+    public Builder addReferencedFromContext(DefinitionContext missingDefinitionContext) {
       referencedFromContextsBuilder.add(missingDefinitionContext);
       return this;
     }
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionInfoUtils.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionInfoUtils.java
index 224b2a4..a744297 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionInfoUtils.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionInfoUtils.java
@@ -8,8 +8,8 @@
 import static com.android.tools.r8.utils.FieldReferenceUtils.getFieldReferenceComparator;
 import static com.android.tools.r8.utils.MethodReferenceUtils.getMethodReferenceComparator;
 
+import com.android.tools.r8.diagnostic.DefinitionContext;
 import com.android.tools.r8.diagnostic.MissingClassInfo;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
 import com.android.tools.r8.diagnostic.MissingDefinitionInfo;
 import com.android.tools.r8.diagnostic.MissingFieldInfo;
 import com.android.tools.r8.diagnostic.MissingMethodInfo;
@@ -110,9 +110,9 @@
     Box<ClassReference> classContext = new Box<>();
     Box<FieldReference> fieldContext = new Box<>();
     Box<MethodReference> methodContext = new Box<>();
-    for (MissingDefinitionContext missingDefinitionContext :
+    for (DefinitionContext missingDefinitionContext :
         missingDefinitionInfo.getReferencedFromContexts()) {
-      MissingDefinitionContextUtils.accept(
+      DefinitionContextUtils.accept(
           missingDefinitionContext,
           missingDefinitionClassContext ->
               classContext.setMin(
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingFieldInfoImpl.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingFieldInfoImpl.java
index 216080d..d7acc21 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingFieldInfoImpl.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingFieldInfoImpl.java
@@ -4,7 +4,7 @@
 
 package com.android.tools.r8.diagnostic.internal;
 
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.DefinitionContext;
 import com.android.tools.r8.diagnostic.MissingDefinitionInfo;
 import com.android.tools.r8.diagnostic.MissingFieldInfo;
 import com.android.tools.r8.references.FieldReference;
@@ -15,7 +15,7 @@
   private final FieldReference fieldReference;
 
   private MissingFieldInfoImpl(
-      FieldReference fieldReference, Collection<MissingDefinitionContext> referencedFromContexts) {
+      FieldReference fieldReference, Collection<DefinitionContext> referencedFromContexts) {
     super(referencedFromContexts);
     this.fieldReference = fieldReference;
   }
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingMethodInfoImpl.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingMethodInfoImpl.java
index 5be14dc..8ab85d9 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingMethodInfoImpl.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingMethodInfoImpl.java
@@ -4,7 +4,7 @@
 
 package com.android.tools.r8.diagnostic.internal;
 
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.DefinitionContext;
 import com.android.tools.r8.diagnostic.MissingDefinitionInfo;
 import com.android.tools.r8.diagnostic.MissingMethodInfo;
 import com.android.tools.r8.references.MethodReference;
@@ -15,8 +15,7 @@
   private final MethodReference methodReference;
 
   private MissingMethodInfoImpl(
-      MethodReference methodReference,
-      Collection<MissingDefinitionContext> referencedFromContexts) {
+      MethodReference methodReference, Collection<DefinitionContext> referencedFromContexts) {
     super(referencedFromContexts);
     this.methodReference = methodReference;
   }
diff --git a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
index 646fca7..acd8b41 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -555,6 +555,7 @@
   public final RecordMembers recordMembers = new RecordMembers();
   public final ShortMembers shortMembers = new ShortMembers();
   public final StringMembers stringMembers = new StringMembers();
+  public final SupplierMembers supplierMembers = new SupplierMembers();
   public final DoubleMembers doubleMembers = new DoubleMembers();
   public final ThrowableMethods throwableMethods = new ThrowableMethods();
   public final AssertionErrorMethods assertionErrorMethods = new AssertionErrorMethods();
@@ -1340,11 +1341,29 @@
 
   public class ObjectsMethods {
 
+    public final DexMethod equals =
+        createMethod(objectsType, createProto(booleanType, objectType, objectType), "equals");
+    public final DexMethod hashCode =
+        createMethod(objectsType, createProto(intType, objectType), "hashCode");
+    public final DexMethod isNull =
+        createMethod(objectsType, createProto(booleanType, objectType), "isNull");
+    public final DexMethod nonNull =
+        createMethod(objectsType, createProto(booleanType, objectType), "nonNull");
     public final DexMethod requireNonNull;
     public final DexMethod requireNonNullWithMessage;
     public final DexMethod requireNonNullWithMessageSupplier;
+    public final DexMethod requireNonNullElse =
+        createMethod(
+            objectsType, createProto(objectType, objectType, objectType), "requireNonNullElse");
+    public final DexMethod requireNonNullElseGet =
+        createMethod(
+            objectsType,
+            createProto(objectType, objectType, supplierType),
+            "requireNonNullElseGet");
     public final DexMethod toStringWithObject =
         createMethod(objectsType, createProto(stringType, objectType), "toString");
+    public final DexMethod toStringWithObjectAndNullDefault =
+        createMethod(objectsType, createProto(stringType, objectType, stringType), "toString");
 
     private ObjectsMethods() {
       DexString requireNonNullMethodName = createString("requireNonNull");
@@ -1365,7 +1384,13 @@
     public boolean isRequireNonNullMethod(DexMethod method) {
       return method == requireNonNull
           || method == requireNonNullWithMessage
-          || method == requireNonNullWithMessageSupplier;
+          || method == requireNonNullWithMessageSupplier
+          || method == requireNonNullElse
+          || method == requireNonNullElseGet;
+    }
+
+    public boolean isToStringMethod(DexMethod method) {
+      return method == toStringWithObject || method == toStringWithObjectAndNullDefault;
     }
 
     public Iterable<DexMethod> requireNonNullMethods() {
@@ -1883,6 +1908,13 @@
     }
   }
 
+  public class SupplierMembers extends LibraryMembers {
+
+    public final DexMethod get = createMethod(supplierType, createProto(objectType), "get");
+
+    private SupplierMembers() {}
+  }
+
   public class PolymorphicMethods {
 
     private final DexProto signature = createProto(objectType, objectArrayType);
diff --git a/src/main/java/com/android/tools/r8/graph/DexString.java b/src/main/java/com/android/tools/r8/graph/DexString.java
index af2ad74..ba4d653 100644
--- a/src/main/java/com/android/tools/r8/graph/DexString.java
+++ b/src/main/java/com/android/tools/r8/graph/DexString.java
@@ -50,6 +50,10 @@
     throw new Unreachable();
   }
 
+  public byte byteAt(int index) {
+    return content[index];
+  }
+
   /** DexString is a leaf item so we directly define its compareTo which avoids overhead. */
   @Override
   public int compareTo(DexString other) {
@@ -437,11 +441,19 @@
   }
 
   public boolean startsWith(DexString prefix) {
-    if (content.length < prefix.content.length) {
+    return startsWith(prefix.content);
+  }
+
+  public boolean startsWith(String prefix) {
+    return startsWith(encodeToMutf8(prefix));
+  }
+
+  public boolean startsWith(byte[] prefixContent) {
+    if (content.length < prefixContent.length) {
       return false;
     }
-    for (int i = 0; i < prefix.content.length - 1; i++) {
-      if (content[i] != prefix.content[i]) {
+    for (int i = 0; i < prefixContent.length - 1; i++) {
+      if (content[i] != prefixContent[i]) {
         return false;
       }
     }
diff --git a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
index d0e0027..7bd9cf9 100644
--- a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
@@ -304,7 +304,7 @@
       return true;
     }
     InvokeMethod replacement;
-    if (appView.options().canUseRequireNonNull()) {
+    if (appView.options().canUseJavaUtilObjectsRequireNonNull()) {
       DexMethod requireNonNullMethod = appView.dexItemFactory().objectsMethods.requireNonNull;
       replacement = new InvokeStatic(requireNonNullMethod, null, ImmutableList.of(receiver));
     } else {
diff --git a/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java
index 32b1f29..14a7d45 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java
@@ -107,10 +107,18 @@
   void replaceCurrentInstructionWithConstClass(
       AppView<?> appView, IRCode code, DexType type, DebugLocalInfo localInfo);
 
+  default void replaceCurrentInstructionWithConstFalse(IRCode code) {
+    replaceCurrentInstructionWithConstInt(code, 0);
+  }
+
   void replaceCurrentInstructionWithConstInt(IRCode code, int value);
 
   void replaceCurrentInstructionWithConstString(AppView<?> appView, IRCode code, DexString value);
 
+  default void replaceCurrentInstructionWithConstTrue(IRCode code) {
+    replaceCurrentInstructionWithConstInt(code, 1);
+  }
+
   default void replaceCurrentInstructionWithConstString(
       AppView<?> appView, IRCode code, String value) {
     replaceCurrentInstructionWithConstString(
diff --git a/src/main/java/com/android/tools/r8/ir/code/Invoke.java b/src/main/java/com/android/tools/r8/ir/code/Invoke.java
index d076960..02c1ad0 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Invoke.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Invoke.java
@@ -190,6 +190,10 @@
     return getArgument(0);
   }
 
+  public Value getLastArgument() {
+    return getArgument(arguments().size() - 1);
+  }
+
   public int requiredArgumentRegisters() {
     int registers = 0;
     for (Value inValue : inValues) {
diff --git a/src/main/java/com/android/tools/r8/ir/code/Value.java b/src/main/java/com/android/tools/r8/ir/code/Value.java
index 85d90e6..d582fdb 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Value.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Value.java
@@ -578,14 +578,24 @@
   }
 
   public void replaceUsers(Value newValue) {
+    replaceUsers(newValue, null);
+  }
+
+  public void replaceUsers(Value newValue, Set<Value> affectedValues) {
     if (this == newValue) {
       return;
     }
     for (Instruction user : uniqueUsers()) {
       user.replaceValue(this, newValue);
+      if (affectedValues != null && user.hasOutValue()) {
+        affectedValues.add(user.outValue);
+      }
     }
     for (Phi user : uniquePhiUsers()) {
       user.replaceOperand(this, newValue);
+      if (affectedValues != null) {
+        affectedValues.add(user);
+      }
     }
     if (debugData != null) {
       for (Instruction user : debugData.users) {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryConfiguration.java b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryConfiguration.java
index d19fd84..9ec7242 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryConfiguration.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryConfiguration.java
@@ -161,6 +161,10 @@
     return rewritePrefix;
   }
 
+  public boolean hasEmulatedLibraryInterfaces() {
+    return !getEmulateLibraryInterface().isEmpty();
+  }
+
   public Map<DexType, DexType> getEmulateLibraryInterface() {
     return emulateLibraryInterface;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
index 32ec969..36d70df 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
@@ -305,7 +305,7 @@
             if (invokedMethod == dexItemFactory.npeMethods.init) {
               message = null;
             } else if (invokedMethod == dexItemFactory.npeMethods.initWithMessage) {
-              if (!appView.options().canUseRequireNonNull()) {
+              if (!appView.options().canUseJavaUtilObjectsRequireNonNull()) {
                 continue;
               }
               message = constructorCall.getArgument(1);
@@ -3348,7 +3348,7 @@
     assert theIf == block.exit();
     iterator.previous();
     Instruction instruction;
-    if (appView.options().canUseRequireNonNull()) {
+    if (appView.options().canUseJavaUtilObjectsRequireNonNull()) {
       if (message != null) {
         DexMethod requireNonNullMethod =
             appView.dexItemFactory().objectsMethods.requireNonNullWithMessage;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
index e034587..41a298a 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
@@ -776,7 +776,7 @@
 
         InstructionListIterator iterator = throwBlock.listIterator(code);
         iterator.setInsertionPosition(invoke.getPosition());
-        if (appView.options().canUseRequireNonNull()) {
+        if (appView.options().canUseJavaUtilObjectsRequireNonNull()) {
           DexMethod requireNonNullMethod = appView.dexItemFactory().objectsMethods.requireNonNull;
           iterator.add(new InvokeStatic(requireNonNullMethod, null, ImmutableList.of(receiver)));
         } else {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/library/ObjectsMethodOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/library/ObjectsMethodOptimizer.java
index 831236b..08199da 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/library/ObjectsMethodOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/library/ObjectsMethodOptimizer.java
@@ -8,12 +8,17 @@
 import com.android.tools.r8.graph.DexClassAndMethod;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexItemFactory.ObjectsMethods;
+import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.InstructionListIterator;
 import com.android.tools.r8.ir.code.InvokeMethod;
+import com.android.tools.r8.ir.code.InvokeStatic;
+import com.android.tools.r8.ir.code.InvokeVirtual;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.utils.InternalOptions;
+import com.google.common.collect.ImmutableList;
 import java.util.Set;
 
 public class ObjectsMethodOptimizer extends StatelessLibraryMethodModelCollection {
@@ -21,12 +26,14 @@
   private final AppView<?> appView;
   private final DexItemFactory dexItemFactory;
   private final ObjectsMethods objectsMethods;
+  private final InternalOptions options;
 
   ObjectsMethodOptimizer(AppView<?> appView) {
     DexItemFactory dexItemFactory = appView.dexItemFactory();
     this.appView = appView;
     this.dexItemFactory = dexItemFactory;
     this.objectsMethods = dexItemFactory.objectsMethods;
+    this.options = appView.options();
   }
 
   @Override
@@ -41,24 +48,152 @@
       InvokeMethod invoke,
       DexClassAndMethod singleTarget,
       Set<Value> affectedValues) {
-    if (objectsMethods.isRequireNonNullMethod(singleTarget.getReference())) {
-      optimizeRequireNonNull(instructionIterator, invoke, affectedValues);
-    } else if (singleTarget.getReference() == objectsMethods.toStringWithObject) {
-      optimizeToStringWithObject(code, instructionIterator, invoke, affectedValues);
+    DexMethod singleTargetReference = singleTarget.getReference();
+    switch (singleTargetReference.getName().byteAt(0)) {
+      case 'e':
+        if (singleTargetReference == objectsMethods.equals) {
+          optimizeEquals(code, instructionIterator, invoke);
+        }
+        break;
+      case 'h':
+        if (singleTargetReference == objectsMethods.hashCode) {
+          optimizeHashCode(code, instructionIterator, invoke);
+        }
+        break;
+      case 'i':
+        if (singleTargetReference == objectsMethods.isNull) {
+          optimizeIsNull(code, instructionIterator, invoke);
+        }
+        break;
+      case 'n':
+        if (singleTargetReference == objectsMethods.nonNull) {
+          optimizeNonNull(code, instructionIterator, invoke);
+        }
+        break;
+      case 'r':
+        if (objectsMethods.isRequireNonNullMethod(singleTargetReference)) {
+          optimizeRequireNonNull(instructionIterator, invoke, affectedValues, singleTarget);
+        }
+        break;
+      case 't':
+        if (objectsMethods.isToStringMethod(singleTargetReference)) {
+          optimizeToStringWithObject(
+              code, instructionIterator, invoke, affectedValues, singleTarget);
+        }
+        break;
+      default:
+        // Intentionally empty.
+        break;
+    }
+  }
+
+  private void optimizeEquals(
+      IRCode code, InstructionListIterator instructionIterator, InvokeMethod invoke) {
+    Value aValue = invoke.getFirstArgument();
+    Value bValue = invoke.getLastArgument();
+    if (aValue.isAlwaysNull(appView)) {
+      // Optimize Objects.equals(null, b) into true if b is null, false if b is never null, and
+      // Objects.isNull(b) otherwise.
+      if (bValue.isAlwaysNull(appView)) {
+        instructionIterator.replaceCurrentInstructionWithConstTrue(code);
+      } else if (bValue.isNeverNull()) {
+        instructionIterator.replaceCurrentInstructionWithConstFalse(code);
+      } else if (options.canUseJavaUtilObjectsIsNull()) {
+        instructionIterator.replaceCurrentInstruction(
+            InvokeStatic.builder()
+                .setMethod(objectsMethods.isNull)
+                .setOutValue(invoke.outValue())
+                .setSingleArgument(bValue)
+                .build());
+      }
+    } else if (aValue.isNeverNull()) {
+      // Optimize Objects.equals(nonNull, b) into nonNull.equals(b).
+      instructionIterator.replaceCurrentInstruction(
+          InvokeVirtual.builder()
+              .setMethod(dexItemFactory.objectMembers.equals)
+              .setOutValue(invoke.outValue())
+              .setArguments(ImmutableList.of(aValue, bValue))
+              .build());
+    }
+  }
+
+  private void optimizeHashCode(
+      IRCode code, InstructionListIterator instructionIterator, InvokeMethod invoke) {
+    Value inValue = invoke.getFirstArgument();
+    if (inValue.isAlwaysNull(appView)) {
+      // Optimize Objects.hashCode(null) into 0.
+      instructionIterator.replaceCurrentInstructionWithConstInt(code, 0);
+    } else if (inValue.isNeverNull()) {
+      // Optimize Objects.hashCode(nonNull) into nonNull.hashCode().
+      instructionIterator.replaceCurrentInstruction(
+          InvokeVirtual.builder()
+              .setMethod(dexItemFactory.objectMembers.hashCode)
+              .setOutValue(invoke.outValue())
+              .setSingleArgument(inValue)
+              .build());
+    }
+  }
+
+  private void optimizeIsNull(
+      IRCode code, InstructionListIterator instructionIterator, InvokeMethod invoke) {
+    Value inValue = invoke.getFirstArgument();
+    if (inValue.isAlwaysNull(appView)) {
+      // Optimize Objects.isNull(null) into true.
+      instructionIterator.replaceCurrentInstructionWithConstTrue(code);
+    } else if (inValue.isNeverNull()) {
+      // Optimize Objects.isNull(nonNull) into false.
+      instructionIterator.replaceCurrentInstructionWithConstFalse(code);
+    }
+  }
+
+  private void optimizeNonNull(
+      IRCode code, InstructionListIterator instructionIterator, InvokeMethod invoke) {
+    Value inValue = invoke.getFirstArgument();
+    if (inValue.isAlwaysNull(appView)) {
+      // Optimize Objects.nonNull(null) into false.
+      instructionIterator.replaceCurrentInstructionWithConstFalse(code);
+    } else if (inValue.isNeverNull()) {
+      // Optimize Objects.nonNull(nonNull) into true.
+      instructionIterator.replaceCurrentInstructionWithConstTrue(code);
     }
   }
 
   private void optimizeRequireNonNull(
-      InstructionListIterator instructionIterator, InvokeMethod invoke, Set<Value> affectedValues) {
+      InstructionListIterator instructionIterator,
+      InvokeMethod invoke,
+      Set<Value> affectedValues,
+      DexClassAndMethod singleTarget) {
+    if (invoke.hasOutValue() && invoke.outValue().hasLocalInfo()) {
+      // Replacing the out-value with an in-value would change debug info.
+      return;
+    }
+
     Value inValue = invoke.getFirstArgument();
-    if (inValue.getType().isDefinitelyNotNull()) {
-      Value outValue = invoke.outValue();
-      if (outValue != null) {
-        affectedValues.addAll(outValue.affectedValues());
-        outValue.replaceUsers(inValue);
+    if (inValue.isNeverNull()) {
+      // Optimize Objects.requireNonNull*(nonNull, ...) into nonNull.
+      if (invoke.hasOutValue()) {
+        invoke.outValue().replaceUsers(inValue, affectedValues);
       }
-      // TODO(b/152853271): Debugging information is lost here (DebugLocalWrite may be required).
       instructionIterator.removeOrReplaceByDebugLocalRead();
+    } else if (inValue.isAlwaysNull(appView)) {
+      if (singleTarget.getReference() == objectsMethods.requireNonNullElse) {
+        // Optimize Objects.requireNonNullElse(null, defaultObj) into defaultObj.
+        if (invoke.hasOutValue()) {
+          invoke.outValue().replaceUsers(invoke.getLastArgument(), affectedValues);
+        }
+        instructionIterator.removeOrReplaceByDebugLocalRead();
+      } else if (singleTarget.getReference() == objectsMethods.requireNonNullElseGet) {
+        // Optimize Objects.requireNonNullElseGet(null, supplier) into supplier.get().
+        if (invoke.hasOutValue()) {
+          invoke.outValue().replaceUsers(invoke.getLastArgument(), affectedValues);
+        }
+        instructionIterator.replaceCurrentInstruction(
+            InvokeVirtual.builder()
+                .setMethod(dexItemFactory.supplierMembers.get)
+                .setOutValue(invoke.outValue())
+                .setSingleArgument(invoke.getLastArgument())
+                .build());
+      }
     }
   }
 
@@ -66,15 +201,24 @@
       IRCode code,
       InstructionListIterator instructionIterator,
       InvokeMethod invoke,
-      Set<Value> affectedValues) {
+      Set<Value> affectedValues,
+      DexClassAndMethod singleTarget) {
     Value object = invoke.getFirstArgument();
     TypeElement type = object.getType();
 
     // Optimize Objects.toString(null) into "null".
     if (type.isDefinitelyNull()) {
-      instructionIterator.replaceCurrentInstructionWithConstString(appView, code, "null");
-      if (invoke.hasOutValue()) {
-        affectedValues.addAll(invoke.outValue().affectedValues());
+      if (singleTarget.getReference() == objectsMethods.toStringWithObject) {
+        if (invoke.hasOutValue()) {
+          affectedValues.addAll(invoke.outValue().affectedValues());
+        }
+        instructionIterator.replaceCurrentInstructionWithConstString(appView, code, "null");
+      } else {
+        assert singleTarget.getReference() == objectsMethods.toStringWithObjectAndNullDefault;
+        if (invoke.hasOutValue()) {
+          invoke.outValue().replaceUsers(invoke.getLastArgument(), affectedValues);
+        }
+        instructionIterator.removeOrReplaceByDebugLocalRead();
       }
       return;
     }
diff --git a/src/main/java/com/android/tools/r8/shaking/MissingClasses.java b/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
index 3e8ad60..0ec8c27 100644
--- a/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
+++ b/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
@@ -9,8 +9,8 @@
 import static com.android.tools.r8.utils.collections.IdentityHashSetFromMap.newProgramDerivedContextSet;
 
 import com.android.tools.r8.diagnostic.MissingDefinitionsDiagnostic;
+import com.android.tools.r8.diagnostic.internal.DefinitionContextUtils;
 import com.android.tools.r8.diagnostic.internal.MissingClassInfoImpl;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionContextUtils;
 import com.android.tools.r8.diagnostic.internal.MissingDefinitionsDiagnosticImpl;
 import com.android.tools.r8.errors.dontwarn.DontWarnConfiguration;
 import com.android.tools.r8.graph.AppView;
@@ -147,7 +147,7 @@
                 MissingClassInfoImpl.builder().setClass(missingClass.asClassReference());
             for (ProgramDerivedContext programDerivedContext : programDerivedContexts) {
               missingClassInfoBuilder.addReferencedFromContext(
-                  MissingDefinitionContextUtils.create(programDerivedContext));
+                  DefinitionContextUtils.create(programDerivedContext));
             }
             diagnosticBuilder.addMissingDefinitionInfo(missingClassInfoBuilder.build());
           });
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
index 2871b74..ff71812 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
@@ -81,6 +81,8 @@
   private static final List<String> IGNORED_CLASS_DESCRIPTOR_OPTIONS =
       ImmutableList.of("isclassnamestring", "whyarenotsimple", "convertchecknotnull");
 
+  private static final List<String> IGNORED_RETURN_VALUE_ATTRIBUTES = ImmutableList.of("_NONNULL_");
+
   private static final List<String> WARNED_SINGLE_ARG_OPTIONS = ImmutableList.of(
       // TODO(b/37137994): -outjars should be reported as errors, not just as warnings!
       "outjars");
@@ -588,6 +590,19 @@
           || parseOptimizationOption(optionStart);
     }
 
+    private boolean parseIgnoredReturnValueAttribute() {
+      return Iterables.any(IGNORED_RETURN_VALUE_ATTRIBUTES, this::skipReturnValueAttribute);
+    }
+
+    private boolean parseIgnoredReturnValueAttributes() {
+      boolean anySkipped = false;
+      while (parseIgnoredReturnValueAttribute()) {
+        anySkipped = true;
+        skipWhitespace();
+      }
+      return anySkipped;
+    }
+
     private void parseInclude() throws ProguardRuleParserException {
       TextPosition start = getPosition();
       Path included = parseFileName(false);
@@ -673,6 +688,10 @@
       return false;
     }
 
+    private boolean skipReturnValueAttribute(String name) {
+      return acceptString(name);
+    }
+
     private boolean parseOptimizationOption(TextPosition optionStart)
         throws ProguardRuleParserException {
       if (!acceptString("optimizations")) {
@@ -1317,49 +1336,52 @@
                   // Parse "return ..." if present.
                   if (acceptString("return")) {
                     skipWhitespace();
-                    if (acceptString("true")) {
-                      ruleBuilder.setReturnValue(new ProguardMemberRuleReturnValue(true));
-                    } else if (acceptString("false")) {
-                      ruleBuilder.setReturnValue(new ProguardMemberRuleReturnValue(false));
-                    } else if (acceptString("null")) {
-                      ruleBuilder.setReturnValue(new ProguardMemberRuleReturnValue());
-                    } else {
-                      TextPosition fieldOrValueStart = getPosition();
-                      String qualifiedFieldNameOrInteger = acceptFieldNameOrIntegerForReturn();
-                      if (qualifiedFieldNameOrInteger != null) {
-                        if (isInteger(qualifiedFieldNameOrInteger)) {
-                          Integer min = Integer.parseInt(qualifiedFieldNameOrInteger);
-                          Integer max = min;
-                          skipWhitespace();
-                          if (acceptString("..")) {
+                    boolean anyReturnValueAttributesSkipped = parseIgnoredReturnValueAttributes();
+                    if (!anyReturnValueAttributesSkipped || !hasNextChar(';')) {
+                      if (acceptString("true")) {
+                        ruleBuilder.setReturnValue(new ProguardMemberRuleReturnValue(true));
+                      } else if (acceptString("false")) {
+                        ruleBuilder.setReturnValue(new ProguardMemberRuleReturnValue(false));
+                      } else if (acceptString("null")) {
+                        ruleBuilder.setReturnValue(new ProguardMemberRuleReturnValue());
+                      } else {
+                        TextPosition fieldOrValueStart = getPosition();
+                        String qualifiedFieldNameOrInteger = acceptFieldNameOrIntegerForReturn();
+                        if (qualifiedFieldNameOrInteger != null) {
+                          if (isInteger(qualifiedFieldNameOrInteger)) {
+                            Integer min = Integer.parseInt(qualifiedFieldNameOrInteger);
+                            Integer max = min;
                             skipWhitespace();
-                            max = acceptInteger();
-                            if (max == null) {
-                              throw parseError("Expected integer value");
+                            if (acceptString("..")) {
+                              skipWhitespace();
+                              max = acceptInteger();
+                              if (max == null) {
+                                throw parseError("Expected integer value");
+                              }
                             }
-                          }
-                          if (!allowValueSpecification) {
-                            throw parseError("Unexpected value specification", fieldOrValueStart);
-                          }
-                          ruleBuilder.setReturnValue(
-                              new ProguardMemberRuleReturnValue(new LongInterval(min, max)));
-                        } else {
-                          if (ruleBuilder.getTypeMatcher() instanceof MatchSpecificType) {
-                            int lastDotIndex = qualifiedFieldNameOrInteger.lastIndexOf(".");
-                            DexType fieldType = ((MatchSpecificType) ruleBuilder
-                                .getTypeMatcher()).type;
-                            DexType fieldClass =
-                                dexItemFactory.createType(
-                                    javaTypeToDescriptor(
-                                        qualifiedFieldNameOrInteger.substring(0, lastDotIndex)));
-                            DexString fieldName =
-                                dexItemFactory.createString(
-                                    qualifiedFieldNameOrInteger.substring(lastDotIndex + 1));
-                            DexField field = dexItemFactory
-                                .createField(fieldClass, fieldType, fieldName);
-                            ruleBuilder.setReturnValue(new ProguardMemberRuleReturnValue(field));
+                            if (!allowValueSpecification) {
+                              throw parseError("Unexpected value specification", fieldOrValueStart);
+                            }
+                            ruleBuilder.setReturnValue(
+                                new ProguardMemberRuleReturnValue(new LongInterval(min, max)));
                           } else {
-                            throw parseError("Expected specific type", fieldOrValueStart);
+                            if (ruleBuilder.getTypeMatcher() instanceof MatchSpecificType) {
+                              int lastDotIndex = qualifiedFieldNameOrInteger.lastIndexOf(".");
+                              DexType fieldType =
+                                  ((MatchSpecificType) ruleBuilder.getTypeMatcher()).type;
+                              DexType fieldClass =
+                                  dexItemFactory.createType(
+                                      javaTypeToDescriptor(
+                                          qualifiedFieldNameOrInteger.substring(0, lastDotIndex)));
+                              DexString fieldName =
+                                  dexItemFactory.createString(
+                                      qualifiedFieldNameOrInteger.substring(lastDotIndex + 1));
+                              DexField field =
+                                  dexItemFactory.createField(fieldClass, fieldType, fieldName);
+                              ruleBuilder.setReturnValue(new ProguardMemberRuleReturnValue(field));
+                            } else {
+                              throw parseError("Expected specific type", fieldOrValueStart);
+                            }
                           }
                         }
                       }
diff --git a/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesKeepRules.java b/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesKeepRules.java
index 6940f63..d1926db 100644
--- a/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesKeepRules.java
+++ b/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesKeepRules.java
@@ -50,7 +50,7 @@
     private boolean allowObfuscation;
 
     /**
-     * Indicate if the generated keep rules should have the <code>allobobfuscation</code> modifier.
+     * Indicate if the generated keep rules should have the <code>allowobfuscation</code> modifier.
      */
     public Builder setAllowObfuscation(boolean value) {
       allowObfuscation = value;
diff --git a/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesResult.java b/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesResult.java
index e0ce86a..1b16d54 100644
--- a/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesResult.java
+++ b/src/main/java/com/android/tools/r8/tracereferences/TraceReferencesResult.java
@@ -34,7 +34,7 @@
     this.keepPackageNames = keepPackageNames;
   }
 
-  static Builder builder() {
+  public static Builder builder() {
     return new Builder();
   }
 
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 1dc8da6..3e8de35 100644
--- a/src/main/java/com/android/tools/r8/tracereferences/Tracer.java
+++ b/src/main/java/com/android/tools/r8/tracereferences/Tracer.java
@@ -12,12 +12,12 @@
 import com.android.tools.r8.diagnostic.internal.MissingMethodInfoImpl;
 import com.android.tools.r8.features.ClassToFeatureSplitMap;
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexAnnotation;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexClassAndField;
 import com.android.tools.r8.graph.DexClassAndMethod;
 import com.android.tools.r8.graph.DexEncodedField;
-import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
@@ -38,14 +38,10 @@
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.shaking.MainDexInfo;
-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.tracereferences.internal.TracedClassImpl;
+import com.android.tools.r8.tracereferences.internal.TracedFieldImpl;
+import com.android.tools.r8.tracereferences.internal.TracedMethodImpl;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.Timing;
@@ -54,199 +50,7 @@
 import java.util.Set;
 import java.util.function.Predicate;
 
-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 type) {
-      this(type, null);
-    }
-
-    private TracedClassImpl(DexType reference, DexClass definition) {
-      super(
-          reference.asClassReference(),
-          definition != null ? new ClassAccessFlagsImpl(definition.getAccessFlags()) : null,
-          definition == null);
-    }
-
-    private TracedClassImpl(DexClass clazz) {
-      this(clazz.getType(), clazz);
-    }
-
-    @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 field) {
-      this(field, null);
-    }
-
-    private TracedFieldImpl(DexField reference, DexEncodedField definition) {
-      super(
-          reference.asFieldReference(),
-          definition != null ? new FieldAccessFlagsImpl(definition.getAccessFlags()) : null,
-          definition == null);
-    }
-
-    private TracedFieldImpl(DexClassAndField field) {
-      this(field.getReference(), field.getDefinition());
-    }
-
-    @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) {
-      this(reference, null);
-    }
-
-    private TracedMethodImpl(DexMethod reference, DexEncodedMethod definition) {
-      super(
-          reference.asMethodReference(),
-          definition != null ? new MethodAccessFlagsImpl(definition.getAccessFlags()) : null,
-          definition == null);
-    }
-
-    private TracedMethodImpl(DexClassAndMethod method) {
-      this(method.getReference(), method.getDefinition());
-    }
-
-    @Override
-    public String getKindName() {
-      return "method";
-    }
-
-    @Override
-    public String toString() {
-      return getReference().toString();
-    }
-  }
+public class Tracer {
 
   private final AppInfoWithClassHierarchy appInfo;
   private final DiagnosticsHandler diagnostics;
@@ -269,6 +73,18 @@
         type -> targetDescriptors.contains(type.toDescriptorString()));
   }
 
+  public Tracer(
+      AppView<? extends AppInfoWithClassHierarchy> appView,
+      DiagnosticsHandler diagnostics,
+      Predicate<DexType> targetPredicate) {
+    this(
+        appView.appInfo(),
+        diagnostics,
+        appView.graphLens(),
+        appView.initClassLens(),
+        targetPredicate);
+  }
+
   private Tracer(
       AppInfoWithClassHierarchy appInfo,
       DiagnosticsHandler diagnostics,
@@ -282,7 +98,7 @@
     this.targetPredicate = targetPredicate;
   }
 
-  void run(TraceReferencesConsumer consumer) {
+  public void run(TraceReferencesConsumer consumer) {
     UseCollector useCollector = new UseCollector(appInfo, consumer, diagnostics, targetPredicate);
     for (DexProgramClass clazz : appInfo.classes()) {
       useCollector.registerSuperType(clazz, clazz.superType);
@@ -389,7 +205,7 @@
       }
     }
 
-    private <R, T extends TracedReferenceBase<R, ?>> void collectMissing(
+    private <R, T extends TracedReference<R, ?>> void collectMissing(
         T tracedReference, Set<R> missingCollection) {
       if (tracedReference.isMissingDefinition()) {
         missingCollection.add(tracedReference.getReference());
diff --git a/src/main/java/com/android/tools/r8/tracereferences/internal/AccessFlagsImpl.java b/src/main/java/com/android/tools/r8/tracereferences/internal/AccessFlagsImpl.java
new file mode 100644
index 0000000..978e1c2
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/tracereferences/internal/AccessFlagsImpl.java
@@ -0,0 +1,36 @@
+// Copyright (c) 2021, 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.internal;
+
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.AccessFlags;
+
+public 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();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/tracereferences/internal/ClassAccessFlagsImpl.java b/src/main/java/com/android/tools/r8/tracereferences/internal/ClassAccessFlagsImpl.java
new file mode 100644
index 0000000..a5753d2
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/tracereferences/internal/ClassAccessFlagsImpl.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2021, 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.internal;
+
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.ClassAccessFlags;
+
+public 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();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/tracereferences/internal/FieldAccessFlagsImpl.java b/src/main/java/com/android/tools/r8/tracereferences/internal/FieldAccessFlagsImpl.java
new file mode 100644
index 0000000..012f3c0
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/tracereferences/internal/FieldAccessFlagsImpl.java
@@ -0,0 +1,15 @@
+// Copyright (c) 2021, 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.internal;
+
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.FieldAccessFlags;
+
+public class FieldAccessFlagsImpl
+    extends AccessFlagsImpl<com.android.tools.r8.graph.FieldAccessFlags>
+    implements FieldAccessFlags {
+  FieldAccessFlagsImpl(com.android.tools.r8.graph.FieldAccessFlags accessFlags) {
+    super(accessFlags);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/tracereferences/internal/MethodAccessFlagsImpl.java b/src/main/java/com/android/tools/r8/tracereferences/internal/MethodAccessFlagsImpl.java
new file mode 100644
index 0000000..2f0fa66
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/tracereferences/internal/MethodAccessFlagsImpl.java
@@ -0,0 +1,15 @@
+// Copyright (c) 2021, 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.internal;
+
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.MethodAccessFlags;
+
+public class MethodAccessFlagsImpl
+    extends AccessFlagsImpl<com.android.tools.r8.graph.MethodAccessFlags>
+    implements MethodAccessFlags {
+  MethodAccessFlagsImpl(com.android.tools.r8.graph.MethodAccessFlags accessFlags) {
+    super(accessFlags);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/tracereferences/internal/TracedClassImpl.java b/src/main/java/com/android/tools/r8/tracereferences/internal/TracedClassImpl.java
new file mode 100644
index 0000000..fd9a353
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/tracereferences/internal/TracedClassImpl.java
@@ -0,0 +1,31 @@
+// Copyright (c) 2021, 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.internal;
+
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.ClassAccessFlags;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedClass;
+
+public class TracedClassImpl extends TracedReferenceBase<ClassReference, ClassAccessFlags>
+    implements TracedClass {
+  public TracedClassImpl(DexType type) {
+    this(type.asClassReference(), null);
+  }
+
+  public TracedClassImpl(DexClass clazz) {
+    this(clazz.getClassReference(), new ClassAccessFlagsImpl(clazz.getAccessFlags()));
+  }
+
+  public TracedClassImpl(ClassReference classReference, ClassAccessFlags accessFlags) {
+    super(classReference, accessFlags, accessFlags == null);
+  }
+
+  @Override
+  public String toString() {
+    return getReference().getTypeName();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/tracereferences/internal/TracedFieldImpl.java b/src/main/java/com/android/tools/r8/tracereferences/internal/TracedFieldImpl.java
new file mode 100644
index 0000000..9c6ac2d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/tracereferences/internal/TracedFieldImpl.java
@@ -0,0 +1,31 @@
+// Copyright (c) 2021, 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.internal;
+
+import com.android.tools.r8.graph.DexClassAndField;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.FieldAccessFlags;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedField;
+
+public class TracedFieldImpl extends TracedReferenceBase<FieldReference, FieldAccessFlags>
+    implements TracedField {
+  public TracedFieldImpl(DexField field) {
+    this(field.asFieldReference(), null);
+  }
+
+  public TracedFieldImpl(DexClassAndField field) {
+    this(field.getFieldReference(), new FieldAccessFlagsImpl(field.getAccessFlags()));
+  }
+
+  public TracedFieldImpl(FieldReference fieldReference, FieldAccessFlags accessFlags) {
+    super(fieldReference, accessFlags, accessFlags == null);
+  }
+
+  @Override
+  public String toString() {
+    return getReference().toString();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/tracereferences/internal/TracedMethodImpl.java b/src/main/java/com/android/tools/r8/tracereferences/internal/TracedMethodImpl.java
new file mode 100644
index 0000000..c12cbd4
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/tracereferences/internal/TracedMethodImpl.java
@@ -0,0 +1,31 @@
+// Copyright (c) 2021, 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.internal;
+
+import com.android.tools.r8.graph.DexClassAndMethod;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.MethodAccessFlags;
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedMethod;
+
+public class TracedMethodImpl extends TracedReferenceBase<MethodReference, MethodAccessFlags>
+    implements TracedMethod {
+  public TracedMethodImpl(DexMethod method) {
+    this(method.asMethodReference(), null);
+  }
+
+  public TracedMethodImpl(DexClassAndMethod method) {
+    this(method.getMethodReference(), new MethodAccessFlagsImpl(method.getAccessFlags()));
+  }
+
+  public TracedMethodImpl(MethodReference methodReference, MethodAccessFlags accessFlags) {
+    super(methodReference, accessFlags, accessFlags == null);
+  }
+
+  @Override
+  public String toString() {
+    return getReference().toString();
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/tracereferences/internal/TracedReferenceBase.java b/src/main/java/com/android/tools/r8/tracereferences/internal/TracedReferenceBase.java
new file mode 100644
index 0000000..254048b
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/tracereferences/internal/TracedReferenceBase.java
@@ -0,0 +1,50 @@
+// Copyright (c) 2021, 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.internal;
+
+import com.android.tools.r8.tracereferences.TraceReferencesConsumer.TracedReference;
+
+abstract class TracedReferenceBase<T, F> implements TracedReference<T, F> {
+  private final T reference;
+  private final F accessFlags;
+  private final boolean missingDefinition;
+
+  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);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/ClassReferenceUtils.java b/src/main/java/com/android/tools/r8/utils/ClassReferenceUtils.java
index fa2a18c..30754f0 100644
--- a/src/main/java/com/android/tools/r8/utils/ClassReferenceUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/ClassReferenceUtils.java
@@ -4,6 +4,8 @@
 
 package com.android.tools.r8.utils;
 
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.MethodReference;
@@ -33,4 +35,8 @@
   public static Comparator<ClassReference> getClassReferenceComparator() {
     return COMPARATOR;
   }
+
+  public static DexType toDexType(ClassReference classReference, DexItemFactory dexItemFactory) {
+    return dexItemFactory.createType(classReference.getDescriptor());
+  }
 }
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 d868ed1..ff812b6 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -1325,6 +1325,7 @@
     public boolean enableSwitchToIfRewriting = true;
     public boolean enableEnumUnboxingDebugLogs = false;
     public boolean forceRedundantConstNumberRemoval = false;
+    public boolean enableExperimentalDesugaredLibraryKeepRuleGenerator = false;
     public boolean enableExperimentalRecordDesugaring = false;
     public boolean invertConditionals = false;
     public boolean placeExceptionalBlocksLast = false;
@@ -1560,7 +1561,11 @@
     return !isDesugaring() || hasMinApi(AndroidApiLevel.K);
   }
 
-  public boolean canUseRequireNonNull() {
+  public boolean canUseJavaUtilObjectsIsNull() {
+    return isGeneratingDex() && hasMinApi(AndroidApiLevel.N);
+  }
+
+  public boolean canUseJavaUtilObjectsRequireNonNull() {
     return isGeneratingDex() && hasMinApi(AndroidApiLevel.K);
   }
 
diff --git a/src/main/java/com/android/tools/r8/utils/NopDiagnosticsHandler.java b/src/main/java/com/android/tools/r8/utils/NopDiagnosticsHandler.java
new file mode 100644
index 0000000..1487bd3
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/NopDiagnosticsHandler.java
@@ -0,0 +1,32 @@
+// Copyright (c) 2021, 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.utils;
+
+import com.android.tools.r8.Diagnostic;
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.DiagnosticsLevel;
+
+public class NopDiagnosticsHandler implements DiagnosticsHandler {
+
+  @Override
+  public void error(Diagnostic error) {
+    // Intentionally empty.
+  }
+
+  @Override
+  public void warning(Diagnostic warning) {
+    // Intentionally empty.
+  }
+
+  @Override
+  public void info(Diagnostic info) {
+    // Intentionally empty.
+  }
+
+  @Override
+  public DiagnosticsLevel modifyDiagnosticsLevel(DiagnosticsLevel level, Diagnostic diagnostic) {
+    return level;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/TypeReferenceUtils.java b/src/main/java/com/android/tools/r8/utils/TypeReferenceUtils.java
index 15344f9..20f1e99 100644
--- a/src/main/java/com/android/tools/r8/utils/TypeReferenceUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/TypeReferenceUtils.java
@@ -4,8 +4,17 @@
 
 package com.android.tools.r8.utils;
 
+import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexProto;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.references.ArrayReference;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.PrimitiveReference;
 import com.android.tools.r8.references.TypeReference;
 import java.util.Comparator;
+import java.util.List;
+import java.util.function.Function;
 
 public class TypeReferenceUtils {
 
@@ -27,4 +36,70 @@
   public static Comparator<TypeReference> getTypeReferenceComparator() {
     return COMPARATOR;
   }
+
+  /**
+   * Converts the given {@param formalTypes} and {@param returnType} to a {@link DexProto}.
+   *
+   * @param classReferenceConverter is used to convert {@link ClassReference} instances into {@link
+   *     DexType}, to allow caching of intermediate results at the call site.
+   */
+  public static DexProto toDexProto(
+      List<TypeReference> formalTypes,
+      TypeReference returnType,
+      DexItemFactory dexItemFactory,
+      Function<ClassReference, DexType> classReferenceConverter) {
+    return dexItemFactory.createProto(
+        toDexType(returnType, dexItemFactory, classReferenceConverter),
+        ListUtils.map(
+            formalTypes,
+            formalType -> toDexType(formalType, dexItemFactory, classReferenceConverter)));
+  }
+
+  /**
+   * Converts the given {@param typeReference} to a {@link DexType}.
+   *
+   * @param classReferenceConverter is used to convert {@link ClassReference} instances into {@link
+   *     DexType}, to allow caching of intermediate results at the call site.
+   */
+  public static DexType toDexType(
+      TypeReference typeReference,
+      DexItemFactory dexItemFactory,
+      Function<ClassReference, DexType> classReferenceConverter) {
+    if (typeReference == null) {
+      return null;
+    }
+    if (typeReference.isPrimitive()) {
+      PrimitiveReference primitiveReference = typeReference.asPrimitive();
+      switch (primitiveReference.getDescriptor().charAt(0)) {
+        case 'Z':
+          return dexItemFactory.booleanType;
+        case 'B':
+          return dexItemFactory.byteType;
+        case 'C':
+          return dexItemFactory.charType;
+        case 'S':
+          return dexItemFactory.shortType;
+        case 'I':
+          return dexItemFactory.intType;
+        case 'F':
+          return dexItemFactory.floatType;
+        case 'J':
+          return dexItemFactory.longType;
+        case 'D':
+          return dexItemFactory.doubleType;
+        default:
+          throw new Unreachable(
+              "Invalid primitive descriptor: " + primitiveReference.getDescriptor());
+      }
+    }
+    if (typeReference.isArray()) {
+      ArrayReference arrayReference = typeReference.asArray();
+      TypeReference baseType = arrayReference.getBaseType();
+      return dexItemFactory.createArrayType(
+          arrayReference.getDimensions(),
+          toDexType(baseType, dexItemFactory, classReferenceConverter));
+    }
+    assert typeReference.isClass();
+    return classReferenceConverter.apply(typeReference.asClass());
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index 0577d2f..79bfbde 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -1754,7 +1754,12 @@
         || parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.K);
   }
 
-  public static boolean canUseRequireNonNull(TestParameters parameters) {
+  public static boolean canUseJavaUtilObjectsIsNull(TestParameters parameters) {
+    return parameters.isDexRuntime()
+        && parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N);
+  }
+
+  public static boolean canUseJavaUtilObjectsRequireNonNull(TestParameters parameters) {
     return parameters.isDexRuntime()
         && parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.K);
   }
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ObjectsTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ObjectsTest.java
index efddc67..3e89a4f 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ObjectsTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/ObjectsTest.java
@@ -526,22 +526,22 @@
       // Android K methods.
       objectsCompare("b", "a");
       objectsDeepEquals(args, new Object());
-      objectsEquals(args, new Object());
+      objectsEquals(makeNullable(args), new Object());
       objectsHash(1, 2);
       objectsHashCode(4);
-      objectsRequireNonNull(System.currentTimeMillis() >= 0 ? null : new Object());
+      objectsRequireNonNull(getNonNullableNull());
       objectsRequireNonNullWithMessage(null, "Was null");
       if (objectsRequireNonNullWithSupplierSupported) {
         objectsRequireNonNullWithSupplier(null, () -> "Supplier said was null");
       } else {
         System.out.println("Not supported (b/174840626)");
       }
-      objectsToString("5");
-      objectsToStringWithNullDefault(null, "6");
+      objectsToString(makeNullable("5"));
+      objectsToStringWithNullDefault(getNonNullableNull(), "6");
 
       // Android N methods.
-      objectsIsNull(null);
-      objectsNonNull(null);
+      objectsIsNull(getNonNullableNull());
+      objectsNonNull(getNonNullableNull());
 
       // Android R methods.
       Class<?> c = Class.forName("AndroidRUtilsObjectsMethods");
@@ -553,6 +553,14 @@
       c.getDeclaredMethod("requireNonNullElse", Object.class, Object.class).invoke(null, null, 4);
       // TODO(b/174840626) Also support requireNonNullElseGet.
     }
+
+    private static Object makeNullable(Object obj) {
+      return System.currentTimeMillis() > 0 ? obj : null;
+    }
+
+    private static Object getNonNullableNull() {
+      return System.currentTimeMillis() > 0 ? null : new Object();
+    }
   }
 
   /*
diff --git a/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionContextSubject.java b/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionContextSubject.java
index 4178db4..f058329 100644
--- a/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionContextSubject.java
+++ b/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionContextSubject.java
@@ -7,35 +7,35 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.diagnostic.MissingDefinitionClassContext;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.MissingDefinitionFieldContext;
-import com.android.tools.r8.diagnostic.MissingDefinitionMethodContext;
+import com.android.tools.r8.diagnostic.DefinitionClassContext;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.DefinitionFieldContext;
+import com.android.tools.r8.diagnostic.DefinitionMethodContext;
 
 public class FoundMissingDefinitionContextSubject {
 
-  private final MissingDefinitionContext context;
+  private final DefinitionContext context;
 
-  public FoundMissingDefinitionContextSubject(MissingDefinitionContext context) {
+  public FoundMissingDefinitionContextSubject(DefinitionContext context) {
     this.context = context;
   }
 
   public FoundMissingDefinitionContextSubject assertEqualTo(
-      MissingDefinitionClassContext expectedContext) {
+      DefinitionClassContext expectedContext) {
     assertTrue(context.isClassContext());
     assertEquals(expectedContext.getClassReference(), context.asClassContext().getClassReference());
     return this;
   }
 
   public FoundMissingDefinitionContextSubject assertEqualTo(
-      MissingDefinitionFieldContext expectedContext) {
+      DefinitionFieldContext expectedContext) {
     assertTrue(context.isFieldContext());
     assertEquals(expectedContext.getFieldReference(), context.asFieldContext().getFieldReference());
     return this;
   }
 
   public FoundMissingDefinitionContextSubject assertEqualTo(
-      MissingDefinitionMethodContext expectedContext) {
+      DefinitionMethodContext expectedContext) {
     assertTrue(context.isMethodContext());
     assertEquals(
         expectedContext.getMethodReference(), context.asMethodContext().getMethodReference());
diff --git a/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionInfoSubject.java b/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionInfoSubject.java
index 89a5db5..2fc9bfa 100644
--- a/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionInfoSubject.java
+++ b/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionInfoSubject.java
@@ -7,9 +7,9 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.DefinitionContext;
 import com.android.tools.r8.diagnostic.MissingDefinitionInfo;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionContextUtils;
+import com.android.tools.r8.diagnostic.internal.DefinitionContextUtils;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.MethodReference;
@@ -34,7 +34,7 @@
         .getReferencedFromContexts()
         .forEach(
             context ->
-                MissingDefinitionContextUtils.accept(
+                DefinitionContextUtils.accept(
                     context,
                     classContext ->
                         classContexts.put(
@@ -51,11 +51,11 @@
   }
 
   public FoundMissingDefinitionInfoSubject assertExactContexts(
-      List<MissingDefinitionContext> expectedContexts) {
+      List<DefinitionContext> expectedContexts) {
     assertEquals(expectedContexts.size(), missingDefinitionInfo.getReferencedFromContexts().size());
     expectedContexts.forEach(
         expectedContext ->
-            MissingDefinitionContextUtils.accept(
+            DefinitionContextUtils.accept(
                 expectedContext,
                 expectedClassContext -> {
                   FoundMissingDefinitionContextSubject subject =
diff --git a/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionsDiagnosticSubject.java b/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionsDiagnosticSubject.java
index 28c8fbd..990d480 100644
--- a/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionsDiagnosticSubject.java
+++ b/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionsDiagnosticSubject.java
@@ -9,8 +9,8 @@
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.diagnostic.DefinitionContext;
 import com.android.tools.r8.diagnostic.MissingClassInfo;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
 import com.android.tools.r8.diagnostic.MissingDefinitionInfo;
 import com.android.tools.r8.diagnostic.MissingDefinitionsDiagnostic;
 import com.android.tools.r8.diagnostic.MissingFieldInfo;
@@ -66,12 +66,12 @@
   }
 
   public FoundMissingDefinitionsDiagnosticSubject assertIsMissingClassWithExactContexts(
-      ClassReference classReference, MissingDefinitionContext... expectedContexts) {
+      ClassReference classReference, DefinitionContext... expectedContexts) {
     return assertIsMissingClassWithExactContexts(classReference, Arrays.asList(expectedContexts));
   }
 
   public FoundMissingDefinitionsDiagnosticSubject assertIsMissingClassWithExactContexts(
-      ClassReference classReference, List<MissingDefinitionContext> expectedContexts) {
+      ClassReference classReference, List<DefinitionContext> expectedContexts) {
     return inspectMissingClassInfo(
         classReference,
         missingClassInfoSubject -> missingClassInfoSubject.assertExactContexts(expectedContexts));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/SyntheticInlineNullCheckPositionTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/SyntheticInlineNullCheckPositionTest.java
index 4eadc56..b5588bd 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/SyntheticInlineNullCheckPositionTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/SyntheticInlineNullCheckPositionTest.java
@@ -71,7 +71,7 @@
         .assertFailureWithErrorThatThrows(NullPointerException.class)
         .inspectStackTrace(
             stackTrace -> {
-              if (canUseRequireNonNull(parameters)) {
+              if (canUseJavaUtilObjectsIsNull(parameters)) {
                 assertThat(
                     stackTrace,
                     isSameExceptForSpecificLineNumber(
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsEqualsTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsEqualsTest.java
new file mode 100644
index 0000000..109c991
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsEqualsTest.java
@@ -0,0 +1,123 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.library;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethodWithHolderAndName;
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethodWithName;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
+import static com.android.tools.r8.utils.codeinspector.Matchers.onlyIf;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.Objects;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ObjectsEqualsTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters()
+        .withDexRuntimes()
+        .withApiLevelsStartingAtIncluding(AndroidApiLevel.K)
+        .build();
+  }
+
+  public ObjectsEqualsTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .enableInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(
+            inspector -> {
+              ClassSubject mainClassSubject = inspector.clazz(Main.class);
+              assertThat(mainClassSubject, isPresent());
+
+              MethodSubject testNonNullArgumentsMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNonNullArguments");
+              assertThat(testNonNullArgumentsMethodSubject, isPresent());
+              assertThat(
+                  testNonNullArgumentsMethodSubject,
+                  not(invokesMethodWithHolderAndName("java.util.Objects", "equals")));
+              assertThat(
+                  testNonNullArgumentsMethodSubject,
+                  invokesMethodWithHolderAndName("java.lang.Object", "equals"));
+
+              MethodSubject testNullAndNullArgumentsMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNullAndNullArguments");
+              assertThat(testNullAndNullArgumentsMethodSubject, isPresent());
+              assertThat(
+                  testNullAndNullArgumentsMethodSubject, not(invokesMethodWithName("equals")));
+
+              MethodSubject testNullAndNonNullArgumentsMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNullAndNonNullArguments");
+              assertThat(testNullAndNonNullArgumentsMethodSubject, isPresent());
+              assertThat(
+                  testNullAndNonNullArgumentsMethodSubject, not(invokesMethodWithName("equals")));
+
+              MethodSubject testNullAndMaybeNullArgumentsMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNullAndMaybeNullArguments");
+              assertThat(testNullAndMaybeNullArgumentsMethodSubject, isPresent());
+              assertThat(
+                  testNullAndMaybeNullArgumentsMethodSubject,
+                  notIf(invokesMethodWithName("equals"), canUseJavaUtilObjectsIsNull(parameters)));
+              assertThat(
+                  testNullAndMaybeNullArgumentsMethodSubject,
+                  onlyIf(canUseJavaUtilObjectsIsNull(parameters), invokesMethodWithName("isNull")));
+            })
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("false", "true", "false", "false");
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      testNonNullArguments();
+      testNullAndNullArguments();
+      testNullAndNonNullArguments();
+      testNullAndMaybeNullArguments();
+    }
+
+    @NeverInline
+    static void testNonNullArguments() {
+      System.out.println(Objects.equals(new Object(), new Object()));
+    }
+
+    @NeverInline
+    static void testNullAndNullArguments() {
+      System.out.println(Objects.equals(null, null));
+    }
+
+    @NeverInline
+    static void testNullAndNonNullArguments() {
+      System.out.println(Objects.equals(null, new Object()));
+    }
+
+    @NeverInline
+    static void testNullAndMaybeNullArguments() {
+      System.out.println(
+          Objects.equals(null, System.currentTimeMillis() > 0 ? new Object() : null));
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsHashCodeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsHashCodeTest.java
new file mode 100644
index 0000000..8ed1eac
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsHashCodeTest.java
@@ -0,0 +1,95 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.library;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethodWithHolderAndName;
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethodWithName;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.Objects;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ObjectsHashCodeTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public ObjectsHashCodeTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(
+            inspector -> {
+              ClassSubject mainClassSubject = inspector.clazz(Main.class);
+              assertThat(mainClassSubject, isPresent());
+
+              MethodSubject testNonNullArgumentMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+              assertThat(testNonNullArgumentMethodSubject, isPresent());
+              assertThat(
+                  testNonNullArgumentMethodSubject,
+                  not(invokesMethodWithHolderAndName("java.util.Objects", "hashCode")));
+
+              MethodSubject testNullArgumentMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNullArgument");
+              assertThat(testNullArgumentMethodSubject, isPresent());
+              assertThat(testNullArgumentMethodSubject, not(invokesMethodWithName("hashCode")));
+            })
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("42", "0");
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      testNonNullArgument();
+      testNullArgument();
+    }
+
+    @NeverInline
+    static void testNonNullArgument() {
+      System.out.println(Objects.hashCode(new A()));
+    }
+
+    @NeverInline
+    static void testNullArgument() {
+      System.out.println(Objects.hashCode(null));
+    }
+  }
+
+  @NeverClassInline
+  static class A {
+
+    @Override
+    public int hashCode() {
+      return System.currentTimeMillis() > 0 ? 42 : -1;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsIsNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsIsNullTest.java
new file mode 100644
index 0000000..6064fec
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsIsNullTest.java
@@ -0,0 +1,81 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.library;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethodWithName;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.Objects;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ObjectsIsNullTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public ObjectsIsNullTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .enableInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(
+            inspector -> {
+              ClassSubject mainClassSubject = inspector.clazz(Main.class);
+              assertThat(mainClassSubject, isPresent());
+
+              MethodSubject testNonNullArgumentMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+              assertThat(testNonNullArgumentMethodSubject, isPresent());
+              assertThat(testNonNullArgumentMethodSubject, not(invokesMethodWithName("isNull")));
+
+              MethodSubject testNullArgumentMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNullArgument");
+              assertThat(testNullArgumentMethodSubject, isPresent());
+              assertThat(testNullArgumentMethodSubject, not(invokesMethodWithName("isNull")));
+            })
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("false", "true");
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      testNonNullArgument();
+      testNullArgument();
+    }
+
+    @NeverInline
+    static void testNonNullArgument() {
+      System.out.println(Objects.isNull(new Object()));
+    }
+
+    @NeverInline
+    static void testNullArgument() {
+      System.out.println(Objects.isNull(null));
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsNonNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsNonNullTest.java
new file mode 100644
index 0000000..d4b4d35
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsNonNullTest.java
@@ -0,0 +1,81 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.library;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethodWithName;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.Objects;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ObjectsNonNullTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public ObjectsNonNullTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .enableInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(
+            inspector -> {
+              ClassSubject mainClassSubject = inspector.clazz(Main.class);
+              assertThat(mainClassSubject, isPresent());
+
+              MethodSubject testNonNullArgumentMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+              assertThat(testNonNullArgumentMethodSubject, isPresent());
+              assertThat(testNonNullArgumentMethodSubject, not(invokesMethodWithName("nonNull")));
+
+              MethodSubject testNullArgumentMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNullArgument");
+              assertThat(testNullArgumentMethodSubject, isPresent());
+              assertThat(testNullArgumentMethodSubject, not(invokesMethodWithName("nonNull")));
+            })
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("true", "false");
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      testNonNullArgument();
+      testNullArgument();
+    }
+
+    @NeverInline
+    static void testNonNullArgument() {
+      System.out.println(Objects.nonNull(new Object()));
+    }
+
+    @NeverInline
+    static void testNullArgument() {
+      System.out.println(Objects.nonNull(null));
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseGetTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseGetTest.java
new file mode 100644
index 0000000..e0a4c6d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseGetTest.java
@@ -0,0 +1,106 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.library;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethodWithName;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.io.IOException;
+import java.util.Objects;
+import java.util.function.Supplier;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ObjectsRequireNonNullElseGetTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters()
+        .withDexRuntimes()
+        .withApiLevelsStartingAtIncluding(AndroidApiLevel.N)
+        .build();
+  }
+
+  public ObjectsRequireNonNullElseGetTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClassFileData(getProgramClassFileData())
+        .addKeepMainRule(Main.class)
+        .enableInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(
+            inspector -> {
+              ClassSubject mainClassSubject = inspector.clazz(Main.class);
+              assertThat(mainClassSubject, isPresent());
+
+              MethodSubject testNonNullArgumentMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+              assertThat(testNonNullArgumentMethodSubject, isPresent());
+              assertThat(
+                  testNonNullArgumentMethodSubject,
+                  not(invokesMethodWithName("requireNonNullElseGet")));
+
+              MethodSubject testNullArgumentMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNullArgument");
+              assertThat(testNullArgumentMethodSubject, isPresent());
+              assertThat(
+                  testNullArgumentMethodSubject,
+                  not(invokesMethodWithName("requireNonNullElseGet")));
+            })
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("Foo", "Bar");
+  }
+
+  private byte[] getProgramClassFileData() throws IOException {
+    return transformer(Main.class)
+        .replaceClassDescriptorInMethodInstructions(
+            descriptor(Mock.class), descriptor(Objects.class))
+        .transform();
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      testNonNullArgument();
+      testNullArgument();
+    }
+
+    @NeverInline
+    static void testNonNullArgument() {
+      System.out.println(Mock.requireNonNullElseGet("Foo", null));
+    }
+
+    @NeverInline
+    static void testNullArgument() {
+      System.out.println(Mock.requireNonNullElseGet(null, () -> "Bar"));
+    }
+  }
+
+  // References to this class are rewritten to java.util.Objects by transformation.
+  static class Mock {
+
+    public static Object requireNonNullElseGet(Object obj, Supplier<?> supplier) {
+      throw new RuntimeException();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseTest.java
new file mode 100644
index 0000000..39acb1e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsRequireNonNullElseTest.java
@@ -0,0 +1,100 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.library;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethodWithName;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.io.IOException;
+import java.util.Objects;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ObjectsRequireNonNullElseTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+  }
+
+  public ObjectsRequireNonNullElseTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClassFileData(getProgramClassFileData())
+        .addKeepMainRule(Main.class)
+        .enableInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(
+            inspector -> {
+              ClassSubject mainClassSubject = inspector.clazz(Main.class);
+              assertThat(mainClassSubject, isPresent());
+
+              MethodSubject testNonNullArgumentMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+              assertThat(testNonNullArgumentMethodSubject, isPresent());
+              assertThat(
+                  testNonNullArgumentMethodSubject,
+                  not(invokesMethodWithName("requireNonNullElse")));
+
+              MethodSubject testNullArgumentMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNullArgument");
+              assertThat(testNullArgumentMethodSubject, isPresent());
+              assertThat(
+                  testNullArgumentMethodSubject, not(invokesMethodWithName("requireNonNullElse")));
+            })
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("Foo", "Bar");
+  }
+
+  private byte[] getProgramClassFileData() throws IOException {
+    return transformer(Main.class)
+        .replaceClassDescriptorInMethodInstructions(
+            descriptor(Mock.class), descriptor(Objects.class))
+        .transform();
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      testNonNullArgument();
+      testNullArgument();
+    }
+
+    @NeverInline
+    static void testNonNullArgument() {
+      System.out.println(Mock.requireNonNullElse("Foo", ":-("));
+    }
+
+    @NeverInline
+    static void testNullArgument() {
+      System.out.println(Mock.requireNonNullElse(null, "Bar"));
+    }
+  }
+
+  // References to this class are rewritten to java.util.Objects by transformation.
+  static class Mock {
+
+    public static Object requireNonNullElse(Object obj, Object defaultObj) {
+      throw new RuntimeException();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsToStringWithNullDefaultTest.java b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsToStringWithNullDefaultTest.java
new file mode 100644
index 0000000..fe974a5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/library/ObjectsToStringWithNullDefaultTest.java
@@ -0,0 +1,86 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.library;
+
+import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethodWithName;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.Objects;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ObjectsToStringWithNullDefaultTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters()
+        .withCfRuntimes()
+        .withDexRuntimes()
+        .withApiLevelsStartingAtIncluding(AndroidApiLevel.K)
+        .build();
+  }
+
+  public ObjectsToStringWithNullDefaultTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .enableInliningAnnotations()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(
+            inspector -> {
+              ClassSubject mainClassSubject = inspector.clazz(Main.class);
+              assertThat(mainClassSubject, isPresent());
+
+              MethodSubject testNonNullArgumentMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNonNullArgument");
+              assertThat(testNonNullArgumentMethodSubject, isPresent());
+              assertThat(testNonNullArgumentMethodSubject, not(invokesMethodWithName("toString")));
+
+              MethodSubject testNullArgumentMethodSubject =
+                  mainClassSubject.uniqueMethodWithName("testNullArgument");
+              assertThat(testNullArgumentMethodSubject, isPresent());
+              assertThat(testNullArgumentMethodSubject, not(invokesMethodWithName("toString")));
+            })
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("Foo", "Bar");
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      testNonNullArgument();
+      testNullArgument();
+    }
+
+    @NeverInline
+    static void testNonNullArgument() {
+      System.out.println(Objects.toString("Foo", ":-("));
+    }
+
+    @NeverInline
+    static void testNullArgument() {
+      System.out.println(Objects.toString(null, "Bar"));
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/AssumeInstanceFieldValueTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/AssumeInstanceFieldValueTest.java
index f975e36..18618ca 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/AssumeInstanceFieldValueTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/AssumeInstanceFieldValueTest.java
@@ -70,7 +70,7 @@
 
     MethodSubject mainMethodSubject = testClassSubject.mainMethod();
     assertThat(mainMethodSubject, isPresent());
-    if (canUseRequireNonNull(parameters)) {
+    if (canUseJavaUtilObjectsIsNull(parameters)) {
       assertThat(mainMethodSubject, invokesMethodWithName("requireNonNull"));
     } else {
       assertThat(mainMethodSubject, invokesMethodWithName("getClass"));
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCatchHandlerTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCatchHandlerTest.java
index f45220d..11bc862 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCatchHandlerTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCatchHandlerTest.java
@@ -7,15 +7,15 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
 public class MissingClassReferencedFromCatchHandlerTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCheckCastTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCheckCastTest.java
index 37df585..773261d 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCheckCastTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCheckCastTest.java
@@ -7,15 +7,15 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
 public class MissingClassReferencedFromCheckCastTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationTest.java
index d114dc02..cfb378f 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionClassContextImpl;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
 import org.junit.Test;
@@ -17,8 +17,8 @@
 //  we retain missing annotations even if there is no -keepattributes *Annotations*.
 public class MissingClassReferencedFromClassAnnotationTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionClassContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionClassContextImpl.builder()
           .setClassContext(Reference.classFromClass(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationWithDataTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationWithDataTest.java
index 10663fa..3499bdb 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationWithDataTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationWithDataTest.java
@@ -9,8 +9,8 @@
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionClassContextImpl;
 import com.android.tools.r8.references.Reference;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -18,8 +18,8 @@
 
 public class MissingClassReferencedFromClassAnnotationWithDataTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionClassContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionClassContextImpl.builder()
           .setClassContext(Reference.classFromClass(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromConstClassTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromConstClassTest.java
index 94550b8..3cdf187 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromConstClassTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromConstClassTest.java
@@ -7,15 +7,15 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
 public class MissingClassReferencedFromConstClassTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromEnclosingMethodAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromEnclosingMethodAttributeTest.java
index 40408ee..da337fd 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromEnclosingMethodAttributeTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromEnclosingMethodAttributeTest.java
@@ -11,8 +11,8 @@
 import com.android.tools.r8.R8TestBuilder;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionClassContextImpl;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.BooleanUtils;
@@ -22,8 +22,8 @@
 
 public class MissingClassReferencedFromEnclosingMethodAttributeTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionClassContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionClassContextImpl.builder()
           .setClassContext(Reference.classFromClass(getMainClass()))
           .setOrigin(getOrigin(getMainClass()))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromFieldAnnotationTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromFieldAnnotationTest.java
index 7638885..71e9638 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromFieldAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromFieldAnnotationTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionFieldContextImpl;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.FieldReferenceUtils;
@@ -18,8 +18,8 @@
 //  we retain missing annotations even if there is no -keepattributes *Annotations*.
 public class MissingClassReferencedFromFieldAnnotationTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionFieldContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionFieldContextImpl.builder()
           .setFieldContext(FieldReferenceUtils.fieldFromField(Main.class, "FIELD"))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromImplementsClauseTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromImplementsClauseTest.java
index 51da805..e221fbe 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromImplementsClauseTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromImplementsClauseTest.java
@@ -8,16 +8,16 @@
 import com.android.tools.r8.TestCompilerBuilder;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionClassContextImpl;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
 import org.junit.Test;
 
 public class MissingClassReferencedFromImplementsClauseTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionClassContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionClassContextImpl.builder()
           .setClassContext(Reference.classFromClass(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInnerClassAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInnerClassAttributeTest.java
index f421eb1..ce77469 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInnerClassAttributeTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInnerClassAttributeTest.java
@@ -11,8 +11,8 @@
 import com.android.tools.r8.R8TestBuilder;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionClassContextImpl;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.BooleanUtils;
@@ -22,8 +22,8 @@
 
 public class MissingClassReferencedFromInnerClassAttributeTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionClassContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionClassContextImpl.builder()
           .setClassContext(Reference.classFromClass(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToExistingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToExistingFieldTest.java
index 1ce5f9f..f2803fc 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToExistingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToExistingFieldTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionFieldContextImpl;
 import com.android.tools.r8.utils.FieldReferenceUtils;
 import org.junit.Test;
 
@@ -19,8 +19,8 @@
 public class MissingClassReferencedFromInstanceGetToExistingFieldTest
     extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionFieldContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionFieldContextImpl.builder()
           .setFieldContext(FieldReferenceUtils.fieldFromField(Main.class, "field"))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToMissingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToMissingFieldTest.java
index f367fed..49105ae 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToMissingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToMissingFieldTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
@@ -19,8 +19,8 @@
 public class MissingClassReferencedFromInstanceGetToMissingFieldTest
     extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceOfTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceOfTest.java
index 7ec1e09..7059a7d 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceOfTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceOfTest.java
@@ -7,15 +7,15 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
 public class MissingClassReferencedFromInstanceOfTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToExistingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToExistingFieldTest.java
index 1f0e5a7..21e65c8 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToExistingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToExistingFieldTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionFieldContextImpl;
 import com.android.tools.r8.utils.FieldReferenceUtils;
 import org.junit.Test;
 
@@ -19,8 +19,8 @@
 public class MissingClassReferencedFromInstancePutToExistingFieldTest
     extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionFieldContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionFieldContextImpl.builder()
           .setFieldContext(FieldReferenceUtils.fieldFromField(Main.class, "field"))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToMissingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToMissingFieldTest.java
index b4dd5a1..687aa72 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToMissingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToMissingFieldTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
@@ -19,8 +19,8 @@
 public class MissingClassReferencedFromInstancePutToMissingFieldTest
     extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodParameterTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodParameterTest.java
index 31e1942..1d7d4ca 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodParameterTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodParameterTest.java
@@ -9,8 +9,8 @@
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import com.google.common.collect.ImmutableList;
 import java.io.IOException;
@@ -24,8 +24,8 @@
 public class MissingClassReferencedFromInvokeVirtualToAbsentMethodParameterTest
     extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodReturnTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodReturnTest.java
index 4c62ad2..b997418 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodReturnTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodReturnTest.java
@@ -9,8 +9,8 @@
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import com.google.common.collect.ImmutableList;
 import java.io.IOException;
@@ -24,8 +24,8 @@
 public class MissingClassReferencedFromInvokeVirtualToAbsentMethodReturnTest
     extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodParameterTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodParameterTest.java
index 28c1a79..9930828 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodParameterTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodParameterTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
@@ -19,8 +19,8 @@
 public class MissingClassReferencedFromInvokeVirtualToPresentMethodParameterTest
     extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(
               MethodReferenceUtils.methodFromMethod(Main.class, "get", MissingClass.class))
           .setOrigin(getOrigin(Main.class))
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodReturnTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodReturnTest.java
index 396117f..49f5b94 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodReturnTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodReturnTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
@@ -19,8 +19,8 @@
 public class MissingClassReferencedFromInvokeVirtualToPresentMethodReturnTest
     extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.methodFromMethod(Main.class, "get"))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptFieldTest.java
index c212d86..9c82922 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptFieldTest.java
@@ -8,16 +8,16 @@
 import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionFieldContextImpl;
 import com.android.tools.r8.utils.FieldReferenceUtils;
 import org.junit.Test;
 
 /** If a field definition refers to a missing class, then the field definition is to be blamed. */
 public class MissingClassReferencedFromKeptFieldTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionFieldContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionFieldContextImpl.builder()
           .setFieldContext(FieldReferenceUtils.fieldFromField(Main.class, "FIELD"))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodParameterTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodParameterTest.java
index fc2d8d3..ba2d1eb 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodParameterTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodParameterTest.java
@@ -8,16 +8,16 @@
 import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
 /** If a method definition refers to a missing class, then the method definition is to be blamed. */
 public class MissingClassReferencedFromKeptMethodParameterTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(
               MethodReferenceUtils.methodFromMethod(Main.class, "get", MissingClass.class))
           .setOrigin(getOrigin(Main.class))
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodReturnTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodReturnTest.java
index 6dc3edb..dc940b2 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodReturnTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodReturnTest.java
@@ -8,16 +8,16 @@
 import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
 /** If a method definition refers to a missing class, then the method definition is to be blamed. */
 public class MissingClassReferencedFromKeptMethodReturnTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.methodFromMethod(Main.class, "get"))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryInstanceFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryInstanceFieldTest.java
index 860bce2..e3e4d0f 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryInstanceFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryInstanceFieldTest.java
@@ -11,15 +11,15 @@
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionFieldContextImpl;
 import com.android.tools.r8.utils.FieldReferenceUtils;
 import org.junit.Test;
 
 public class MissingClassReferencedFromLibraryInstanceFieldTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionFieldContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionFieldContextImpl.builder()
           .setFieldContext(FieldReferenceUtils.fieldFromField(Library.class, "field"))
           .setOrigin(getOrigin(Library.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryStaticFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryStaticFieldTest.java
index c5c7950..87ccb41 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryStaticFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryStaticFieldTest.java
@@ -11,15 +11,15 @@
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionFieldContextImpl;
 import com.android.tools.r8.utils.FieldReferenceUtils;
 import org.junit.Test;
 
 public class MissingClassReferencedFromLibraryStaticFieldTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionFieldContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionFieldContextImpl.builder()
           .setFieldContext(FieldReferenceUtils.fieldFromField(Library.class, "field"))
           .setOrigin(getOrigin(Library.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryVirtualMethodParameterTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryVirtualMethodParameterTest.java
index 4a56add..654ae54 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryVirtualMethodParameterTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryVirtualMethodParameterTest.java
@@ -11,16 +11,16 @@
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
 public class MissingClassReferencedFromLibraryVirtualMethodParameterTest
     extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(
               MethodReferenceUtils.methodFromMethod(Library.class, "method", MissingClass.class))
           .setOrigin(getOrigin(Library.class))
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryVirtualMethodReturnTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryVirtualMethodReturnTest.java
index 5c627ef..1e659de 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryVirtualMethodReturnTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryVirtualMethodReturnTest.java
@@ -11,16 +11,16 @@
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
 public class MissingClassReferencedFromLibraryVirtualMethodReturnTest
     extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.methodFromMethod(Library.class, "method"))
           .setOrigin(getOrigin(Library.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromMethodAnnotationTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromMethodAnnotationTest.java
index 5130304..b4c5a43 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromMethodAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromMethodAnnotationTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.MethodReferenceUtils;
@@ -18,8 +18,8 @@
 //  we retain missing annotations even if there is no -keepattributes *Annotations*.
 public class MissingClassReferencedFromMethodAnnotationTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestHostAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestHostAttributeTest.java
index 194e12d..da8c6cb 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestHostAttributeTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestHostAttributeTest.java
@@ -9,8 +9,8 @@
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionClassContextImpl;
 import com.android.tools.r8.missingclasses.MissingClassReferencedFromNestHostAttributeTest.MissingClass.Main;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
@@ -21,8 +21,8 @@
 
 public class MissingClassReferencedFromNestHostAttributeTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionClassContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionClassContextImpl.builder()
           .setClassContext(Reference.classFromClass(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestMemberAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestMemberAttributeTest.java
index 540620e..ae99dbc 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestMemberAttributeTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestMemberAttributeTest.java
@@ -9,8 +9,8 @@
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionClassContextImpl;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
 import com.google.common.collect.ImmutableList;
@@ -20,8 +20,8 @@
 
 public class MissingClassReferencedFromNestMemberAttributeTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionClassContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionClassContextImpl.builder()
           .setClassContext(Reference.classFromClass(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewArrayTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewArrayTest.java
index 003b28e..2e047e5 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewArrayTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewArrayTest.java
@@ -7,15 +7,15 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
 public class MissingClassReferencedFromNewArrayTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewInstanceTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewInstanceTest.java
index ee919b2..274e3d0 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewInstanceTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewInstanceTest.java
@@ -7,15 +7,15 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
 public class MissingClassReferencedFromNewInstanceTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromOuterClassAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromOuterClassAttributeTest.java
index 21d5683..38b464d 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromOuterClassAttributeTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromOuterClassAttributeTest.java
@@ -11,8 +11,8 @@
 import com.android.tools.r8.R8TestBuilder;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionClassContextImpl;
 import com.android.tools.r8.missingclasses.MissingClassReferencedFromOuterClassAttributeTest.MissingClass.Main;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
@@ -23,8 +23,8 @@
 
 public class MissingClassReferencedFromOuterClassAttributeTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionClassContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionClassContextImpl.builder()
           .setClassContext(Reference.classFromClass(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromParameterAnnotationTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromParameterAnnotationTest.java
index a5b5432..021991f 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromParameterAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromParameterAnnotationTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.MethodReferenceUtils;
@@ -18,8 +18,8 @@
 //  we retain missing annotations even if there is no -keepattributes *Annotations*.
 public class MissingClassReferencedFromParameterAnnotationTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToExistingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToExistingFieldTest.java
index 332da9c..d870671 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToExistingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToExistingFieldTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionFieldContextImpl;
 import com.android.tools.r8.utils.FieldReferenceUtils;
 import org.junit.Test;
 
@@ -18,8 +18,8 @@
  */
 public class MissingClassReferencedFromStaticGetToExistingFieldTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionFieldContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionFieldContextImpl.builder()
           .setFieldContext(FieldReferenceUtils.fieldFromField(Main.class, "FIELD"))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToMissingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToMissingFieldTest.java
index 9028167..52944a8 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToMissingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToMissingFieldTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
@@ -18,8 +18,8 @@
  */
 public class MissingClassReferencedFromStaticGetToMissingFieldTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToExistingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToExistingFieldTest.java
index cbbd217..3b0f099 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToExistingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToExistingFieldTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionFieldContextImpl;
 import com.android.tools.r8.utils.FieldReferenceUtils;
 import org.junit.Test;
 
@@ -18,8 +18,8 @@
  */
 public class MissingClassReferencedFromStaticPutToExistingFieldTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionFieldContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionFieldContextImpl.builder()
           .setFieldContext(FieldReferenceUtils.fieldFromField(Main.class, "FIELD"))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToMissingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToMissingFieldTest.java
index e1ba4c6..b8488cc 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToMissingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToMissingFieldTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
@@ -18,8 +18,8 @@
  */
 public class MissingClassReferencedFromStaticPutToMissingFieldTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromSuperClassTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromSuperClassTest.java
index 79cff47..651b6dd 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromSuperClassTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromSuperClassTest.java
@@ -8,15 +8,15 @@
 import com.android.tools.r8.TestCompilerBuilder;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionClassContextImpl;
 import com.android.tools.r8.references.Reference;
 import org.junit.Test;
 
 public class MissingClassReferencedFromSuperClassTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionClassContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionClassContextImpl.builder()
           .setClassContext(Reference.classFromClass(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseTest.java
index 275e6f2..f5fd22e 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseTest.java
@@ -8,15 +8,15 @@
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestShrinkerBuilder;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import org.junit.Test;
 
 public class MissingClassReferencedFromThrowsClauseTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
           .setOrigin(getOrigin(Main.class))
           .build();
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseWithNoShrinkingTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseWithNoShrinkingTest.java
index b9d0ef6..7542952 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseWithNoShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseWithNoShrinkingTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -21,8 +21,8 @@
   private static final String NEW_A_DESCRIPTOR = "Lfoo/a;";
   private static final String NEW_B_DESCRIPTOR = "Lfoo/b;";
 
-  private static final MissingDefinitionContext referencedFrom =
-      MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext referencedFrom =
+      DefinitionMethodContextImpl.builder()
           .setMethodContext(
               Reference.method(
                   Reference.classFromDescriptor("Lfoo/a;"), "foo", ImmutableList.of(), null))
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUnusedLambdaParameterTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUnusedLambdaParameterTest.java
index 31ca7d1..59dea00 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUnusedLambdaParameterTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUnusedLambdaParameterTest.java
@@ -11,8 +11,8 @@
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import com.google.common.collect.ImmutableList;
@@ -20,9 +20,9 @@
 
 public class MissingClassReferencedFromUnusedLambdaParameterTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext[] referencedFrom =
-      new MissingDefinitionContext[] {
-        MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext[] referencedFrom =
+      new DefinitionContext[] {
+        DefinitionMethodContextImpl.builder()
             .setMethodContext(
                 Reference.method(
                     Reference.classFromClass(Main.class),
@@ -31,7 +31,7 @@
                     null))
             .setOrigin(getOrigin(Main.class))
             .build(),
-        MissingDefinitionMethodContextImpl.builder()
+        DefinitionMethodContextImpl.builder()
             .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
             .setOrigin(getOrigin(Main.class))
             .build(),
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUnusedLambdaReturnTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUnusedLambdaReturnTest.java
index 8859780..c1da466 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUnusedLambdaReturnTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUnusedLambdaReturnTest.java
@@ -11,8 +11,8 @@
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import java.util.Collections;
@@ -20,9 +20,9 @@
 
 public class MissingClassReferencedFromUnusedLambdaReturnTest extends MissingClassesTestBase {
 
-  private static final MissingDefinitionContext[] referencedFrom =
-      new MissingDefinitionContext[] {
-        MissingDefinitionMethodContextImpl.builder()
+  private static final DefinitionContext[] referencedFrom =
+      new DefinitionContext[] {
+        DefinitionMethodContextImpl.builder()
             .setMethodContext(
                 Reference.method(
                     Reference.classFromClass(Main.class),
@@ -31,7 +31,7 @@
                     Reference.classFromClass(MissingClass.class)))
             .setOrigin(getOrigin(Main.class))
             .build(),
-        MissingDefinitionMethodContextImpl.builder()
+        DefinitionMethodContextImpl.builder()
             .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
             .setOrigin(getOrigin(Main.class))
             .build(),
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUsedLambdaParameterTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUsedLambdaParameterTest.java
index a9ece97..eddc508 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUsedLambdaParameterTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUsedLambdaParameterTest.java
@@ -9,8 +9,8 @@
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import com.google.common.collect.ImmutableList;
@@ -18,14 +18,14 @@
 
 public class MissingClassReferencedFromUsedLambdaParameterTest extends MissingClassesTestBase {
 
-  private final MissingDefinitionContext[] referencedFrom =
-      new MissingDefinitionContext[] {
-        MissingDefinitionMethodContextImpl.builder()
+  private final DefinitionContext[] referencedFrom =
+      new DefinitionContext[] {
+        DefinitionMethodContextImpl.builder()
             .setMethodContext(
                 MethodReferenceUtils.methodFromMethod(I.class, "m", MissingClass.class))
             .setOrigin(getOrigin(I.class))
             .build(),
-        MissingDefinitionMethodContextImpl.builder()
+        DefinitionMethodContextImpl.builder()
             .setMethodContext(
                 Reference.method(
                     Reference.classFromClass(Main.class),
@@ -34,7 +34,7 @@
                     null))
             .setOrigin(getOrigin(Main.class))
             .build(),
-        MissingDefinitionMethodContextImpl.builder()
+        DefinitionMethodContextImpl.builder()
             .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
             .setOrigin(getOrigin(Main.class))
             .build()
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUsedLambdaReturnTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUsedLambdaReturnTest.java
index ba46bfc..1d46283 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUsedLambdaReturnTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUsedLambdaReturnTest.java
@@ -9,8 +9,8 @@
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionMethodContextImpl;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import java.util.Collections;
@@ -18,13 +18,13 @@
 
 public class MissingClassReferencedFromUsedLambdaReturnTest extends MissingClassesTestBase {
 
-  private final MissingDefinitionContext[] referencedFrom =
-      new MissingDefinitionContext[] {
-        MissingDefinitionMethodContextImpl.builder()
+  private final DefinitionContext[] referencedFrom =
+      new DefinitionContext[] {
+        DefinitionMethodContextImpl.builder()
             .setMethodContext(MethodReferenceUtils.methodFromMethod(I.class, "m"))
             .setOrigin(getOrigin(I.class))
             .build(),
-        MissingDefinitionMethodContextImpl.builder()
+        DefinitionMethodContextImpl.builder()
             .setMethodContext(
                 Reference.method(
                     Reference.classFromClass(Main.class),
@@ -33,7 +33,7 @@
                     Reference.classFromClass(MissingClass.class)))
             .setOrigin(getOrigin(Main.class))
             .build(),
-        MissingDefinitionMethodContextImpl.builder()
+        DefinitionMethodContextImpl.builder()
             .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
             .setOrigin(getOrigin(Main.class))
             .build()
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java
index 3022ea4..4dfeca1 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java
@@ -13,8 +13,8 @@
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.diagnostic.MissingDefinitionContext;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionContextUtils;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionContextUtils;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
 import java.lang.annotation.Retention;
@@ -101,19 +101,18 @@
   }
 
   void inspectDiagnosticsWithIgnoreWarnings(
-      TestDiagnosticMessages diagnostics, MissingDefinitionContext... referencedFrom) {
+      TestDiagnosticMessages diagnostics, DefinitionContext... referencedFrom) {
     assertTrue(referencedFrom.length > 0);
     inspectDiagnosticsWithIgnoreWarnings(
         diagnostics,
         referencedFrom,
         getExpectedDiagnosticMessage(
-            MissingDefinitionContextUtils.toSourceString(referencedFrom[0]),
-            referencedFrom.length));
+            DefinitionContextUtils.toSourceString(referencedFrom[0]), referencedFrom.length));
   }
 
   void inspectDiagnosticsWithIgnoreWarnings(
       TestDiagnosticMessages diagnostics,
-      MissingDefinitionContext[] referencedFrom,
+      DefinitionContext[] referencedFrom,
       String expectedDiagnosticMessage) {
     diagnostics
         .assertOnlyWarnings()
@@ -132,19 +131,18 @@
   }
 
   void inspectDiagnosticsWithNoRules(
-      TestDiagnosticMessages diagnostics, MissingDefinitionContext... referencedFrom) {
+      TestDiagnosticMessages diagnostics, DefinitionContext... referencedFrom) {
     assertTrue(referencedFrom.length > 0);
     inspectDiagnosticsWithNoRules(
         diagnostics,
         referencedFrom,
         getExpectedDiagnosticMessage(
-            MissingDefinitionContextUtils.toSourceString(referencedFrom[0]),
-            referencedFrom.length));
+            DefinitionContextUtils.toSourceString(referencedFrom[0]), referencedFrom.length));
   }
 
   void inspectDiagnosticsWithNoRules(
       TestDiagnosticMessages diagnostics,
-      MissingDefinitionContext[] referencedFrom,
+      DefinitionContext[] referencedFrom,
       String expectedDiagnosticMessage) {
     diagnostics
         .assertOnlyErrors()
diff --git a/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java b/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java
index f49dc97..c93200c 100644
--- a/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ProguardConfigurationParserTest.java
@@ -442,8 +442,8 @@
     assertEquals(1, assumeNoSideEffects.size());
     int matches = 0;
     for (ProguardMemberRule rule : assumeNoSideEffects.get(0).getMemberRules()) {
-      assertTrue(rule.hasReturnValue());
       if (rule.getName().matches("returnsTrue") || rule.getName().matches("returnsFalse")) {
+        assertTrue(rule.hasReturnValue());
         assertTrue(rule.getReturnValue().isBoolean());
         assertFalse(rule.getReturnValue().isValueRange());
         assertFalse(rule.getReturnValue().isField());
@@ -451,6 +451,7 @@
         assertEquals(rule.getName().matches("returnsTrue"), rule.getReturnValue().getBoolean());
         matches |= 1 << 0;
       } else if (rule.getName().matches("returns1")) {
+        assertTrue(rule.hasReturnValue());
         assertFalse(rule.getReturnValue().isBoolean());
         assertTrue(rule.getReturnValue().isValueRange());
         assertFalse(rule.getReturnValue().isField());
@@ -461,6 +462,7 @@
         assertEquals(1, rule.getReturnValue().getSingleValue());
         matches |= 1 << 1;
       } else if (rule.getName().matches("returns2To4")) {
+        assertTrue(rule.hasReturnValue());
         assertFalse(rule.getReturnValue().isBoolean());
         assertTrue(rule.getReturnValue().isValueRange());
         assertFalse(rule.getReturnValue().isField());
@@ -470,6 +472,7 @@
         assertEquals(4, rule.getReturnValue().getValueRange().getMax());
         matches |= 1 << 2;
       } else if (rule.getName().matches("returns234To567")) {
+        assertTrue(rule.hasReturnValue());
         assertFalse(rule.getReturnValue().isBoolean());
         assertTrue(rule.getReturnValue().isValueRange());
         assertFalse(rule.getReturnValue().isField());
@@ -479,6 +482,7 @@
         assertEquals(567, rule.getReturnValue().getValueRange().getMax());
         matches |= 1 << 3;
       } else if (rule.getName().matches("returnsField")) {
+        assertTrue(rule.hasReturnValue());
         assertFalse(rule.getReturnValue().isBoolean());
         assertFalse(rule.getReturnValue().isValueRange());
         assertTrue(rule.getReturnValue().isField());
@@ -488,17 +492,31 @@
         assertEquals("X", rule.getReturnValue().getField().name.toString());
         matches |= 1 << 4;
       } else if (rule.getName().matches("returnsNull")) {
+        assertTrue(rule.hasReturnValue());
         assertFalse(rule.getReturnValue().isBoolean());
         assertFalse(rule.getReturnValue().isValueRange());
         assertFalse(rule.getReturnValue().isField());
         assertTrue(rule.getReturnValue().isNull());
         assertTrue(rule.getReturnValue().isSingleValue());
         matches |= 1 << 5;
+      } else if (rule.getName().matches("returnsNonNull")) {
+        assertFalse(rule.hasReturnValue());
+        matches |= 1 << 6;
+      } else if (rule.getName().matches("returnsNonNullField")) {
+        assertTrue(rule.hasReturnValue());
+        assertFalse(rule.getReturnValue().isBoolean());
+        assertFalse(rule.getReturnValue().isValueRange());
+        assertTrue(rule.getReturnValue().isField());
+        assertFalse(rule.getReturnValue().isNull());
+        assertEquals("com.google.C", rule.getReturnValue().getField().holder.toString());
+        assertEquals("Object", rule.getReturnValue().getField().type.toString());
+        assertEquals("X", rule.getReturnValue().getField().name.toString());
+        matches |= 1 << 7;
       } else {
         fail("Unexpected");
       }
     }
-    assertEquals((1 << 6) - 1, matches);
+    assertEquals((1 << 8) - 1, matches);
   }
 
   @Test
@@ -511,8 +529,8 @@
     assertEquals(1, assumeValues.size());
     int matches = 0;
     for (ProguardMemberRule rule : assumeValues.get(0).getMemberRules()) {
-      assertTrue(rule.hasReturnValue());
       if (rule.getName().matches("isTrue") || rule.getName().matches("isFalse")) {
+        assertTrue(rule.hasReturnValue());
         assertTrue(rule.getReturnValue().isBoolean());
         assertFalse(rule.getReturnValue().isValueRange());
         assertFalse(rule.getReturnValue().isField());
@@ -520,6 +538,7 @@
         assertEquals(rule.getName().matches("isTrue"), rule.getReturnValue().getBoolean());
         matches |= 1 << 0;
       } else if (rule.getName().matches("is1")) {
+        assertTrue(rule.hasReturnValue());
         assertFalse(rule.getReturnValue().isBoolean());
         assertTrue(rule.getReturnValue().isValueRange());
         assertFalse(rule.getReturnValue().isField());
@@ -530,6 +549,7 @@
         assertEquals(1, rule.getReturnValue().getSingleValue());
         matches |= 1 << 1;
       } else if (rule.getName().matches("is2To4")) {
+        assertTrue(rule.hasReturnValue());
         assertFalse(rule.getReturnValue().isBoolean());
         assertTrue(rule.getReturnValue().isValueRange());
         assertFalse(rule.getReturnValue().isField());
@@ -539,6 +559,7 @@
         assertEquals(4, rule.getReturnValue().getValueRange().getMax());
         matches |= 1 << 2;
       } else if (rule.getName().matches("is234To567")) {
+        assertTrue(rule.hasReturnValue());
         assertFalse(rule.getReturnValue().isBoolean());
         assertTrue(rule.getReturnValue().isValueRange());
         assertFalse(rule.getReturnValue().isField());
@@ -548,6 +569,7 @@
         assertEquals(567, rule.getReturnValue().getValueRange().getMax());
         matches |= 1 << 3;
       } else if (rule.getName().matches("isField")) {
+        assertTrue(rule.hasReturnValue());
         assertFalse(rule.getReturnValue().isBoolean());
         assertFalse(rule.getReturnValue().isValueRange());
         assertTrue(rule.getReturnValue().isField());
@@ -557,17 +579,31 @@
         assertEquals("X", rule.getReturnValue().getField().name.toString());
         matches |= 1 << 4;
       } else if (rule.getName().matches("isNull")) {
+        assertTrue(rule.hasReturnValue());
         assertFalse(rule.getReturnValue().isBoolean());
         assertFalse(rule.getReturnValue().isValueRange());
         assertFalse(rule.getReturnValue().isField());
         assertTrue(rule.getReturnValue().isNull());
         assertTrue(rule.getReturnValue().isSingleValue());
         matches |= 1 << 5;
+      } else if (rule.getName().matches("returnsNonNull")) {
+        assertFalse(rule.hasReturnValue());
+        matches |= 1 << 6;
+      } else if (rule.getName().matches("returnsNonNullField")) {
+        assertTrue(rule.hasReturnValue());
+        assertFalse(rule.getReturnValue().isBoolean());
+        assertFalse(rule.getReturnValue().isValueRange());
+        assertTrue(rule.getReturnValue().isField());
+        assertFalse(rule.getReturnValue().isNull());
+        assertEquals("com.google.C", rule.getReturnValue().getField().holder.toString());
+        assertEquals("Object", rule.getReturnValue().getField().type.toString());
+        assertEquals("X", rule.getReturnValue().getField().name.toString());
+        matches |= 1 << 7;
       } else {
         fail("Unexpected");
       }
     }
-    assertEquals((1 << 6) - 1, matches);
+    assertEquals((1 << 8) - 1, matches);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/CodeMatchers.java b/src/test/java/com/android/tools/r8/utils/codeinspector/CodeMatchers.java
index 2b57e91..10a68c1 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/CodeMatchers.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/CodeMatchers.java
@@ -149,6 +149,11 @@
     };
   }
 
+  public static Matcher<MethodSubject> invokesMethodWithHolderAndName(
+      String holderType, String name) {
+    return invokesMethod(null, holderType, name, null);
+  }
+
   public static Matcher<MethodSubject> invokesMethodWithName(String name) {
     return invokesMethod(null, null, name, null);
   }
diff --git a/src/test/proguard/valid/assume-no-side-effects-with-return-value.flags b/src/test/proguard/valid/assume-no-side-effects-with-return-value.flags
index b233ea3..d63e2e1 100644
--- a/src/test/proguard/valid/assume-no-side-effects-with-return-value.flags
+++ b/src/test/proguard/valid/assume-no-side-effects-with-return-value.flags
@@ -10,4 +10,6 @@
     public static int returns234To567() return 234..567;
     public static int returnsField() return com.google.C.X;
     public static Object returnsNull() return null;
+    public static Object returnsNonNull() return _NONNULL_;
+    public static Object returnsNonNullField() return _NONNULL_ com.google.C.X;
 }
diff --git a/src/test/proguard/valid/assume-values-with-return-value.flags b/src/test/proguard/valid/assume-values-with-return-value.flags
index 90cefbe..fdb6a25 100644
--- a/src/test/proguard/valid/assume-values-with-return-value.flags
+++ b/src/test/proguard/valid/assume-values-with-return-value.flags
@@ -10,4 +10,6 @@
     public static final int is234To567() return 234..567;
     public static final int isField() return com.google.C.X;
     public static final Object isNull() return null;
+    public static Object returnsNonNull() return _NONNULL_;
+    public static Object returnsNonNullField() return _NONNULL_ com.google.C.X;
 }
\ No newline at end of file