| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.tools.metalava.model |
| |
| import com.android.SdkConstants |
| import com.android.SdkConstants.ATTR_VALUE |
| import com.android.SdkConstants.INT_DEF_ANNOTATION |
| import com.android.SdkConstants.LONG_DEF_ANNOTATION |
| import com.android.SdkConstants.STRING_DEF_ANNOTATION |
| import com.android.tools.lint.annotations.Extractor.ANDROID_INT_DEF |
| import com.android.tools.lint.annotations.Extractor.ANDROID_LONG_DEF |
| import com.android.tools.lint.annotations.Extractor.ANDROID_STRING_DEF |
| import com.android.tools.metalava.ANDROIDX_ANNOTATION_PREFIX |
| import com.android.tools.metalava.ANDROIDX_NONNULL |
| import com.android.tools.metalava.ANDROIDX_NULLABLE |
| import com.android.tools.metalava.ANDROID_NONNULL |
| import com.android.tools.metalava.ANDROID_NULLABLE |
| import com.android.tools.metalava.ANDROID_SUPPORT_ANNOTATION_PREFIX |
| import com.android.tools.metalava.Compatibility |
| import com.android.tools.metalava.JAVA_LANG_PREFIX |
| import com.android.tools.metalava.Options |
| import com.android.tools.metalava.RECENTLY_NONNULL |
| import com.android.tools.metalava.RECENTLY_NULLABLE |
| import com.android.tools.metalava.doclava1.ApiPredicate |
| import com.android.tools.metalava.model.psi.PsiBasedCodebase |
| import com.android.tools.metalava.options |
| import java.util.function.Predicate |
| |
| fun isNullableAnnotation(qualifiedName: String): Boolean { |
| return qualifiedName.endsWith("Nullable") |
| } |
| |
| fun isNonNullAnnotation(qualifiedName: String): Boolean { |
| return qualifiedName.endsWith("NonNull") || |
| qualifiedName.endsWith("NotNull") || |
| qualifiedName.endsWith("Nonnull") |
| } |
| |
| interface AnnotationItem { |
| val codebase: Codebase |
| |
| /** Fully qualified name of the annotation */ |
| fun qualifiedName(): String? |
| |
| /** Fully qualified name of the annotation (prior to name mapping) */ |
| fun originalName(): String? |
| |
| /** Generates source code for this annotation (using fully qualified names) */ |
| fun toSource(target: AnnotationTarget = AnnotationTarget.SIGNATURE_FILE): String |
| |
| /** The applicable targets for this annotation */ |
| fun targets(): Set<AnnotationTarget> |
| |
| /** Attributes of the annotation (may be empty) */ |
| fun attributes(): List<AnnotationAttribute> |
| |
| /** True if this annotation represents @Nullable or @NonNull (or some synonymous annotation) */ |
| fun isNullnessAnnotation(): Boolean { |
| return isNullable() || isNonNull() |
| } |
| |
| /** True if this annotation represents @Nullable (or some synonymous annotation) */ |
| fun isNullable(): Boolean { |
| return isNullableAnnotation(qualifiedName() ?: return false) |
| } |
| |
| /** True if this annotation represents @NonNull (or some synonymous annotation) */ |
| fun isNonNull(): Boolean { |
| return isNonNullAnnotation(qualifiedName() ?: return false) |
| } |
| |
| /** True if this annotation represents @IntDef, @LongDef or @StringDef */ |
| fun isTypeDefAnnotation(): Boolean { |
| val name = qualifiedName() ?: return false |
| if (!(name.endsWith("Def"))) { |
| return false |
| } |
| return (INT_DEF_ANNOTATION.isEquals(name) || |
| STRING_DEF_ANNOTATION.isEquals(name) || |
| LONG_DEF_ANNOTATION.isEquals(name) || |
| ANDROID_INT_DEF == name || |
| ANDROID_STRING_DEF == name || |
| ANDROID_LONG_DEF == name) |
| } |
| |
| /** |
| * True if this annotation represents a @ParameterName annotation (or some synonymous annotation). |
| * The parameter name should be the default attribute or "value". |
| */ |
| fun isParameterName(): Boolean { |
| return qualifiedName()?.endsWith(".ParameterName") ?: return false |
| } |
| |
| /** |
| * True if this annotation represents a @DefaultValue annotation (or some synonymous annotation). |
| * The default value should be the default attribute or "value". |
| */ |
| fun isDefaultValue(): Boolean { |
| return qualifiedName()?.endsWith(".DefaultValue") ?: return false |
| } |
| |
| /** Returns the given named attribute if specified */ |
| fun findAttribute(name: String?): AnnotationAttribute? { |
| val actualName = name ?: ATTR_VALUE |
| return attributes().firstOrNull { it.name == actualName } |
| } |
| |
| /** Find the class declaration for the given annotation */ |
| fun resolve(): ClassItem? { |
| return codebase.findClass(qualifiedName() ?: return null) |
| } |
| |
| /** If this annotation has a typedef annotation associated with it, return it */ |
| fun findTypedefAnnotation(): AnnotationItem? { |
| val className = originalName() ?: return null |
| return codebase.findClass(className)?.modifiers?.annotations()?.firstOrNull { it.isTypeDefAnnotation() } |
| } |
| |
| /** Returns the retention of this annotation */ |
| val retention: AnnotationRetention |
| get() { |
| val name = qualifiedName() |
| if (name != null) { |
| val cls = codebase.findClass(name) ?: (codebase as? PsiBasedCodebase)?.findOrCreateClass(name) |
| if (cls != null) { |
| if (cls.isAnnotationType()) { |
| return cls.getRetention() |
| } |
| } |
| } |
| |
| return AnnotationRetention.CLASS |
| } |
| |
| companion object { |
| /** The simple name of an annotation, which is the annotation name (not qualified name) prefixed by @ */ |
| fun simpleName(item: AnnotationItem): String { |
| val qualifiedName = item.qualifiedName() ?: return "" |
| return "@${qualifiedName.substring(qualifiedName.lastIndexOf('.') + 1)}" |
| } |
| |
| /** |
| * Maps an annotation name to the name to be used in signatures/stubs/external annotation files. |
| * Annotations that should not be exported are mapped to null. |
| */ |
| fun mapName( |
| codebase: Codebase, |
| qualifiedName: String?, |
| filter: Predicate<Item>? = null, |
| target: AnnotationTarget = AnnotationTarget.SIGNATURE_FILE |
| ): String? { |
| qualifiedName ?: return null |
| |
| when (qualifiedName) { |
| // Resource annotations |
| "android.support.annotation.AnimRes", |
| "android.annotation.AnimRes" -> return "androidx.annotation.AnimRes" |
| "android.support.annotation.AnimatorRes", |
| "android.annotation.AnimatorRes" -> return "androidx.annotation.AnimatorRes" |
| "android.support.annotation.AnyRes", |
| "android.annotation.AnyRes" -> return "androidx.annotation.AnyRes" |
| "android.support.annotation.ArrayRes", |
| "android.annotation.ArrayRes" -> return "androidx.annotation.ArrayRes" |
| "android.support.annotation.AttrRes", |
| "android.annotation.AttrRes" -> return "androidx.annotation.AttrRes" |
| "android.support.annotation.BoolRes", |
| "android.annotation.BoolRes" -> return "androidx.annotation.BoolRes" |
| "android.support.annotation.ColorRes", |
| "android.annotation.ColorRes" -> return "androidx.annotation.ColorRes" |
| "android.support.annotation.DimenRes", |
| "android.annotation.DimenRes" -> return "androidx.annotation.DimenRes" |
| "android.support.annotation.DrawableRes", |
| "android.annotation.DrawableRes" -> return "androidx.annotation.DrawableRes" |
| "android.support.annotation.FontRes", |
| "android.annotation.FontRes" -> return "androidx.annotation.FontRes" |
| "android.support.annotation.FractionRes", |
| "android.annotation.FractionRes" -> return "androidx.annotation.FractionRes" |
| "android.support.annotation.IdRes", |
| "android.annotation.IdRes" -> return "androidx.annotation.IdRes" |
| "android.support.annotation.IntegerRes", |
| "android.annotation.IntegerRes" -> return "androidx.annotation.IntegerRes" |
| "android.support.annotation.InterpolatorRes", |
| "android.annotation.InterpolatorRes" -> return "androidx.annotation.InterpolatorRes" |
| "android.support.annotation.LayoutRes", |
| "android.annotation.LayoutRes" -> return "androidx.annotation.LayoutRes" |
| "android.support.annotation.MenuRes", |
| "android.annotation.MenuRes" -> return "androidx.annotation.MenuRes" |
| "android.support.annotation.PluralsRes", |
| "android.annotation.PluralsRes" -> return "androidx.annotation.PluralsRes" |
| "android.support.annotation.RawRes", |
| "android.annotation.RawRes" -> return "androidx.annotation.RawRes" |
| "android.support.annotation.StringRes", |
| "android.annotation.StringRes" -> return "androidx.annotation.StringRes" |
| "android.support.annotation.StyleRes", |
| "android.annotation.StyleRes" -> return "androidx.annotation.StyleRes" |
| "android.support.annotation.StyleableRes", |
| "android.annotation.StyleableRes" -> return "androidx.annotation.StyleableRes" |
| "android.support.annotation.TransitionRes", |
| "android.annotation.TransitionRes" -> return "androidx.annotation.TransitionRes" |
| "android.support.annotation.XmlRes", |
| "android.annotation.XmlRes" -> return "androidx.annotation.XmlRes" |
| |
| // Threading |
| "android.support.annotation.AnyThread", |
| "android.annotation.AnyThread" -> return "androidx.annotation.AnyThread" |
| "android.support.annotation.BinderThread", |
| "android.annotation.BinderThread" -> return "androidx.annotation.BinderThread" |
| "android.support.annotation.MainThread", |
| "android.annotation.MainThread" -> return "androidx.annotation.MainThread" |
| "android.support.annotation.UiThread", |
| "android.annotation.UiThread" -> return "androidx.annotation.UiThread" |
| "android.support.annotation.WorkerThread", |
| "android.annotation.WorkerThread" -> return "androidx.annotation.WorkerThread" |
| |
| // Colors |
| "android.support.annotation.ColorInt", |
| "android.annotation.ColorInt" -> return "androidx.annotation.ColorInt" |
| "android.support.annotation.ColorLong", |
| "android.annotation.ColorLong" -> return "androidx.annotation.ColorLong" |
| "android.support.annotation.HalfFloat", |
| "android.annotation.HalfFloat" -> return "androidx.annotation.HalfFloat" |
| |
| // Ranges and sizes |
| "android.support.annotation.FloatRange", |
| "android.annotation.FloatRange" -> return "androidx.annotation.FloatRange" |
| "android.support.annotation.IntRange", |
| "android.annotation.IntRange" -> return "androidx.annotation.IntRange" |
| "android.support.annotation.Size", |
| "android.annotation.Size" -> return "androidx.annotation.Size" |
| "android.support.annotation.Px", |
| "android.annotation.Px" -> return "androidx.annotation.Px" |
| "android.support.annotation.Dimension", |
| "android.annotation.Dimension" -> return "androidx.annotation.Dimension" |
| |
| // Null |
| // We only change recently/newly nullable annotation in stubs |
| RECENTLY_NULLABLE -> return if (target == AnnotationTarget.SDK_STUBS_FILE) qualifiedName else ANDROIDX_NULLABLE |
| RECENTLY_NONNULL -> return if (target == AnnotationTarget.SDK_STUBS_FILE) qualifiedName else ANDROIDX_NONNULL |
| |
| ANDROIDX_NULLABLE, |
| ANDROID_NULLABLE, |
| "android.support.annotation.Nullable", |
| "libcore.util.Nullable", |
| "org.jetbrains.annotations.Nullable" -> return if (target == AnnotationTarget.SDK_STUBS_FILE) ANDROID_NULLABLE else ANDROIDX_NULLABLE |
| |
| ANDROIDX_NONNULL, |
| ANDROID_NONNULL, |
| "android.support.annotation.NonNull", |
| "libcore.util.NonNull", |
| "org.jetbrains.annotations.NotNull" -> return if (target == AnnotationTarget.SDK_STUBS_FILE) ANDROID_NONNULL else ANDROIDX_NONNULL |
| |
| // Typedefs |
| "android.support.annotation.IntDef", |
| "android.annotation.IntDef" -> return "androidx.annotation.IntDef" |
| "android.support.annotation.StringDef", |
| "android.annotation.StringDef" -> return "androidx.annotation.StringDef" |
| "android.support.annotation.LongDef", |
| "android.annotation.LongDef" -> return "androidx.annotation.LongDef" |
| |
| // Misc |
| "android.support.annotation.CallSuper", |
| "android.annotation.CallSuper" -> return "androidx.annotation.CallSuper" |
| "android.support.annotation.CheckResult", |
| "android.annotation.CheckResult" -> return "androidx.annotation.CheckResult" |
| "android.support.annotation.RequiresPermission", |
| "android.annotation.RequiresPermission" -> return "androidx.annotation.RequiresPermission" |
| "android.annotation.RequiresPermission.Read" -> return "androidx.annotation.RequiresPermission.Read" |
| "android.annotation.RequiresPermission.Write" -> return "androidx.annotation.RequiresPermission.Write" |
| |
| // These aren't support annotations, but could/should be: |
| "android.annotation.CurrentTimeMillisLong", |
| "android.annotation.DurationMillisLong", |
| "android.annotation.ElapsedRealtimeLong", |
| "android.annotation.UserIdInt", |
| "android.annotation.BytesLong", |
| |
| // These aren't support annotations |
| "android.annotation.AppIdInt", |
| "android.annotation.SuppressAutoDoc", |
| "android.annotation.SystemApi", |
| "android.annotation.TestApi", |
| "android.annotation.CallbackExecutor", |
| "android.annotation.Condemned", |
| |
| "android.annotation.Widget" -> { |
| // Remove, unless (a) public or (b) specifically included in --showAnnotations |
| return if (options.showAnnotations.contains(qualifiedName)) { |
| qualifiedName |
| } else if (filter != null) { |
| val cls = codebase.findClass(qualifiedName) |
| if (cls != null && filter.test(cls)) { |
| qualifiedName |
| } else { |
| null |
| } |
| } else { |
| qualifiedName |
| } |
| } |
| |
| // Included for analysis, but should not be exported: |
| "android.annotation.BroadcastBehavior", |
| "android.annotation.SdkConstant", |
| "android.annotation.RequiresFeature", |
| "android.annotation.SystemService" -> return qualifiedName |
| |
| // Should not be mapped to a different package name: |
| "android.annotation.TargetApi", |
| "android.annotation.SuppressLint" -> return qualifiedName |
| |
| else -> { |
| // Some new annotations added to the platform: assume they are support annotations? |
| return when { |
| // Special Kotlin annotations recognized by the compiler: map to supported package name |
| qualifiedName.endsWith(".ParameterName") || qualifiedName.endsWith(".DefaultValue") -> |
| "kotlin.annotations.jvm.internal${qualifiedName.substring(qualifiedName.lastIndexOf('.'))}" |
| |
| // Other third party nullness annotations? |
| isNullableAnnotation(qualifiedName) -> ANDROIDX_NULLABLE |
| isNonNullAnnotation(qualifiedName) -> ANDROIDX_NONNULL |
| |
| // Support library annotations are all included, as is the built-in stuff like @Retention |
| qualifiedName.startsWith(ANDROIDX_ANNOTATION_PREFIX) -> return qualifiedName |
| qualifiedName.startsWith(JAVA_LANG_PREFIX) -> return qualifiedName |
| |
| // Unknown Android platform annotations |
| qualifiedName.startsWith("android.annotation.") -> { |
| // Remove, unless specifically included in --showAnnotations |
| return if (options.showAnnotations.contains(qualifiedName)) { |
| qualifiedName |
| } else { |
| null |
| } |
| } |
| |
| qualifiedName.startsWith(ANDROID_SUPPORT_ANNOTATION_PREFIX) -> { |
| return mapName( |
| codebase, |
| ANDROIDX_ANNOTATION_PREFIX + qualifiedName.substring(ANDROID_SUPPORT_ANNOTATION_PREFIX.length), |
| filter, |
| target |
| ) |
| } |
| |
| else -> { |
| // Remove, unless (a) public or (b) specifically included in --showAnnotations |
| return if (options.showAnnotations.contains(qualifiedName)) { |
| qualifiedName |
| } else if (filter != null) { |
| val cls = codebase.findClass(qualifiedName) |
| if (cls != null && filter.test(cls)) { |
| qualifiedName |
| } else { |
| null |
| } |
| } else { |
| qualifiedName |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /** The applicable targets for this annotation */ |
| fun computeTargets(annotation: AnnotationItem, codebase: Codebase): Set<AnnotationTarget> { |
| val qualifiedName = annotation.qualifiedName() ?: return NO_ANNOTATION_TARGETS |
| when (qualifiedName) { |
| |
| // The typedef annotations are special: they should not be in the signature |
| // files, but we want to include them in the external annotations file such that tools |
| // can enforce them. |
| "android.support.annotation.IntDef", |
| "android.annotation.IntDef", |
| "androidx.annotation.IntDef", |
| "android.support.annotation.StringDef", |
| "android.annotation.StringDef", |
| "androidx.annotation.StringDef", |
| "android.support.annotation.LongDef", |
| "android.annotation.LongDef", |
| "androidx.annotation.LongDef" -> return ANNOTATION_EXTERNAL_ONLY |
| |
| // Skip known annotations that we (a) never want in external annotations and (b) we are |
| // specially overwriting anyway in the stubs (and which are (c) not API significant) |
| "java.lang.annotation.Native", |
| "java.lang.SuppressWarnings", |
| "java.lang.Override" -> return NO_ANNOTATION_TARGETS |
| |
| "java.lang.Deprecated", // tracked separately as a pseudo-modifier |
| |
| // Below this when-statement we perform the correct lookup: check API predicate, and check |
| // that retention is class or runtime, but we've hardcoded the answers here |
| // for some common annotations. |
| |
| "android.view.ViewDebug.ExportedProperty", |
| "android.widget.RemoteViews.RemoteView", |
| "android.view.ViewDebug.CapturedViewProperty", |
| |
| "kotlin.annotation.Target", |
| "kotlin.annotation.Retention", |
| "kotlin.annotation.Repeatable", |
| "kotlin.annotation.MustBeDocumented", |
| "kotlin.DslMarker", |
| "kotlin.PublishedApi", |
| "kotlin.ExtensionFunctionType", |
| |
| "java.lang.FunctionalInterface", |
| "java.lang.SafeVarargs", |
| "java.lang.annotation.Documented", |
| "java.lang.annotation.Inherited", |
| "java.lang.annotation.Repeatable", |
| "java.lang.annotation.Retention", |
| "java.lang.annotation.Target" -> return ANNOTATION_IN_ALL_STUBS |
| } |
| |
| // @android.annotation.Nullable and NonNullable specially recognized annotations by the Kotlin |
| // compiler 1.3 and above: they always go in the stubs. |
| if (qualifiedName == ANDROID_NULLABLE || |
| qualifiedName == ANDROID_NONNULL || |
| qualifiedName == ANDROIDX_NULLABLE || |
| qualifiedName == ANDROIDX_NONNULL |
| ) { |
| return ANNOTATION_IN_ALL_STUBS |
| } |
| |
| if (qualifiedName.startsWith("android.annotation.")) { |
| // internal annotations not mapped to androidx: things like @SystemApi. Skip from |
| // stubs, external annotations, signature files, etc. |
| return NO_ANNOTATION_TARGETS |
| } |
| |
| // @RecentlyNullable and @RecentlyNonNull are specially recognized annotations by the Kotlin |
| // compiler: they always go in the stubs. |
| if (qualifiedName == RECENTLY_NULLABLE || |
| qualifiedName == RECENTLY_NONNULL |
| ) { |
| return ANNOTATION_IN_ALL_STUBS |
| } |
| |
| // Determine the retention of the annotation: source retention annotations go |
| // in the external annotations file, class and runtime annotations go in |
| // the stubs files (except for the androidx annotations which are not included |
| // in the SDK and therefore cannot be referenced from it due to apt's unfortunate |
| // habit of loading all annotation classes it encounters.) |
| |
| if (qualifiedName.startsWith("androidx.annotation.")) { |
| if (options.includeSourceRetentionAnnotations) { |
| return ANNOTATION_IN_ALL_STUBS |
| } |
| |
| if (qualifiedName == ANDROIDX_NULLABLE || qualifiedName == ANDROIDX_NONNULL) { |
| // Right now, nullness annotations (other than @RecentlyNullable and @RecentlyNonNull) |
| // have to go in external annotations since they aren't in the class path for |
| // annotation processors. However, we do want them showing up in the documentation using |
| // their real annotation names. |
| return ANNOTATION_IN_DOC_STUBS_AND_EXTERNAL |
| } |
| |
| return ANNOTATION_EXTERNAL |
| } |
| |
| // See if the annotation is pointing to an annotation class that is part of the API; if not, skip it. |
| val cls = codebase.findClass(qualifiedName) ?: return NO_ANNOTATION_TARGETS |
| if (!ApiPredicate().test(cls)) { |
| if (options.typedefMode != Options.TypedefMode.NONE) { |
| if (cls.modifiers.annotations().any { it.isTypeDefAnnotation() }) { |
| return ANNOTATION_SIGNATURE_ONLY |
| } |
| } |
| |
| return NO_ANNOTATION_TARGETS |
| } |
| |
| if (cls.isAnnotationType()) { |
| val retention = cls.getRetention() |
| if (retention == AnnotationRetention.RUNTIME || retention == AnnotationRetention.CLASS) { |
| return ANNOTATION_IN_SDK_STUBS |
| } |
| } |
| |
| return ANNOTATION_EXTERNAL |
| } |
| |
| /** |
| * Given a "full" annotation name, shortens it by removing redundant package names. |
| * This is intended to be used by the [Compatibility.omitCommonPackages] flag |
| * to reduce clutter in signature files. |
| * |
| * For example, this method will convert `@androidx.annotation.Nullable` to just |
| * `@Nullable`, and `@androidx.annotation.IntRange(from=20)` to `IntRange(from=20)`. |
| */ |
| fun shortenAnnotation(source: String): String { |
| return when { |
| source == "@java.lang.Deprecated" -> "@Deprecated" |
| source.startsWith("android.annotation.", 1) -> { |
| "@" + source.substring("@android.annotation.".length) |
| } |
| source.startsWith(ANDROID_SUPPORT_ANNOTATION_PREFIX, 1) -> { |
| "@" + source.substring("@android.support.annotation.".length) |
| } |
| source.startsWith(ANDROIDX_ANNOTATION_PREFIX, 1) -> { |
| "@" + source.substring("@androidx.annotation.".length) |
| } |
| else -> source |
| } |
| } |
| |
| /** |
| * Reverses the [shortenAnnotation] method. Intended for use when reading in signature files |
| * that contain shortened type references. |
| */ |
| fun unshortenAnnotation(source: String): String { |
| return when { |
| source == "@Deprecated" -> "@java.lang.Deprecated" |
| // These 3 annotations are in the android.annotation. package, not android.support.annotation |
| source.startsWith("@SystemService") || |
| source.startsWith("@TargetApi") || |
| source.startsWith("@SuppressLint") -> |
| "@android.annotation." + source.substring(1) |
| else -> { |
| "@androidx.annotation." + source.substring(1) |
| } |
| } |
| } |
| |
| /** |
| * If the given element has an *implicit* nullness, return it. This returns |
| * true for implicitly nullable elements, such as the parameter to the equals |
| * method, false for implicitly non null elements (such as annotation type |
| * members), and null if there is no implicit nullness. |
| */ |
| fun getImplicitNullness(item: Item): Boolean? { |
| var nullable: Boolean? = null |
| |
| // Constant field not initialized to null? |
| if (item is FieldItem && |
| (item.isEnumConstant() || item.modifiers.isFinal() && item.initialValue(false) != null) |
| ) { |
| // Assigned to constant: not nullable |
| nullable = false |
| } |
| |
| // Annotation type members cannot be null |
| if (item is MemberItem && item.containingClass().isAnnotationType()) { |
| nullable = false |
| } |
| |
| // Equals and toString have known nullness |
| if (item is MethodItem && item.name() == "toString" && item.parameters().isEmpty()) { |
| nullable = false |
| } else if (item is ParameterItem && item.containingMethod().name() == "equals" && |
| item.containingMethod().parameters().size == 1 |
| ) { |
| nullable = true |
| } |
| |
| return nullable |
| } |
| } |
| } |
| |
| /** Default implementation of an annotation item */ |
| abstract class DefaultAnnotationItem(override val codebase: Codebase) : AnnotationItem { |
| private var targets: Set<AnnotationTarget>? = null |
| |
| override fun targets(): Set<AnnotationTarget> { |
| if (targets == null) { |
| targets = AnnotationItem.computeTargets(this, codebase) |
| } |
| return targets!! |
| } |
| } |
| |
| /** An attribute of an annotation, such as "value" */ |
| interface AnnotationAttribute { |
| /** The name of the annotation */ |
| val name: String |
| /** The annotation value */ |
| val value: AnnotationAttributeValue |
| |
| /** |
| * Return all leaf values; this flattens the complication of handling |
| * {@code @SuppressLint("warning")} and {@code @SuppressLint({"warning1","warning2"}) |
| */ |
| fun leafValues(): List<AnnotationAttributeValue> { |
| val result = mutableListOf<AnnotationAttributeValue>() |
| AnnotationAttributeValue.addValues(value, result) |
| return result |
| } |
| } |
| |
| /** An annotation value */ |
| interface AnnotationAttributeValue { |
| /** Generates source code for this annotation value */ |
| fun toSource(): String |
| |
| /** The value of the annotation */ |
| fun value(): Any? |
| |
| /** If the annotation declaration references a field (or class etc), return the resolved class */ |
| fun resolve(): Item? |
| |
| companion object { |
| fun addValues(value: AnnotationAttributeValue, into: MutableList<AnnotationAttributeValue>) { |
| if (value is AnnotationArrayAttributeValue) { |
| for (v in value.values) { |
| addValues(v, into) |
| } |
| } else if (value is AnnotationSingleAttributeValue) { |
| into.add(value) |
| } |
| } |
| } |
| } |
| |
| /** An annotation value (for a single item, not an array) */ |
| interface AnnotationSingleAttributeValue : AnnotationAttributeValue { |
| /** The annotation value, expressed as source code */ |
| val valueSource: String |
| /** The annotation value */ |
| val value: Any? |
| |
| override fun value() = value |
| } |
| |
| /** An annotation value for an array of items */ |
| interface AnnotationArrayAttributeValue : AnnotationAttributeValue { |
| /** The annotation values */ |
| val values: List<AnnotationAttributeValue> |
| |
| override fun resolve(): Item? { |
| error("resolve() should not be called on an array value") |
| } |
| |
| override fun value() = values.mapNotNull { it.value() }.toTypedArray() |
| } |
| |
| class DefaultAnnotationAttribute( |
| override val name: String, |
| override val value: DefaultAnnotationValue |
| ) : AnnotationAttribute { |
| companion object { |
| fun create(name: String, value: String): DefaultAnnotationAttribute { |
| return DefaultAnnotationAttribute(name, DefaultAnnotationValue.create(value)) |
| } |
| |
| fun createList(source: String): List<AnnotationAttribute> { |
| val list = mutableListOf<AnnotationAttribute>() // TODO: default size = 2 |
| var begin = 0 |
| var index = 0 |
| val length = source.length |
| while (index < length) { |
| val c = source[index] |
| if (c == '{') { |
| index = findEnd(source, index + 1, length, '}') |
| } else if (c == '"') { |
| index = findEnd(source, index + 1, length, '"') |
| } else if (c == ',') { |
| addAttribute(list, source, begin, index) |
| index++ |
| begin = index |
| continue |
| } else if (c == ' ' && index == begin) { |
| begin++ |
| } |
| |
| index++ |
| } |
| |
| if (begin < length) { |
| addAttribute(list, source, begin, length) |
| } |
| |
| return list |
| } |
| |
| private fun findEnd(source: String, from: Int, to: Int, sentinel: Char): Int { |
| var i = from |
| while (i < to) { |
| val c = source[i] |
| if (c == '\\') { |
| i++ |
| } else if (c == sentinel) { |
| return i |
| } |
| i++ |
| } |
| return to |
| } |
| |
| private fun addAttribute(list: MutableList<AnnotationAttribute>, source: String, from: Int, to: Int) { |
| var split = source.indexOf('=', from) |
| if (split >= to) { |
| split = -1 |
| } |
| val name: String |
| val value: String |
| val valueBegin: Int |
| val valueEnd: Int |
| if (split == -1) { |
| valueBegin = split + 1 |
| valueEnd = to |
| name = "value" |
| } else { |
| name = source.substring(from, split).trim() |
| valueBegin = split + 1 |
| valueEnd = to |
| } |
| value = source.substring(valueBegin, valueEnd).trim() |
| list.add(DefaultAnnotationAttribute.create(name, value)) |
| } |
| } |
| |
| override fun toString(): String { |
| return "DefaultAnnotationAttribute(name='$name', value=$value)" |
| } |
| } |
| |
| abstract class DefaultAnnotationValue : AnnotationAttributeValue { |
| companion object { |
| fun create(value: String): DefaultAnnotationValue { |
| return if (value.startsWith("{")) { // Array |
| DefaultAnnotationArrayAttributeValue(value) |
| } else { |
| DefaultAnnotationSingleAttributeValue(value) |
| } |
| } |
| } |
| |
| override fun toString(): String = toSource() |
| } |
| |
| class DefaultAnnotationSingleAttributeValue(override val valueSource: String) : DefaultAnnotationValue(), |
| AnnotationSingleAttributeValue { |
| @Suppress("IMPLICIT_CAST_TO_ANY") |
| override val value = when { |
| valueSource == SdkConstants.VALUE_TRUE -> true |
| valueSource == SdkConstants.VALUE_FALSE -> false |
| valueSource.startsWith("\"") -> valueSource.removeSurrounding("\"") |
| valueSource.startsWith('\'') -> valueSource.removeSurrounding("'")[0] |
| else -> try { |
| if (valueSource.contains(".")) { |
| valueSource.toDouble() |
| } else { |
| valueSource.toLong() |
| } |
| } catch (e: NumberFormatException) { |
| valueSource |
| } |
| } |
| |
| override fun resolve(): Item? = null |
| |
| override fun toSource() = valueSource |
| } |
| |
| class DefaultAnnotationArrayAttributeValue(val value: String) : DefaultAnnotationValue(), |
| AnnotationArrayAttributeValue { |
| init { |
| assert(value.startsWith("{") && value.endsWith("}")) { value } |
| } |
| |
| override val values = value.substring(1, value.length - 1).split(",").map { |
| DefaultAnnotationValue.create(it.trim()) |
| }.toList() |
| |
| override fun toSource() = value |
| } |
