Refactor API database generation to production code.
Bug: b/510269018
Change-Id: Ia38db8f52d798855dc8012e036a5d5de8950d8ca
diff --git a/src/main/java/com/android/tools/r8/androidapi/ApiDatabaseEntry.java b/src/main/java/com/android/tools/r8/androidapi/ApiDatabaseEntry.java
index ba19aa9..3c5c80e 100644
--- a/src/main/java/com/android/tools/r8/androidapi/ApiDatabaseEntry.java
+++ b/src/main/java/com/android/tools/r8/androidapi/ApiDatabaseEntry.java
@@ -11,9 +11,10 @@
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexReference;
import com.android.tools.r8.graph.DexString;
-import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.MethodReference;
import com.android.tools.r8.utils.internal.ThrowingFunction;
-import com.android.tools.r8.utils.internal.exceptions.Unreachable;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
@@ -26,7 +27,7 @@
* pooled in a constant pool (see {@link ConstantPoolEntry}).
*
* <p>Each entry can be serialized into a "unique descriptor" which is a compact byte array
- * containing identifiers and constant pool indices. See {@code
+ * containing identifiers and constant pool indices. See {@link
* com.android.tools.r8.apimodel.AndroidApiHashingDatabaseBuilderGenerator} for the serialization
* format.
*/
@@ -48,8 +49,6 @@
ThrowingFunction<ConstantPoolEntry, Integer, IOException> constantPoolLookup)
throws IOException;
- public abstract ApiDatabaseEntry withHolder(DexType newHolder);
-
@Override
public final int hashCode() {
return apiDatabaseHashCode();
@@ -85,6 +84,29 @@
DexString.encodeToMutf8(reference.getFieldName()));
}
+ public static ApiDatabaseEntry of(ClassReference reference) {
+ return new TypeEntry(DexString.encodeToMutf8(reference.getDescriptor()));
+ }
+
+ public static ApiDatabaseEntry of(MethodReference reference) {
+ byte[][] parameters = new byte[reference.getFormalTypes().size()][];
+ for (int i = 0; i < parameters.length; i++) {
+ parameters[i] = DexString.encodeToMutf8(reference.getFormalTypes().get(i).getDescriptor());
+ }
+ return new MethodEntry(
+ DexString.encodeToMutf8(reference.getHolderClass().getDescriptor()),
+ DexString.encodeToMutf8(reference.getMethodName()),
+ parameters,
+ DexString.encodeToMutf8(
+ reference.getReturnType() == null ? "V" : reference.getReturnType().getDescriptor()));
+ }
+
+ public static ApiDatabaseEntry of(FieldReference reference) {
+ return new FieldEntry(
+ DexString.encodeToMutf8(reference.getHolderClass().getDescriptor()),
+ DexString.encodeToMutf8(reference.getFieldName()));
+ }
+
private static byte getFirstByteFromShort(int value) {
assert isU2(value);
return (byte) (value >> 8);
@@ -159,10 +181,6 @@
};
}
- @Override
- public ApiDatabaseEntry withHolder(DexType newHolder) {
- throw new Unreachable();
- }
@Override
public boolean equals(Object obj) {
@@ -223,10 +241,6 @@
return baos.toByteArray();
}
- @Override
- public ApiDatabaseEntry withHolder(DexType newHolder) {
- throw new Unreachable();
- }
@Override
public boolean equals(Object obj) {
@@ -279,10 +293,6 @@
};
}
- @Override
- public ApiDatabaseEntry withHolder(DexType newHolder) {
- return new FieldEntry(newHolder.getDescriptor().content, this.name);
- }
@Override
public boolean equals(Object obj) {
diff --git a/src/main/java/com/android/tools/r8/apimodel/AndroidApiHashingDatabaseBuilderGenerator.java b/src/main/java/com/android/tools/r8/apimodel/AndroidApiHashingDatabaseBuilderGenerator.java
new file mode 100644
index 0000000..8f889e8
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/apimodel/AndroidApiHashingDatabaseBuilderGenerator.java
@@ -0,0 +1,359 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.apimodel;
+
+import static com.android.tools.r8.androidapi.AndroidApiDataAccess.constantPoolHash;
+import static com.android.tools.r8.lightir.ByteUtils.isU2;
+import static com.android.tools.r8.lightir.ByteUtils.setBitAtIndex;
+import static com.android.tools.r8.utils.internal.MapUtils.ignoreKey;
+
+import com.android.tools.r8.androidapi.AndroidApiDataAccess;
+import com.android.tools.r8.androidapi.ApiDatabaseEntry;
+import com.android.tools.r8.androidapi.ApiDatabaseEntry.ConstantPoolEntry;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.internal.IntBox;
+import com.android.tools.r8.utils.internal.ThrowingBiConsumer;
+import com.android.tools.r8.utils.internal.collections.Pair;
+import it.unimi.dsi.fastutil.ints.Int2ObjectLinkedOpenHashMap;
+import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
+import it.unimi.dsi.fastutil.objects.Object2IntLinkedOpenHashMap;
+import it.unimi.dsi.fastutil.objects.Object2IntMap;
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+public class AndroidApiHashingDatabaseBuilderGenerator {
+
+ public static class GenerationException extends Exception {
+ public GenerationException(String message) {
+ super(message);
+ }
+
+ public GenerationException(String message, Throwable cause) {
+ super(message, cause);
+ }
+ }
+
+ /** The returned map has hash-independent iteration. */
+ public static Map<ApiDatabaseEntry, AndroidApiLevel> generateEntries(
+ List<ParsedApiClass> apiClasses) throws GenerationException {
+ Map<ClassReference, ParsedApiClass> lookupMap = new HashMap<>();
+ Map<ApiDatabaseEntry, AndroidApiLevel> databaseEntries = new LinkedHashMap<>();
+
+ for (ParsedApiClass apiClass : apiClasses) {
+ lookupMap.put(apiClass.getClassReference(), apiClass);
+ databaseEntries.put(
+ ApiDatabaseEntry.of(apiClass.getClassReference()), apiClass.getApiLevel());
+ }
+
+ for (ParsedApiClass apiClass : apiClasses) {
+ computeAllReferencesInHierarchy(
+ lookupMap, apiClass.getClassReference(), apiClass, AndroidApiLevel.B, databaseEntries);
+ }
+
+ return databaseEntries;
+ }
+
+ /**
+ * This method will generate one single database file where the format is as follows (uX is X
+ * number of unsigned bytes):
+ *
+ * <pre>
+ * constant_pool_size: u4
+ * constant_pool: [constant_pool_size * payload_entry]
+ * constant_pool_map: [0..max_hash(ConstantPoolEntry) * payload_entry]
+ * api_map: [0..max_hash(ApiDatabaseEntry) * payload_entry]
+ * payload raw data.
+ *
+ * payload_entry: u4:relative_offset_from_payload_start_or_tagged_value + u2:length
+ * </pre>
+ *
+ * For hash_definitions and entries see {@link AndroidApiDataAccess}.
+ */
+ public static void writeEntries(
+ Map<ApiDatabaseEntry, AndroidApiLevel> databaseEntries, Path pathToApiLevels)
+ throws GenerationException {
+ try (FileOutputStream fileOutputStream = new FileOutputStream(pathToApiLevels.toFile())) {
+ DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);
+ generateDatabase(databaseEntries, dataOutputStream);
+ } catch (IOException e) {
+ throw new GenerationException("Failed to write API database to " + pathToApiLevels, e);
+ }
+ }
+
+ private static class ConstantPool {
+
+ private final IntBox intBox = new IntBox(0);
+ private final Object2IntMap<ConstantPoolEntry> pool = new Object2IntLinkedOpenHashMap<>();
+
+ public int getOrAdd(ConstantPoolEntry entry) {
+ return pool.computeIfAbsent(entry, ignored -> intBox.getAndIncrement());
+ }
+
+ public void forEach(ThrowingBiConsumer<ConstantPoolEntry, Integer, IOException> consumer)
+ throws IOException {
+ for (var mapEntry : pool.object2IntEntrySet()) {
+ consumer.accept(mapEntry.getKey(), mapEntry.getIntValue());
+ }
+ }
+
+ public int size() {
+ return pool.size();
+ }
+ }
+
+ private static int setUniqueConstantPoolEntry(int id) {
+ return setBitAtIndex(id, 32);
+ }
+
+ private static void generateDatabase(
+ Map<ApiDatabaseEntry, AndroidApiLevel> databaseEntries, DataOutputStream outputStream)
+ throws GenerationException, IOException {
+ Int2ObjectMap<List<Pair<ApiDatabaseEntry, AndroidApiLevel>>> generationMap =
+ new Int2ObjectLinkedOpenHashMap<>();
+ ConstantPool constantPool = new ConstantPool();
+
+ int constantPoolHashMapSize = 1 << AndroidApiDataAccess.entrySizeInBitsForConstantPoolMap();
+ int apiHashMapSize = 1 << AndroidApiDataAccess.entrySizeInBitsForApiLevelMap();
+
+ for (Entry<ApiDatabaseEntry, AndroidApiLevel> entry : databaseEntries.entrySet()) {
+ int newCode = AndroidApiDataAccess.apiLevelHash(entry.getKey());
+ if (newCode < 0 || newCode > apiHashMapSize) {
+ throw new GenerationException("Hash code out of bounds: " + newCode);
+ }
+ generationMap
+ .computeIfAbsent(newCode, ignoreKey(ArrayList::new))
+ .add(Pair.create(entry.getKey(), entry.getValue()));
+ }
+
+ Set<String> uniqueHashes = new HashSet<>();
+ Int2ObjectMap<Pair<Integer, Integer>> offsetMap = new Int2ObjectLinkedOpenHashMap<>();
+ ByteArrayOutputStream payload = new ByteArrayOutputStream();
+
+ // Serialize api map into payload. This will also generate the entire needed constant pool.
+ for (Int2ObjectMap.Entry<List<Pair<ApiDatabaseEntry, AndroidApiLevel>>> entry :
+ generationMap.int2ObjectEntrySet()) {
+ int startingOffset = payload.size();
+ int length = serializeIntoPayload(entry.getValue(), payload, constantPool, uniqueHashes);
+ offsetMap.put(entry.getIntKey(), Pair.create(startingOffset, length));
+ }
+
+ // Write constant pool size <u4:size>.
+ outputStream.writeInt(constantPool.size());
+
+ // Write constant pool consisting of <u4:payload_offset><u2:length>.
+ if (outputStream.size() != AndroidApiDataAccess.constantPoolOffset()) {
+ throw new GenerationException(
+ "Unexpected constant pool offset: expected "
+ + AndroidApiDataAccess.constantPoolOffset()
+ + ", got "
+ + outputStream.size());
+ }
+ IntBox lastReadIndex = new IntBox(-1);
+ constantPool.forEach(
+ (entry, id) -> {
+ if (id <= lastReadIndex.getAndIncrement()) {
+ throw new IOException("Constant pool ID out of order");
+ }
+ outputStream.writeInt(payload.size());
+ outputStream.writeShort(entry.getLength());
+ entry.writeTo(payload);
+ });
+
+ // Serialize hash lookup table for constant pool.
+ Map<Integer, List<Integer>> constantPoolLookupTable = new HashMap<>();
+ constantPool.forEach(
+ (entry, id) -> {
+ int constantPoolHash = constantPoolHash(entry);
+ assert constantPoolHash >= 0 && constantPoolHash <= constantPoolHashMapSize;
+ constantPoolLookupTable
+ .computeIfAbsent(constantPoolHash, ignoreKey(ArrayList::new))
+ .add(id);
+ });
+
+ int[] constantPoolEntries = new int[constantPoolHashMapSize];
+ int[] constantPoolEntryLengths = new int[constantPoolHashMapSize];
+ for (Entry<Integer, List<Integer>> entry : constantPoolLookupTable.entrySet()) {
+ // Tag if we have a unique value.
+ if (entry.getValue().size() == 1) {
+ int id = entry.getValue().get(0);
+ constantPoolEntries[entry.getKey()] = setUniqueConstantPoolEntry(id);
+ } else {
+ constantPoolEntries[entry.getKey()] = payload.size();
+ ByteArrayOutputStream temp = new ByteArrayOutputStream();
+ for (Integer id : entry.getValue()) {
+ temp.write(intToShortEncodedByteArray(id));
+ }
+ payload.write(temp.toByteArray());
+ constantPoolEntryLengths[entry.getKey()] = temp.size();
+ }
+ }
+ // Write constant pool lookup entries consisting of <u4:payload_offset><u2:length>.
+ if (outputStream.size()
+ != AndroidApiDataAccess.constantPoolHashMapOffset(constantPool.size())) {
+ throw new GenerationException("Unexpected constant pool hash map offset");
+ }
+ for (int i = 0; i < constantPoolEntries.length; i++) {
+ outputStream.writeInt(constantPoolEntries[i]);
+ outputStream.writeShort(constantPoolEntryLengths[i]);
+ }
+
+ int[] apiOffsets = new int[apiHashMapSize];
+ int[] apiOffsetLengths = new int[apiHashMapSize];
+ for (Int2ObjectMap.Entry<Pair<Integer, Integer>> hashIndexAndOffset :
+ offsetMap.int2ObjectEntrySet()) {
+ if (apiOffsets[hashIndexAndOffset.getIntKey()] != 0) {
+ throw new GenerationException(
+ "Hash collision in API map at index " + hashIndexAndOffset.getIntKey());
+ }
+ Pair<Integer, Integer> value = hashIndexAndOffset.getValue();
+ int offset = value.getFirst();
+ int length = value.getSecond();
+ apiOffsets[hashIndexAndOffset.getKey()] = offset;
+ apiOffsetLengths[hashIndexAndOffset.getKey()] = length;
+ }
+
+ // Write api lookup entries consisting of <u4:payload_offset><u2:length>.
+ if (outputStream.size() != AndroidApiDataAccess.apiLevelHashMapOffset(constantPool.size())) {
+ throw new GenerationException("Unexpected api level hash map offset");
+ }
+ for (int i = 0; i < apiOffsets.length; i++) {
+ outputStream.writeInt(apiOffsets[i]);
+ outputStream.writeShort(apiOffsetLengths[i]);
+ }
+
+ // Write the payload.
+ outputStream.write(payload.toByteArray());
+ }
+
+ /** This will serialize a collection of DexReferences and apis into a byte stream. */
+ private static int serializeIntoPayload(
+ List<Pair<ApiDatabaseEntry, AndroidApiLevel>> pairs,
+ ByteArrayOutputStream payload,
+ ConstantPool constantPool,
+ Set<String> seen)
+ throws GenerationException, IOException {
+ ByteArrayOutputStream temp = new ByteArrayOutputStream();
+ for (Pair<ApiDatabaseEntry, AndroidApiLevel> pair : pairs) {
+ byte[] uniqueDescriptorForReference =
+ pair.getFirst().getUniqueDescriptor(constantPool::getOrAdd);
+ if (uniqueDescriptorForReference == ApiDatabaseEntry.getNonExistingDescriptor()) {
+ throw new GenerationException("Reference descriptor does not exist: " + pair.getFirst());
+ }
+ if (!seen.add(Arrays.toString(uniqueDescriptorForReference))) {
+ throw new GenerationException(
+ "Duplicate reference descriptor in payload: " + pair.getFirst());
+ }
+ temp.write(intToShortEncodedByteArray(uniqueDescriptorForReference.length));
+ temp.write(uniqueDescriptorForReference);
+ if (pair.getSecond() == AndroidApiLevel.MAIN
+ || pair.getSecond() == AndroidApiLevel.EXTENSION) {
+ throw new GenerationException("Invalid API level for database entry: " + pair.getSecond());
+ }
+ temp.write(pair.getSecond().serializeAsByte());
+ }
+ byte[] tempArray = temp.toByteArray();
+ payload.write(tempArray);
+ return tempArray.length;
+ }
+
+ public static byte[] intToShortEncodedByteArray(int value) {
+ assert isU2(value);
+ byte[] bytes = new byte[2];
+ bytes[0] = (byte) (value >> 8);
+ bytes[1] = (byte) value;
+ return bytes;
+ }
+
+ private static final String OBJECT_DESCRIPTOR = "Ljava/lang/Object;";
+
+ private static void computeAllReferencesInHierarchy(
+ Map<ClassReference, ParsedApiClass> lookupMap,
+ ClassReference holder,
+ ParsedApiClass apiClass,
+ AndroidApiLevel linkLevel,
+ Map<ApiDatabaseEntry, AndroidApiLevel> databaseEntries)
+ throws GenerationException {
+ if (!apiClass.getClassReference().getDescriptor().equals(OBJECT_DESCRIPTOR)) {
+ apiClass.forEachMethod(
+ (methodReference, apiLevel) -> {
+ MethodReference methodWithNewHolder =
+ Reference.method(
+ holder,
+ methodReference.getMethodName(),
+ methodReference.getFormalTypes(),
+ methodReference.getReturnType());
+ addIfNewOrApiLevelIsLower(
+ linkLevel, databaseEntries, apiLevel, ApiDatabaseEntry.of(methodWithNewHolder));
+ });
+ apiClass.forEachField(
+ (fieldReference, apiLevel) -> {
+ FieldTypelessReference fieldWithNewHolder =
+ new FieldTypelessReference(holder, fieldReference.getFieldName());
+ addIfNewOrApiLevelIsLower(
+ linkLevel, databaseEntries, apiLevel, ApiDatabaseEntry.of(fieldWithNewHolder));
+ });
+
+ apiClass.forEachSupertypeThrowing(
+ (superType, apiLevel) -> {
+ ParsedApiClass superApiClass = lookupMap.get(superType);
+ if (superApiClass == null) {
+ if (!superType.getDescriptor().equals(OBJECT_DESCRIPTOR)) {
+ throw new GenerationException(
+ "Supertype "
+ + superType.getTypeName()
+ + " of "
+ + apiClass.getClassReference().getTypeName()
+ + " is missing from the parsed API classes.");
+ }
+ } else {
+ computeAllReferencesInHierarchy(
+ lookupMap, holder, superApiClass, linkLevel.max(apiLevel), databaseEntries);
+ }
+ });
+
+ apiClass.forEachInterfaceThrowing(
+ (interfaceReference, apiLevel) -> {
+ ParsedApiClass interfaceApiClass = lookupMap.get(interfaceReference);
+ if (interfaceApiClass == null) {
+ throw new GenerationException(
+ "Interface "
+ + interfaceReference.getTypeName()
+ + " implemented by "
+ + apiClass.getClassReference().getTypeName()
+ + " is missing from the parsed API classes.");
+ }
+ computeAllReferencesInHierarchy(
+ lookupMap, holder, interfaceApiClass, linkLevel.max(apiLevel), databaseEntries);
+ });
+ }
+ }
+
+ private static void addIfNewOrApiLevelIsLower(
+ AndroidApiLevel linkLevel,
+ Map<ApiDatabaseEntry, AndroidApiLevel> additionMap,
+ AndroidApiLevel apiLevel,
+ ApiDatabaseEntry member) {
+ AndroidApiLevel currentApiLevel = apiLevel.max(linkLevel);
+ AndroidApiLevel existingApiLevel = additionMap.get(member);
+ if (existingApiLevel == null || currentApiLevel.isLessThanOrEqualTo(existingApiLevel)) {
+ additionMap.put(member, currentApiLevel);
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/apimodel/ParsedApiClass.java b/src/main/java/com/android/tools/r8/apimodel/ParsedApiClass.java
index 14ba584..2a32fda 100644
--- a/src/main/java/com/android/tools/r8/apimodel/ParsedApiClass.java
+++ b/src/main/java/com/android/tools/r8/apimodel/ParsedApiClass.java
@@ -7,6 +7,7 @@
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.MethodReference;
import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.internal.ThrowingBiConsumer;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.function.BiConsumer;
@@ -47,6 +48,14 @@
supertypes.forEach(consumer);
}
+ /** Visited in insertion order. */
+ public <E extends Throwable> void forEachSupertypeThrowing(
+ ThrowingBiConsumer<ClassReference, AndroidApiLevel, E> consumer) throws E {
+ for (Map.Entry<ClassReference, AndroidApiLevel> entry : supertypes.entrySet()) {
+ consumer.accept(entry.getKey(), entry.getValue());
+ }
+ }
+
public void registerInterface(ClassReference reference, AndroidApiLevel introApiLevel) {
assert !interfaces.containsKey(reference) : reference + " is already registered";
interfaces.put(reference, introApiLevel);
@@ -61,6 +70,14 @@
interfaces.forEach(consumer);
}
+ /** Visited in insertion order. */
+ public <E extends Throwable> void forEachInterfaceThrowing(
+ ThrowingBiConsumer<ClassReference, AndroidApiLevel, E> consumer) throws E {
+ for (Map.Entry<ClassReference, AndroidApiLevel> entry : interfaces.entrySet()) {
+ consumer.accept(entry.getKey(), entry.getValue());
+ }
+ }
+
public void registerMethod(MethodReference reference, AndroidApiLevel introApiLevel) {
assert !methods.containsKey(reference) : reference + " is already registered";
methods.put(reference, introApiLevel);
diff --git a/src/test/java/com/android/tools/r8/apimodel/AndroidApiHashingDatabaseBuilderGenerator.java b/src/test/java/com/android/tools/r8/apimodel/AndroidApiHashingDatabaseBuilderGenerator.java
deleted file mode 100644
index 55b096b..0000000
--- a/src/test/java/com/android/tools/r8/apimodel/AndroidApiHashingDatabaseBuilderGenerator.java
+++ /dev/null
@@ -1,464 +0,0 @@
-// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.apimodel;
-
-import static com.android.tools.r8.androidapi.AndroidApiDataAccess.constantPoolHash;
-import static com.android.tools.r8.lightir.ByteUtils.isU2;
-import static com.android.tools.r8.lightir.ByteUtils.setBitAtIndex;
-import static com.android.tools.r8.utils.internal.MapUtils.ignoreKey;
-import static org.junit.Assert.assertEquals;
-
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.androidapi.AndroidApiDataAccess;
-import com.android.tools.r8.androidapi.ApiDatabaseEntry;
-import com.android.tools.r8.androidapi.ApiDatabaseEntry.ConstantPoolEntry;
-import com.android.tools.r8.androidapi.GenerateCovariantReturnTypeMethodsTest.CovariantMethodsInJarResult;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexLibraryClass;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.utils.AndroidApiLevel;
-import com.android.tools.r8.utils.AndroidApp;
-import com.android.tools.r8.utils.internal.IntBox;
-import com.android.tools.r8.utils.internal.ThrowingBiConsumer;
-import com.android.tools.r8.utils.internal.collections.Pair;
-import com.android.tools.r8.utils.internal.exceptions.Unreachable;
-import com.android.tools.r8.utils.timing.Timing;
-import java.io.ByteArrayOutputStream;
-import java.io.DataOutputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.IdentityHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-public class AndroidApiHashingDatabaseBuilderGenerator extends TestBase {
-
- /**
- * Generate the information needed for looking up api level of references in the android.jar. This
- * method will generate one single database file where the format is as follows (uX is X number of
- * unsigned bytes):
- *
- * <pre>
- * constant_pool_size: u4
- * constant_pool: [constant_pool_size * payload_entry]
- * constant_pool_map: [0..max_hash(ConstantPoolEntry) * payload_entry]
- * api_map: [0..max_hash(ApiDatabaseEntry) * payload_entry]
- * payload raw data.
- *
- * payload_entry: u4:relative_offset_from_payload_start_or_tagged_value + u2:length
- * </pre>
- *
- * For hash_definitions and entries see {@code AndroidApiDataAccess}.
- */
- public static void generate(
- List<ParsedApiClass> apiClasses, Path pathToApiLevels, AndroidApiLevel androidJarApiLevel)
- throws Exception {
- Map<ClassReference, Map<DexMethod, AndroidApiLevel>> methodMap = new HashMap<>();
- Map<ClassReference, Map<FieldTypelessReference, AndroidApiLevel>> fieldMap = new HashMap<>();
- Map<ClassReference, ParsedApiClass> lookupMap = new HashMap<>();
-
- Map<ApiDatabaseEntry, AndroidApiLevel> databaseEntries = new HashMap<>();
-
- Path androidJar = ToolHelper.getAndroidJar(androidJarApiLevel);
- AndroidApp androidApp =
- AndroidApp.builder()
- .addLibraryFile(androidJar)
- .disableAndroidJarHiddenClassExtension()
- .build();
- AppView<AppInfoWithClassHierarchy> appView =
- computeAppViewWithClassHierarchy(androidApp, Timing.empty());
- DexItemFactory factory = appView.dexItemFactory();
-
- CovariantMethodsInJarResult covariantMethodsInJar = CovariantMethodsInJarResult.create();
-
- for (ParsedApiClass apiClass : apiClasses) {
- Map<DexMethod, AndroidApiLevel> methodsForApiClass = new HashMap<>();
- apiClass.forEachMethod(
- (method, apiLevel) -> methodsForApiClass.put(factory.createMethod(method), apiLevel));
- covariantMethodsInJar.visitCovariantMethodsForHolder(
- apiClass.getClassReference(),
- methodReferenceWithApiLevel -> {
- DexMethod method =
- factory.createMethod(methodReferenceWithApiLevel.getMethodReference());
- if (!methodsForApiClass.containsKey(method)) {
- apiClass.registerMethod(
- methodReferenceWithApiLevel.getMethodReference(),
- methodReferenceWithApiLevel.getApiLevel());
- methodsForApiClass.put(method, methodReferenceWithApiLevel.getApiLevel());
- }
- });
- Map<FieldTypelessReference, AndroidApiLevel> fieldsForApiClass = new HashMap<>();
- apiClass.forEachField(fieldsForApiClass::put);
- methodMap.put(apiClass.getClassReference(), methodsForApiClass);
- fieldMap.put(apiClass.getClassReference(), fieldsForApiClass);
- lookupMap.put(apiClass.getClassReference(), apiClass);
-
- databaseEntries.put(
- ApiDatabaseEntry.of(factory.createType(apiClass.getClassReference().getDescriptor())),
- apiClass.getApiLevel());
- }
-
- for (ParsedApiClass apiClass : apiClasses) {
- computeAllReferencesInHierarchy(
- lookupMap,
- factory,
- factory.createType(apiClass.getClassReference().getDescriptor()),
- apiClass,
- AndroidApiLevel.B,
- databaseEntries);
- }
-
- assert ensureAllPublicMethodsAreMapped(
- appView, lookupMap, methodMap, fieldMap, databaseEntries, androidJarApiLevel, androidJar);
-
- try (FileOutputStream fileOutputStream = new FileOutputStream(pathToApiLevels.toFile())) {
- DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);
- generateDatabase(databaseEntries, dataOutputStream);
- }
- }
-
- private static boolean ensureAllPublicMethodsAreMapped(
- AppView<AppInfoWithClassHierarchy> appView,
- Map<ClassReference, ParsedApiClass> lookupMap,
- Map<ClassReference, Map<DexMethod, AndroidApiLevel>> methodMap,
- Map<ClassReference, Map<FieldTypelessReference, AndroidApiLevel>> fieldMap,
- Map<ApiDatabaseEntry, AndroidApiLevel> databaseEntries,
- AndroidApiLevel apiLevel,
- Path androidJar) {
- Map<DexType, String> missingMemberInformation = new IdentityHashMap<>();
- DexItemFactory factory = appView.dexItemFactory();
- for (DexLibraryClass clazz : appView.app().asDirect().libraryClasses()) {
- ParsedApiClass parsedApiClass = lookupMap.get(clazz.getClassReference());
- if (parsedApiClass == null) {
- if (clazz.isPublic()) {
- missingMemberInformation.put(clazz.getType(), "Could not be found in " + androidJar);
- }
- continue;
- }
- StringBuilder classBuilder = new StringBuilder();
- Map<FieldTypelessReference, AndroidApiLevel> fieldMapForClass =
- fieldMap.get(clazz.getClassReference());
- assert fieldMapForClass != null;
- clazz.forEachClassField(
- field -> {
- if (field.getAccessFlags().isPublic()
- && databaseEntries.get(ApiDatabaseEntry.of(field.getReference())) == null
- && !field.toSourceString().contains("this$0")) {
- classBuilder.append(" ").append(field).append(" is missing\n");
- }
- });
- Map<DexMethod, AndroidApiLevel> methodMapForClass = methodMap.get(clazz.getClassReference());
- assert methodMapForClass != null;
- clazz.forEachClassMethod(
- method -> {
- if (method.getAccessFlags().isPublic()
- && databaseEntries.get(ApiDatabaseEntry.of(method.getReference())) == null
- && !factory.objectMembers.isObjectMember(method.getReference())) {
- classBuilder.append(" ").append(method).append(" is missing\n");
- }
- });
- if (classBuilder.length() > 0) {
- missingMemberInformation.put(clazz.getType(), classBuilder.toString());
- }
- }
-
- Set<DexType> expectedMissingMembers = new HashSet<>();
- // api-versions.xml do not encode all members of StringBuffers and StringBuilders, check that we
- // only have missing definitions for those two classes.
- expectedMissingMembers.add(factory.stringBufferType);
- expectedMissingMembers.add(factory.stringBuilderType);
- // TODO(b/231126636): api-versions.xml has missing definitions for the below classes.
- expectedMissingMembers.add(
- factory.createType("Ljava/util/concurrent/ConcurrentHashMap$KeySetView;"));
- expectedMissingMembers.add(factory.createType("Ljava/time/chrono/ThaiBuddhistDate;"));
- expectedMissingMembers.add(factory.createType("Ljava/time/chrono/HijrahDate;"));
- expectedMissingMembers.add(factory.createType("Ljava/time/chrono/JapaneseDate;"));
- expectedMissingMembers.add(factory.createType("Ljava/time/chrono/MinguoDate;"));
- expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/NfcV;"));
- expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/IsoDep;"));
- expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/MifareUltralight;"));
- expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/MifareClassic;"));
- expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/NdefFormatable;"));
- expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/NfcA;"));
- expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/NfcBarcode;"));
- expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/NfcF;"));
- expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/NfcB;"));
- expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/Ndef;"));
- expectedMissingMembers.add(factory.createType("Landroid/webkit/CookieSyncManager;"));
- if (apiLevel.isLessThan(AndroidApiLevel.BAKLAVA_1)) {
- expectedMissingMembers.add(
- factory.createType("Landroid/adservices/adselection/AdSelectionOutcome;"));
- expectedMissingMembers.add(
- factory.createType("Landroid/adservices/adselection/ReportEventRequest;"));
- expectedMissingMembers.add(
- factory.createType(
- "Landroid/adservices/ondevicepersonalization/FederatedComputeScheduleRequest;"));
- expectedMissingMembers.add(
- factory.createType(
- "Landroid/adservices/ondevicepersonalization/FederatedComputeScheduleResponse;"));
- expectedMissingMembers.add(
- factory.createType(
- "Landroid/adservices/ondevicepersonalization/FederatedComputeScheduler;"));
- expectedMissingMembers.add(
- factory.createType("Landroid/adservices/ondevicepersonalization/InferenceInput;"));
- expectedMissingMembers.add(
- factory.createType(
- "Landroid/adservices/ondevicepersonalization/InferenceInput$Builder;"));
- expectedMissingMembers.add(
- factory.createType("Landroid/adservices/ondevicepersonalization/InferenceInput$Params;"));
- expectedMissingMembers.add(
- factory.createType("Landroid/adservices/ondevicepersonalization/InferenceOutput;"));
- expectedMissingMembers.add(
- factory.createType(
- "Landroid/adservices/ondevicepersonalization/InferenceOutput$Builder;"));
- expectedMissingMembers.add(
- factory.createType(
- "Landroid/adservices/ondevicepersonalization/OnDevicePersonalizationManager;"));
- }
- assertEquals(
- expectedMissingMembers.stream()
- .map(DexType::toDescriptorString)
- .sorted()
- .collect(Collectors.joining("\n"))
- + "\n---\n"
- + missingMemberInformation.keySet().stream()
- .map(DexType::toDescriptorString)
- .sorted()
- .collect(Collectors.joining("\n")),
- expectedMissingMembers,
- missingMemberInformation.keySet());
- return true;
- }
-
- private static class ConstantPool {
-
- private final IntBox intBox = new IntBox(0);
- private final Map<ConstantPoolEntry, Integer> pool = new java.util.LinkedHashMap<>();
-
- public int getOrAdd(ConstantPoolEntry entry) {
- return pool.computeIfAbsent(entry, ignored -> intBox.getAndIncrement());
- }
-
- public void forEach(ThrowingBiConsumer<ConstantPoolEntry, Integer, IOException> consumer)
- throws IOException {
- for (Entry<ConstantPoolEntry, Integer> entry : pool.entrySet()) {
- consumer.accept(entry.getKey(), entry.getValue());
- }
- }
-
- public int size() {
- return pool.size();
- }
- }
-
- private static int setUniqueConstantPoolEntry(int id) {
- return setBitAtIndex(id, 32);
- }
-
- public static void generateDatabase(
- Map<ApiDatabaseEntry, AndroidApiLevel> databaseEntries, DataOutputStream outputStream)
- throws Exception {
- Map<Integer, List<Pair<ApiDatabaseEntry, AndroidApiLevel>>> generationMap = new HashMap<>();
- ConstantPool constantPool = new ConstantPool();
-
- int constantPoolHashMapSize = 1 << AndroidApiDataAccess.entrySizeInBitsForConstantPoolMap();
- int apiHashMapSize = 1 << AndroidApiDataAccess.entrySizeInBitsForApiLevelMap();
-
- for (Entry<ApiDatabaseEntry, AndroidApiLevel> entry : databaseEntries.entrySet()) {
- int newCode = AndroidApiDataAccess.apiLevelHash(entry.getKey());
- assert newCode >= 0 && newCode <= apiHashMapSize;
- generationMap
- .computeIfAbsent(newCode, ignoreKey(ArrayList::new))
- .add(Pair.create(entry.getKey(), entry.getValue()));
- }
-
- Set<String> uniqueHashes = new HashSet<>();
- Map<Integer, Pair<Integer, Integer>> offsetMap = new HashMap<>();
- ByteArrayOutputStream payload = new ByteArrayOutputStream();
-
- // Serialize api map into payload. This will also generate the entire needed constant pool.
- for (Entry<Integer, List<Pair<ApiDatabaseEntry, AndroidApiLevel>>> entry :
- generationMap.entrySet()) {
- int startingOffset = payload.size();
- int length = serializeIntoPayload(entry.getValue(), payload, constantPool, uniqueHashes);
- offsetMap.put(entry.getKey(), Pair.create(startingOffset, length));
- }
-
- // Write constant pool size <u4:size>.
- outputStream.writeInt(constantPool.size());
-
- // Write constant pool consisting of <u4:payload_offset><u2:length>.
- assertEquals(AndroidApiDataAccess.constantPoolOffset(), outputStream.size());
- IntBox lastReadIndex = new IntBox(-1);
- constantPool.forEach(
- (entry, id) -> {
- assert id > lastReadIndex.getAndIncrement();
- outputStream.writeInt(payload.size());
- outputStream.writeShort(entry.getLength());
- entry.writeTo(payload);
- });
-
- // Serialize hash lookup table for constant pool.
- Map<Integer, List<Integer>> constantPoolLookupTable = new HashMap<>();
- constantPool.forEach(
- (entry, id) -> {
- int constantPoolHash = constantPoolHash(entry);
- assert constantPoolHash >= 0 && constantPoolHash <= constantPoolHashMapSize;
- constantPoolLookupTable
- .computeIfAbsent(constantPoolHash, ignoreKey(ArrayList::new))
- .add(id);
- });
-
- int[] constantPoolEntries = new int[constantPoolHashMapSize];
- int[] constantPoolEntryLengths = new int[constantPoolHashMapSize];
- for (Entry<Integer, List<Integer>> entry : constantPoolLookupTable.entrySet()) {
- // Tag if we have a unique value
- if (entry.getValue().size() == 1) {
- int id = entry.getValue().get(0);
- constantPoolEntries[entry.getKey()] = setUniqueConstantPoolEntry(id);
- } else {
- constantPoolEntries[entry.getKey()] = payload.size();
- ByteArrayOutputStream temp = new ByteArrayOutputStream();
- for (Integer id : entry.getValue()) {
- temp.write(intToShortEncodedByteArray(id));
- }
- payload.write(temp.toByteArray());
- constantPoolEntryLengths[entry.getKey()] = temp.size();
- }
- }
- // Write constant pool lookup entries consisting of <u4:payload_offset><u2:length>
- assertEquals(
- AndroidApiDataAccess.constantPoolHashMapOffset(constantPool.size()), outputStream.size());
- for (int i = 0; i < constantPoolEntries.length; i++) {
- outputStream.writeInt(constantPoolEntries[i]);
- outputStream.writeShort(constantPoolEntryLengths[i]);
- }
-
- int[] apiOffsets = new int[apiHashMapSize];
- int[] apiOffsetLengths = new int[apiHashMapSize];
- for (Entry<Integer, Pair<Integer, Integer>> hashIndexAndOffset : offsetMap.entrySet()) {
- assert apiOffsets[hashIndexAndOffset.getKey()] == 0;
- Pair<Integer, Integer> value = hashIndexAndOffset.getValue();
- int offset = value.getFirst();
- int length = value.getSecond();
- apiOffsets[hashIndexAndOffset.getKey()] = offset;
- apiOffsetLengths[hashIndexAndOffset.getKey()] = length;
- }
-
- // Write api lookup entries consisting of <u4:payload_offset><u2:length>
- assertEquals(
- AndroidApiDataAccess.apiLevelHashMapOffset(constantPool.size()), outputStream.size());
- for (int i = 0; i < apiOffsets.length; i++) {
- outputStream.writeInt(apiOffsets[i]);
- outputStream.writeShort(apiOffsetLengths[i]);
- }
-
- // Write the payload.
- outputStream.write(payload.toByteArray());
- }
-
- /** This will serialize a collection of DexReferences and apis into a byte stream. */
- private static int serializeIntoPayload(
- List<Pair<ApiDatabaseEntry, AndroidApiLevel>> pairs,
- ByteArrayOutputStream payload,
- ConstantPool constantPool,
- Set<String> seen)
- throws IOException {
- ByteArrayOutputStream temp = new ByteArrayOutputStream();
- for (Pair<ApiDatabaseEntry, AndroidApiLevel> pair : pairs) {
- byte[] uniqueDescriptorForReference =
- pair.getFirst().getUniqueDescriptor(constantPool::getOrAdd);
- assert uniqueDescriptorForReference != ApiDatabaseEntry.getNonExistingDescriptor();
- if (!seen.add(Arrays.toString(uniqueDescriptorForReference))) {
- throw new Unreachable("Hash is not unique");
- }
- temp.write(intToShortEncodedByteArray(uniqueDescriptorForReference.length));
- temp.write(uniqueDescriptorForReference);
- assert pair.getSecond() != AndroidApiLevel.MAIN
- && pair.getSecond() != AndroidApiLevel.EXTENSION;
- temp.write(pair.getSecond().serializeAsByte());
- }
- byte[] tempArray = temp.toByteArray();
- payload.write(tempArray);
- return tempArray.length;
- }
-
- public static byte[] intToShortEncodedByteArray(int value) {
- assert isU2(value);
- byte[] bytes = new byte[2];
- bytes[0] = (byte) (value >> 8);
- bytes[1] = (byte) value;
- return bytes;
- }
-
- private static void computeAllReferencesInHierarchy(
- Map<ClassReference, ParsedApiClass> lookupMap,
- DexItemFactory factory,
- DexType holder,
- ParsedApiClass apiClass,
- AndroidApiLevel linkLevel,
- Map<ApiDatabaseEntry, AndroidApiLevel> databaseEntries) {
- if (!apiClass.getClassReference().getDescriptor().equals(factory.objectDescriptor.toString())) {
- apiClass.forEachMethod(
- (methodReference, apiLevel) ->
- addIfNewOrApiLevelIsLower(
- linkLevel,
- databaseEntries,
- apiLevel,
- ApiDatabaseEntry.of(
- factory.createMethod(methodReference).withHolder(holder, factory))));
- apiClass.forEachField(
- (fieldReference, apiLevel) ->
- addIfNewOrApiLevelIsLower(
- linkLevel,
- databaseEntries,
- apiLevel,
- ApiDatabaseEntry.of(fieldReference).withHolder(holder)));
- apiClass.forEachSupertype(
- (superType, apiLevel) ->
- computeAllReferencesInHierarchy(
- lookupMap,
- factory,
- holder,
- lookupMap.get(superType),
- linkLevel.max(apiLevel),
- databaseEntries));
- apiClass.forEachInterface(
- (interfaceReference, apiLevel) ->
- computeAllReferencesInHierarchy(
- lookupMap,
- factory,
- holder,
- lookupMap.get(interfaceReference),
- linkLevel.max(apiLevel),
- databaseEntries));
- }
- }
-
- private static void addIfNewOrApiLevelIsLower(
- AndroidApiLevel linkLevel,
- Map<ApiDatabaseEntry, AndroidApiLevel> additionMap,
- AndroidApiLevel apiLevel,
- ApiDatabaseEntry member) {
- AndroidApiLevel currentApiLevel = apiLevel.max(linkLevel);
- AndroidApiLevel existingApiLevel = additionMap.get(member);
- if (existingApiLevel == null || currentApiLevel.isLessThanOrEqualTo(existingApiLevel)) {
- additionMap.put(member, currentApiLevel);
- }
- }
-}
diff --git a/src/test/java/com/android/tools/r8/apimodel/AndroidApiHashingDatabaseBuilderGeneratorTest.java b/src/test/java/com/android/tools/r8/apimodel/AndroidApiHashingDatabaseBuilderGeneratorTest.java
index ce2c65f..b7b5dc8 100644
--- a/src/test/java/com/android/tools/r8/apimodel/AndroidApiHashingDatabaseBuilderGeneratorTest.java
+++ b/src/test/java/com/android/tools/r8/apimodel/AndroidApiHashingDatabaseBuilderGeneratorTest.java
@@ -22,7 +22,9 @@
import com.android.tools.r8.androidapi.AndroidApiLevelCompute;
import com.android.tools.r8.androidapi.AndroidApiLevelCompute.DefaultAndroidApiLevelCompute;
import com.android.tools.r8.androidapi.AndroidApiLevelHashingDatabaseImpl;
+import com.android.tools.r8.androidapi.ApiDatabaseEntry;
import com.android.tools.r8.androidapi.ComputedApiLevel;
+import com.android.tools.r8.androidapi.GenerateCovariantReturnTypeMethodsTest.CovariantMethodsInJarResult;
import com.android.tools.r8.androidapi.SunMiscUnsafeApiTest;
import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
@@ -55,6 +57,7 @@
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
+import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
@@ -113,10 +116,166 @@
TemporaryFolder temp = new TemporaryFolder();
temp.create();
Path apiLevels = temp.newFile("new_api_levels.ser").toPath();
- AndroidApiHashingDatabaseBuilderGenerator.generate(apiClasses, apiLevels, androidJarApiLevel);
+ DexItemFactory factory = new DexItemFactory();
+ mergeCovariantMethods(apiClasses, factory);
+
+ Map<ApiDatabaseEntry, AndroidApiLevel> databaseEntries =
+ AndroidApiHashingDatabaseBuilderGenerator.generateEntries(apiClasses);
+
+ Path androidJar = ToolHelper.getAndroidJar(androidJarApiLevel);
+ AndroidApp androidApp =
+ AndroidApp.builder()
+ .addLibraryFile(androidJar)
+ .disableAndroidJarHiddenClassExtension()
+ .build();
+ AppView<AppInfoWithClassHierarchy> appView =
+ computeAppViewWithClassHierarchy(androidApp, Timing.empty());
+
+ ensureAllPublicMethodsAreMapped(
+ appView, apiClasses, databaseEntries, androidJarApiLevel, androidJar);
+
+ AndroidApiHashingDatabaseBuilderGenerator.writeEntries(databaseEntries, apiLevels);
+
return new GenerateDatabaseResourceFilesResult(apiLevels);
}
+ private static void ensureAllPublicMethodsAreMapped(
+ AppView<AppInfoWithClassHierarchy> appView,
+ List<ParsedApiClass> apiClasses,
+ Map<ApiDatabaseEntry, AndroidApiLevel> databaseEntries,
+ AndroidApiLevel apiLevel,
+ Path androidJar) {
+ Map<ClassReference, ParsedApiClass> lookupMap = new HashMap<>();
+ Map<ClassReference, Map<DexMethod, AndroidApiLevel>> methodMap = new HashMap<>();
+ Map<ClassReference, Map<FieldTypelessReference, AndroidApiLevel>> fieldMap = new HashMap<>();
+ DexItemFactory factory = appView.dexItemFactory();
+
+ for (ParsedApiClass apiClass : apiClasses) {
+ lookupMap.put(apiClass.getClassReference(), apiClass);
+ Map<DexMethod, AndroidApiLevel> methodsForApiClass = new HashMap<>();
+ apiClass.forEachMethod(
+ (method, lvl) -> methodsForApiClass.put(factory.createMethod(method), lvl));
+ methodMap.put(apiClass.getClassReference(), methodsForApiClass);
+
+ Map<FieldTypelessReference, AndroidApiLevel> fieldsForApiClass = new HashMap<>();
+ apiClass.forEachField(fieldsForApiClass::put);
+ fieldMap.put(apiClass.getClassReference(), fieldsForApiClass);
+ }
+
+ Map<DexType, String> missingMemberInformation = new IdentityHashMap<>();
+ for (DexLibraryClass clazz : appView.app().asDirect().libraryClasses()) {
+ ParsedApiClass parsedApiClass = lookupMap.get(clazz.getClassReference());
+ if (parsedApiClass == null) {
+ if (clazz.isPublic()) {
+ missingMemberInformation.put(clazz.getType(), "Could not be found in " + androidJar);
+ }
+ continue;
+ }
+ StringBuilder classBuilder = new StringBuilder();
+ Map<FieldTypelessReference, AndroidApiLevel> fieldMapForClass =
+ fieldMap.get(clazz.getClassReference());
+ assert fieldMapForClass != null;
+ clazz.forEachClassField(
+ field -> {
+ if (field.getAccessFlags().isPublic()
+ && databaseEntries.get(ApiDatabaseEntry.of(field.getReference())) == null
+ && !field.toSourceString().contains("this$0")) {
+ classBuilder.append(" ").append(field).append(" is missing\n");
+ }
+ });
+ Map<DexMethod, AndroidApiLevel> methodMapForClass = methodMap.get(clazz.getClassReference());
+ assert methodMapForClass != null;
+ clazz.forEachClassMethod(
+ method -> {
+ if (method.getAccessFlags().isPublic()
+ && databaseEntries.get(ApiDatabaseEntry.of(method.getReference())) == null
+ && !factory.objectMembers.isObjectMember(method.getReference())) {
+ classBuilder.append(" ").append(method).append(" is missing\n");
+ }
+ });
+ if (classBuilder.length() > 0) {
+ missingMemberInformation.put(clazz.getType(), classBuilder.toString());
+ }
+ }
+
+ Set<DexType> expectedMissingMembers = new HashSet<>();
+ // api-versions.xml do not encode all members of StringBuffers and StringBuilders, check that we
+ // only have missing definitions for those two classes.
+ expectedMissingMembers.add(factory.stringBufferType);
+ expectedMissingMembers.add(factory.stringBuilderType);
+ // TODO(b/231126636): api-versions.xml has missing definitions for the below classes.
+ expectedMissingMembers.add(
+ factory.createType("Ljava/util/concurrent/ConcurrentHashMap$KeySetView;"));
+ expectedMissingMembers.add(factory.createType("Ljava/time/chrono/ThaiBuddhistDate;"));
+ expectedMissingMembers.add(factory.createType("Ljava/time/chrono/HijrahDate;"));
+ expectedMissingMembers.add(factory.createType("Ljava/time/chrono/JapaneseDate;"));
+ expectedMissingMembers.add(factory.createType("Ljava/time/chrono/MinguoDate;"));
+ expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/NfcV;"));
+ expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/IsoDep;"));
+ expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/MifareUltralight;"));
+ expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/MifareClassic;"));
+ expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/NdefFormatable;"));
+ expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/NfcA;"));
+ expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/NfcBarcode;"));
+ expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/NfcF;"));
+ expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/NfcB;"));
+ expectedMissingMembers.add(factory.createType("Landroid/nfc/tech/Ndef;"));
+ expectedMissingMembers.add(factory.createType("Landroid/webkit/CookieSyncManager;"));
+ if (apiLevel.isLessThan(AndroidApiLevel.BAKLAVA_1)) {
+ expectedMissingMembers.add(
+ factory.createType("Landroid/adservices/adselection/AdSelectionOutcome;"));
+ expectedMissingMembers.add(
+ factory.createType("Landroid/adservices/adselection/ReportEventRequest;"));
+ expectedMissingMembers.add(
+ factory.createType(
+ "Landroid/adservices/ondevicepersonalization/FederatedComputeScheduleRequest;"));
+ expectedMissingMembers.add(
+ factory.createType(
+ "Landroid/adservices/ondevicepersonalization/FederatedComputeScheduleResponse;"));
+ expectedMissingMembers.add(
+ factory.createType(
+ "Landroid/adservices/ondevicepersonalization/FederatedComputeScheduler;"));
+ expectedMissingMembers.add(
+ factory.createType("Landroid/adservices/ondevicepersonalization/InferenceInput;"));
+ expectedMissingMembers.add(
+ factory.createType(
+ "Landroid/adservices/ondevicepersonalization/InferenceInput$Builder;"));
+ expectedMissingMembers.add(
+ factory.createType("Landroid/adservices/ondevicepersonalization/InferenceInput$Params;"));
+ expectedMissingMembers.add(
+ factory.createType("Landroid/adservices/ondevicepersonalization/InferenceOutput;"));
+ expectedMissingMembers.add(
+ factory.createType(
+ "Landroid/adservices/ondevicepersonalization/InferenceOutput$Builder;"));
+ expectedMissingMembers.add(
+ factory.createType(
+ "Landroid/adservices/ondevicepersonalization/OnDevicePersonalizationManager;"));
+ }
+ assertThat(missingMemberInformation.keySet(), matchesItemsOneToOne(expectedMissingMembers));
+ }
+
+ private static void mergeCovariantMethods(List<ParsedApiClass> apiClasses, DexItemFactory factory)
+ throws Exception {
+ CovariantMethodsInJarResult covariantMethodsInJar = CovariantMethodsInJarResult.create();
+ for (ParsedApiClass apiClass : apiClasses) {
+ Map<DexMethod, AndroidApiLevel> methodsForApiClass = new HashMap<>();
+ apiClass.forEachMethod(
+ (method, apiLevel) -> methodsForApiClass.put(factory.createMethod(method), apiLevel));
+ covariantMethodsInJar.visitCovariantMethodsForHolder(
+ apiClass.getClassReference(),
+ methodReferenceWithApiLevel -> {
+ DexMethod method =
+ factory.createMethod(methodReferenceWithApiLevel.getMethodReference());
+ if (!methodsForApiClass.containsKey(method)) {
+ apiClass.registerMethod(
+ methodReferenceWithApiLevel.getMethodReference(),
+ methodReferenceWithApiLevel.getApiLevel());
+ methodsForApiClass.put(method, methodReferenceWithApiLevel.getApiLevel());
+ }
+ });
+ }
+ }
+
@Test
public void testCanParseApiVersionsXml() throws Exception {
// This tests makes a rudimentary check on the number of classes, fields and methods in
diff --git a/third_party/api_database/api_database.tar.gz.sha1 b/third_party/api_database/api_database.tar.gz.sha1
index f5a7dcf..839dea4 100644
--- a/third_party/api_database/api_database.tar.gz.sha1
+++ b/third_party/api_database/api_database.tar.gz.sha1
@@ -1 +1 @@
-83f980bfe52868bf67129526ea1c626ba5f37fec
\ No newline at end of file
+ebc62b3efc8ffa79035399941c1c3d8bf995b5ec
\ No newline at end of file
