diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/annotations/firAnnotationUtils.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/annotations/firAnnotationUtils.kt index f83697a9b5c..b79e530dd98 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/annotations/firAnnotationUtils.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/annotations/firAnnotationUtils.kt @@ -35,7 +35,8 @@ internal fun mapAnnotationParameters(annotation: FirAnnotation): Map name } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt index 3568f78b806..b9cff7424dc 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt @@ -220,7 +220,7 @@ internal class KtFirCallResolver( return when (this) { is FirResolvable, is FirVariableAssignment -> { - when (val calleeReference = toReference()) { + when (val calleeReference = toReference(analysisSession.useSiteSession)) { is FirResolvedErrorReference -> transformErrorReference(this, calleeReference) is FirResolvedNamedReference -> when (calleeReference.resolvedSymbol) { // `calleeReference.resolvedSymbol` isn't guaranteed to be callable. For example, function type parameters used in @@ -794,7 +794,10 @@ internal class KtFirCallResolver( @OptIn(SymbolInternals::class) private fun getInitializerOfReferencedLocalVariable(variableReference: FirExpression): FirFunctionCall? { - return variableReference.toReference()?.toResolvedVariableSymbol()?.fir?.initializer as? FirFunctionCall + return variableReference.toReference(firResolveSession.useSiteFirSession) + ?.toResolvedVariableSymbol() + ?.fir + ?.initializer as? FirFunctionCall } private fun getOperationPartiallyAppliedSymbolsForCompoundVariableAccess( diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionTypeProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionTypeProvider.kt index f7983ac9297..40dbdb54f1e 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionTypeProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionTypeProvider.kt @@ -222,7 +222,7 @@ internal class KtFirExpressionTypeProvider( val (ktCallElement, argumentExpression) = expression.getFunctionCallAsWithThisAsParameter() ?: return null val firCall = ktCallElement.getOrBuildFir(firResolveSession)?.unwrapSafeCall() as? FirCall ?: return null - val callee = (firCall.toReference() as? FirResolvedNamedReference)?.resolvedSymbol + val callee = (firCall.toReference(firResolveSession.useSiteFirSession) as? FirResolvedNamedReference)?.resolvedSymbol if (callee?.fir?.origin == FirDeclarationOrigin.SamConstructor) { val substitutor = (firCall as? FirQualifiedAccessExpression) ?.createConeSubstitutorFromTypeArguments(discardErrorTypes = true) diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirImportOptimizer.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirImportOptimizer.kt index ebb71cea327..1c0c2f2d6de 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirImportOptimizer.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirImportOptimizer.kt @@ -41,7 +41,6 @@ import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.getCallNameExpression import org.jetbrains.kotlin.psi.psiUtil.getPossiblyQualifiedCallExpression import org.jetbrains.kotlin.psi.psiUtil.unwrapNullability -import org.jetbrains.kotlin.resolve.ImportPath import org.jetbrains.kotlin.resolve.calls.util.getCalleeExpressionIfAny import org.jetbrains.kotlin.util.OperatorNameConventions import org.jetbrains.kotlin.utils.exceptions.errorWithAttachment diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/compile/CodeFragmentCapturedValueAnalyzer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/compile/CodeFragmentCapturedValueAnalyzer.kt index 43bb57391bd..7a89ca4a10d 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/compile/CodeFragmentCapturedValueAnalyzer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/compile/CodeFragmentCapturedValueAnalyzer.kt @@ -98,7 +98,7 @@ private class CodeFragmentCapturedValueVisitor( override fun visitElement(element: FirElement) { processElement(element) - val lhs = (element as? FirVariableAssignment)?.lValue?.toResolvedCallableSymbol() + val lhs = (element as? FirVariableAssignment)?.lValue?.toResolvedCallableSymbol(session) if (lhs != null) { assignmentLhs.add(lhs) } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/resolver/AllCandidatesResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/resolver/AllCandidatesResolver.kt index a0c58bffd81..48fc808561b 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/resolver/AllCandidatesResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/resolver/AllCandidatesResolver.kt @@ -138,7 +138,7 @@ class AllCandidatesResolver(private val firSession: FirSession) { */ private fun OverloadCandidate.preserveCalleeInapplicability() { val callSite = candidate.callInfo.callSite - val calleeReference = callSite.toReference() as? FirDiagnosticHolder ?: return + val calleeReference = callSite.toReference(firSession) as? FirDiagnosticHolder ?: return val diagnostic = calleeReference.diagnostic as? ConeInapplicableCandidateError ?: return if (diagnostic.applicability != CandidateApplicability.INAPPLICABLE) return diff --git a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsDefinedExternallyCallChecker.kt b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsDefinedExternallyCallChecker.kt index 0e2ad33be7b..df4d77ca8bd 100644 --- a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsDefinedExternallyCallChecker.kt +++ b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsDefinedExternallyCallChecker.kt @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.name.JsStandardClassIds object FirJsDefinedExternallyCallChecker : FirBasicExpressionChecker(MppCheckerKind.Common) { override fun check(expression: FirStatement, context: CheckerContext, reporter: DiagnosticReporter) { - val symbol = expression.toReference()?.toResolvedCallableSymbol() ?: return + val symbol = expression.toReference(context.session)?.toResolvedCallableSymbol() ?: return if (symbol.callableId !in JsStandardClassIds.Callables.definedExternallyPropertyNames) { return diff --git a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsDynamicCallChecker.kt b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsDynamicCallChecker.kt index d9b29d0f61e..dc92986ab30 100644 --- a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsDynamicCallChecker.kt +++ b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsDynamicCallChecker.kt @@ -9,6 +9,7 @@ import org.jetbrains.kotlin.KtFakeSourceElementKind import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirQualifiedAccessExpressionChecker @@ -42,7 +43,7 @@ object FirJsDynamicCallChecker : FirQualifiedAccessExpressionChecker(MppCheckerK ?: error("Resolved call callee without a callable symbol") when { - expression is FirCall && expression.isArrayAccessWithMultipleIndices -> reporter.reportOn( + expression is FirCall && expression.isArrayAccessWithMultipleIndices(context.session) -> reporter.reportOn( expression.source, FirJsErrors.WRONG_OPERATION_WITH_DYNAMIC, "indexed access with more than one index", context ) expression is FirFunctionCall && expression.isInOperator -> reporter.reportOn( @@ -62,22 +63,21 @@ object FirJsDynamicCallChecker : FirQualifiedAccessExpressionChecker(MppCheckerK } } - private val FirCall.isArrayAccessWithMultipleIndices: Boolean - get() { - val callee = toReference() as? FirNamedReference - ?: return false + private fun FirCall.isArrayAccessWithMultipleIndices(session: FirSession): Boolean { + val callee = toReference(session) as? FirNamedReference + ?: return false - if (callee.source?.kind != KtFakeSourceElementKind.ArrayAccessNameReference) { - return false - } - - val arguments = (arguments.singleOrNull() as? FirVarargArgumentsExpression)?.arguments - ?: return false - - return callee.name == OperatorNameConventions.GET && arguments.size >= 2 - || callee.name == OperatorNameConventions.SET && arguments.size >= 3 + if (callee.source?.kind != KtFakeSourceElementKind.ArrayAccessNameReference) { + return false } + val arguments = (arguments.singleOrNull() as? FirVarargArgumentsExpression)?.arguments + ?: return false + + return callee.name == OperatorNameConventions.GET && arguments.size >= 2 + || callee.name == OperatorNameConventions.SET && arguments.size >= 3 + } + private val FirFunctionCall.isInOperator get() = calleeReference.resolved?.name == OperatorNameConventions.CONTAINS && origin == FirFunctionCallOrigin.Operator diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmProtectedInSuperClassCompanionCallChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmProtectedInSuperClassCompanionCallChecker.kt index 7272389ac46..ca78661c405 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmProtectedInSuperClassCompanionCallChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmProtectedInSuperClassCompanionCallChecker.kt @@ -39,7 +39,7 @@ object FirJvmProtectedInSuperClassCompanionCallChecker : FirBasicExpressionCheck } ?: return val dispatchClassSymbol = dispatchReceiver.resolvedType.toRegularClassSymbol(context.session) ?: return - val calleeReference = expression.toReference() + val calleeReference = expression.toReference(context.session) val resolvedSymbol = calleeReference?.toResolvedCallableSymbol() ?: return val visibility = if (resolvedSymbol is FirPropertySymbol) { diff --git a/compiler/fir/checkers/checkers.wasm/src/org/jetbrains/kotlin/fir/analysis/wasm/checkers/expression/FirWasmDefinedExternallyCallChecker.kt b/compiler/fir/checkers/checkers.wasm/src/org/jetbrains/kotlin/fir/analysis/wasm/checkers/expression/FirWasmDefinedExternallyCallChecker.kt index dd715881412..a80218ae48f 100644 --- a/compiler/fir/checkers/checkers.wasm/src/org/jetbrains/kotlin/fir/analysis/wasm/checkers/expression/FirWasmDefinedExternallyCallChecker.kt +++ b/compiler/fir/checkers/checkers.wasm/src/org/jetbrains/kotlin/fir/analysis/wasm/checkers/expression/FirWasmDefinedExternallyCallChecker.kt @@ -20,7 +20,7 @@ import org.jetbrains.kotlin.name.WebCommonStandardClassIds object FirWasmDefinedExternallyCallChecker : FirBasicExpressionChecker(MppCheckerKind.Common) { override fun check(expression: FirStatement, context: CheckerContext, reporter: DiagnosticReporter) { - val symbol = expression.toReference()?.toResolvedCallableSymbol() ?: return + val symbol = expression.toReference(context.session)?.toResolvedCallableSymbol() ?: return if (symbol.callableId != WebCommonStandardClassIds.Callables.JsDefinedExternally) { return diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt index 39fcde040fb..6ed8dad275b 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt @@ -10,7 +10,6 @@ import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirField import org.jetbrains.kotlin.fir.declarations.hasAnnotation import org.jetbrains.kotlin.fir.declarations.utils.isConst import org.jetbrains.kotlin.fir.declarations.utils.isStatic @@ -194,7 +193,7 @@ private class FirConstCheckVisitor(private val session: FirSession) : FirVisitor override fun visitPropertyAccessExpression( propertyAccessExpression: FirPropertyAccessExpression, data: Nothing? ): ConstantArgumentKind { - val propertySymbol = propertyAccessExpression.toReference()?.toResolvedCallableSymbol(discardErrorReference = true) + val propertySymbol = propertyAccessExpression.toReference(session)?.toResolvedCallableSymbol(discardErrorReference = true) when (propertySymbol) { // Null symbol means some error occurred. // We use the same logic as in `visitErrorExpression`. @@ -364,4 +363,4 @@ private class FirConstCheckVisitor(private val session: FirSession) : FirVisitor ?.coneTypeSafe() ?.lookupTag ?.toSymbol(session) -} \ No newline at end of file +} diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateFieldTypeMismatchChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateFieldTypeMismatchChecker.kt index 6df0d53c427..7c534ba2a46 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateFieldTypeMismatchChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateFieldTypeMismatchChecker.kt @@ -27,7 +27,7 @@ object FirDelegateFieldTypeMismatchChecker : FirRegularClassChecker(MppCheckerKi val supertype = declaration.superTypeRefs[it] val field = declaration.delegateFieldsMap?.get(it)?.fir ?: continue val initializer = field.initializer ?: continue - val isReportedByErrorNodeDiagnosticCollector = initializer is FirCall && initializer.toReference()?.isError() == true + val isReportedByErrorNodeDiagnosticCollector = initializer is FirCall && initializer.toReference(context.session)?.isError() == true if ( !isReportedByErrorNodeDiagnosticCollector && diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirEnumCompanionInEnumConstructorCallChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirEnumCompanionInEnumConstructorCallChecker.kt index 7f06015451a..65483f92b6f 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirEnumCompanionInEnumConstructorCallChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirEnumCompanionInEnumConstructorCallChecker.kt @@ -97,7 +97,7 @@ object FirEnumCompanionInEnumConstructorCallChecker : FirClassChecker(MppChecker is FirResolvedQualifier -> { this.resolvedType.toRegularClassSymbol(session) } - else -> (this.toReference() as? FirThisReference)?.boundSymbol + else -> (this.toReference(session) as? FirThisReference)?.boundSymbol } as? FirRegularClassSymbol } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt index 7a62ad25cbb..7d21eb975c5 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt @@ -133,7 +133,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker(MppCheckerKind.Common) { val argumentMapping = functionCall.resolvedArgumentMapping ?: return for ((wrappedArgument, valueParameter) in argumentMapping) { val argument = wrappedArgument.unwrapArgument() - val resolvedArgumentSymbol = argument.toResolvedCallableSymbol() as? FirVariableSymbol<*> ?: continue + val resolvedArgumentSymbol = argument.toResolvedCallableSymbol(session) as? FirVariableSymbol<*> ?: continue val valueParameterOfOriginalInlineFunction = inlinableParameters.firstOrNull { it == resolvedArgumentSymbol } if (valueParameterOfOriginalInlineFunction != null) { @@ -163,7 +163,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker(MppCheckerKind.Common) { reporter: DiagnosticReporter, ) { if (receiverExpression == null) return - val receiverSymbol = receiverExpression.toResolvedCallableSymbol() as? FirValueParameterSymbol ?: return + val receiverSymbol = receiverExpression.toResolvedCallableSymbol(session) as? FirValueParameterSymbol ?: return if (receiverSymbol in inlinableParameters) { if (!isInvokeOrInlineExtension(targetSymbol)) { reporter.reportOn( diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirValueClassDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirValueClassDeclarationChecker.kt index 2a8189cb048..36dd0ceebf5 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirValueClassDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirValueClassDeclarationChecker.kt @@ -129,7 +129,7 @@ sealed class FirValueClassDeclarationChecker(mppKind: MppCheckerKind) : FirRegul is FirField -> { if (innerDeclaration.isSynthetic) { - val symbol = innerDeclaration.initializer?.toResolvedCallableSymbol() + val symbol = innerDeclaration.initializer?.toResolvedCallableSymbol(context.session) if (context.languageVersionSettings.supportsFeature(LanguageFeature.InlineClassImplementationByDelegation) && symbol != null && symbol in primaryConstructorParametersSymbolsSet ) { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/AbstractFirReflectionApiCallChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/AbstractFirReflectionApiCallChecker.kt index 90e030bc525..622df9f385c 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/AbstractFirReflectionApiCallChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/AbstractFirReflectionApiCallChecker.kt @@ -40,7 +40,7 @@ abstract class AbstractFirReflectionApiCallChecker : FirBasicExpressionChecker(M // Do not report the diagnostic on kotlin-reflect sources. if (isReflectionSource(context)) return - val resolvedReference = expression.toReference()?.resolved ?: return + val resolvedReference = expression.toReference(context.session)?.resolved ?: return val referencedSymbol = resolvedReference.resolvedSymbol as? FirCallableSymbol ?: return val containingClassId = (expression as? FirQualifiedAccessExpression)?.dispatchReceiver?.resolvedType?.fullyExpandedClassId(context.session) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirDeprecationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirDeprecationChecker.kt index 0d1c0ec5cf7..ad48dda1132 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirDeprecationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirDeprecationChecker.kt @@ -49,7 +49,7 @@ object FirDeprecationChecker : FirBasicExpressionChecker(MppCheckerKind.Common) if (expression is FirAnnotation) return // checked by FirDeprecatedTypeChecker if (expression.isLhsOfAssignment(context)) return - val calleeReference = expression.toReference() ?: return + val calleeReference = expression.toReference(context.session) ?: return val resolvedReference = calleeReference.resolved ?: return val referencedSymbol = resolvedReference.resolvedSymbol diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageAccessChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageAccessChecker.kt index 8f8949b3862..98041468f9a 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageAccessChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageAccessChecker.kt @@ -28,7 +28,7 @@ object FirOptInUsageAccessChecker : FirBasicExpressionChecker(MppCheckerKind.Com if (expression.isLhsOfAssignment(context)) return - val resolvedSymbol = expression.toReference()?.toResolvedBaseSymbol() ?: return + val resolvedSymbol = expression.toReference(context.session)?.toResolvedBaseSymbol() ?: return with(FirOptInUsageBaseChecker) { when { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUselessTypeOperationCallChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUselessTypeOperationCallChecker.kt index 7362f50a447..9991c12a96a 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUselessTypeOperationCallChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUselessTypeOperationCallChecker.kt @@ -53,7 +53,7 @@ object FirUselessTypeOperationCallChecker : FirTypeOperatorCallChecker(MppChecke return when (expression.operation) { FirOperation.AS, FirOperation.SAFE_AS -> { if (arg is FirFunctionCall) { - val functionSymbol = arg.toResolvedCallableSymbol() as? FirFunctionSymbol<*> + val functionSymbol = arg.toResolvedCallableSymbol(context.session) as? FirFunctionSymbol<*> if (functionSymbol != null && functionSymbol.isFunctionForExpectTypeFromCastFeature()) return false } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt index 87e21a5f237..7dbe3c1d817 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt @@ -60,7 +60,7 @@ class ErrorNodeDiagnosticCollectorComponent( var source = reference.source val callOrAssignment = context.callsOrAssignments.lastOrNull()?.takeIf { // Use the source of the enclosing FirQualifiedAccess if it is exactly the call to the erroneous callee. - it.toReference() == reference + it.toReference(session) == reference } // Don't report duplicated unresolved reference on annotation entry (already reported on its type) if (source?.elementType == KtNodeTypes.ANNOTATION_ENTRY && diagnostic is ConeUnresolvedNameError) return diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt index df30625fcab..0d9cc3d1491 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt @@ -14,9 +14,7 @@ import org.jetbrains.kotlin.diagnostics.rendering.Renderer import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.containingClassLookupTag import org.jetbrains.kotlin.fir.declarations.utils.* -import org.jetbrains.kotlin.fir.expressions.FirExpression -import org.jetbrains.kotlin.fir.expressions.toReference -import org.jetbrains.kotlin.fir.expressions.unwrapSmartcastExpression +import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.references.FirNamedReference import org.jetbrains.kotlin.fir.references.FirSuperReference import org.jetbrains.kotlin.fir.references.FirThisReference @@ -84,7 +82,8 @@ object FirDiagnosticRenderers { } val CALLEE_NAME = Renderer { element: FirExpression -> - when (val reference = element.unwrapSmartcastExpression().toReference()) { + @OptIn(UnsafeExpressionUtility::class) + when (val reference = element.unwrapSmartcastExpression().toReferenceUnsafe()) { is FirNamedReference -> reference.name.asString() is FirThisReference -> "this" is FirSuperReference -> "super" diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt index ddf11b653c7..6367660a77b 100644 --- a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt +++ b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt @@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirArrayOfCall import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol -import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.resolvedType import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor @@ -108,7 +107,7 @@ internal object FirToConstantValueTransformer : FirDefaultVisitor arguments.flatMap { it.toEnumNames() } is FirVarargArgumentsExpression -> arguments.flatMap { it.toEnumNames() } else -> { - val name = when (val reference = toReference()) { + val name = when (val reference = toReference(session)) { is FirResolvedNamedReference -> (reference.resolvedSymbol as? FirCallableSymbol<*>)?.callableId?.callableName?.asString() is FirFromMissingDependenciesNamedReference -> reference.name.asString() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt index a0908f3cfb2..b57f704a752 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt @@ -114,7 +114,7 @@ class FirCallResolver( val resultFunctionCall = if (candidate != null && candidate.callInfo != result.info) { // This branch support case for the call of the type `a.invoke()` // 1. Handle candidate for `a` - (resolvedReceiver?.toReference() as? FirNamedReferenceWithCandidate)?.candidate?.updateSourcesOfReceivers() + (resolvedReceiver?.toReference(session) as? FirNamedReferenceWithCandidate)?.candidate?.updateSourcesOfReceivers() // 2. Handle candidate for `invoke` candidate.updateSourcesOfReceivers() functionCall.copyAsImplicitInvokeCall { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt index 733a360c5d2..16b01567e75 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt @@ -533,7 +533,7 @@ private fun getExpectedTypeWithImplicitIntegerCoercion( if (argument.isIntegerLiteralOrOperatorCall()) { argument.resolvedType } else { - argument.toReference()?.toResolvedCallableSymbol()?.takeIf { + argument.toReference(session)?.toResolvedCallableSymbol()?.takeIf { it.rawStatus.isConst && it.isMarkedWithImplicitIntegerCoercion }?.resolvedReturnType } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt index e388401910e..4b1460d1ece 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt @@ -320,7 +320,7 @@ object CheckDslScopeViolation : ResolutionStage() { override suspend fun check(candidate: Candidate, callInfo: CallInfo, sink: CheckerSink, context: ResolutionContext) { fun checkReceiver(receiver: FirExpression?) { - val thisReference = receiver?.toReference() as? FirThisReference ?: return + val thisReference = receiver?.toReference(context.session) as? FirThisReference ?: return if (thisReference.isImplicit) { checkImpl( candidate, @@ -755,7 +755,7 @@ internal object CheckHiddenDeclaration : ResolutionStage() { /** Actual declarations are checked by [FirDeprecationChecker] */ if (symbol.isActual) return val deprecation = symbol.getDeprecation(context.session, callInfo.callSite) - if (deprecation?.deprecationLevel == DeprecationLevelValue.HIDDEN || isHiddenForThisCallSite(symbol, callInfo, candidate)) { + if (deprecation?.deprecationLevel == DeprecationLevelValue.HIDDEN || isHiddenForThisCallSite(symbol, callInfo, candidate, context.session)) { sink.yieldDiagnostic(HiddenCandidate) } } @@ -764,8 +764,9 @@ internal object CheckHiddenDeclaration : ResolutionStage() { symbol: FirCallableSymbol<*>, callInfo: CallInfo, candidate: Candidate, + session: FirSession ): Boolean { - val isSuperCall = callInfo.callSite.isSuperCall() + val isSuperCall = callInfo.callSite.isSuperCall(session) if (symbol.fir.dispatchReceiverType == null || symbol !is FirNamedFunctionSymbol) return false if (symbol.isHidden(isSuperCall)) return true @@ -784,8 +785,8 @@ internal object CheckHiddenDeclaration : ResolutionStage() { return result } - private fun FirElement.isSuperCall(): Boolean = - this is FirQualifiedAccessExpression && explicitReceiver?.toReference() is FirSuperReference + private fun FirElement.isSuperCall(session: FirSession): Boolean = + this is FirQualifiedAccessExpression && explicitReceiver?.toReference(session) is FirSuperReference private fun FirCallableSymbol<*>.isHidden(isSuperCall: Boolean): Boolean { val fir = fir diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/VisibilityUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/VisibilityUtils.kt index 76423459294..a9399a31982 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/VisibilityUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/VisibilityUtils.kt @@ -166,7 +166,8 @@ private fun FirMemberDeclaration.getBackingFieldIfApplicable(): FirBackingField? private fun isExplicitReceiverExpression(receiverExpression: FirExpression?): Boolean { if (receiverExpression == null) return false // Only FirThisReference may be a reference in implicit receiver - val thisReference = receiverExpression.toReference() as? FirThisReference ?: return true + @OptIn(UnsafeExpressionUtility::class) + val thisReference = receiverExpression.toReferenceUnsafe() as? FirThisReference ?: return true return !thisReference.isImplicit } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt index 43b3704aaae..acdb95d8e4b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt @@ -306,7 +306,9 @@ private object WhenOnEnumExhaustivenessChecker : WhenExhaustivenessChecker() { override fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: MutableSet) { if (!equalityOperatorCall.operation.let { it == FirOperation.EQ || it == FirOperation.IDENTITY }) return val argument = equalityOperatorCall.arguments[1] - val symbol = argument.toResolvedCallableReference()?.resolvedSymbol as? FirVariableSymbol<*> ?: return + + @OptIn(UnsafeExpressionUtility::class) + val symbol = argument.toResolvedCallableReferenceUnsafe()?.resolvedSymbol as? FirVariableSymbol<*> ?: return val checkedEnumEntry = symbol.fir as? FirEnumEntry ?: return data.add(checkedEnumEntry) } @@ -360,7 +362,8 @@ private object WhenOnSealedClassExhaustivenessChecker : WhenExhaustivenessChecke } } else -> { - argument.toResolvedCallableSymbol()?.takeIf { it.fir is FirEnumEntry } + @OptIn(UnsafeExpressionUtility::class) + argument.toResolvedCallableSymbolUnsafe()?.takeIf { it.fir is FirEnumEntry } } } ?: return processBranch(symbol, isNegated, data) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index 25b311269ff..291eebf215c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt @@ -591,7 +591,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT val generator = GeneratorOfPlusAssignCalls( assignmentOperatorStatement, - assignmentOperatorStatement.toReference()?.source, + assignmentOperatorStatement.toReference(session)?.source, operation, leftArgument, rightArgument @@ -623,7 +623,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT // following `!!` is safe since `operatorIsSuccessful = true` implies `operatorCallReference != null` val operatorReturnTypeMatches = operatorIsSuccessful && operatorReturnTypeMatches(operatorCallReference!!.candidate) - val lhsReference = leftArgument.toReference() + val lhsReference = leftArgument.toReference(session) val lhsSymbol = lhsReference?.toResolvedVariableSymbol() val lhsVariable = lhsSymbol?.fir val lhsIsVar = lhsVariable?.isVar == true diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/ConeEffectExtractor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/ConeEffectExtractor.kt index 6d2ea05c4b2..bdb2cf7f847 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/ConeEffectExtractor.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/ConeEffectExtractor.kt @@ -235,7 +235,7 @@ class ConeEffectExtractor( private fun FirExpression.parseInvocationKind(): EventOccurrencesRange? { if (this !is FirQualifiedAccessExpression) return null - val resolvedId = toResolvedCallableSymbol()?.callableId ?: return null + val resolvedId = toResolvedCallableSymbol(session)?.callableId ?: return null return when (resolvedId) { FirContractsDslNames.EXACTLY_ONCE_KIND -> EventOccurrencesRange.EXACTLY_ONCE FirContractsDslNames.AT_LEAST_ONCE_KIND -> EventOccurrencesRange.AT_LEAST_ONCE diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/AbstractFirSpecificAnnotationResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/AbstractFirSpecificAnnotationResolveTransformer.kt index 594dcf0cebf..697c79c2ede 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/AbstractFirSpecificAnnotationResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/AbstractFirSpecificAnnotationResolveTransformer.kt @@ -213,7 +213,7 @@ abstract class AbstractFirSpecificAnnotationResolveTransformer( // If fully qualified, check that given package name matches the resolved one. val segments = generateSequence(receiver.explicitReceiver) { (it as? FirQualifiedAccessExpression)?.explicitReceiver } - .mapNotNull { (it.toReference() as? FirSimpleNamedReference)?.name?.identifier } + .mapNotNull { (it.toReference(session) as? FirSimpleNamedReference)?.name?.identifier } .toList() if (segments.isNotEmpty() && FqName.fromSegments(segments.asReversed()) != symbol.classId.packageFqName) { diff --git a/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/expressions/ReferenceUtils.kt b/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/expressions/ReferenceUtils.kt index 6a80db1a634..a45b56b58c9 100644 --- a/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/expressions/ReferenceUtils.kt +++ b/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/expressions/ReferenceUtils.kt @@ -6,36 +6,106 @@ package org.jetbrains.kotlin.fir.expressions import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.references.FirReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.resolved import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol -fun FirElement.toReference(): FirReference? { +@RequiresOptIn(level = RequiresOptIn.Level.ERROR) +annotation class UnsafeExpressionUtility + +/** + * Returns the [FirReference] of this [FirElement], if available. + * The reference is resolved in the context of a use-site [session], which may be required to find a symbol for an ID-based expression. + */ +fun FirElement.toReference(session: FirSession): FirReference? { return when (this) { - is FirExpression -> toReference() + is FirExpression -> toReferenceImpl(session) is FirVariableAssignment -> calleeReference is FirResolvable -> calleeReference else -> null } } -fun FirExpression.toReference(): FirReference? { +/** + * Returns the [FirReference] of this [FirExpression], if available. + * The reference is resolved in the context of a use-site [session], which may be required to find a symbol for an ID-based expression. + */ +fun FirExpression.toReference(session: FirSession): FirReference? { + return toReferenceImpl(session) +} + +/** + * This utility won't return proper reference for `FirEnumEntryDeserializedAccessExpression`, + * so use only if you are really sure that it be never called on this node + * + * In most cases it's better to use safe [toReference] methods with session parameter. + */ +@UnsafeExpressionUtility +fun FirExpression.toReferenceUnsafe(): FirReference? { + return toReferenceImpl(session = null) +} + +private fun FirExpression.toReferenceImpl(session: FirSession?): FirReference? { return when (this) { - is FirWrappedArgumentExpression -> expression.toResolvedCallableReference() - is FirSmartCastExpression -> originalExpression.toReference() - is FirDesugaredAssignmentValueReferenceExpression -> expressionRef.value.toReference() + is FirWrappedArgumentExpression -> expression.toResolvedCallableReferenceImpl(session) + is FirSmartCastExpression -> originalExpression.toReferenceImpl(session) + is FirDesugaredAssignmentValueReferenceExpression -> expressionRef.value.toReferenceImpl(session) is FirResolvable -> calleeReference else -> null } } -val FirVariableAssignment.calleeReference: FirReference? get() = lValue.toReference() +val FirVariableAssignment.calleeReference: FirReference? + get() { + // non-nullable session for `toReferenceImpl` is needed only for `FirEnumEntryDeserializedAccessExpression` value, + // which never can appear in the lhs of variable assignment + return lValue.toReferenceImpl(session = null) + } -fun FirExpression.toResolvedCallableReference(): FirResolvedNamedReference? { - return toReference()?.resolved +// -------------------------------------------------------------------------------------------------------- + +fun FirExpression.toResolvedCallableReference(session: FirSession): FirResolvedNamedReference? { + return toResolvedCallableReferenceImpl(session) } -fun FirExpression.toResolvedCallableSymbol(): FirCallableSymbol<*>? { - return toResolvedCallableReference()?.resolvedSymbol as? FirCallableSymbol<*>? +fun FirResolvable.toResolvedCallableReference(): FirResolvedNamedReference? { + return calleeReference.resolved +} + +/** + * This utility won't return proper reference for `FirEnumEntryDeserializedAccessExpression`, + * so use only if you are really sure that it be never called on this node + * + * In most cases it's better to use safe [toResolvedCallableReference] methods with session parameter + */ +@UnsafeExpressionUtility +fun FirExpression.toResolvedCallableReferenceUnsafe(): FirResolvedNamedReference? { + return toResolvedCallableReferenceImpl(session = null) +} + +fun FirExpression.toResolvedCallableReferenceImpl(session: FirSession?): FirResolvedNamedReference? { + return toReferenceImpl(session)?.resolved +} + +// -------------------------------------------------------------------------------------------------------- + +fun FirExpression.toResolvedCallableSymbol(session: FirSession): FirCallableSymbol<*>? { + return toResolvedCallableReference(session)?.resolvedSymbol as? FirCallableSymbol<*>? +} + +fun FirResolvable.toResolvedCallableSymbol(): FirCallableSymbol<*>? { + return toResolvedCallableReference()?.resolvedSymbol as? FirCallableSymbol<*> +} + +/** + * This utility won't return proper reference for `FirEnumEntryDeserializedAccessExpression`, + * so use only if you are really sure that it be never called on this node + * + * In most cases it's better to use safe [toResolvedCallableSymbol] methods with session parameter + */ +@UnsafeExpressionUtility +fun FirExpression.toResolvedCallableSymbolUnsafe(): FirCallableSymbol<*>? { + return toResolvedCallableReferenceUnsafe()?.resolvedSymbol as? FirCallableSymbol<*>? } diff --git a/plugins/lombok/lombok.k2/src/org/jetbrains/kotlin/lombok/k2/config/annotationUtils.kt b/plugins/lombok/lombok.k2/src/org/jetbrains/kotlin/lombok/k2/config/annotationUtils.kt index bac744717e4..a0cf1608236 100644 --- a/plugins/lombok/lombok.k2/src/org/jetbrains/kotlin/lombok/k2/config/annotationUtils.kt +++ b/plugins/lombok/lombok.k2/src/org/jetbrains/kotlin/lombok/k2/config/annotationUtils.kt @@ -8,11 +8,7 @@ package org.jetbrains.kotlin.lombok.k2.config import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.declarations.findArgumentByName import org.jetbrains.kotlin.fir.declarations.getStringArgument -import org.jetbrains.kotlin.fir.expressions.FirAnnotation -import org.jetbrains.kotlin.fir.expressions.FirConstExpression -import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression -import org.jetbrains.kotlin.fir.expressions.toResolvedCallableSymbol -import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol +import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol import org.jetbrains.kotlin.lombok.config.AccessLevel import org.jetbrains.kotlin.lombok.utils.trimToNull @@ -27,8 +23,10 @@ private fun FirAnnotation.getArgumentAsString(field: Name): String? { val argument = findArgumentByName(field) ?: return null return when (argument) { is FirConstExpression<*> -> argument.value as? String + is FirEnumEntryDeserializedAccessExpression -> argument.enumEntryName.identifier is FirQualifiedAccessExpression -> { - val symbol = argument.toResolvedCallableSymbol() + @OptIn(UnsafeExpressionUtility::class) + val symbol = argument.toResolvedCallableSymbolUnsafe() if (symbol is FirEnumEntrySymbol) { symbol.callableId.callableName.identifier } else {