get() = annotations
}

public typealias KtAnnotated = KaAnnotated

/**
 * A list of annotations applied.
 *
 * To check if annotation is present, please use [hasAnnotation].
 *
 * @see [KaAnnotationList.annotations]
 */
@Deprecated("Use the 'annotations' the member property instead.")
public val KaAnnotated.annotations: List<KaAnnotation>
    get() = annotations

            List<Annotation> annotations = parameterAnnotations.get(paramIndex);
            boolean annotatedWithEach = hasAnnotation(annotations, Each.class);
            if (paramIndex == subjectParamIndex) {
                if (annotatedWithEach && hasAnnotation(annotations, Path.class)) {
                    problems.add(ruleDefinition, "Rule subject must not be annotated with both @Path and @Each.");
                }

     * ```
     * annotationsList.hasAnnotation(classId) == annotationsList.annotations.any { it.classId == classId }
     * ```
     * @param classId [ClassId] to search
     */
    public operator fun contains(classId: ClassId): Boolean

    @Deprecated("Use 'contains' instead.", replaceWith = ReplaceWith("contains(classId)"))
    public fun hasAnnotation(classId: ClassId): Boolean = contains(classId)

    /**

        }
    }

    private static boolean hasNullableAnnotation(CtField field) {
        return NULLABLE_ANNOTATIONS.any { field.hasAnnotation(it) }
    }

    private static boolean hasNullableAnnotation(CtMethod method) {
        return NULLABLE_ANNOTATIONS.any { method.hasAnnotation(it) }
    }

    private static boolean isNullableCtAnnotation(Object ann) {
        if (Proxy.isProxyClass(ann.class)) {

    override fun get(index: Int): KaAnnotation = withValidityAssertion {
        return backingAnnotations[index]
    }

    override fun contains(classId: ClassId): Boolean = withValidityAssertion {
        return hasAnnotation(firCallableSymbol, classId, useSiteSession, receiverParameter)
    }

    override fun get(classId: ClassId, ): List<KaAnnotation> = withValidityAssertion {

    private
    fun hasRestrictedAnnotationCached(kClass: KClass<*>) = hasRestrictedAnnotationCache.computeIfAbsent(kClass) { hasAnnotation(it) }

    private
    fun hasAnnotation(kClass: KClass<*>) = kClass.annotations.any { annotationType.isInstance(it) }

        if (psiClass.isKotlinCompiledClass()) return null

        return KaFirPsiJavaClassSymbol(psiClass, analysisSession)
    }

    private fun PsiClass.isKotlinCompiledClass() =
        this is ClsElementImpl && hasAnnotation(JvmAnnotationNames.METADATA_FQ_NAME.asString())

    override fun getCallableSymbol(callable: PsiMember): KaCallableSymbol? {
        if (callable !is PsiMethod && callable !is PsiField) return null

			object: createPod("p1"),
		},
	}

	for _, scenario := range scenarios {
		t.Run(scenario.name, func(t *testing.T) {
			hasAnnotation, err := storage.HasInitialEventsEndBookmarkAnnotation(scenario.object)
			require.NoError(t, err)
			require.Equal(t, scenario.expectAnnotation, hasAnnotation)
		})
	}

    override fun get(index: Int): KaAnnotation = withValidityAssertion {
        return backingAnnotations[index]
    }

    override fun contains(classId: ClassId): Boolean = withValidityAssertion {
        return hasAnnotation(firSymbol, classId, useSiteSession)
    }

    override fun get(classId: ClassId): List<KaAnnotation> = withValidityAssertion {
        return annotationsByClassId(firSymbol, classId, builder)
    }

                    add(classId)
                }
            }
        }

    override fun contains(classId: ClassId): Boolean = withValidityAssertion {
        fe10Annotations.hasAnnotation(classId.asSingleFqName())
    }

    override fun get(classId: ClassId): List<KaAnnotation> = withValidityAssertion {
        if (classId in ignoredAnnotations) return@withValidityAssertion emptyList()