Make @SubclassOptInRequired accept multiple experimental markers

BlondeHex · Space Team · commit 2d0815cfe4f1 · 2024-09-24T00:36:42.000Z
[1/5] Prepare frontend checkers to support SubclassOptInRequired
arguments from different stdlib versions.

These changes are required first to ensure that tests continue to work
while updating the SubclassOptInRequired annotation in the stdlib.
Support for K1 checkers is necessary for the Kotlin IDE plugin, as it
uses on the old frontend.

^KT-70562 in progress
diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInAnnotationCallChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInAnnotationCallChecker.kt
@@ -14,16 +14,14 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
-import org.jetbrains.kotlin.fir.analysis.checkers.extractClassFromArgument
 import org.jetbrains.kotlin.fir.analysis.checkers.extractClassesFromArgument
 import org.jetbrains.kotlin.fir.analysis.checkers.modality
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.findArgumentByName
 import org.jetbrains.kotlin.fir.declarations.utils.isFun
 import org.jetbrains.kotlin.fir.declarations.utils.isLocal
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.arguments
+import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.classLikeLookupTagIfAny
@@ -82,8 +80,11 @@ object FirOptInAnnotationCallChecker : FirAnnotationCallChecker(MppCheckerKind.C
                     return
                 }
             }
-            val classSymbol = expression.findArgumentByName(OPT_IN_ANNOTATION_CLASS)?.extractClassFromArgument(context.session) ?: return
-            checkOptInArgumentIsMarker(classSymbol, classId, expression.source, reporter, context)
+            val classSymbols = expression.findArgumentByName(OPT_IN_ANNOTATION_CLASS)?.extractClassesFromArgument(context.session).orEmpty()
+          
+            classSymbols.forEach {
+                checkOptInArgumentIsMarker(it, classId, expression.source, reporter, context)
+            }
         }
     }
 
diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt
@@ -48,7 +48,7 @@ object FirOptInUsageBaseChecker {
         val severity: Severity,
         val message: String?,
         val supertypeName: String? = null,
-        val fromSupertype: Boolean = false
+        val fromSupertype: Boolean = false,
     ) {
         enum class Severity { WARNING, ERROR }
         companion object {
@@ -77,7 +77,7 @@ object FirOptInUsageBaseChecker {
     // Note: receiver is an OptIn marker class and parameter is an annotated member owner class / self class name
     fun FirRegularClassSymbol.loadExperimentalityForMarkerAnnotation(
         session: FirSession,
-        annotatedOwnerClassName: String? = null
+        annotatedOwnerClassName: String? = null,
     ): Experimentality? {
         lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
         @OptIn(SymbolInternals::class)
@@ -93,7 +93,7 @@ object FirOptInUsageBaseChecker {
     private fun FirDeclaration.loadExperimentalitiesFromAnnotationTo(
         session: FirSession,
         result: MutableCollection<Experimentality>,
-        fromSupertype: Boolean
+        fromSupertype: Boolean,
     ) {
         for (annotation in annotations) {
             val annotationType = annotation.annotationTypeRef.coneType as? ConeClassLikeType ?: continue
@@ -110,26 +110,28 @@ object FirOptInUsageBaseChecker {
             if (fromSupertype) {
                 if (annotationType.lookupTag.classId == OptInNames.SUBCLASS_OPT_IN_REQUIRED_CLASS_ID) {
                     val annotationClass = annotation.findArgumentByName(OptInNames.OPT_IN_ANNOTATION_CLASS) ?: continue
-                    result.addIfNotNull(
-                        annotationClass.extractClassFromArgument(session)
-                            ?.loadExperimentalityForMarkerAnnotation(session)?.copy(fromSupertype = true)
-                    )
+                    val classes = annotationClass.extractClassesFromArgument(session)
+                    classes.forEach { klass ->
+                        result.addIfNotNull(
+                            klass.loadExperimentalityForMarkerAnnotation(session)?.copy(fromSupertype = true)
+                        )
+                    }
                 }
             }
         }
     }
 
     fun loadExperimentalitiesFromTypeArguments(
         context: CheckerContext,
-        typeArguments: List<FirTypeProjection>
+        typeArguments: List<FirTypeProjection>,
     ): Set<Experimentality> {
         if (typeArguments.isEmpty()) return emptySet()
         return loadExperimentalitiesFromConeArguments(context, typeArguments.map { it.toConeTypeProjection() })
     }
 
     fun loadExperimentalitiesFromConeArguments(
         context: CheckerContext,
-        typeArguments: List<ConeTypeProjection>
+        typeArguments: List<ConeTypeProjection>,
     ): Set<Experimentality> {
         if (typeArguments.isEmpty()) return emptySet()
         val result = SmartSet.create<Experimentality>()
@@ -140,7 +142,7 @@ object FirOptInUsageBaseChecker {
     }
 
     fun FirBasedSymbol<*>.loadExperimentalities(
-        context: CheckerContext, fromSetter: Boolean, dispatchReceiverType: ConeKotlinType?
+        context: CheckerContext, fromSetter: Boolean, dispatchReceiverType: ConeKotlinType?,
     ): Set<Experimentality> = loadExperimentalities(
         context, knownExperimentalities = null, visited = mutableSetOf(), fromSetter, dispatchReceiverType, fromSupertype = false
     )
@@ -199,7 +201,7 @@ object FirOptInUsageBaseChecker {
         visited: MutableSet<FirDeclaration>,
         fromSetter: Boolean,
         dispatchReceiverType: ConeKotlinType?,
-        result: SmartSet<Experimentality>
+        result: SmartSet<Experimentality>,
     ) {
         val parentClassSymbol = containingClassLookupTag()?.toRegularClassSymbol(context.session)
         if (this is FirConstructor) {
@@ -242,7 +244,7 @@ object FirOptInUsageBaseChecker {
         symbol: FirBasedSymbol<*>,
         context: CheckerContext,
         visited: MutableSet<FirDeclaration>,
-        result: SmartSet<Experimentality>
+        result: SmartSet<Experimentality>,
     ) {
         when (this) {
             is FirRegularClass -> if (symbol is FirRegularClassSymbol) {
@@ -260,7 +262,7 @@ object FirOptInUsageBaseChecker {
     private fun ConeKotlinType?.addExperimentalities(
         context: CheckerContext,
         result: SmartSet<Experimentality>,
-        visited: MutableSet<FirDeclaration> = mutableSetOf()
+        visited: MutableSet<FirDeclaration> = mutableSetOf(),
     ) {
         if (this !is ConeClassLikeType) return
         lookupTag.toSymbol(context.session)?.loadExperimentalities(
@@ -274,7 +276,7 @@ object FirOptInUsageBaseChecker {
     // Note: receiver is an OptIn marker class and parameter is an annotated member owner class / self class name
     private fun FirRegularClass.loadExperimentalityForMarkerAnnotation(
         session: FirSession,
-        annotatedOwnerClassName: String? = null
+        annotatedOwnerClassName: String? = null,
     ): Experimentality? {
         val experimental = getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID, session)
             ?: return null
@@ -337,7 +339,7 @@ object FirOptInUsageBaseChecker {
         experimentalities: Collection<Experimentality>,
         symbol: FirCallableSymbol<*>,
         context: CheckerContext,
-        reporter: DiagnosticReporter
+        reporter: DiagnosticReporter,
     ) {
         for ((annotationClassId, severity, markerMessage, supertypeName) in experimentalities) {
             if (!symbol.fir.isExperimentalityAcceptable(context.session, annotationClassId, fromSupertype = false) &&
@@ -361,7 +363,7 @@ object FirOptInUsageBaseChecker {
     private fun isExperimentalityAcceptableInContext(
         annotationClassId: ClassId,
         context: CheckerContext,
-        fromSupertype: Boolean
+        fromSupertype: Boolean,
     ): Boolean {
         val languageVersionSettings = context.session.languageVersionSettings
         val fqNameAsString = annotationClassId.asFqNameString()
@@ -379,7 +381,7 @@ object FirOptInUsageBaseChecker {
     private fun FirAnnotationContainer.isExperimentalityAcceptable(
         session: FirSession,
         annotationClassId: ClassId,
-        fromSupertype: Boolean
+        fromSupertype: Boolean,
     ): Boolean {
         return getAnnotationByClassId(annotationClassId, session) != null ||
                 isAnnotatedWithOptIn(annotationClassId, session) ||
@@ -396,7 +398,7 @@ object FirOptInUsageBaseChecker {
     @OptIn(SymbolInternals::class)
     private fun FirAnnotationContainer.primaryConstructorParameterIsExperimentalityAcceptable(
         session: FirSession,
-        annotationClassId: ClassId
+        annotationClassId: ClassId,
     ): Boolean {
         if (this !is FirProperty) return false
         val parameterSymbol = correspondingValueParameterFromPrimaryConstructor ?: return false
@@ -420,15 +422,15 @@ object FirOptInUsageBaseChecker {
 
     private fun FirAnnotationContainer.isAnnotatedWithSubclassOptInRequired(
         session: FirSession,
-        annotationClassId: ClassId
+        annotationClassId: ClassId,
     ): Boolean {
         for (annotation in annotations) {
             val coneType = annotation.annotationTypeRef.coneType as? ConeClassLikeType
             if (coneType?.lookupTag?.classId != OptInNames.SUBCLASS_OPT_IN_REQUIRED_CLASS_ID) {
                 continue
             }
             val annotationClass = annotation.findArgumentByName(OptInNames.OPT_IN_ANNOTATION_CLASS) ?: continue
-            if (annotationClass.extractClassFromArgument(session)?.classId == annotationClassId) {
+            if (annotationClass.extractClassesFromArgument(session).any { it.classId == annotationClassId }) {
                 return true
             }
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/OptInMarkerDeclarationAnnotationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/OptInMarkerDeclarationAnnotationChecker.kt
@@ -21,7 +21,6 @@ import org.jetbrains.kotlin.resolve.AdditionalAnnotationChecker
 import org.jetbrains.kotlin.resolve.AnnotationChecker
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.constants.ArrayValue
 import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.resolve.constants.KClassValue
 import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
@@ -42,14 +41,12 @@ class OptInMarkerDeclarationAnnotationChecker(private val module: ModuleDescript
             val annotation = trace.bindingContext.get(BindingContext.ANNOTATION, entry) ?: continue
             when (annotation.fqName) {
                 OptInNames.OPT_IN_FQ_NAME -> {
-                    val annotationClasses = (annotation.allValueArguments[OptInNames.OPT_IN_ANNOTATION_CLASS] as? ArrayValue)
-                        ?.value.orEmpty()
+                    val annotationClasses = getOptInAnnotationArgs(annotation)
                     checkOptInUsage(annotationClasses, trace, entry)
                 }
                 OptInNames.SUBCLASS_OPT_IN_REQUIRED_FQ_NAME -> {
-                    val annotationClass =
-                        annotation.allValueArguments[OptInNames.OPT_IN_ANNOTATION_CLASS]
-                    checkSubclassOptInUsage(annotated, listOfNotNull(annotationClass), trace, entry)
+                    val annotationClasses = getOptInAnnotationArgs(annotation)
+                    checkSubclassOptInUsage(annotated, annotationClasses, trace, entry)
                 }
                 OptInNames.REQUIRES_OPT_IN_FQ_NAME -> {
                     hasOptIn = true
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/OptInUsageChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/OptInUsageChecker.kt
@@ -39,18 +39,13 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.checkers.OptInNames.OPT_IN_FQ_NAME
 import org.jetbrains.kotlin.resolve.checkers.OptInNames.REQUIRES_OPT_IN_FQ_NAME
 import org.jetbrains.kotlin.resolve.checkers.OptInNames.SUBCLASS_OPT_IN_REQUIRED_FQ_NAME
-import org.jetbrains.kotlin.resolve.checkers.OptInNames.OPT_IN_ANNOTATION_CLASS
 import org.jetbrains.kotlin.resolve.checkers.OptInNames.WAS_EXPERIMENTAL_FQ_NAME
-import org.jetbrains.kotlin.resolve.constants.ArrayValue
-import org.jetbrains.kotlin.resolve.constants.EnumValue
-import org.jetbrains.kotlin.resolve.constants.KClassValue
-import org.jetbrains.kotlin.resolve.constants.StringValue
+import org.jetbrains.kotlin.resolve.constants.*
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationLevelValue
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationSettings
 import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlin.resolve.descriptorUtil.module
 import org.jetbrains.kotlin.resolve.sam.SamConstructorDescriptor
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.types.AbbreviatedType
@@ -224,10 +219,12 @@ class OptInUsageChecker : CallChecker {
             }
 
             for (annotation in annotations) {
-                result.addIfNotNull(
-                    annotation.annotationClass?.loadOptInForMarkerAnnotation(useFutureError)
-                        ?: if (fromSupertype) annotation.loadSubclassOptInRequired(module) else null
-                )
+                val optInMarker = annotation.annotationClass?.loadOptInForMarkerAnnotation(useFutureError)
+                if (optInMarker != null) {
+                    result.addIfNotNull(optInMarker)
+                } else if (fromSupertype) {
+                    result.addAll(annotation.loadSubclassOptInRequired(module))
+                }
             }
 
             if (this is CallableDescriptor && this !is ClassConstructorDescriptor) {
@@ -316,14 +313,14 @@ class OptInUsageChecker : CallChecker {
             return OptInDescription(fqNameSafe, severity, message, subclassesOnly)
         }
 
-        private fun AnnotationDescriptor.loadSubclassOptInRequired(module: ModuleDescriptor): OptInDescription? {
-            if (this.fqName != SUBCLASS_OPT_IN_REQUIRED_FQ_NAME) return null
-            val markerClass = allValueArguments[OPT_IN_ANNOTATION_CLASS]
-            if (markerClass !is KClassValue) return null
-            val value = markerClass.value
-            if (value !is KClassValue.Value.NormalClass) return null
-            val markerDescriptor = markerClass.getArgumentType(module).constructor.declarationDescriptor as? ClassDescriptor
-            return markerDescriptor?.loadOptInForMarkerAnnotation(subclassesOnly = true)
+        private fun AnnotationDescriptor.loadSubclassOptInRequired(module: ModuleDescriptor): List<OptInDescription> {
+            if (this.fqName != SUBCLASS_OPT_IN_REQUIRED_FQ_NAME) return emptyList()
+            val markerClasses = getOptInAnnotationArgs(this)
+            return markerClasses.mapNotNull { constant ->
+                val klass = constant as? KClassValue ?: return@mapNotNull null
+                val markerDescriptor = klass.getArgumentType(module).constructor.declarationDescriptor as? ClassDescriptor
+                markerDescriptor?.loadOptInForMarkerAnnotation(subclassesOnly = true)
+            }
         }
 
         private fun PsiElement.isOptInAllowed(annotationFqName: FqName, context: CheckerContext, subclassesOnly: Boolean): Boolean =
@@ -368,8 +365,8 @@ class OptInUsageChecker : CallChecker {
             return this is KtAnnotated && annotationEntries.any { entry ->
                 val descriptor = bindingContext.get(BindingContext.ANNOTATION, entry)
                 if (descriptor != null && descriptor.fqName == OPT_IN_FQ_NAME) {
-                    val annotationClasses = descriptor.allValueArguments[OPT_IN_ANNOTATION_CLASS]
-                    annotationClasses is ArrayValue && annotationClasses.value.any { annotationClass ->
+                    val annotationClasses = getOptInAnnotationArgs(descriptor)
+                    annotationClasses.any { annotationClass ->
                         annotationClass is KClassValue && annotationClass.value.let { value ->
                             value is KClassValue.Value.NormalClass &&
                                     value.classId.asSingleFqName() == annotationFqName && value.arrayDimensions == 0
@@ -386,10 +383,10 @@ class OptInUsageChecker : CallChecker {
             return this is KtAnnotated && annotationEntries.any { entry ->
                 val descriptor = bindingContext.get(BindingContext.ANNOTATION, entry)
                 if (descriptor != null && descriptor.fqName == SUBCLASS_OPT_IN_REQUIRED_FQ_NAME) {
-                    val annotationClass = descriptor.allValueArguments[OPT_IN_ANNOTATION_CLASS]
-                    annotationClass is KClassValue && annotationClass.value.let { value ->
-                        value is KClassValue.Value.NormalClass &&
-                                value.classId.asSingleFqName() == annotationFqName && value.arrayDimensions == 0
+                    val annotationClasses = getOptInAnnotationArgs(descriptor)
+                    annotationClasses.any { constant ->
+                        val klass = constant.value as? KClassValue.Value.NormalClass ?: return false
+                        klass.classId.asSingleFqName() == annotationFqName && klass.arrayDimensions == 0
                     }
                 } else false
             }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/OptInUsageCheckerUtils.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/OptInUsageCheckerUtils.kt
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2010-2024 JetBrains s.r.o.
+ *
+ * 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 org.jetbrains.kotlin.resolve.checkers
+
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.resolve.constants.*
+
+fun getOptInAnnotationArgs(annotation: AnnotationDescriptor): List<ConstantValue<*>> =
+    when (val arguments = annotation.allValueArguments[OptInNames.OPT_IN_ANNOTATION_CLASS]) {
+        // @SubclassOptInRequired from stdlib versions 2.1 and above
+        is ArrayValue -> arguments.value
+        // Applies @SubclassOptInRequired for stdlib versions below 2.1
+        else -> listOfNotNull(arguments)
+    }
