| // Copyright (c) 2016, 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.graph; |
| |
| import com.android.tools.r8.androidapi.AndroidApiLevelCompute; |
| import com.android.tools.r8.androidapi.ComputedApiLevel; |
| import com.android.tools.r8.dex.IndexedItemCollection; |
| import com.android.tools.r8.dex.MixedSectionCollection; |
| import com.android.tools.r8.graph.DexValue.DexValueAnnotation; |
| import com.android.tools.r8.graph.DexValue.DexValueArray; |
| import com.android.tools.r8.graph.DexValue.DexValueByte; |
| import com.android.tools.r8.graph.DexValue.DexValueInt; |
| import com.android.tools.r8.graph.DexValue.DexValueMethod; |
| import com.android.tools.r8.graph.DexValue.DexValueNull; |
| import com.android.tools.r8.graph.DexValue.DexValueString; |
| import com.android.tools.r8.graph.DexValue.DexValueType; |
| import com.android.tools.r8.graph.GenericSignature.FieldTypeSignature; |
| import com.android.tools.r8.ir.desugar.CovariantReturnTypeAnnotationTransformer; |
| import com.android.tools.r8.origin.Origin; |
| import com.android.tools.r8.synthesis.SyntheticItems; |
| import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind; |
| import com.android.tools.r8.utils.AndroidApiLevel; |
| import com.android.tools.r8.utils.InternalOptions; |
| import com.android.tools.r8.utils.Pair; |
| import com.android.tools.r8.utils.structural.StructuralItem; |
| import com.android.tools.r8.utils.structural.StructuralMapping; |
| import com.android.tools.r8.utils.structural.StructuralSpecification; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.function.Function; |
| |
| public class DexAnnotation extends DexItem implements StructuralItem<DexAnnotation> { |
| |
| public enum AnnotatedKind { |
| FIELD, |
| METHOD, |
| TYPE, |
| PARAMETER; |
| |
| public static AnnotatedKind from(DexDefinition definition) { |
| return from(definition.getReference()); |
| } |
| |
| public static AnnotatedKind from(ProgramDefinition definition) { |
| return from(definition.getReference()); |
| } |
| |
| public static AnnotatedKind from(DexReference reference) { |
| return reference.apply(type -> TYPE, field -> FIELD, method -> METHOD); |
| } |
| |
| public boolean isParameter() { |
| return this == PARAMETER; |
| } |
| } |
| |
| public static final DexAnnotation[] EMPTY_ARRAY = {}; |
| public static final int VISIBILITY_BUILD = 0x00; |
| public static final int VISIBILITY_RUNTIME = 0x01; |
| public static final int VISIBILITY_SYSTEM = 0x02; |
| public final int visibility; |
| public final DexEncodedAnnotation annotation; |
| |
| private static final int UNKNOWN_API_LEVEL = -1; |
| private static final int NOT_SET_API_LEVEL = -2; |
| |
| protected static void specify(StructuralSpecification<DexAnnotation, ?> spec) { |
| spec.withItem(a -> a.annotation).withInt(a -> a.visibility); |
| } |
| |
| public DexAnnotation(int visibility, DexEncodedAnnotation annotation) { |
| this.visibility = visibility; |
| this.annotation = annotation; |
| } |
| |
| public boolean isTypeAnnotation() { |
| return false; |
| } |
| |
| public DexTypeAnnotation asTypeAnnotation() { |
| return null; |
| } |
| |
| @Override |
| public DexAnnotation self() { |
| return this; |
| } |
| |
| @Override |
| public StructuralMapping<DexAnnotation> getStructuralMapping() { |
| return DexAnnotation::specify; |
| } |
| |
| public DexType getAnnotationType() { |
| return annotation.type; |
| } |
| |
| @Override |
| public int hashCode() { |
| return visibility + annotation.hashCode() * 3; |
| } |
| |
| @Override |
| public boolean equals(Object other) { |
| if (this == other) { |
| return true; |
| } |
| if (other instanceof DexAnnotation) { |
| DexAnnotation o = (DexAnnotation) other; |
| return (visibility == o.visibility) && annotation.equals(o.annotation); |
| } |
| return false; |
| } |
| |
| @Override |
| public String toString() { |
| return visibility + " " + annotation; |
| } |
| |
| public int getVisibility() { |
| return visibility; |
| } |
| |
| public void collectIndexedItems(AppView<?> appView, IndexedItemCollection indexedItems) { |
| annotation.collectIndexedItems(appView, indexedItems); |
| } |
| |
| @Override |
| protected void collectMixedSectionItems(MixedSectionCollection mixedItems) { |
| mixedItems.add(this); |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static boolean retainCompileTimeAnnotation(DexType annotation, InternalOptions options) { |
| if (options.retainCompileTimeAnnotations) { |
| return true; |
| } |
| if (annotation == options.itemFactory.annotationSynthesizedClass |
| || annotation |
| .getDescriptor() |
| .startsWith(options.itemFactory.dalvikAnnotationOptimizationPrefix)) { |
| return true; |
| } |
| if (options.processCovariantReturnTypeAnnotations) { |
| // @CovariantReturnType annotations are processed by CovariantReturnTypeAnnotationTransformer, |
| // they thus need to be read here and will then be removed as part of the processing. |
| return CovariantReturnTypeAnnotationTransformer.isCovariantReturnTypeAnnotation( |
| annotation, options.itemFactory); |
| } |
| return false; |
| } |
| |
| public static DexAnnotation createEnclosingClassAnnotation(DexType enclosingClass, |
| DexItemFactory factory) { |
| return createSystemValueAnnotation(factory.annotationEnclosingClass, factory, |
| new DexValueType(enclosingClass)); |
| } |
| |
| public static DexType getEnclosingClassFromAnnotation( |
| DexAnnotation annotation, DexItemFactory factory) { |
| DexValue value = getSystemValueAnnotationValue(factory.annotationEnclosingClass, annotation); |
| if (value == null) { |
| return null; |
| } |
| return value.asDexValueType().value; |
| } |
| |
| public static DexAnnotation createEnclosingMethodAnnotation(DexMethod enclosingMethod, |
| DexItemFactory factory) { |
| return createSystemValueAnnotation(factory.annotationEnclosingMethod, factory, |
| new DexValueMethod(enclosingMethod)); |
| } |
| |
| public static DexMethod getEnclosingMethodFromAnnotation( |
| DexAnnotation annotation, DexItemFactory factory) { |
| DexValue value = getSystemValueAnnotationValue(factory.annotationEnclosingMethod, annotation); |
| if (value == null) { |
| return null; |
| } |
| return value.asDexValueMethod().value; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static boolean isEnclosingClassAnnotation( |
| DexAnnotation annotation, DexItemFactory factory) { |
| return annotation.annotation.type == factory.annotationEnclosingClass; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static boolean isEnclosingMethodAnnotation( |
| DexAnnotation annotation, DexItemFactory factory) { |
| return annotation.annotation.type == factory.annotationEnclosingMethod; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static boolean isInnerClassAnnotation(DexAnnotation annotation, DexItemFactory factory) { |
| return annotation.annotation.type == factory.annotationInnerClass; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static boolean isMemberClassesAnnotation( |
| DexAnnotation annotation, DexItemFactory factory) { |
| return annotation.annotation.type == factory.annotationMemberClasses; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static boolean isNestHostAnnotation(DexAnnotation annotation, DexItemFactory factory) { |
| return annotation.annotation.type == factory.annotationNestHost; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static boolean isNestMembersAnnotation(DexAnnotation annotation, DexItemFactory factory) { |
| return annotation.annotation.type == factory.annotationNestMembers; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static boolean isPermittedSubclassesAnnotation( |
| DexAnnotation annotation, DexItemFactory factory) { |
| return annotation.annotation.type == factory.annotationPermittedSubclasses; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static boolean isRecordAnnotation(DexAnnotation annotation, DexItemFactory factory) { |
| return annotation.getAnnotationType() == factory.annotationRecord; |
| } |
| |
| public static DexAnnotation createInnerClassAnnotation( |
| DexString clazz, int access, DexItemFactory factory) { |
| return new DexAnnotation( |
| VISIBILITY_SYSTEM, |
| new DexEncodedAnnotation( |
| factory.annotationInnerClass, |
| new DexAnnotationElement[] { |
| new DexAnnotationElement( |
| factory.createString("accessFlags"), DexValueInt.create(access)), |
| new DexAnnotationElement( |
| factory.createString("name"), |
| (clazz == null) ? DexValueNull.NULL : new DexValueString(clazz)) |
| })); |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static Pair<DexString, Integer> getInnerClassFromAnnotation( |
| DexAnnotation annotation, DexItemFactory factory) { |
| assert isInnerClassAnnotation(annotation, factory); |
| DexAnnotationElement[] elements = annotation.annotation.elements; |
| Pair<DexString, Integer> result = new Pair<>(); |
| for (DexAnnotationElement element : elements) { |
| if (element.name == factory.createString("name")) { |
| if (element.value.isDexValueString()) { |
| result.setFirst(element.value.asDexValueString().getValue()); |
| } |
| } else { |
| assert element.name == factory.createString("accessFlags"); |
| result.setSecond(element.value.asDexValueInt().getValue()); |
| } |
| } |
| return result; |
| } |
| |
| public static DexAnnotation createMemberClassesAnnotation(List<DexType> classes, |
| DexItemFactory factory) { |
| DexValue[] values = new DexValue[classes.size()]; |
| for (int i = 0; i < classes.size(); i++) { |
| values[i] = new DexValueType(classes.get(i)); |
| } |
| return createSystemValueAnnotation(factory.annotationMemberClasses, factory, |
| new DexValueArray(values)); |
| } |
| |
| public static List<DexType> getMemberClassesFromAnnotation( |
| DexAnnotation annotation, DexItemFactory factory) { |
| DexValue value = getSystemValueAnnotationValue(factory.annotationMemberClasses, annotation); |
| if (value == null) { |
| return null; |
| } |
| DexValueArray membersArray = value.asDexValueArray(); |
| List<DexType> types = new ArrayList<>(membersArray.getValues().length); |
| for (DexValue elementValue : membersArray.getValues()) { |
| types.add(elementValue.asDexValueType().value); |
| } |
| return types; |
| } |
| |
| public static DexType getNestHostFromAnnotation( |
| DexAnnotation annotation, DexItemFactory factory) { |
| DexValue value = getSystemValueAnnotationValue(factory.annotationNestHost, annotation); |
| if (value == null) { |
| return null; |
| } |
| return value.asDexValueType().getValue(); |
| } |
| |
| private static List<DexType> getTypesFromAnnotation( |
| DexType annotationType, DexAnnotation annotation) { |
| DexValue value = getSystemValueAnnotationValue(annotationType, annotation); |
| if (value == null) { |
| return null; |
| } |
| DexValueArray membersArray = value.asDexValueArray(); |
| List<DexType> types = new ArrayList<>(membersArray.getValues().length); |
| for (DexValue elementValue : membersArray.getValues()) { |
| types.add(elementValue.asDexValueType().value); |
| } |
| return types; |
| } |
| |
| public static List<DexType> getNestMembersFromAnnotation( |
| DexAnnotation annotation, DexItemFactory factory) { |
| return getTypesFromAnnotation(factory.annotationNestMembers, annotation); |
| } |
| |
| public static List<DexType> getPermittedSubclassesFromAnnotation( |
| DexAnnotation annotation, DexItemFactory factory) { |
| return getTypesFromAnnotation(factory.annotationPermittedSubclasses, annotation); |
| } |
| |
| /** See {@link #createRecordAnnotation(DexProgramClass, AppView)} for the representation. */ |
| public static List<RecordComponentInfo> getRecordComponentInfoFromAnnotation( |
| DexType type, DexAnnotation annotation, DexItemFactory factory, Origin origin) { |
| DexValue componentNamesValue = |
| getSystemValueAnnotationValueWithName( |
| factory.annotationRecord, annotation, factory.annotationRecordComponentNames); |
| DexValue componentTypesValue = |
| getSystemValueAnnotationValueWithName( |
| factory.annotationRecord, annotation, factory.annotationRecordComponentTypes); |
| DexValue componentSignaturesValue = |
| getSystemValueAnnotationValueWithName( |
| factory.annotationRecord, annotation, factory.annotationRecordComponentSignatures); |
| DexValue componentAnnotationVisibilitiesValue = |
| getSystemValueAnnotationValueWithName( |
| factory.annotationRecord, |
| annotation, |
| factory.annotationRecordComponentAnnotationVisibilities); |
| DexValue componentAnnotationsValue = |
| getSystemValueAnnotationValueWithName( |
| factory.annotationRecord, annotation, factory.annotationRecordComponentAnnotations); |
| |
| if (componentNamesValue == null |
| || componentTypesValue == null |
| || componentSignaturesValue == null |
| || componentAnnotationVisibilitiesValue == null |
| || componentAnnotationsValue == null) { |
| return null; |
| } |
| if (!componentNamesValue.isDexValueArray() |
| || !componentTypesValue.isDexValueArray() |
| || !componentSignaturesValue.isDexValueArray() |
| || !componentAnnotationVisibilitiesValue.isDexValueArray() |
| || !componentAnnotationsValue.isDexValueArray()) { |
| return null; |
| } |
| DexValueArray componentNamesValueArray = componentNamesValue.asDexValueArray(); |
| DexValueArray componentTypesValueArray = componentTypesValue.asDexValueArray(); |
| DexValueArray componentSignaturesValueArray = componentSignaturesValue.asDexValueArray(); |
| DexValueArray componentAnnotationVisibilitiesValueArray = |
| componentAnnotationVisibilitiesValue.asDexValueArray(); |
| DexValueArray componentAnnotationsValueArray = componentAnnotationsValue.asDexValueArray(); |
| if (componentNamesValueArray.size() != componentTypesValueArray.size() |
| || componentNamesValueArray.size() != componentSignaturesValueArray.size() |
| || componentNamesValueArray.size() != componentAnnotationVisibilitiesValueArray.size() |
| || componentNamesValueArray.size() != componentAnnotationsValueArray.size()) { |
| return null; |
| } |
| List<RecordComponentInfo> result = new ArrayList<>(componentNamesValueArray.size()); |
| for (int componentIndex = 0; |
| componentIndex < componentNamesValueArray.size(); |
| componentIndex++) { |
| DexValue nameValue = componentNamesValueArray.getValue(componentIndex); |
| DexValue typeValue = componentTypesValueArray.getValue(componentIndex); |
| DexValue signatureValue = componentSignaturesValueArray.getValue(componentIndex); |
| DexValue visibilitiesValue = |
| componentAnnotationVisibilitiesValueArray.getValue(componentIndex); |
| DexValue annotationsValue = componentAnnotationsValueArray.getValue(componentIndex); |
| if (!nameValue.isDexValueString() |
| || !typeValue.isDexValueType() |
| || !(signatureValue.isDexValueAnnotation() || signatureValue.isDexValueNull()) |
| || !visibilitiesValue.isDexValueArray() |
| || !annotationsValue.isDexValueArray()) { |
| return null; |
| } |
| DexValueArray visibilitiesValueArray = visibilitiesValue.asDexValueArray(); |
| DexValueArray annotationsValueArray = annotationsValue.asDexValueArray(); |
| if (visibilitiesValueArray.size() != annotationsValueArray.size()) { |
| return null; |
| } |
| List<DexAnnotation> componentAnnotations = Collections.emptyList(); |
| if (annotationsValueArray.size() > 0) { |
| componentAnnotations = new ArrayList<>(annotationsValueArray.size()); |
| for (int annotationIndex = 0; |
| annotationIndex < annotationsValueArray.size(); |
| annotationIndex++) { |
| DexValue visibilityValue = visibilitiesValueArray.getValue(annotationIndex); |
| DexValue annotationValue = annotationsValueArray.getValue(annotationIndex); |
| if (!visibilityValue.isDexValueByte() || !annotationValue.isDexValueAnnotation()) { |
| return null; |
| } |
| componentAnnotations.add( |
| new DexAnnotation( |
| visibilityValue.asDexValueByte().getValue(), |
| annotationValue.asDexValueAnnotation().getValue())); |
| } |
| } |
| FieldTypeSignature componentSignature = |
| GenericSignature.parseFieldTypeSignature( |
| nameValue.asDexValueString().getValue().toString(), |
| signatureValue.isDexValueAnnotation() |
| ? getSignature(signatureValue.asDexValueAnnotation().getValue()) |
| : null, |
| origin, |
| factory, |
| null); |
| |
| DexType componentType = typeValue.asDexValueType().getValue(); |
| DexString componentName = nameValue.asDexValueString().getValue(); |
| DexField componentField = factory.createField(type, componentType, componentName); |
| result.add(new RecordComponentInfo(componentField, componentSignature, componentAnnotations)); |
| } |
| return result; |
| } |
| |
| public static DexAnnotation createSourceDebugExtensionAnnotation(DexValue value, |
| DexItemFactory factory) { |
| return new DexAnnotation(VISIBILITY_SYSTEM, |
| new DexEncodedAnnotation(factory.annotationSourceDebugExtension, |
| new DexAnnotationElement[] { |
| new DexAnnotationElement(factory.createString("value"), value) |
| })); |
| } |
| |
| public static DexAnnotation createMethodParametersAnnotation(DexValue[] names, |
| DexValue[] accessFlags, DexItemFactory factory) { |
| assert names.length == accessFlags.length; |
| return new DexAnnotation(VISIBILITY_SYSTEM, |
| new DexEncodedAnnotation(factory.annotationMethodParameters, |
| new DexAnnotationElement[]{ |
| new DexAnnotationElement( |
| factory.createString("names"), |
| new DexValueArray(names)), |
| new DexAnnotationElement( |
| factory.createString("accessFlags"), |
| new DexValueArray(accessFlags)) |
| })); |
| } |
| |
| public static DexAnnotation createAnnotationDefaultAnnotation(DexType type, |
| List<DexAnnotationElement> defaults, DexItemFactory factory) { |
| return createSystemValueAnnotation(factory.annotationDefault, factory, |
| new DexValueAnnotation( |
| new DexEncodedAnnotation(type, |
| defaults.toArray(DexAnnotationElement.EMPTY_ARRAY))) |
| ); |
| } |
| |
| public static DexAnnotation createSignatureAnnotation(String signature, DexItemFactory factory) { |
| return createSystemValueAnnotation(factory.annotationSignature, factory, |
| compressSignature(signature, factory)); |
| } |
| |
| public static DexAnnotation createNestHostAnnotation( |
| NestHostClassAttribute host, DexItemFactory factory) { |
| return createSystemValueAnnotation( |
| factory.annotationNestHost, factory, new DexValue.DexValueType(host.getNestHost())); |
| } |
| |
| public static DexAnnotation createNestMembersAnnotation( |
| List<NestMemberClassAttribute> members, DexItemFactory factory) { |
| List<DexValueType> list = new ArrayList<>(members.size()); |
| for (NestMemberClassAttribute member : members) { |
| list.add(new DexValue.DexValueType(member.getNestMember())); |
| } |
| return createSystemValueAnnotation( |
| factory.annotationNestMembers, |
| factory, |
| new DexValue.DexValueArray(list.toArray(DexValue.EMPTY_ARRAY))); |
| } |
| |
| public static DexAnnotation createPermittedSubclassesAnnotation( |
| List<PermittedSubclassAttribute> permittedSubclasses, DexItemFactory factory) { |
| List<DexValueType> list = new ArrayList<>(permittedSubclasses.size()); |
| for (PermittedSubclassAttribute permittedSubclass : permittedSubclasses) { |
| list.add(new DexValue.DexValueType(permittedSubclass.getPermittedSubclass())); |
| } |
| return createSystemValueAnnotation( |
| factory.annotationPermittedSubclasses, |
| factory, |
| new DexValue.DexValueArray(list.toArray(DexValue.EMPTY_ARRAY))); |
| } |
| |
| /** |
| * Record component information is written to DEX as a system annotation named <code> |
| * dalvik.annotation.Record</code> with the following content: |
| * |
| * <pre> |
| * componentAnnotationVisibilities byte[][] |
| * componentAnnotations Annotation[][] |
| * componentNames String[] |
| * componentSignatures Annotation[] // Annotation dalvik.annotation.Signature or NULL |
| * componentTypes String[] |
| * </pre> |
| * |
| * Each of the arrays have one element for each component. |
| * |
| * <p>Example of a two component record with two annotations on the first component and one on the |
| * second and with a signature on the first component. |
| * |
| * <pre> |
| * .annotation system Ldalvik/annotation/Record; |
| * componentAnnotationVisibilities = { |
| * { |
| * 0x1, |
| * 0x1 |
| * }, |
| * { |
| * 0x1 |
| * } |
| * } |
| * componentAnnotations = { |
| * { |
| * .subannotation LAnnotation1; |
| * value = "a" |
| * .end subannotation, |
| * .subannotation LAnnotation2; |
| * value = "c" |
| * .end subannotation |
| * }, |
| * { |
| * .subannotation LAnnotation3; |
| * value = "z" |
| * .end subannotation |
| * } |
| * } |
| * componentNames = { |
| * "name", |
| * "age" |
| * } |
| * componentSignatures = { |
| * .subannotation Ldalvik/annotation/Signature; |
| * value = { |
| * "TX;" |
| * } |
| * .end subannotation, |
| * NULL |
| * } |
| * componentTypes = { |
| * Ljava/lang/CharSequence;, |
| * Ljava/lang/Object; |
| * } |
| * .end annotation |
| * </pre> |
| */ |
| public static DexAnnotation createRecordAnnotation(DexProgramClass clazz, AppView<?> appView) { |
| DexItemFactory factory = appView.dexItemFactory(); |
| int componentCount = clazz.getRecordComponents().size(); |
| DexValueString[] componentNames = new DexValueString[componentCount]; |
| DexValueType[] componentTypes = new DexValueType[componentCount]; |
| DexValue[] componentSignatures = new DexValue[componentCount]; |
| DexValueArray[] componentAnnotationVisibilities = new DexValueArray[componentCount]; |
| DexValueArray[] componentAnnotations = new DexValueArray[componentCount]; |
| for (int componentIndex = 0; componentIndex < componentCount; componentIndex++) { |
| RecordComponentInfo info = clazz.getRecordComponents().get(componentIndex); |
| componentNames[componentIndex] = |
| new DexValueString(appView.getNamingLens().lookupName(info.getField())); |
| componentTypes[componentIndex] = new DexValueType(info.getType()); |
| if (info.getSignature().hasNoSignature()) { |
| componentSignatures[componentIndex] = DexValueNull.NULL; |
| } else { |
| componentSignatures[componentIndex] = |
| new DexValueAnnotation( |
| createSignatureAnnotation(info.getSignature().toString(), factory).annotation); |
| } |
| int annotationsSize = info.getAnnotations().size(); |
| DexValueByte[] visibilities = new DexValueByte[annotationsSize]; |
| DexValueAnnotation[] annotations = new DexValueAnnotation[annotationsSize]; |
| componentAnnotationVisibilities[componentIndex] = new DexValueArray(visibilities); |
| componentAnnotations[componentIndex] = new DexValueArray(annotations); |
| for (int annotationIndex = 0; annotationIndex < annotationsSize; annotationIndex++) { |
| DexAnnotation annotation = info.getAnnotations().get(annotationIndex); |
| visibilities[annotationIndex] = DexValueByte.create((byte) annotation.getVisibility()); |
| annotations[annotationIndex] = new DexValueAnnotation(annotation.annotation); |
| } |
| } |
| |
| return new DexAnnotation( |
| VISIBILITY_SYSTEM, |
| new DexEncodedAnnotation( |
| factory.annotationRecord, |
| new DexAnnotationElement[] { |
| new DexAnnotationElement( |
| factory.annotationRecordComponentNames, new DexValueArray(componentNames)), |
| new DexAnnotationElement( |
| factory.annotationRecordComponentTypes, new DexValueArray(componentTypes)), |
| new DexAnnotationElement( |
| factory.annotationRecordComponentSignatures, |
| new DexValueArray(componentSignatures)), |
| new DexAnnotationElement( |
| factory.annotationRecordComponentAnnotationVisibilities, |
| new DexValueArray(componentAnnotationVisibilities)), |
| new DexAnnotationElement( |
| factory.annotationRecordComponentAnnotations, |
| new DexValueArray(componentAnnotations)) |
| })); |
| } |
| |
| public static String getSignature(DexAnnotation signatureAnnotation) { |
| return getSignature(signatureAnnotation.annotation); |
| } |
| |
| public static String getSignature(DexEncodedAnnotation signatureAnnotation) { |
| return getSignature(signatureAnnotation.elements[0].value.asDexValueArray()); |
| } |
| |
| public static String getSignature(DexValueArray elements) { |
| StringBuilder signature = new StringBuilder(); |
| for (DexValue element : elements.getValues()) { |
| signature.append(element.asDexValueString().value.toString()); |
| } |
| return signature.toString(); |
| } |
| |
| public static String getSignature(DexAnnotationSet signatureAnnotations, DexItemFactory factory) { |
| DexAnnotation signature = signatureAnnotations.getFirstMatching(factory.annotationSignature); |
| return signature == null ? null : getSignature(signature); |
| } |
| |
| public static DexAnnotation createThrowsAnnotation(DexValue[] exceptions, |
| DexItemFactory factory) { |
| return createSystemValueAnnotation(factory.annotationThrows, factory, |
| new DexValueArray(exceptions)); |
| } |
| |
| private static DexAnnotation createSystemValueAnnotation(DexType type, DexItemFactory factory, |
| DexValue value) { |
| return new DexAnnotation(VISIBILITY_SYSTEM, |
| new DexEncodedAnnotation(type, new DexAnnotationElement[]{ |
| new DexAnnotationElement(factory.createString("value"), value) |
| })); |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| private static DexValue getSystemValueAnnotationValue(DexType type, DexAnnotation annotation) { |
| assert annotation.visibility == VISIBILITY_SYSTEM; |
| assert annotation.annotation.type == type; |
| return annotation.annotation.elements.length == 0 |
| ? null |
| : annotation.annotation.elements[0].value; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| private static DexValue getSystemValueAnnotationValueWithName( |
| DexType type, DexAnnotation annotation, DexString name) { |
| assert annotation.visibility == VISIBILITY_SYSTEM; |
| assert annotation.getAnnotationType() == type; |
| for (DexAnnotationElement element : annotation.annotation.elements) { |
| if (element.name == name) { |
| return element.value; |
| } |
| } |
| return null; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static boolean isThrowingAnnotation(DexAnnotation annotation, DexItemFactory factory) { |
| return annotation.annotation.type == factory.annotationThrows; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static boolean isSignatureAnnotation(DexAnnotation annotation, DexItemFactory factory) { |
| return annotation.annotation.type == factory.annotationSignature; |
| |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static boolean isAnnotationDefaultAnnotation( |
| DexAnnotation annotation, DexItemFactory factory) { |
| return annotation.annotation.type == factory.annotationDefault; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static boolean isJavaLangRetentionAnnotation( |
| DexAnnotation annotation, DexItemFactory factory) { |
| return annotation.getAnnotationType() == factory.retentionType; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static boolean isSourceDebugExtension(DexAnnotation annotation, DexItemFactory factory) { |
| return annotation.annotation.type == factory.annotationSourceDebugExtension; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static boolean isParameterNameAnnotation( |
| DexAnnotation annotation, DexItemFactory factory) { |
| return annotation.annotation.type == factory.annotationMethodParameters; |
| } |
| |
| /** |
| * As a simple heuristic for compressing a signature by splitting on fully qualified class names |
| * and make them individual part. All other parts of the signature are simply grouped and separate |
| * the names. |
| * For examples, "()Ljava/lang/List<Lfoo/bar/Baz;>;" splits into: |
| * <pre> |
| * ["()", "Ljava/lang/List<", "Lfoo/bar/Baz;", ">;"] |
| * </pre> |
| */ |
| private static DexValue compressSignature(String signature, DexItemFactory factory) { |
| final int length = signature.length(); |
| List<DexValue> parts = new ArrayList<>(); |
| |
| for (int at = 0; at < length; /*at*/) { |
| char c = signature.charAt(at); |
| int endAt = at + 1; |
| if (c == 'L') { |
| // Scan to ';' or '<' and consume them. |
| while (endAt < length) { |
| c = signature.charAt(endAt); |
| if (c == ';' || c == '<') { |
| endAt++; |
| break; |
| } |
| endAt++; |
| } |
| } else { |
| // Scan to 'L' without consuming it. |
| while (endAt < length) { |
| c = signature.charAt(endAt); |
| if (c == 'L') { |
| break; |
| } |
| endAt++; |
| } |
| } |
| |
| parts.add(toDexValue(signature.substring(at, endAt), factory)); |
| at = endAt; |
| } |
| |
| return new DexValueArray(parts.toArray(DexValue.EMPTY_ARRAY)); |
| } |
| |
| private static DexValue toDexValue(String string, DexItemFactory factory) { |
| return new DexValueString(factory.createString(string)); |
| } |
| |
| public static DexAnnotation createAnnotationSynthesizedClass( |
| SyntheticKind kind, DexItemFactory dexItemFactory, ComputedApiLevel computedApiLevel) { |
| DexString versionHash = |
| dexItemFactory.createString(dexItemFactory.getSyntheticNaming().getVersionHash()); |
| DexAnnotationElement kindElement = |
| new DexAnnotationElement(dexItemFactory.kindString, DexValueInt.create(kind.getId())); |
| DexAnnotationElement versionHashElement = |
| new DexAnnotationElement(dexItemFactory.versionHashString, new DexValueString(versionHash)); |
| int apiLevel = getApiLevelForSerialization(computedApiLevel); |
| DexAnnotationElement apiLevelElement = |
| new DexAnnotationElement(dexItemFactory.apiLevelString, DexValueInt.create(apiLevel)); |
| DexAnnotationElement[] elements = |
| new DexAnnotationElement[] {apiLevelElement, kindElement, versionHashElement}; |
| return new DexAnnotation( |
| VISIBILITY_BUILD, |
| new DexEncodedAnnotation(dexItemFactory.annotationSynthesizedClass, elements)); |
| } |
| |
| public static boolean hasSynthesizedClassAnnotation( |
| DexAnnotationSet annotations, |
| DexItemFactory factory, |
| SyntheticItems synthetics, |
| AndroidApiLevelCompute apiLevelCompute) { |
| return getSynthesizedClassAnnotationInfo(annotations, factory, synthetics, apiLevelCompute) |
| != null; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public static SynthesizedAnnotationClassInfo getSynthesizedClassAnnotationInfo( |
| DexAnnotationSet annotations, |
| DexItemFactory factory, |
| SyntheticItems synthetics, |
| AndroidApiLevelCompute apiLevelCompute) { |
| if (annotations.size() != 1) { |
| return null; |
| } |
| DexAnnotation annotation = annotations.annotations[0]; |
| if (annotation.annotation.type != factory.annotationSynthesizedClass) { |
| return null; |
| } |
| int length = annotation.annotation.elements.length; |
| if (length != 3) { |
| return null; |
| } |
| assert factory.kindString.isLessThan(factory.versionHashString); |
| DexAnnotationElement apiLevelElement = annotation.annotation.elements[0]; |
| DexAnnotationElement kindElement = annotation.annotation.elements[1]; |
| DexAnnotationElement versionHashElement = annotation.annotation.elements[2]; |
| if (kindElement.name != factory.kindString) { |
| return null; |
| } |
| if (!kindElement.value.isDexValueInt()) { |
| return null; |
| } |
| if (versionHashElement.name != factory.versionHashString) { |
| return null; |
| } |
| if (!versionHashElement.value.isDexValueString()) { |
| return null; |
| } |
| if (apiLevelElement.name != factory.apiLevelString || !apiLevelElement.value.isDexValueInt()) { |
| return null; |
| } |
| String currentVersionHash = synthetics.getNaming().getVersionHash(); |
| String syntheticVersionHash = versionHashElement.value.asDexValueString().getValue().toString(); |
| if (!currentVersionHash.equals(syntheticVersionHash)) { |
| return null; |
| } |
| int apiLevelValue = apiLevelElement.value.asDexValueInt().getValue(); |
| ComputedApiLevel computedApiLevel = getSerializedApiLevel(apiLevelCompute, apiLevelValue); |
| SyntheticKind syntheticKind = |
| synthetics.getNaming().fromId(kindElement.value.asDexValueInt().getValue()); |
| assert syntheticKind != synthetics.getNaming().API_MODEL_OUTLINE |
| || computedApiLevel.isKnownApiLevel(); |
| return SynthesizedAnnotationClassInfo.create(syntheticKind, computedApiLevel); |
| } |
| |
| private static int getApiLevelForSerialization(ComputedApiLevel computedApiLevel) { |
| if (computedApiLevel.isNotSetApiLevel()) { |
| return NOT_SET_API_LEVEL; |
| } else if (computedApiLevel.isUnknownApiLevel()) { |
| return UNKNOWN_API_LEVEL; |
| } else { |
| assert computedApiLevel.isKnownApiLevel(); |
| return computedApiLevel.asKnownApiLevel().getApiLevel().getLevel(); |
| } |
| } |
| |
| private static ComputedApiLevel getSerializedApiLevel( |
| AndroidApiLevelCompute apiLevelCompute, int apiLevelValue) { |
| if (apiLevelValue == NOT_SET_API_LEVEL) { |
| return ComputedApiLevel.notSet(); |
| } else if (apiLevelValue == UNKNOWN_API_LEVEL) { |
| return ComputedApiLevel.unknown(); |
| } else { |
| return apiLevelCompute.of(AndroidApiLevel.getAndroidApiLevel(apiLevelValue)); |
| } |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public DexAnnotation rewrite(Function<DexEncodedAnnotation, DexEncodedAnnotation> rewriter) { |
| DexEncodedAnnotation rewritten = rewriter.apply(annotation); |
| if (rewritten == annotation) { |
| return this; |
| } |
| if (rewritten == null) { |
| return null; |
| } |
| return new DexAnnotation(visibility, rewritten); |
| } |
| |
| public static class SynthesizedAnnotationClassInfo { |
| |
| private final SyntheticKind syntheticKind; |
| private final ComputedApiLevel computedApiLevel; |
| |
| private SynthesizedAnnotationClassInfo( |
| SyntheticKind syntheticKind, ComputedApiLevel computedApiLevel) { |
| this.syntheticKind = syntheticKind; |
| this.computedApiLevel = computedApiLevel; |
| } |
| |
| private static SynthesizedAnnotationClassInfo create( |
| SyntheticKind syntheticKind, ComputedApiLevel computedApiLevel) { |
| return new SynthesizedAnnotationClassInfo(syntheticKind, computedApiLevel); |
| } |
| |
| public SyntheticKind getSyntheticKind() { |
| return syntheticKind; |
| } |
| |
| public ComputedApiLevel getComputedApiLevel() { |
| return computedApiLevel; |
| } |
| } |
| } |
