IssueTracker

I wonder if you need to specify: @Target(ElementType.PARAMETER). Otherwise, that is annotated on parameter type int (or maybe both, as per https://youtrack.jetbrains.com/issue/IDEA-336319)?

Actually, just recalled the previous issue: b/199932515.

I'm afraid a workaround to handle duplicate visit on Java synthetic setter (on setter itself and setter parameter) that I recommend at b/199932515#comment15 and then you did at b/199932515#comment17 (or http://aosp/2753185) bite us back?

// Don't visit values assigned to annotated fields or properties, parameters passed to
// annotated methods, or annotated properties being referenced as fields. We'll visit the
// annotated fields and methods separately.
if (referenced is PsiField && type == ASSIGNMENT_RHS ||
    referenced is PsiMethod && type == ASSIGNMENT_RHS ||
    referenced is PsiMethod && type == FIELD_REFERENCE ||
    referenced is PsiMethod && type == METHOD_CALL_PARAMETER
) {
  return
}

It's not calling visitAnnotationUsage at all, so I don't think it could be related to that workaround inside visitAnnotationUsage. I don't think it's the target, either, because none of the following result in a callback (see aosp/2852626):

    public Object unsafeAnnotatedAnnotationUsageOnParam(@AnnotatedJavaAnnotation Object param) {
        return param;
    }

    @AnnotatedJavaAnnotation
    public Object unsafeAnnotatedAnnotationUsageOnMethod(Object param) {
        return param;
    }

    @AnnotatedJavaAnnotation
    class UnsafeAnnotatedAnnotationUsageOnClass {}

Somehow this issue is still opened as one of my tabs; before closing it, just tried to reproduce the issue, and noticed two things:

1. AnnotationHandler never visits value parameter as a declaration at all

2. "usages of annotated annotations" are handled, e.g., @IntDef, like an annotation annotated with @IntDef and tracking call arguments to value parameter; but @AnnotatedJavaAnnotation needs one step further: AnnotatedJavaAnnotation's meta annotation, ExperimentalJavaAnnotation, is annotated with the annotation of interest, RequiresOptIn.

First one---visiting annotation on value parameter as a DECLARATION usage type---is done/merged.

Second one, though, seems to cause huge overhead if visiting meta annotations over and over again is not guarded...

Changes will be available at AGP 8.6.0-alpha03

Thank you for your patience while our engineering team worked to resolve this issue. A fix for this issue is now available in:

• Android Studio Koala Feature Drop | 2024.1.2 Canary 3
• Android Gradle Plugin 8.6.0-alpha03

We encourage you to try the latest update.

If you notice further issues or have questions, please file a new bug report.

Thank you for taking the time to submit feedback — we really appreciate it!

Re-opening since I'm still seeing the issue described in comment#1 and comment#4 with AGP 8.6.0-alpha03 and Lint 31.6.0-alpha03. No callbacks for the sample code.

I used the exactly same example. Please note that

visiting annotation on value parameter as a DECLARATION usage type

because the annotation in question is annotated in a declaration (value parameter).

And that type is off by default: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:lint/libs/lint-api/src/main/java/com/android/tools/lint/detector/api/Detector.kt;l=608-620;drc=670807c36b334c691d4047ea74b0bf48b37cef54

So you may need to do something like:

override fun isApplicableAnnotationUsage(type: AnnotationUsageType): Boolean {
  return when (type) {
    AnnotationUsageType.DEFINITION -> true
    else -> super.isApplicableAnnotationUsage(type)
  }
}

As shown at aosp/3108427, I can confirm comment#10 is the case. (The detector also needs to examine meta-level annotations.)

(The detector also needs to examine meta-level annotations.)

Actually, this is the only reason we didn't see warning. Even though parameter is visited as DECLARATION usage, it's immediately bailed out at isExperimentalityAccepted. Rather, when visiting the use-site (which is not DECLARATION), now the examination of meta-level annotation matters only.