diff --git a/src/main/java/com/android/tools/r8/naming/MemberNaming.java b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
index 2c85270..c766c37 100644
--- a/src/main/java/com/android/tools/r8/naming/MemberNaming.java
+++ b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
@@ -299,5 +299,16 @@
       }
       writer.append(')');
     }
+
+    public String toDescriptor() {
+      StringBuilder sb = new StringBuilder();
+      sb.append('(');
+      for (String parameterType : parameters) {
+        sb.append(javaTypeToDescriptor(parameterType));
+      }
+      sb.append(')');
+      sb.append(javaTypeToDescriptor(type));
+      return sb.toString();
+    }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
index bb83093..c175e04 100644
--- a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
+++ b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
@@ -49,6 +49,12 @@
   // invoke the tested method.
   private static final String JASMIN_MAIN_CLASS = "TestMain";
 
+  @Parameter(0) public boolean allowAccessModification;
+  @Parameter(1) public KotlinTargetVersion targetVersion;
+
+  private final List<Path> classpath = new ArrayList<>();
+  private final List<Path> extraClasspath = new ArrayList<>();
+
   @Parameters(name = "allowAccessModification: {0} target: {1}")
   public static Collection<Object[]> data() {
     ImmutableList.Builder<Object[]> builder = new ImmutableList.Builder<>();
@@ -59,11 +65,6 @@
     return builder.build();
   }
 
-  @Parameter(0) public boolean allowAccessModification;
-  @Parameter(1) public KotlinTargetVersion targetVersion;
-
-  private final List<Path> extraClasspath = new ArrayList<>();
-
   protected void addExtraClasspath(Path path) {
     extraClasspath.add(path);
   }
@@ -111,47 +112,67 @@
     }));
   }
 
-  protected static ClassSubject checkClassExists(DexInspector inspector, String className) {
+  protected ClassSubject checkClassIsKept(DexInspector inspector, String className) {
+    checkClassExistsInInput(className);
     ClassSubject classSubject = inspector.clazz(className);
     assertNotNull(classSubject);
     assertTrue("No class " + className, classSubject.isPresent());
     return classSubject;
   }
 
-  protected static FieldSubject checkFieldIsPresent(ClassSubject classSubject, String fieldType,
+  protected FieldSubject checkFieldIsKept(ClassSubject classSubject, String fieldType,
       String fieldName) {
+    // Field must exist in the input.
+    checkFieldPresenceInInput(classSubject.getOriginalName(), fieldType, fieldName, true);
     FieldSubject fieldSubject = classSubject.field(fieldType, fieldName);
     assertTrue("No field " + fieldName + " in " + classSubject.getOriginalName(),
         fieldSubject.isPresent());
     return fieldSubject;
   }
 
-  protected static void checkFieldIsAbsent(ClassSubject classSubject, String fieldType,
+  protected void checkFieldIsAbsent(ClassSubject classSubject, String fieldType,
       String fieldName) {
+    // Field must NOT exist in the input.
+    checkFieldPresenceInInput(classSubject.getOriginalName(), fieldType, fieldName, false);
     FieldSubject fieldSubject = classSubject.field(fieldType, fieldName);
     assertNotNull(fieldSubject);
     assertFalse(fieldSubject.isPresent());
   }
 
-  protected static MethodSubject checkMethodIsPresent(ClassSubject classSubject,
+  protected void checkMethodIsAbsent(ClassSubject classSubject,
       MethodSignature methodSignature) {
-    return checkMethod(classSubject, methodSignature, true);
+    checkMethodPresenceInInput(classSubject.getOriginalName(), methodSignature, false);
+    checkMethodPresenceInOutput(classSubject, methodSignature, false);
   }
 
-  protected static void checkMethodIsAbsent(ClassSubject classSubject,
+  protected MethodSubject checkMethodIsKept(ClassSubject classSubject,
       MethodSignature methodSignature) {
-    checkMethod(classSubject, methodSignature, false);
+    checkMethodPresenceInInput(classSubject.getOriginalName(), methodSignature, true);
+    return checkMethodisKeptOrRemoved(classSubject, methodSignature, true);
   }
 
-  protected static MethodSubject checkMethod(ClassSubject classSubject,
+  protected void checkMethodIsRemoved(ClassSubject classSubject,
+      MethodSignature methodSignature) {
+    checkMethodPresenceInInput(classSubject.getOriginalName(), methodSignature, true);
+    checkMethodisKeptOrRemoved(classSubject, methodSignature, false);
+  }
+
+  protected MethodSubject checkMethodisKeptOrRemoved(ClassSubject classSubject,
+      MethodSignature methodSignature, boolean isPresent) {
+    checkMethodPresenceInInput(classSubject.getOriginalName(), methodSignature, true);
+    return checkMethodPresenceInOutput(classSubject, methodSignature, isPresent);
+  }
+
+  private MethodSubject checkMethodPresenceInOutput(ClassSubject classSubject,
       MethodSignature methodSignature, boolean isPresent) {
     MethodSubject methodSubject = classSubject.method(methodSignature);
     assertNotNull(methodSubject);
 
+    String methodSig = methodSignature.name + methodSignature.toDescriptor();
     if (isPresent) {
-      assertTrue("No method " + methodSignature.name, methodSubject.isPresent());
+      assertTrue("No method " + methodSig + " in output", methodSubject.isPresent());
     } else {
-      assertFalse("Method " + methodSignature.name + " exists", methodSubject.isPresent());
+      assertFalse("Method " + methodSig + " exists in output", methodSubject.isPresent());
     }
     return methodSubject;
   }
@@ -210,7 +231,7 @@
     }
 
     // Build classpath for compilation (and java execution)
-    List<Path> classpath = new ArrayList<>(extraClasspath.size() + 1);
+    assert classpath.isEmpty();
     classpath.add(getKotlinJarFile(folder));
     classpath.add(getJavaJarFile(folder));
     classpath.addAll(extraClasspath);
@@ -240,6 +261,36 @@
     inspector.inspectApp(app);
   }
 
+  protected void checkClassExistsInInput(String className) {
+    if (!AsmUtils.doesClassExist(classpath, className)) {
+      throw new AssertionError("Class " + className + " does not exist in input");
+    }
+  }
+
+  private void checkMethodPresenceInInput(String className, MethodSignature methodSignature,
+      boolean isPresent) {
+    boolean foundMethod = AsmUtils.doesMethodExist(classpath, className,
+        methodSignature.name, methodSignature.toDescriptor());
+    if (isPresent != foundMethod) {
+      throw new AssertionError(
+          "Method " + methodSignature.name + methodSignature.toDescriptor()
+              + " " + (foundMethod ? "exists" : "does not exist")
+              + " in input class " + className + " but is expected to be "
+              + (isPresent ? "present" : "absent"));
+    }
+  }
+
+  private void checkFieldPresenceInInput(String className, String fieldType, String fieldName,
+      boolean isPresent) {
+    boolean foundField = AsmUtils.doesFieldExist(classpath, className, fieldName, fieldType);
+    if (isPresent != foundField) {
+      throw new AssertionError(
+          "Field " + fieldName + " " + (foundField ? "exists" : "does not exist")
+              + " in input class " + className + " but is expected to be "
+              + (isPresent ? "present" : "absent"));
+    }
+  }
+
   private Path getKotlinJarFile(String folder) {
     return Paths.get(ToolHelper.TESTS_BUILD_DIR, "kotlinR8TestResources",
         targetVersion.getFolderName(), folder + FileUtils.JAR_EXTENSION);
diff --git a/src/test/java/com/android/tools/r8/kotlin/AsmUtils.java b/src/test/java/com/android/tools/r8/kotlin/AsmUtils.java
new file mode 100644
index 0000000..7b7abcb
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/AsmUtils.java
@@ -0,0 +1,144 @@
+// Copyright (c) 2018, 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.kotlin;
+
+import com.android.tools.r8.utils.DescriptorUtils;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.jar.JarEntry;
+import java.util.jar.JarInputStream;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+/**
+ * Utilities to lookup symbols in a classpath using ASM.
+ */
+public final class AsmUtils {
+
+  private AsmUtils() {
+  }
+
+  public static boolean doesClassExist(List<Path> classpath, String className) {
+    byte[] classData = loadClassBytesFromClasspath(classpath, className);
+    return classData != null;
+  }
+
+  public static boolean doesMethodExist(List<Path> classpath, String className,
+      String methodName,
+      String methodDescriptor) {
+    MethodFinder classVisitor = new MethodFinder(methodName, methodDescriptor);
+    visitClass(classpath, className, classVisitor);
+    return classVisitor.foundMethod;
+  }
+
+  private static final class MethodFinder extends ClassVisitor {
+
+    private final String methodName;
+    private final String methodDescriptor;
+    public boolean foundMethod = false;
+
+    public MethodFinder(String methodName, String methodDescriptor) {
+      super(Opcodes.ASM6);
+      this.methodName = methodName;
+      this.methodDescriptor = methodDescriptor;
+    }
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String desc, String signature,
+        String[] exceptions) {
+      if (name.equals(methodName) && desc.equals(methodDescriptor)) {
+        assert !foundMethod;
+        foundMethod = true;
+      }
+      return null;
+    }
+  }
+
+  public static boolean doesFieldExist(List<Path> classpath, String className,
+      String fieldName,
+      String fieldType) {
+    FieldFinder classVisitor = new FieldFinder(fieldName, fieldType);
+    visitClass(classpath, className, classVisitor);
+    return classVisitor.foundField;
+  }
+
+  private static final class FieldFinder extends ClassVisitor {
+
+    private final String fieldName;
+    private final String fieldDescriptor;
+    public boolean foundField = false;
+
+    public FieldFinder(String fieldName, String fieldType) {
+      super(Opcodes.ASM6);
+      this.fieldName = fieldName;
+      this.fieldDescriptor = DescriptorUtils.javaTypeToDescriptor(fieldType);
+    }
+
+    @Override
+    public FieldVisitor visitField(int access, String name, String desc, String signature,
+        Object value) {
+      if (name.equals(fieldName) && desc.equals(fieldDescriptor)) {
+        assert !foundField;
+        foundField = true;
+      }
+      return null;
+    }
+  }
+
+  private static void visitClass(List<Path> classpath, String className,
+      ClassVisitor classVisitor) {
+    byte[] classData = loadClassBytesFromClasspath(classpath, className);
+    new ClassReader(classData).accept(classVisitor,
+        ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+  }
+
+  private static byte[] loadClassBytesFromClasspath(List<Path> classpath, String className) {
+    String classFilename = DescriptorUtils.getPathFromJavaType(className);
+    for (Path path : classpath) {
+      if (path.toFile().getPath().endsWith(".jar")) {
+        try (JarInputStream jarInputStream = new JarInputStream(Files.newInputStream(path))) {
+          JarEntry jarEntry;
+          while ((jarEntry = jarInputStream.getNextJarEntry()) != null) {
+            if (jarEntry.isDirectory()) {
+              continue;
+            }
+            String entryName = jarEntry.getName();
+            if (entryName.equals(classFilename)) {
+              byte[] data = new byte[1024];
+              ByteArrayOutputStream baos = new ByteArrayOutputStream();
+              while (true) {
+                int bytesRead = jarInputStream.read(data, 0, data.length);
+                if (bytesRead < 0) {
+                  break;
+                }
+                baos.write(data, 0, bytesRead);
+              }
+              return baos.toByteArray();
+            }
+          }
+        } catch (IOException e) {
+          throw new AssertionError(e);
+        }
+      } else if (path.toFile().getPath().endsWith(".class")) {
+        if (path.toFile().getPath().equals(classFilename)) {
+          try {
+            return Files.readAllBytes(path);
+          } catch (IOException e) {
+            throw new AssertionError(e);
+          }
+        }
+
+      }
+    }
+    return null;
+  }
+
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
index df04931..7425082 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
@@ -66,9 +66,9 @@
         "companionProperties_usePrimitiveProp");
     runTest(PROPERTIES_PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector, testedClass.getOuterClassName());
+      ClassSubject outerClass = checkClassIsKept(dexInspector, testedClass.getOuterClassName());
       String propertyName = "primitiveProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, "int", propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, "int", propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getterAccessor = testedClass
@@ -78,12 +78,12 @@
 
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(outerClass, getterAccessor);
-        checkMethodIsAbsent(outerClass, setterAccessor);
+        checkMethodIsRemoved(outerClass, getterAccessor);
+        checkMethodIsRemoved(outerClass, setterAccessor);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(outerClass, getterAccessor);
-        checkMethodIsPresent(outerClass, setterAccessor);
+        checkMethodIsKept(outerClass, getterAccessor);
+        checkMethodIsKept(outerClass, setterAccessor);
       }
     });
   }
@@ -95,9 +95,9 @@
         "companionProperties_usePrivateProp");
     runTest(PROPERTIES_PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector, testedClass.getOuterClassName());
+      ClassSubject outerClass = checkClassIsKept(dexInspector, testedClass.getOuterClassName());
       String propertyName = "privateProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getterAccessor = testedClass
@@ -107,13 +107,13 @@
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
 
-        checkMethodIsAbsent(outerClass, getterAccessor);
-        checkMethodIsAbsent(outerClass, setterAccessor);
+        checkMethodIsRemoved(outerClass, getterAccessor);
+        checkMethodIsRemoved(outerClass, setterAccessor);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
 
-        checkMethodIsPresent(outerClass, getterAccessor);
-        checkMethodIsPresent(outerClass, setterAccessor);
+        checkMethodIsKept(outerClass, getterAccessor);
+        checkMethodIsKept(outerClass, setterAccessor);
       }
     });
   }
@@ -125,9 +125,9 @@
         "companionProperties_useInternalProp");
     runTest(PROPERTIES_PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector, testedClass.getOuterClassName());
+      ClassSubject outerClass = checkClassIsKept(dexInspector, testedClass.getOuterClassName());
       String propertyName = "internalProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getterAccessor = testedClass
@@ -137,12 +137,12 @@
 
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(outerClass, getterAccessor);
-        checkMethodIsAbsent(outerClass, setterAccessor);
+        checkMethodIsRemoved(outerClass, getterAccessor);
+        checkMethodIsRemoved(outerClass, setterAccessor);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(outerClass, getterAccessor);
-        checkMethodIsPresent(outerClass, setterAccessor);
+        checkMethodIsKept(outerClass, getterAccessor);
+        checkMethodIsKept(outerClass, setterAccessor);
       }
     });
   }
@@ -154,9 +154,9 @@
         "companionProperties_usePublicProp");
     runTest(PROPERTIES_PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector, testedClass.getOuterClassName());
+      ClassSubject outerClass = checkClassIsKept(dexInspector, testedClass.getOuterClassName());
       String propertyName = "publicProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getterAccessor = testedClass
@@ -166,12 +166,12 @@
 
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(outerClass, getterAccessor);
-        checkMethodIsAbsent(outerClass, setterAccessor);
+        checkMethodIsRemoved(outerClass, getterAccessor);
+        checkMethodIsRemoved(outerClass, setterAccessor);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(outerClass, getterAccessor);
-        checkMethodIsPresent(outerClass, setterAccessor);
+        checkMethodIsKept(outerClass, getterAccessor);
+        checkMethodIsKept(outerClass, setterAccessor);
       }
     });
   }
@@ -183,9 +183,9 @@
         "companionLateInitProperties_usePrivateLateInitProp");
     runTest(PROPERTIES_PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector, testedClass.getOuterClassName());
+      ClassSubject outerClass = checkClassIsKept(dexInspector, testedClass.getOuterClassName());
       String propertyName = "privateLateInitProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getterAccessor = testedClass
@@ -194,12 +194,12 @@
           .getSetterAccessorForProperty(propertyName, AccessorKind.FROM_COMPANION);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(outerClass, getterAccessor);
-        checkMethodIsAbsent(outerClass, setterAccessor);
+        checkMethodIsRemoved(outerClass, getterAccessor);
+        checkMethodIsRemoved(outerClass, setterAccessor);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(outerClass, getterAccessor);
-        checkMethodIsPresent(outerClass, setterAccessor);
+        checkMethodIsKept(outerClass, getterAccessor);
+        checkMethodIsKept(outerClass, setterAccessor);
       }
     });
   }
@@ -211,10 +211,11 @@
         "companionLateInitProperties_useInternalLateInitProp");
     runTest(PROPERTIES_PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector, testedClass.getOuterClassName());
+      ClassSubject outerClass = checkClassIsKept(dexInspector, testedClass.getOuterClassName());
       String propertyName = "internalLateInitProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
+      assertTrue(fieldSubject.getField().accessFlags.isPublic());
 
       MemberNaming.MethodSignature getterAccessor = testedClass
           .getGetterAccessorForProperty(propertyName, AccessorKind.FROM_COMPANION);
@@ -234,10 +235,11 @@
         "companionLateInitProperties_usePublicLateInitProp");
     runTest(PROPERTIES_PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector, testedClass.getOuterClassName());
+      ClassSubject outerClass = checkClassIsKept(dexInspector, testedClass.getOuterClassName());
       String propertyName = "publicLateInitProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
+      assertTrue(fieldSubject.getField().accessFlags.isPublic());
 
       MemberNaming.MethodSignature getterAccessor = testedClass
           .getGetterAccessorForProperty(propertyName, AccessorKind.FROM_COMPANION);
@@ -257,49 +259,50 @@
         "accessor_accessPropertyFromCompanionClass");
     runTest("accessors", mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector, testedClass.getOuterClassName());
-      ClassSubject companionClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject outerClass = checkClassIsKept(dexInspector, testedClass.getOuterClassName());
+      ClassSubject companionClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "property";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       // The getter is always inlined since it just calls into the accessor.
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
-      checkMethodIsAbsent(companionClass, getter);
+      checkMethodIsRemoved(companionClass, getter);
 
       MemberNaming.MethodSignature getterAccessor =
           testedClass.getGetterAccessorForProperty(propertyName, AccessorKind.FROM_COMPANION);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(outerClass, getterAccessor);
+        checkMethodIsRemoved(outerClass, getterAccessor);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(outerClass, getterAccessor);
+        checkMethodIsKept(outerClass, getterAccessor);
       }
     });
   }
 
   @Test
+  @Ignore("b/74103342")
   public void testAccessorFromPrivate() throws Exception {
     TestKotlinCompanionClass testedClass = ACCESSOR_COMPANION_PROPERTY_CLASS;
     String mainClass = addMainToClasspath("accessors.AccessorKt",
         "accessor_accessPropertyFromOuterClass");
     runTest("accessors", mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector, testedClass.getOuterClassName());
-      ClassSubject companionClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject outerClass = checkClassIsKept(dexInspector, testedClass.getOuterClassName());
+      ClassSubject companionClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "property";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       // We cannot inline the getter because we don't know if NPE is preserved.
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
-      checkMethodIsPresent(companionClass, getter);
+      checkMethodIsKept(companionClass, getter);
 
       // We should always inline the static accessor method.
       MemberNaming.MethodSignature getterAccessor =
           testedClass.getGetterAccessorForProperty(propertyName, AccessorKind.FROM_INNER);
-      checkMethodIsAbsent(outerClass, getterAccessor);
+      checkMethodIsRemoved(companionClass, getterAccessor);
 
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
@@ -316,7 +319,7 @@
         "noUseOfPropertyAccessorFromInnerClass");
     runTest("accessors", mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject classSubject = checkClassIsKept(dexInspector, testedClass.getClassName());
 
       for (String propertyName : testedClass.properties.keySet()) {
         MemberNaming.MethodSignature getterAccessor =
@@ -324,8 +327,8 @@
         MemberNaming.MethodSignature setterAccessor =
             testedClass.getSetterAccessorForProperty(propertyName, AccessorKind.FROM_INNER);
 
-        checkMethodIsAbsent(classSubject, getterAccessor);
-        checkMethodIsAbsent(classSubject, setterAccessor);
+        checkMethodIsRemoved(classSubject, getterAccessor);
+        checkMethodIsRemoved(classSubject, setterAccessor);
       }
     });
   }
@@ -338,10 +341,10 @@
         "usePrivatePropertyAccessorFromInnerClass");
     runTest("accessors", mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject classSubject = checkClassIsKept(dexInspector, testedClass.getClassName());
 
       String propertyName = "privateProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(classSubject, JAVA_LANG_STRING,
+      FieldSubject fieldSubject = checkFieldIsKept(classSubject, JAVA_LANG_STRING,
           propertyName);
       assertFalse(fieldSubject.getField().accessFlags.isStatic());
 
@@ -351,12 +354,12 @@
           testedClass.getSetterAccessorForProperty(propertyName, AccessorKind.FROM_INNER);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(classSubject, getterAccessor);
-        checkMethodIsAbsent(classSubject, setterAccessor);
+        checkMethodIsRemoved(classSubject, getterAccessor);
+        checkMethodIsRemoved(classSubject, setterAccessor);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(classSubject, getterAccessor);
-        checkMethodIsPresent(classSubject, setterAccessor);
+        checkMethodIsKept(classSubject, getterAccessor);
+        checkMethodIsKept(classSubject, setterAccessor);
       }
     });
   }
@@ -369,10 +372,10 @@
         "usePrivateLateInitPropertyAccessorFromInnerClass");
     runTest("accessors", mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject classSubject = checkClassIsKept(dexInspector, testedClass.getClassName());
 
       String propertyName = "privateLateInitProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(classSubject, JAVA_LANG_STRING,
+      FieldSubject fieldSubject = checkFieldIsKept(classSubject, JAVA_LANG_STRING,
           propertyName);
       assertFalse(fieldSubject.getField().accessFlags.isStatic());
 
@@ -382,12 +385,12 @@
           testedClass.getSetterAccessorForProperty(propertyName, AccessorKind.FROM_INNER);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(classSubject, getterAccessor);
-        checkMethodIsAbsent(classSubject, setterAccessor);
+        checkMethodIsRemoved(classSubject, getterAccessor);
+        checkMethodIsRemoved(classSubject, setterAccessor);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(classSubject, getterAccessor);
-        checkMethodIsPresent(classSubject, setterAccessor);
+        checkMethodIsKept(classSubject, getterAccessor);
+        checkMethodIsKept(classSubject, setterAccessor);
       }
     });
   }
@@ -400,7 +403,7 @@
         "noUseOfPropertyAccessorFromLambda");
     runTest("accessors", mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject classSubject = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "property";
 
       MemberNaming.MethodSignature getterAccessor =
@@ -408,8 +411,8 @@
       MemberNaming.MethodSignature setterAccessor =
           testedClass.getSetterAccessorForProperty(propertyName, AccessorKind.FROM_LAMBDA);
 
-      checkMethodIsAbsent(classSubject, getterAccessor);
-      checkMethodIsAbsent(classSubject, setterAccessor);
+      checkMethodIsRemoved(classSubject, getterAccessor);
+      checkMethodIsRemoved(classSubject, setterAccessor);
     });
   }
 
@@ -421,9 +424,9 @@
         "usePropertyAccessorFromLambda");
     runTest("accessors", mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject classSubject = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "property";
-      FieldSubject fieldSubject = checkFieldIsPresent(classSubject, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(classSubject, JAVA_LANG_STRING, propertyName);
       assertFalse(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getterAccessor =
@@ -432,12 +435,12 @@
           testedClass.getSetterAccessorForProperty(propertyName, AccessorKind.FROM_LAMBDA);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(classSubject, getterAccessor);
-        checkMethodIsAbsent(classSubject, setterAccessor);
+        checkMethodIsRemoved(classSubject, getterAccessor);
+        checkMethodIsRemoved(classSubject, setterAccessor);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(classSubject, getterAccessor);
-        checkMethodIsPresent(classSubject, setterAccessor);
+        checkMethodIsKept(classSubject, getterAccessor);
+        checkMethodIsKept(classSubject, setterAccessor);
       }
     });
   }
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
index 29c5582..c8c8aec 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
@@ -41,23 +41,23 @@
     final String extraRules = keepClassMethod(mainClassName, testMethodSignature);
     runTest("dataclass", mainClassName, extraRules, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject dataClass = checkClassExists(dexInspector, TEST_DATA_CLASS.getClassName());
+      ClassSubject dataClass = checkClassIsKept(dexInspector, TEST_DATA_CLASS.getClassName());
 
       // Getters should be removed after inlining, which is possible only if access is relaxed.
       final boolean areGetterPresent = !allowAccessModification;
-      checkMethod(dataClass, NAME_GETTER_METHOD, areGetterPresent);
-      checkMethod(dataClass, AGE_GETTER_METHOD, areGetterPresent);
+      checkMethodisKeptOrRemoved(dataClass, NAME_GETTER_METHOD, areGetterPresent);
+      checkMethodisKeptOrRemoved(dataClass, AGE_GETTER_METHOD, areGetterPresent);
 
       // No use of componentN functions.
-      checkMethodIsAbsent(dataClass, COMPONENT1_METHOD);
-      checkMethodIsAbsent(dataClass, COMPONENT2_METHOD);
+      checkMethodIsRemoved(dataClass, COMPONENT1_METHOD);
+      checkMethodIsRemoved(dataClass, COMPONENT2_METHOD);
 
       // No use of copy functions.
-      checkMethodIsAbsent(dataClass, COPY_METHOD);
-      checkMethodIsAbsent(dataClass, COPY_DEFAULT_METHOD);
+      checkMethodIsRemoved(dataClass, COPY_METHOD);
+      checkMethodIsRemoved(dataClass, COPY_DEFAULT_METHOD);
 
-      ClassSubject classSubject = checkClassExists(dexInspector, mainClassName);
-      MethodSubject testMethod = checkMethodIsPresent(classSubject, testMethodSignature);
+      ClassSubject classSubject = checkClassIsKept(dexInspector, mainClassName);
+      MethodSubject testMethod = checkMethodIsKept(classSubject, testMethodSignature);
       DexCode dexCode = getDexCode(testMethod);
       if (allowAccessModification) {
         // Both getters should be inlined
@@ -76,24 +76,24 @@
     final String extraRules = keepClassMethod(mainClassName, testMethodSignature);
     runTest("dataclass", mainClassName, extraRules, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject dataClass = checkClassExists(dexInspector, TEST_DATA_CLASS.getClassName());
+      ClassSubject dataClass = checkClassIsKept(dexInspector, TEST_DATA_CLASS.getClassName());
 
       // ComponentN functions should be removed after inlining, which is possible only if access
       // is relaxed.
       final boolean areComponentMethodsPresent = !allowAccessModification;
-      checkMethod(dataClass, COMPONENT1_METHOD, areComponentMethodsPresent);
-      checkMethod(dataClass, COMPONENT2_METHOD, areComponentMethodsPresent);
+      checkMethodisKeptOrRemoved(dataClass, COMPONENT1_METHOD, areComponentMethodsPresent);
+      checkMethodisKeptOrRemoved(dataClass, COMPONENT2_METHOD, areComponentMethodsPresent);
 
       // No use of getter.
-      checkMethodIsAbsent(dataClass, NAME_GETTER_METHOD);
-      checkMethodIsAbsent(dataClass, AGE_GETTER_METHOD);
+      checkMethodIsRemoved(dataClass, NAME_GETTER_METHOD);
+      checkMethodIsRemoved(dataClass, AGE_GETTER_METHOD);
 
       // No use of copy functions.
-      checkMethodIsAbsent(dataClass, COPY_METHOD);
-      checkMethodIsAbsent(dataClass, COPY_DEFAULT_METHOD);
+      checkMethodIsRemoved(dataClass, COPY_METHOD);
+      checkMethodIsRemoved(dataClass, COPY_DEFAULT_METHOD);
 
-      ClassSubject classSubject = checkClassExists(dexInspector, mainClassName);
-      MethodSubject testMethod = checkMethodIsPresent(classSubject, testMethodSignature);
+      ClassSubject classSubject = checkClassIsKept(dexInspector, mainClassName);
+      MethodSubject testMethod = checkMethodIsKept(classSubject, testMethodSignature);
       DexCode dexCode = getDexCode(testMethod);
       if (allowAccessModification) {
         checkMethodIsNeverInvoked(dexCode, COMPONENT1_METHOD, COMPONENT2_METHOD);
@@ -111,24 +111,24 @@
     final String extraRules = keepClassMethod(mainClassName, testMethodSignature);
     runTest("dataclass", mainClassName, extraRules, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject dataClass = checkClassExists(dexInspector, TEST_DATA_CLASS.getClassName());
+      ClassSubject dataClass = checkClassIsKept(dexInspector, TEST_DATA_CLASS.getClassName());
 
       boolean component2IsPresent = !allowAccessModification;
-      checkMethod(dataClass, COMPONENT2_METHOD, component2IsPresent);
+      checkMethodisKeptOrRemoved(dataClass, COMPONENT2_METHOD, component2IsPresent);
 
       // Function component1 is not used.
-      checkMethodIsAbsent(dataClass, COMPONENT1_METHOD);
+      checkMethodIsRemoved(dataClass, COMPONENT1_METHOD);
 
       // No use of getter.
-      checkMethodIsAbsent(dataClass, NAME_GETTER_METHOD);
-      checkMethodIsAbsent(dataClass, AGE_GETTER_METHOD);
+      checkMethodIsRemoved(dataClass, NAME_GETTER_METHOD);
+      checkMethodIsRemoved(dataClass, AGE_GETTER_METHOD);
 
       // No use of copy functions.
-      checkMethodIsAbsent(dataClass, COPY_METHOD);
-      checkMethodIsAbsent(dataClass, COPY_DEFAULT_METHOD);
+      checkMethodIsRemoved(dataClass, COPY_METHOD);
+      checkMethodIsRemoved(dataClass, COPY_DEFAULT_METHOD);
 
-      ClassSubject classSubject = checkClassExists(dexInspector, mainClassName);
-      MethodSubject testMethod = checkMethodIsPresent(classSubject, testMethodSignature);
+      ClassSubject classSubject = checkClassIsKept(dexInspector, mainClassName);
+      MethodSubject testMethod = checkMethodIsKept(classSubject, testMethodSignature);
       DexCode dexCode = getDexCode(testMethod);
       if (allowAccessModification) {
         checkMethodIsNeverInvoked(dexCode, COMPONENT2_METHOD);
@@ -146,10 +146,10 @@
     final String extraRules = keepClassMethod(mainClassName, testMethodSignature);
     runTest("dataclass", mainClassName, extraRules, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject dataClass = checkClassExists(dexInspector, TEST_DATA_CLASS.getClassName());
+      ClassSubject dataClass = checkClassIsKept(dexInspector, TEST_DATA_CLASS.getClassName());
 
-      checkMethodIsAbsent(dataClass, COPY_METHOD);
-      checkMethodIsAbsent(dataClass, COPY_DEFAULT_METHOD);
+      checkMethodIsRemoved(dataClass, COPY_METHOD);
+      checkMethodIsRemoved(dataClass, COPY_DEFAULT_METHOD);
     });
   }
 
@@ -161,9 +161,9 @@
     final String extraRules = keepClassMethod(mainClassName, testMethodSignature);
     runTest("dataclass", mainClassName, extraRules, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject dataClass = checkClassExists(dexInspector, TEST_DATA_CLASS.getClassName());
+      ClassSubject dataClass = checkClassIsKept(dexInspector, TEST_DATA_CLASS.getClassName());
 
-      checkMethodIsAbsent(dataClass, COPY_DEFAULT_METHOD);
+      checkMethodIsRemoved(dataClass, COPY_DEFAULT_METHOD);
     });
   }
 
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java
index 8fef44c..021e045 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java
@@ -28,7 +28,7 @@
 
     runTest("intrinsics", "intrinsics.IntrinsicsKt", extraRules, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject intrinsicsClass = checkClassExists(
+      ClassSubject intrinsicsClass = checkClassIsKept(
           dexInspector, KOTLIN_INTRINSICS_CLASS.getClassName());
 
       checkMethodsPresence(intrinsicsClass,
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
index f884376..74e3d5e 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
@@ -6,6 +6,7 @@
 
 import static org.junit.Assert.assertTrue;
 
+import com.android.tools.r8.kotlin.TestKotlinClass.KotlinProperty;
 import com.android.tools.r8.kotlin.TestKotlinClass.Visibility;
 import com.android.tools.r8.naming.MemberNaming;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
@@ -13,6 +14,7 @@
 import com.android.tools.r8.utils.DexInspector.ClassSubject;
 import com.android.tools.r8.utils.DexInspector.FieldSubject;
 import com.android.tools.r8.utils.InternalOptions;
+import java.util.Map.Entry;
 import java.util.function.Consumer;
 import org.junit.Test;
 
@@ -89,13 +91,19 @@
         "mutableProperty_noUseOfProperties");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector,
+      ClassSubject classSubject = checkClassIsKept(dexInspector,
           MUTABLE_PROPERTY_CLASS.getClassName());
-      for (String propertyName : MUTABLE_PROPERTY_CLASS.properties.keySet()) {
-        checkMethodIsAbsent(classSubject,
-            MUTABLE_PROPERTY_CLASS.getGetterForProperty(propertyName));
-        checkMethodIsAbsent(classSubject,
-            MUTABLE_PROPERTY_CLASS.getSetterForProperty(propertyName));
+      for (Entry<String, KotlinProperty> property : MUTABLE_PROPERTY_CLASS.properties.entrySet()) {
+        MethodSignature getter = MUTABLE_PROPERTY_CLASS.getGetterForProperty(property.getKey());
+        MethodSignature setter = MUTABLE_PROPERTY_CLASS.getSetterForProperty(property.getKey());
+        if (property.getValue().getVisibility() == Visibility.PRIVATE) {
+          // Private properties have no getter/setter
+          checkMethodIsAbsent(classSubject, getter);
+          checkMethodIsAbsent(classSubject, setter);
+        } else {
+          checkMethodIsRemoved(classSubject, getter);
+          checkMethodIsRemoved(classSubject, setter);
+        }
       }
     });
   }
@@ -106,10 +114,10 @@
         "mutableProperty_usePrivateProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector,
+      ClassSubject classSubject = checkClassIsKept(dexInspector,
           MUTABLE_PROPERTY_CLASS.getClassName());
       String propertyName = "privateProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(classSubject, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(classSubject, JAVA_LANG_STRING, propertyName);
       if (!allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
       } else {
@@ -128,19 +136,19 @@
         "mutableProperty_useProtectedProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector,
+      ClassSubject classSubject = checkClassIsKept(dexInspector,
           MUTABLE_PROPERTY_CLASS.getClassName());
       String propertyName = "protectedProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(classSubject, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(classSubject, JAVA_LANG_STRING, propertyName);
 
       // Protected property has private field.
       MethodSignature getter = MUTABLE_PROPERTY_CLASS.getGetterForProperty(propertyName);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(classSubject, getter);
+        checkMethodIsRemoved(classSubject, getter);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(classSubject, getter);
+        checkMethodIsKept(classSubject, getter);
       }
     });
   }
@@ -151,19 +159,19 @@
         "mutableProperty_useInternalProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector,
+      ClassSubject classSubject = checkClassIsKept(dexInspector,
           MUTABLE_PROPERTY_CLASS.getClassName());
       String propertyName = "internalProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(classSubject, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(classSubject, JAVA_LANG_STRING, propertyName);
 
       // Internal property has private field
       MethodSignature getter = MUTABLE_PROPERTY_CLASS.getGetterForProperty(propertyName);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(classSubject, getter);
+        checkMethodIsRemoved(classSubject, getter);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(classSubject, getter);
+        checkMethodIsKept(classSubject, getter);
       }
     });
   }
@@ -174,19 +182,19 @@
         "mutableProperty_usePublicProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector,
+      ClassSubject classSubject = checkClassIsKept(dexInspector,
           MUTABLE_PROPERTY_CLASS.getClassName());
       String propertyName = "publicProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(classSubject, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(classSubject, JAVA_LANG_STRING, propertyName);
 
       // Public property has private field
       MethodSignature getter = MUTABLE_PROPERTY_CLASS.getGetterForProperty(propertyName);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(classSubject, getter);
+        checkMethodIsRemoved(classSubject, getter);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(classSubject, getter);
+        checkMethodIsKept(classSubject, getter);
       }
     });
   }
@@ -197,21 +205,21 @@
         "mutableProperty_usePrimitiveProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector,
+      ClassSubject classSubject = checkClassIsKept(dexInspector,
           MUTABLE_PROPERTY_CLASS.getClassName());
       String propertyName = "primitiveProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(classSubject, "int", propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(classSubject, "int", propertyName);
 
       MethodSignature getter = MUTABLE_PROPERTY_CLASS.getGetterForProperty(propertyName);
       MethodSignature setter = MUTABLE_PROPERTY_CLASS.getSetterForProperty(propertyName);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(classSubject, getter);
-        checkMethodIsAbsent(classSubject, setter);
+        checkMethodIsRemoved(classSubject, getter);
+        checkMethodIsRemoved(classSubject, setter);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(classSubject, getter);
-        checkMethodIsPresent(classSubject, setter);
+        checkMethodIsKept(classSubject, getter);
+        checkMethodIsKept(classSubject, setter);
       }
     });
   }
@@ -222,13 +230,20 @@
         "lateInitProperty_noUseOfProperties");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector,
+      ClassSubject classSubject = checkClassIsKept(dexInspector,
           LATE_INIT_PROPERTY_CLASS.getClassName());
-      for (String propertyName : LATE_INIT_PROPERTY_CLASS.properties.keySet()) {
-        checkMethodIsAbsent(classSubject,
-            LATE_INIT_PROPERTY_CLASS.getGetterForProperty(propertyName));
-        checkMethodIsAbsent(classSubject,
-            LATE_INIT_PROPERTY_CLASS.getSetterForProperty(propertyName));
+      for (Entry<String, KotlinProperty> property : LATE_INIT_PROPERTY_CLASS.properties.entrySet()) {
+        MethodSignature getter = LATE_INIT_PROPERTY_CLASS.getGetterForProperty(property.getKey());
+        MethodSignature setter = LATE_INIT_PROPERTY_CLASS.getSetterForProperty(property.getKey());
+        if (property.getValue().getVisibility() == Visibility.PRIVATE) {
+          // Private properties have no getter or setter.
+          checkMethodIsAbsent(classSubject, getter);
+          checkMethodIsAbsent(classSubject, setter);
+
+        } else {
+          checkMethodIsRemoved(classSubject, getter);
+          checkMethodIsRemoved(classSubject, setter);
+        }
       }
     });
   }
@@ -239,7 +254,7 @@
         "properties/LateInitPropertyKt", "lateInitProperty_usePrivateLateInitProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector,
+      ClassSubject classSubject = checkClassIsKept(dexInspector,
           LATE_INIT_PROPERTY_CLASS.getClassName());
       String propertyName = "privateLateInitProp";
       FieldSubject fieldSubject = classSubject.field(JAVA_LANG_STRING, propertyName);
@@ -262,7 +277,7 @@
         "lateInitProperty_useProtectedLateInitProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector,
+      ClassSubject classSubject = checkClassIsKept(dexInspector,
           LATE_INIT_PROPERTY_CLASS.getClassName());
       String propertyName = "protectedLateInitProp";
       FieldSubject fieldSubject = classSubject.field(JAVA_LANG_STRING, propertyName);
@@ -272,7 +287,7 @@
       }
 
       // Protected late init property have protected getter
-      checkMethodIsAbsent(classSubject,
+      checkMethodIsRemoved(classSubject,
           LATE_INIT_PROPERTY_CLASS.getGetterForProperty(propertyName));
     });
   }
@@ -283,7 +298,7 @@
         "properties/LateInitPropertyKt", "lateInitProperty_useInternalLateInitProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector,
+      ClassSubject classSubject = checkClassIsKept(dexInspector,
           LATE_INIT_PROPERTY_CLASS.getClassName());
       String propertyName = "internalLateInitProp";
       FieldSubject fieldSubject = classSubject.field(JAVA_LANG_STRING, propertyName);
@@ -291,7 +306,7 @@
       assertTrue(fieldSubject.getField().accessFlags.isPublic());
 
       // Internal late init property have protected getter
-      checkMethodIsAbsent(classSubject,
+      checkMethodIsRemoved(classSubject,
           LATE_INIT_PROPERTY_CLASS.getGetterForProperty(propertyName));
     });
   }
@@ -302,7 +317,7 @@
         "properties/LateInitPropertyKt", "lateInitProperty_usePublicLateInitProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector,
+      ClassSubject classSubject = checkClassIsKept(dexInspector,
           LATE_INIT_PROPERTY_CLASS.getClassName());
       String propertyName = "publicLateInitProp";
       FieldSubject fieldSubject = classSubject.field(JAVA_LANG_STRING, propertyName);
@@ -310,7 +325,7 @@
       assertTrue(fieldSubject.getField().accessFlags.isPublic());
 
       // Internal late init property have protected getter
-      checkMethodIsAbsent(classSubject,
+      checkMethodIsRemoved(classSubject,
           LATE_INIT_PROPERTY_CLASS.getGetterForProperty(propertyName));
     });
   }
@@ -321,12 +336,12 @@
         "properties/UserDefinedPropertyKt", "userDefinedProperty_noUseOfProperties");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector,
+      ClassSubject classSubject = checkClassIsKept(dexInspector,
           USER_DEFINED_PROPERTY_CLASS.getClassName());
       for (String propertyName : USER_DEFINED_PROPERTY_CLASS.properties.keySet()) {
-        checkMethodIsAbsent(classSubject,
+        checkMethodIsRemoved(classSubject,
             USER_DEFINED_PROPERTY_CLASS.getGetterForProperty(propertyName));
-        checkMethodIsAbsent(classSubject,
+        checkMethodIsRemoved(classSubject,
             USER_DEFINED_PROPERTY_CLASS.getSetterForProperty(propertyName));
       }
     });
@@ -338,22 +353,22 @@
         "properties/UserDefinedPropertyKt", "userDefinedProperty_useProperties");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject classSubject = checkClassExists(dexInspector,
+      ClassSubject classSubject = checkClassIsKept(dexInspector,
           USER_DEFINED_PROPERTY_CLASS.getClassName());
       String propertyName = "durationInSeconds";
       // The 'wrapper' property is not assigned to a backing field, it only relies on the wrapped
       // property.
       checkFieldIsAbsent(classSubject, "int", "durationInSeconds");
 
-      FieldSubject fieldSubject = checkFieldIsPresent(classSubject, "int",
+      FieldSubject fieldSubject = checkFieldIsKept(classSubject, "int",
           "durationInMilliSeconds");
       MethodSignature getter = USER_DEFINED_PROPERTY_CLASS.getGetterForProperty(propertyName);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(classSubject, getter);
+        checkMethodIsRemoved(classSubject, getter);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(classSubject, getter);
+        checkMethodIsKept(classSubject, getter);
       }
     });
   }
@@ -364,12 +379,12 @@
         "properties.CompanionPropertiesKt", "companionProperties_usePrimitiveProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector,
+      ClassSubject outerClass = checkClassIsKept(dexInspector,
           "properties.CompanionProperties");
-      ClassSubject companionClass = checkClassExists(dexInspector,
+      ClassSubject companionClass = checkClassIsKept(dexInspector,
           COMPANION_PROPERTY_CLASS.getClassName());
       String propertyName = "primitiveProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, "int", propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, "int", propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = COMPANION_PROPERTY_CLASS
@@ -379,8 +394,8 @@
 
       // Getter and setter cannot be inlined because we don't know if null check semantic is
       // preserved.
-      checkMethodIsPresent(companionClass, getter);
-      checkMethodIsPresent(companionClass, setter);
+      checkMethodIsKept(companionClass, getter);
+      checkMethodIsKept(companionClass, setter);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
       } else {
@@ -395,12 +410,12 @@
         "properties.CompanionPropertiesKt", "companionProperties_usePrivateProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector,
+      ClassSubject outerClass = checkClassIsKept(dexInspector,
           "properties.CompanionProperties");
-      ClassSubject companionClass = checkClassExists(dexInspector,
+      ClassSubject companionClass = checkClassIsKept(dexInspector,
           COMPANION_PROPERTY_CLASS.getClassName());
       String propertyName = "privateProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = COMPANION_PROPERTY_CLASS
@@ -413,8 +428,8 @@
       // non-null, thus the getter/setter can be inlined if their code is small enough.
       // Because the backing field is private, they will call into an accessor (static) method. If
       // access relaxation is enabled, this accessor can be removed.
-      checkMethodIsAbsent(companionClass, getter);
-      checkMethodIsAbsent(companionClass, setter);
+      checkMethodIsRemoved(companionClass, getter);
+      checkMethodIsRemoved(companionClass, setter);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
       } else {
@@ -429,12 +444,12 @@
         "properties.CompanionPropertiesKt", "companionProperties_useInternalProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector,
+      ClassSubject outerClass = checkClassIsKept(dexInspector,
           "properties.CompanionProperties");
-      ClassSubject companionClass = checkClassExists(dexInspector,
+      ClassSubject companionClass = checkClassIsKept(dexInspector,
           COMPANION_PROPERTY_CLASS.getClassName());
       String propertyName = "internalProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = COMPANION_PROPERTY_CLASS
@@ -444,8 +459,8 @@
 
       // Getter and setter cannot be inlined because we don't know if null check semantic is
       // preserved.
-      checkMethodIsPresent(companionClass, getter);
-      checkMethodIsPresent(companionClass, setter);
+      checkMethodIsKept(companionClass, getter);
+      checkMethodIsKept(companionClass, setter);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
       } else {
@@ -460,12 +475,12 @@
         "properties.CompanionPropertiesKt", "companionProperties_usePublicProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector,
+      ClassSubject outerClass = checkClassIsKept(dexInspector,
           "properties.CompanionProperties");
-      ClassSubject companionClass = checkClassExists(dexInspector,
+      ClassSubject companionClass = checkClassIsKept(dexInspector,
           COMPANION_PROPERTY_CLASS.getClassName());
       String propertyName = "publicProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = COMPANION_PROPERTY_CLASS
@@ -475,8 +490,8 @@
 
       // Getter and setter cannot be inlined because we don't know if null check semantic is
       // preserved.
-      checkMethodIsPresent(companionClass, getter);
-      checkMethodIsPresent(companionClass, setter);
+      checkMethodIsKept(companionClass, getter);
+      checkMethodIsKept(companionClass, setter);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
       } else {
@@ -492,10 +507,10 @@
         "companionLateInitProperties_usePrivateLateInitProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector, testedClass.getOuterClassName());
-      ClassSubject companionClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject outerClass = checkClassIsKept(dexInspector, testedClass.getOuterClassName());
+      ClassSubject companionClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "privateLateInitProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
@@ -506,8 +521,8 @@
       // non-null, thus the getter/setter can be inlined if their code is small enough.
       // Because the backing field is private, they will call into an accessor (static) method. If
       // access relaxation is enabled, this accessor can be removed.
-      checkMethodIsAbsent(companionClass, getter);
-      checkMethodIsAbsent(companionClass, setter);
+      checkMethodIsRemoved(companionClass, getter);
+      checkMethodIsRemoved(companionClass, setter);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
       } else {
@@ -523,10 +538,10 @@
         "companionLateInitProperties_useInternalLateInitProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector, testedClass.getOuterClassName());
-      ClassSubject companionClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject outerClass = checkClassIsKept(dexInspector, testedClass.getOuterClassName());
+      ClassSubject companionClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "internalLateInitProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
@@ -534,8 +549,8 @@
 
       // Getter and setter cannot be inlined because we don't know if null check semantic is
       // preserved.
-      checkMethodIsPresent(companionClass, getter);
-      checkMethodIsPresent(companionClass, setter);
+      checkMethodIsKept(companionClass, getter);
+      checkMethodIsKept(companionClass, setter);
       assertTrue(fieldSubject.getField().accessFlags.isPublic());
     });
   }
@@ -547,10 +562,10 @@
         "companionLateInitProperties_usePublicLateInitProp");
     runTest(PACKAGE_NAME, mainClass, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject outerClass = checkClassExists(dexInspector, testedClass.getOuterClassName());
-      ClassSubject companionClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject outerClass = checkClassIsKept(dexInspector, testedClass.getOuterClassName());
+      ClassSubject companionClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "publicLateInitProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(outerClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
@@ -558,8 +573,8 @@
 
       // Getter and setter cannot be inlined because we don't know if null check semantic is
       // preserved.
-      checkMethodIsPresent(companionClass, getter);
-      checkMethodIsPresent(companionClass, setter);
+      checkMethodIsKept(companionClass, getter);
+      checkMethodIsKept(companionClass, setter);
       assertTrue(fieldSubject.getField().accessFlags.isPublic());
     });
   }
@@ -571,9 +586,9 @@
         "properties.ObjectPropertiesKt", "objectProperties_usePrimitiveProp");
     runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject objectClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject objectClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "primitiveProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(objectClass, "int", propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(objectClass, "int", propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
@@ -581,8 +596,8 @@
 
       // Getter and setter cannot be inlined when we don't know if null check semantic is
       // preserved.
-      checkMethodIsPresent(objectClass, getter);
-      checkMethodIsPresent(objectClass, setter);
+      checkMethodIsKept(objectClass, getter);
+      checkMethodIsKept(objectClass, setter);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
       } else {
@@ -598,9 +613,9 @@
         "properties.ObjectPropertiesKt", "objectProperties_usePrivateProp");
     runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject objectClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject objectClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "privateProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(objectClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(objectClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
@@ -625,9 +640,9 @@
         "properties.ObjectPropertiesKt", "objectProperties_useInternalProp");
     runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject objectClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject objectClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "internalProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(objectClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(objectClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
@@ -635,8 +650,8 @@
 
       // Getter and setter cannot be inlined when we don't know if null check semantic is
       // preserved.
-      checkMethodIsPresent(objectClass, getter);
-      checkMethodIsPresent(objectClass, setter);
+      checkMethodIsKept(objectClass, getter);
+      checkMethodIsKept(objectClass, setter);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
       } else {
@@ -652,9 +667,9 @@
         "properties.ObjectPropertiesKt", "objectProperties_usePublicProp");
     runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject objectClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject objectClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "publicProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(objectClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(objectClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
@@ -662,8 +677,8 @@
 
       // Getter and setter cannot be inlined when we don't know if null check semantic is
       // preserved.
-      checkMethodIsPresent(objectClass, getter);
-      checkMethodIsPresent(objectClass, setter);
+      checkMethodIsKept(objectClass, getter);
+      checkMethodIsKept(objectClass, setter);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
       } else {
@@ -679,9 +694,9 @@
         "properties.ObjectPropertiesKt", "objectProperties_useLateInitPrivateProp");
     runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject objectClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject objectClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "privateLateInitProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(objectClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(objectClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
@@ -706,9 +721,9 @@
         "properties.ObjectPropertiesKt", "objectProperties_useLateInitInternalProp");
     runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject objectClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject objectClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "internalLateInitProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(objectClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(objectClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
@@ -716,8 +731,8 @@
 
       // Getter and setter cannot be inlined when we don't know if null check semantic is
       // preserved.
-      checkMethodIsPresent(objectClass, getter);
-      checkMethodIsPresent(objectClass, setter);
+      checkMethodIsKept(objectClass, getter);
+      checkMethodIsKept(objectClass, setter);
       assertTrue(fieldSubject.getField().accessFlags.isPublic());
     });
   }
@@ -729,9 +744,9 @@
         "properties.ObjectPropertiesKt", "objectProperties_useLateInitPublicProp");
     runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject objectClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject objectClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "publicLateInitProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(objectClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(objectClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
@@ -739,8 +754,8 @@
 
       // Getter and setter cannot be inlined when we don't know if null check semantic is
       // preserved.
-      checkMethodIsPresent(objectClass, getter);
-      checkMethodIsPresent(objectClass, setter);
+      checkMethodIsKept(objectClass, getter);
+      checkMethodIsKept(objectClass, setter);
       assertTrue(fieldSubject.getField().accessFlags.isPublic());
     });
   }
@@ -752,9 +767,9 @@
         "properties.FilePropertiesKt", "fileProperties_usePrimitiveProp");
     runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject objectClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject objectClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "primitiveProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(objectClass, "int", propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(objectClass, "int", propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
@@ -762,12 +777,12 @@
 
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(objectClass, getter);
-        checkMethodIsAbsent(objectClass, setter);
+        checkMethodIsRemoved(objectClass, getter);
+        checkMethodIsRemoved(objectClass, setter);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(objectClass, getter);
-        checkMethodIsPresent(objectClass, setter);
+        checkMethodIsKept(objectClass, getter);
+        checkMethodIsKept(objectClass, setter);
       }
     });
   }
@@ -779,9 +794,9 @@
         "properties.FilePropertiesKt", "fileProperties_usePrivateProp");
     runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject objectClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject objectClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "privateProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(objectClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(objectClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
@@ -805,9 +820,9 @@
         "properties.FilePropertiesKt", "fileProperties_useInternalProp");
     runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject objectClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject objectClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "internalProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(objectClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(objectClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       // We expect getter to be inlined when access (of the backing field) is relaxed to public.
@@ -816,10 +831,10 @@
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(objectClass, getter);
+        checkMethodIsRemoved(objectClass, getter);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(objectClass, getter);
+        checkMethodIsKept(objectClass, getter);
       }
     });
   }
@@ -831,9 +846,9 @@
         "properties.FilePropertiesKt", "fileProperties_usePublicProp");
     runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject objectClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject objectClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "publicProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(objectClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(objectClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       // We expect getter to be inlined when access (of the backing field) is relaxed to public.
@@ -843,10 +858,10 @@
 
       if (allowAccessModification) {
         assertTrue(fieldSubject.getField().accessFlags.isPublic());
-        checkMethodIsAbsent(objectClass, getter);
+        checkMethodIsRemoved(objectClass, getter);
       } else {
         assertTrue(fieldSubject.getField().accessFlags.isPrivate());
-        checkMethodIsPresent(objectClass, getter);
+        checkMethodIsKept(objectClass, getter);
       }
     });
   }
@@ -858,9 +873,9 @@
         "properties.FilePropertiesKt", "fileProperties_useLateInitPrivateProp");
     runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject fileClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject fileClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "privateLateInitProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(fileClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(fileClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
@@ -884,9 +899,9 @@
         "properties.FilePropertiesKt", "fileProperties_useLateInitInternalProp");
     runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject objectClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject objectClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "internalLateInitProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(objectClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(objectClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
       assertTrue(fieldSubject.getField().accessFlags.isPublic());
 
@@ -894,10 +909,10 @@
       MemberNaming.MethodSignature setter = testedClass.getSetterForProperty(propertyName);
 
       // Field is public and getter is small so we expect to always inline it.
-      checkMethodIsAbsent(objectClass, getter);
+      checkMethodIsRemoved(objectClass, getter);
 
       // Setter has null check of new value, thus may not be inlined.
-      checkMethodIsPresent(objectClass, setter);
+      checkMethodIsKept(objectClass, setter);
     });
   }
 
@@ -908,16 +923,16 @@
         "properties.FilePropertiesKt", "fileProperties_useLateInitPublicProp");
     runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject objectClass = checkClassExists(dexInspector, testedClass.getClassName());
+      ClassSubject objectClass = checkClassIsKept(dexInspector, testedClass.getClassName());
       String propertyName = "publicLateInitProp";
-      FieldSubject fieldSubject = checkFieldIsPresent(objectClass, JAVA_LANG_STRING, propertyName);
+      FieldSubject fieldSubject = checkFieldIsKept(objectClass, JAVA_LANG_STRING, propertyName);
       assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
       MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
       MemberNaming.MethodSignature setter = testedClass.getSetterForProperty(propertyName);
 
-      checkMethodIsAbsent(objectClass, getter);
-      checkMethodIsPresent(objectClass, setter);
+      checkMethodIsRemoved(objectClass, getter);
+      checkMethodIsKept(objectClass, setter);
       assertTrue(fieldSubject.getField().accessFlags.isPublic());
     });
   }
diff --git a/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java b/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
index 2b1c33f..5a30cfd 100644
--- a/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
@@ -36,9 +36,9 @@
     final String extraRules = keepAllMembers(mainClassName);
     runTest(FOLDER, mainClassName, extraRules, app -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject clazz = checkClassExists(dexInspector, ex1.getClassName());
+      ClassSubject clazz = checkClassIsKept(dexInspector, ex1.getClassName());
 
-      MethodSubject testMethod = checkMethodIsPresent(clazz, testMethodSignature);
+      MethodSubject testMethod = checkMethodIsKept(clazz, testMethodSignature);
       DexCode dexCode = getDexCode(testMethod);
       long count = Arrays.stream(dexCode.instructions)
           .filter(SimplifyIfNotNullKotlinTest::isIf).count();
@@ -62,9 +62,9 @@
     final String extraRules = keepAllMembers(mainClassName);
     runTest(FOLDER, mainClassName, extraRules, app -> {
       DexInspector dexInspector = new DexInspector(app);
-      ClassSubject clazz = checkClassExists(dexInspector, ex2.getClassName());
+      ClassSubject clazz = checkClassIsKept(dexInspector, ex2.getClassName());
 
-      MethodSubject testMethod = checkMethodIsPresent(clazz, testMethodSignature);
+      MethodSubject testMethod = checkMethodIsKept(clazz, testMethodSignature);
       DexCode dexCode = getDexCode(testMethod);
       long count = Arrays.stream(dexCode.instructions)
           .filter(SimplifyIfNotNullKotlinTest::isIf).count();