diff --git a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsExportDeclarationChecker.kt b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsExportDeclarationChecker.kt index d5d0614a228..89ce672c061 100644 --- a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsExportDeclarationChecker.kt +++ b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsExportDeclarationChecker.kt @@ -22,8 +22,9 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.* import org.jetbrains.kotlin.fir.expressions.FirConstExpression import org.jetbrains.kotlin.fir.isEnumEntries -import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirPropertyAccessorSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.js.common.RESERVED_KEYWORDS import org.jetbrains.kotlin.js.common.SPECIAL_KEYWORDS @@ -73,7 +74,7 @@ object FirJsExportDeclarationChecker : FirBasicDeclarationChecker() { checkTypeParameter(typeParameter) } - if (declaration.isInlineWithReified) { + if (declaration.symbol.isInlineWithReified) { reportWrongExportedDeclaration("inline function with reified type parameters") return } @@ -153,13 +154,12 @@ object FirJsExportDeclarationChecker : FirBasicDeclarationChecker() { return parent != null && parent.isInterface } - private val FirCallableDeclaration.isInlineWithReified: Boolean + private val FirCallableSymbol<*>.isInlineWithReified: Boolean get() = when (this) { - is FirPropertyAccessor -> { - @OptIn(SymbolInternals::class) - this.propertySymbol.fir.isInlineWithReified + is FirPropertyAccessorSymbol -> { + this.propertySymbol.isInlineWithReified } - else -> typeParameters.any { it.symbol.isReified } + else -> typeParameterSymbols.any { it.isReified } } private fun ConeKotlinType.isExportableReturn(session: FirSession, currentlyProcessed: MutableSet = hashSetOf()) = @@ -208,8 +208,7 @@ object FirJsExportDeclarationChecker : FirBasicDeclarationChecker() { return when { isPrimitiveExportableType -> true - @OptIn(SymbolInternals::class) - symbol?.fir !is FirMemberDeclaration -> false + symbol?.isMemberDeclaration != true -> false isEnum -> true else -> symbol.isEffectivelyExternal(session) || symbol.isExportedObject(session) } diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/FirJvmOverridesBackwardCompatibilityHelper.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/FirJvmOverridesBackwardCompatibilityHelper.kt index 96e51829bcc..33882aed078 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/FirJvmOverridesBackwardCompatibilityHelper.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/FirJvmOverridesBackwardCompatibilityHelper.kt @@ -8,8 +8,8 @@ package org.jetbrains.kotlin.fir.analysis.jvm import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper import org.jetbrains.kotlin.fir.containingClassLookupTag -import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.declarations.isJavaOrEnhancement +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol /** * With JVM compilation @@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.declarations.isJavaOrEnhancement * `kotlin.Throwable` does not require `override` keyword. */ object FirJvmOverridesBackwardCompatibilityHelper : FirOverridesBackwardCompatibilityHelper() { - override fun additionalCheck(member: FirCallableDeclaration): Boolean? { + override fun additionalCheck(member: FirCallableSymbol<*>): Boolean? { if (!member.isJavaOrEnhancement) return false val containingClassName = member.containingClassLookupTag()?.classId?.asSingleFqName()?.toUnsafe() ?: return false // If the super class is mapped to a Kotlin built-in class, then we don't require `override` keyword. diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmStaticChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmStaticChecker.kt index 22cf176395b..10d4b10633c 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmStaticChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmStaticChecker.kt @@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.* import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.languageVersionSettings -import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.coneType @@ -212,10 +211,7 @@ object FirJvmStaticChecker : FirBasicDeclarationChecker() { private fun CheckerContext.containerIsNonCompanionObject(outerLevel: Int): Boolean { val containingClassSymbol = this.getContainerAt(outerLevel) ?: return false - - @OptIn(SymbolInternals::class) - val containingClass = (containingClassSymbol.fir as? FirRegularClass) ?: return false - + val containingClass = (containingClassSymbol as? FirRegularClassSymbol) ?: return false return containingClass.classKind == ClassKind.OBJECT && !containingClass.isCompanion } diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirOverrideJavaNullabilityWarningChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirOverrideJavaNullabilityWarningChecker.kt index 6c343ea75b8..1deff7639fc 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirOverrideJavaNullabilityWarningChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirOverrideJavaNullabilityWarningChecker.kt @@ -7,18 +7,17 @@ package org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration 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.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirAbstractOverrideChecker import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.java.enhancement.EnhancedForWarningConeSubstitutor -import org.jetbrains.kotlin.fir.scopes.firOverrideChecker -import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions -import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenProperties +import org.jetbrains.kotlin.fir.scopes.* import org.jetbrains.kotlin.fir.scopes.impl.FirFakeOverrideGenerator import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.typeContext @@ -41,22 +40,21 @@ object FirOverrideJavaNullabilityWarningChecker : FirAbstractOverrideChecker() { val enhancedOverrides = scope .getDirectOverriddenFunctions(member.symbol) .map { - @OptIn(SymbolInternals::class) - val substitutedBase = it.fir.substituteOrNull(substitutor, context) ?: return@map it + val substitutedBase = it.substituteOrNull(substitutor, context) ?: return@map it anyBaseEnhanced = true - if (!anyReported && !context.session.firOverrideChecker.isOverriddenFunction(member, substitutedBase)) { + if (!anyReported && !context.session.firOverrideChecker.isOverriddenFunction(member.symbol, substitutedBase)) { anyReported = true reporter.reportOn( member.source, FirJvmErrors.WRONG_NULLABILITY_FOR_JAVA_OVERRIDE, member.symbol, - substitutedBase.symbol, + substitutedBase, context ) } - substitutedBase.symbol + substitutedBase } if (anyBaseEnhanced && !anyReported) { @@ -70,22 +68,21 @@ object FirOverrideJavaNullabilityWarningChecker : FirAbstractOverrideChecker() { val enhancedOverrides = scope .getDirectOverriddenProperties(member.symbol) .map { - @OptIn(SymbolInternals::class) - val substitutedBase = it.fir.substituteOrNull(substitutor, context) ?: return@map it + val substitutedBase = it.substituteOrNull(substitutor, context) ?: return@map it anyBaseEnhanced = true - if (!anyReported && !context.session.firOverrideChecker.isOverriddenProperty(member, substitutedBase)) { + if (!anyReported && !context.session.firOverrideChecker.isOverriddenProperty(member.symbol, substitutedBase)) { anyReported = true reporter.reportOn( member.source, FirJvmErrors.WRONG_NULLABILITY_FOR_JAVA_OVERRIDE, member.symbol, - substitutedBase.symbol, + substitutedBase, context ) } - substitutedBase.symbol + substitutedBase } if (anyBaseEnhanced && !anyReported) { @@ -133,6 +130,15 @@ private fun FirSimpleFunction.substituteOrNull( } } +private fun FirNamedFunctionSymbol.substituteOrNull( + substitutor: EnhancedForWarningConeSubstitutor, + context: CheckerContext, +): FirNamedFunctionSymbol? { + // Ok, because `substituteOrNull` calls lazyResolveToPhase + @OptIn(SymbolInternals::class) + return fir.substituteOrNull(substitutor, context)?.symbol +} + /** * @see org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope.createSubstitutionOverrideProperty * @see org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope.createSubstitutedData @@ -163,4 +169,13 @@ private fun FirProperty.substituteOrNull( newReceiverType = newExtensionReceiverType, ) } -} \ No newline at end of file +} + +private fun FirPropertySymbol.substituteOrNull( + substitutor: EnhancedForWarningConeSubstitutor, + context: CheckerContext, +): FirPropertySymbol? { + // Ok, because `substituteOrNull` calls `lazyResolveToPhase` + @OptIn(SymbolInternals::class) + return fir.substituteOrNull(substitutor, context)?.symbol +} diff --git a/compiler/fir/checkers/checkers.wasm/src/org/jetbrains/kotlin/fir/analysis/wasm/checkers/FirWasmWebCheckerUtils.kt b/compiler/fir/checkers/checkers.wasm/src/org/jetbrains/kotlin/fir/analysis/wasm/checkers/FirWasmWebCheckerUtils.kt index ebe7d1c9e63..c9d9017ac18 100644 --- a/compiler/fir/checkers/checkers.wasm/src/org/jetbrains/kotlin/fir/analysis/wasm/checkers/FirWasmWebCheckerUtils.kt +++ b/compiler/fir/checkers/checkers.wasm/src/org/jetbrains/kotlin/fir/analysis/wasm/checkers/FirWasmWebCheckerUtils.kt @@ -7,14 +7,12 @@ package org.jetbrains.kotlin.fir.analysis.wasm.checkers import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.analysis.web.common.checkers.FirAbstractWebCheckerUtils -import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.utils.isEffectivelyExternal import org.jetbrains.kotlin.fir.declarations.utils.isInterface import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol -import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol object FirWasmWebCheckerUtils : FirAbstractWebCheckerUtils() { - @OptIn(SymbolInternals::class) override fun isNativeOrExternalInterface(symbol: FirBasedSymbol<*>, session: FirSession): Boolean = - symbol.isEffectivelyExternal(session) && (symbol.fir as? FirClass)?.isInterface == true + symbol.isEffectivelyExternal(session) && (symbol as? FirClassSymbol<*>)?.isInterface == true } \ No newline at end of file diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/FirOverridesBackwardCompatibilityHelper.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/FirOverridesBackwardCompatibilityHelper.kt index 9d75a38b5e6..6e4110786f0 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/FirOverridesBackwardCompatibilityHelper.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/FirOverridesBackwardCompatibilityHelper.kt @@ -15,8 +15,9 @@ import org.jetbrains.kotlin.fir.declarations.utils.isInterface import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenProperties -import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase import org.jetbrains.kotlin.fir.types.toRegularClassSymbol import org.jetbrains.kotlin.name.ClassId @@ -54,16 +55,14 @@ abstract class FirOverridesBackwardCompatibilityHelper : FirSessionComponent { val originalMemberSymbol = symbol.originalOrSelf() originalMemberSymbol.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE) - @OptIn(SymbolInternals::class) - val originalMember = originalMemberSymbol.fir - if (originalMember.hasAnnotation(platformDependentAnnotation, context.session)) { + if (originalMemberSymbol.hasAnnotation(platformDependentAnnotation, context.session)) { return true } - additionalCheck(originalMember)?.let { return it } + additionalCheck(originalMemberSymbol)?.let { return it } - if (!originalMember.isAbstract) { - val containingClass = originalMember.containingClassLookupTag()?.toFirRegularClassSymbol(context.session) + if (!originalMemberSymbol.isAbstract) { + val containingClass = originalMemberSymbol.containingClassLookupTag()?.toFirRegularClassSymbol(context.session) if (containingClass?.isInterface == false) { return false } @@ -71,16 +70,16 @@ abstract class FirOverridesBackwardCompatibilityHelper : FirSessionComponent { val scope = symbol.dispatchReceiverClassTypeOrNull()?.toRegularClassSymbol(context.session)?.unsubstitutedScope(context) ?: return false - val overriddenSymbols = when (originalMember) { - is FirSimpleFunction -> scope.getDirectOverriddenFunctions(originalMember.symbol) - is FirProperty -> scope.getDirectOverriddenProperties(originalMember.symbol) + val overriddenSymbols = when (originalMemberSymbol) { + is FirNamedFunctionSymbol -> scope.getDirectOverriddenFunctions(originalMemberSymbol) + is FirPropertySymbol -> scope.getDirectOverriddenProperties(originalMemberSymbol) else -> return false } if (overriddenSymbols.isEmpty()) return false return overriddenSymbols.all { isPlatformSpecificSymbolThatCanBeImplicitlyOverridden(it, visitedSymbols, context) } } - protected open fun additionalCheck(member: FirCallableDeclaration): Boolean? = null + protected open fun additionalCheck(member: FirCallableSymbol<*>): Boolean? = null } val FirSession.overridesBackwardCompatibilityHelper: FirOverridesBackwardCompatibilityHelper by FirSession.sessionComponentAccessor() diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirPropertyInitializationAnalyzer.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirPropertyInitializationAnalyzer.kt index 1a29657c946..d72e3b666e4 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirPropertyInitializationAnalyzer.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirPropertyInitializationAnalyzer.kt @@ -85,7 +85,6 @@ fun PropertyInitializationInfoData.checkPropertyAccesses( ) } -@OptIn(SymbolInternals::class) private fun PropertyInitializationInfoData.checkPropertyAccesses( graph: ControlFlowGraph, properties: Set, @@ -116,7 +115,7 @@ private fun PropertyInitializationInfoData.checkPropertyAccesses( node is VariableAssignmentNode -> { val symbol = node.fir.calleeReference?.toResolvedPropertySymbol() ?: continue - if (!symbol.fir.isVal || node.fir.unwrapLValue()?.hasCorrectReceiver() != true || symbol !in properties) continue + if (!symbol.isVal || node.fir.unwrapLValue()?.hasCorrectReceiver() != true || symbol !in properties) continue if (getValue(node).values.any { it[symbol]?.canBeRevisited() == true }) { reporter.reportOn(node.fir.lValue.source, FirErrors.VAL_REASSIGNMENT, symbol, context) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConflictsHelpers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConflictsHelpers.kt index aa9558aa02a..ed85f906281 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConflictsHelpers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConflictsHelpers.kt @@ -518,15 +518,14 @@ private fun FirDeclarationCollector<*>.areNonConflictingCallables( return session.declarationOverloadabilityHelper.isOverloadable(declaration, conflicting) } -@OptIn(SymbolInternals::class) -internal fun FirVariable.getDestructuredParameter(): FirValueParameter? { +internal fun FirVariable.getDestructuredParameter(): FirValueParameterSymbol? { val initializer = initializer if (initializer !is FirComponentCall) return null if (initializer.source?.kind !is KtFakeSourceElementKind.DesugaredComponentFunctionCall) return null val receiver = initializer.dispatchReceiver ?: initializer.extensionReceiver ?: return null if (receiver !is FirPropertyAccessExpression) return null val calleeReference = receiver.calleeReference as? FirResolvedNamedReference ?: return null - return calleeReference.resolvedSymbol.fir as? FirValueParameter + return calleeReference.resolvedSymbol as? FirValueParameterSymbol } /** Checks for redeclarations of value and type parameters, and local variables. */ 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 f0f89304836..fdc7d04f274 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 @@ -9,7 +9,6 @@ import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.declarations.hasAnnotation import org.jetbrains.kotlin.fir.declarations.utils.isConst import org.jetbrains.kotlin.fir.declarations.utils.isStatic @@ -194,19 +193,19 @@ internal fun checkConstantArguments( val propertySymbol = expressionSymbol as? FirPropertySymbol ?: return ConstantArgumentKind.NOT_CONST - @OptIn(SymbolInternals::class) - val property = propertySymbol.fir when { - property.unwrapFakeOverrides().symbol.canBeEvaluated() || property.isCompileTimeBuiltinProperty(session) -> { + propertySymbol.unwrapFakeOverrides().canBeEvaluated() || propertySymbol.isCompileTimeBuiltinProperty(session) -> { val receiver = listOf(expression.dispatchReceiver, expression.extensionReceiver).single { it != null }!! return checkConstantArguments(receiver, session) } propertySymbol.isLocal -> return ConstantArgumentKind.NOT_CONST expressionType.classId == StandardClassIds.KClass -> return ConstantArgumentKind.NOT_KCLASS_LITERAL } - return when (property.initializer) { + // Ok, because we only look at the structure, not resolution-dependent properties. + @OptIn(SymbolInternals::class) + return when (propertySymbol.fir.initializer) { is FirConstExpression<*> -> when { - property.isVal -> ConstantArgumentKind.NOT_CONST_VAL_IN_CONST_EXPRESSION + propertySymbol.isVal -> ConstantArgumentKind.NOT_CONST_VAL_IN_CONST_EXPRESSION else -> ConstantArgumentKind.NOT_CONST } is FirGetClassCall -> ConstantArgumentKind.NOT_KCLASS_LITERAL @@ -255,7 +254,7 @@ private fun FirFunctionCall.isCompileTimeBuiltinCall(session: FirSession): Boole return false } -private fun FirProperty.isCompileTimeBuiltinProperty(session: FirSession): Boolean { +private fun FirPropertySymbol.isCompileTimeBuiltinProperty(session: FirSession): Boolean { val receiverType = dispatchReceiverType ?: receiverParameter?.typeRef?.coneTypeSafe() ?: return false val receiverClassId = receiverType.fullyExpandedClassId(session) ?: return false return when (name.asString()) { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt index 2cbf7a59aa3..8b2abaebeb4 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt @@ -345,13 +345,11 @@ fun FirCallableSymbol<*>.getImplementationStatus( var hasImplementationVar = false for (intersection in symbol.intersections) { - @OptIn(SymbolInternals::class) - val fir = intersection.fir - val unwrappedFir = fir.unwrapFakeOverrides() - val isVar = unwrappedFir is FirProperty && unwrappedFir.isVar - val isFromClass = unwrappedFir.getContainingClassSymbol(sessionHolder.session)?.classKind == ClassKind.CLASS + val unwrapped = intersection.unwrapFakeOverrides() + val isVar = unwrapped is FirPropertySymbol && unwrapped.isVar + val isFromClass = unwrapped.getContainingClassSymbol(sessionHolder.session)?.classKind == ClassKind.CLASS - if (fir.isAbstract) { + if (intersection.isAbstract) { if (isFromClass) { hasAbstractFromClass = true } @@ -359,7 +357,7 @@ fun FirCallableSymbol<*>.getImplementationStatus( hasAbstractVar = true } } else { - if (fir.origin == FirDeclarationOrigin.Delegated) { + if (intersection.origin == FirDeclarationOrigin.Delegated) { hasInterfaceDelegation = true } if (isFromClass) { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsDeclarationChecker.kt index 037242eb00f..36b46bf0ad3 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsDeclarationChecker.kt @@ -53,7 +53,9 @@ object FirConflictsDeclarationChecker : FirBasicDeclarationChecker() { private fun getDestructuredParameters(function: FirFunction): List { if (function.valueParameters.none { it.name == SpecialNames.DESTRUCT }) return function.valueParameters - val destructuredParametersBoxes = function.valueParameters.filterTo(mutableSetOf()) { it.name == SpecialNames.DESTRUCT } + val destructuredParametersBoxes = function.valueParameters + .filter { it.name == SpecialNames.DESTRUCT } + .mapTo(mutableSetOf()) { it.symbol } return function.body?.statements.orEmpty().mapNotNullTo(function.valueParameters.toMutableList()) { val destructuredParameter = (it as? FirVariable)?.getDestructuredParameter() ?: return@mapNotNullTo null diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirFunctionParameterChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirFunctionParameterChecker.kt index 34feabbba3b..03d14430a8d 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirFunctionParameterChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirFunctionParameterChecker.kt @@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind import org.jetbrains.kotlin.fir.expressions.FirPropertyAccessExpression import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.references.toResolvedValueParameterSymbol -import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid @@ -97,8 +96,7 @@ object FirFunctionParameterChecker : FirFunctionChecker() { override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression) { val referredParameter = qualifiedAccessExpression.calleeReference.toResolvedValueParameterSymbol() ?: return - @OptIn(SymbolInternals::class) - val referredParameterIndex = function.valueParameters.indexOf(referredParameter.fir) + val referredParameterIndex = function.valueParameters.indexOfFirst { it.symbol == referredParameter } // Skip if the referred parameter is not declared in the same function. if (referredParameterIndex < 0) return diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirDeprecatedQualifierChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirDeprecatedQualifierChecker.kt index 52f570b5ebd..c6aac8043f9 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirDeprecatedQualifierChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirDeprecatedQualifierChecker.kt @@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.declarations.fullyExpandedClass import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeDeprecated -import org.jetbrains.kotlin.fir.symbols.SymbolInternals object FirDeprecatedQualifierChecker : FirResolvedQualifierChecker() { override fun check(expression: FirResolvedQualifier, context: CheckerContext, reporter: DiagnosticReporter) { @@ -27,8 +26,7 @@ object FirDeprecatedQualifierChecker : FirResolvedQualifierChecker() { // is handled automatically when getting deprecationInfo // for the typealias symbol (in FirDeprecationChecker). // Below we check "the last transition". - @OptIn(SymbolInternals::class) - val companionSymbol = expression.symbol?.fullyExpandedClass(context.session)?.fir?.companionObjectSymbol ?: return + val companionSymbol = expression.symbol?.fullyExpandedClass(context.session)?.companionObjectSymbol ?: return FirDeprecationChecker.reportApiStatusIfNeeded(expression.source, companionSymbol, context, reporter) } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirIncompatibleClassExpressionChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirIncompatibleClassExpressionChecker.kt index 28e109f05f8..6cbf4a9f074 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirIncompatibleClassExpressionChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirIncompatibleClassExpressionChecker.kt @@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.declarations.utils.sourceElement import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol -import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.coneType @@ -34,8 +33,7 @@ object FirIncompatibleClassExpressionChecker : FirQualifiedAccessExpressionCheck } } - @OptIn(SymbolInternals::class) - checkSourceElement(symbol.fir.containerSource, expression, context, reporter) + checkSourceElement(symbol.containerSource, expression, context, reporter) } internal fun checkType(type: ConeKotlinType?, element: FirElement, context: CheckerContext, reporter: DiagnosticReporter) { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirLateinitIntrinsicApplicabilityChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirLateinitIntrinsicApplicabilityChecker.kt index 15a0001efd0..a96b58be060 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirLateinitIntrinsicApplicabilityChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirLateinitIntrinsicApplicabilityChecker.kt @@ -10,7 +10,6 @@ import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors -import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirFunction import org.jetbrains.kotlin.fir.declarations.hasAnnotation import org.jetbrains.kotlin.fir.declarations.utils.isInline @@ -19,7 +18,7 @@ import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.references.toResolvedPropertySymbol import org.jetbrains.kotlin.fir.resolve.providers.firProvider -import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.name.StandardClassIds.Annotations @@ -51,7 +50,8 @@ object FirLateinitIntrinsicApplicabilityChecker : FirQualifiedAccessExpressionCh } // property must be declared in one of the outer lexical scopes - if (calleePropertySymbol.containingClassOrFile(context) !in context.containingDeclarations) { + val containingSymbol = calleePropertySymbol.containingClassOrFile(context) + if (context.containingDeclarations.none { it.symbol == containingSymbol }) { reporter.reportOn( source, FirErrors.LATEINIT_INTRINSIC_CALL_ON_NON_ACCESSIBLE_PROPERTY, @@ -70,11 +70,10 @@ object FirLateinitIntrinsicApplicabilityChecker : FirQualifiedAccessExpressionCh /** * Returns the containing class or file if the property is top-level. */ - @OptIn(SymbolInternals::class) private fun FirPropertySymbol.containingClassOrFile( context: CheckerContext - ): FirDeclaration? { - return getContainingClassSymbol(context.session)?.fir - ?: context.session.firProvider.getFirCallableContainerFile(this) + ): FirBasedSymbol<*>? { + return getContainingClassSymbol(context.session) + ?: context.session.firProvider.getFirCallableContainerFile(this)?.symbol } } 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 index 148e5dcbca2..0348f93753a 100644 --- 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 @@ -150,9 +150,8 @@ object FirOptInUsageBaseChecker { fromSetter = false, dispatchReceiverType = null, fromSupertype = true ) - @OptIn(SymbolInternals::class) fun FirClassLikeSymbol<*>.isExperimentalMarker(session: FirSession) = - this is FirRegularClassSymbol && fir.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID, session) != null + this is FirRegularClassSymbol && getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID, session) != null @OptIn(SymbolInternals::class) private fun FirBasedSymbol<*>.loadExperimentalities( @@ -284,7 +283,7 @@ object FirOptInUsageBaseChecker { else -> null } - val severity = Experimentality.Severity.values().firstOrNull { it.name == levelName } ?: Experimentality.DEFAULT_SEVERITY + val severity = Experimentality.Severity.entries.firstOrNull { it.name == levelName } ?: Experimentality.DEFAULT_SEVERITY val message = (experimental.findArgumentByName(MESSAGE) as? FirConstExpression<*>)?.value as? String return Experimentality(symbol.classId, severity, message, annotatedOwnerClassName) } diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/FirOverrideChecker.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/FirOverrideChecker.kt index d8dd81f281e..04863273112 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/FirOverrideChecker.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/FirOverrideChecker.kt @@ -10,7 +10,9 @@ import org.jetbrains.kotlin.fir.FirSessionComponent import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol interface FirOverrideChecker : FirSessionComponent { fun isOverriddenFunction( @@ -29,4 +31,9 @@ fun FirOverrideChecker.isOverriddenFunction( baseDeclaration: FirNamedFunctionSymbol ): Boolean = isOverriddenFunction(overrideCandidate.fir, baseDeclaration.fir) +fun FirOverrideChecker.isOverriddenProperty( + overrideCandidate: FirCallableSymbol<*>, + baseDeclaration: FirPropertySymbol +): Boolean = isOverriddenProperty(overrideCandidate.fir, baseDeclaration.fir) + val FirSession.firOverrideChecker: FirOverrideChecker by FirSession.sessionComponentAccessor() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirDeclarationUtil.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirDeclarationUtil.kt index a26dd1471f1..0ce4f218a46 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirDeclarationUtil.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirDeclarationUtil.kt @@ -50,6 +50,10 @@ val FirDeclaration.isNonLocal val FirCallableDeclaration.isExtension get() = receiverParameter != null +val FirBasedSymbol<*>.isMemberDeclaration: Boolean + // Accessing `fir` is ok, because we don't really use it + get() = fir is FirMemberDeclaration + val FirBasedSymbol<*>.memberDeclarationNameOrNull: Name? // Accessing `fir` is ok, because `nameOrSpecialName` only accesses names get() = (fir as? FirMemberDeclaration)?.nameOrSpecialName diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt index 3ddbe4787c7..da45a78add0 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt @@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.mpp.CallableSymbolMarker import org.jetbrains.kotlin.name.CallableId import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource abstract class FirCallableSymbol : FirBasedSymbol(), CallableSymbolMarker { abstract val callableId: CallableId @@ -76,6 +77,10 @@ abstract class FirCallableSymbol : FirBasedSymbol val name: Name get() = callableId.callableName + val containerSource: DeserializedContainerSource? + // This is ok, because containerSource should be set during fir creation + get() = fir.containerSource + fun getDeprecation(languageVersionSettings: LanguageVersionSettings): DeprecationsPerUseSite? { lazyResolveToPhase(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) return fir.deprecationsProvider.getDeprecationsInfo(languageVersionSettings)