Merge "R8 Kotlin tests: also check symbols in input"
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();
