diff --git a/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/AbstractFirLoadBinariesTest.kt b/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/AbstractFirLoadBinariesTest.kt index 8ee7857e8f9..329f4691b83 100644 --- a/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/AbstractFirLoadBinariesTest.kt +++ b/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/AbstractFirLoadBinariesTest.kt @@ -7,12 +7,14 @@ package org.jetbrains.kotlin.fir import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.fir.resolve.symbolProvider +import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.test.KotlinTestUtils import java.io.File +@OptIn(SymbolInternals::class) abstract class AbstractFirLoadBinariesTest : AbstractFirResolveWithSessionTestCase() { /** * Since fir symbol providers can't get all names in package (only fir provider can do it), diff --git a/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt b/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt index 34a299a54d0..2d7f23b62c2 100644 --- a/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt +++ b/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.fir.createSessionForTests import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass import org.jetbrains.kotlin.fir.resolve.symbolProvider import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCompositeSymbolProvider +import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -39,6 +40,7 @@ import java.io.File import java.io.IOException import kotlin.reflect.jvm.javaField +@OptIn(SymbolInternals::class) abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() { private lateinit var javaFilesDir: File diff --git a/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/JavaClassRendering.kt b/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/JavaClassRendering.kt index 9ac4e864382..5998b492959 100644 --- a/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/JavaClassRendering.kt +++ b/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/JavaClassRendering.kt @@ -16,8 +16,10 @@ import org.jetbrains.kotlin.fir.java.declarations.FirJavaField import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope +import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +@OptIn(SymbolInternals::class) fun renderJavaClass(renderer: FirRenderer, javaClass: FirJavaClass, session: FirSession) { val memberScope = javaClass.unsubstitutedScope(session, ScopeSession(), withForcedTypeCalculator = true) diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt index 555e4190843..1990beb0a0b 100644 --- a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt +++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt @@ -134,7 +134,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { val NOT_A_SUPERTYPE by error() val SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE by error() val QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE by error { - parameter("otherSuperType") + parameter("otherSuperType") } val SUPERTYPE_INITIALIZED_IN_INTERFACE by error() val INTERFACE_WITH_SUPERCLASS by error() @@ -384,10 +384,10 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { val NON_VARARG_SPREAD by error() val ARGUMENT_PASSED_TWICE by error(PositioningStrategy.NAME_OF_NAMED_ARGUMENT) val TOO_MANY_ARGUMENTS by error { - parameter("function") + parameter>("function") } val NO_VALUE_FOR_PARAMETER by error(PositioningStrategy.VALUE_ARGUMENTS) { - parameter("violatedParameter") + parameter("violatedParameter") } val NAMED_PARAMETER_NOT_FOUND by error(PositioningStrategy.NAME_OF_NAMED_ARGUMENT) { @@ -498,7 +498,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { val NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER by error { parameter("typeParameterName") - parameter("typeParametersOwner") + parameter("typeParametersOwner") } val BOUND_ON_TYPE_ALIAS_PARAMETER_NOT_ALLOWED by error() @@ -556,7 +556,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { val REFLECTION by object : DiagnosticGroup("Reflection") { val EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED by error(PositioningStrategy.REFERENCE_BY_QUALIFIED) { - parameter("referencedDeclaration") + parameter>("referencedDeclaration") } val CALLABLE_REFERENCE_LHS_NOT_A_CLASS by error() val CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR by error(PositioningStrategy.REFERENCE_BY_QUALIFIED) @@ -570,123 +570,123 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { val OVERRIDES by object : DiagnosticGroup("overrides") { val NOTHING_TO_OVERRIDE by error(PositioningStrategy.OVERRIDE_MODIFIER) { - parameter("declaration") + parameter>("declaration") } val CANNOT_OVERRIDE_INVISIBLE_MEMBER by error(PositioningStrategy.OVERRIDE_MODIFIER) { - parameter("overridingMember") - parameter("baseMember") + parameter>("overridingMember") + parameter>("baseMember") } val DATA_CLASS_OVERRIDE_CONFLICT by error(PositioningStrategy.DATA_MODIFIER) { - parameter("overridingMember") - parameter("baseMember") + parameter>("overridingMember") + parameter>("baseMember") } val CANNOT_WEAKEN_ACCESS_PRIVILEGE by error(PositioningStrategy.VISIBILITY_MODIFIER) { parameter("overridingVisibility") - parameter("overridden") + parameter>("overridden") parameter("containingClassName") } val CANNOT_CHANGE_ACCESS_PRIVILEGE by error(PositioningStrategy.VISIBILITY_MODIFIER) { parameter("overridingVisibility") - parameter("overridden") + parameter>("overridden") parameter("containingClassName") } val OVERRIDING_FINAL_MEMBER by error(PositioningStrategy.OVERRIDE_MODIFIER) { - parameter("overriddenDeclaration") + parameter>("overriddenDeclaration") parameter("containingClassName") } val RETURN_TYPE_MISMATCH_ON_INHERITANCE by error(PositioningStrategy.DECLARATION_NAME) { - parameter("conflictingDeclaration1") - parameter("conflictingDeclaration2") + parameter>("conflictingDeclaration1") + parameter>("conflictingDeclaration2") } val PROPERTY_TYPE_MISMATCH_ON_INHERITANCE by error(PositioningStrategy.DECLARATION_NAME) { - parameter("conflictingDeclaration1") - parameter("conflictingDeclaration2") + parameter>("conflictingDeclaration1") + parameter>("conflictingDeclaration2") } val VAR_TYPE_MISMATCH_ON_INHERITANCE by error(PositioningStrategy.DECLARATION_NAME) { - parameter("conflictingDeclaration1") - parameter("conflictingDeclaration2") + parameter>("conflictingDeclaration1") + parameter>("conflictingDeclaration2") } val RETURN_TYPE_MISMATCH_BY_DELEGATION by error(PositioningStrategy.DECLARATION_NAME) { - parameter("delegateDeclaration") - parameter("baseDeclaration") + parameter>("delegateDeclaration") + parameter>("baseDeclaration") } val PROPERTY_TYPE_MISMATCH_BY_DELEGATION by error(PositioningStrategy.DECLARATION_NAME) { - parameter("delegateDeclaration") - parameter("baseDeclaration") + parameter>("delegateDeclaration") + parameter>("baseDeclaration") } val VAR_OVERRIDDEN_BY_VAL_BY_DELEGATION by error(PositioningStrategy.DECLARATION_NAME) { - parameter("delegateDeclaration") - parameter("baseDeclaration") + parameter>("delegateDeclaration") + parameter>("baseDeclaration") } val CONFLICTING_INHERITED_MEMBERS by error(PositioningStrategy.DECLARATION_NAME) { - parameter>("conflictingDeclarations") + parameter>>("conflictingDeclarations") } val ABSTRACT_MEMBER_NOT_IMPLEMENTED by error(PositioningStrategy.DECLARATION_NAME) { - parameter("classOrObject") - parameter("missingDeclaration") + parameter>("classOrObject") + parameter>("missingDeclaration") } val ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED by error(PositioningStrategy.DECLARATION_NAME) { - parameter("classOrObject") - parameter("missingDeclaration") + parameter>("classOrObject") + parameter>("missingDeclaration") } val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER by error(PositioningStrategy.DECLARATION_NAME) { - parameter("classOrObject") - parameter("invisibleDeclaration") + parameter>("classOrObject") + parameter>("invisibleDeclaration") } val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING by warning(PositioningStrategy.DECLARATION_NAME) { - parameter("classOrObject") - parameter("invisibleDeclaration") + parameter>("classOrObject") + parameter>("invisibleDeclaration") } val MANY_IMPL_MEMBER_NOT_IMPLEMENTED by error(PositioningStrategy.DECLARATION_NAME) { - parameter("classOrObject") - parameter("missingDeclaration") + parameter>("classOrObject") + parameter>("missingDeclaration") } val MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED by error(PositioningStrategy.DECLARATION_NAME) { - parameter("classOrObject") - parameter("missingDeclaration") + parameter>("classOrObject") + parameter>("missingDeclaration") } val OVERRIDING_FINAL_MEMBER_BY_DELEGATION by error(PositioningStrategy.DECLARATION_NAME) { - parameter("delegatedDeclaration") - parameter("overriddenDeclaration") + parameter>("delegatedDeclaration") + parameter>("overriddenDeclaration") } val DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE by warning(PositioningStrategy.DECLARATION_NAME) { - parameter("delegatedDeclaration") - parameter("overriddenDeclaration") + parameter>("delegatedDeclaration") + parameter>("overriddenDeclaration") } val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error(PositioningStrategy.DECLARATION_RETURN_TYPE) { - parameter("function") - parameter("superFunction") + parameter>("function") + parameter>("superFunction") } val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error(PositioningStrategy.DECLARATION_RETURN_TYPE) { - parameter("property") - parameter("superProperty") + parameter>("property") + parameter>("superProperty") } val VAR_TYPE_MISMATCH_ON_OVERRIDE by error(PositioningStrategy.DECLARATION_RETURN_TYPE) { - parameter("variable") - parameter("superVariable") + parameter>("variable") + parameter>("superVariable") } val VAR_OVERRIDDEN_BY_VAL by error(PositioningStrategy.VAL_OR_VAR_NODE) { - parameter("overridingDeclaration") - parameter("overriddenDeclaration") + parameter>("overridingDeclaration") + parameter>("overriddenDeclaration") } val NON_FINAL_MEMBER_IN_FINAL_CLASS by warning(PositioningStrategy.OPEN_MODIFIER) val NON_FINAL_MEMBER_IN_OBJECT by warning(PositioningStrategy.OPEN_MODIFIER) val VIRTUAL_MEMBER_HIDDEN by error(PositioningStrategy.DECLARATION_NAME) { - parameter("declared") - parameter("overriddenContainer") + parameter>("declared") + parameter("overriddenContainer") } } @@ -712,21 +712,21 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { val FUNCTIONS by object : DiagnosticGroup("Functions") { val ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS by error(PositioningStrategy.MODALITY_MODIFIER) { - parameter("function") - parameter("containingClass") + parameter>("function") + parameter>("containingClass") } val ABSTRACT_FUNCTION_WITH_BODY by error(PositioningStrategy.MODALITY_MODIFIER) { - parameter("function") + parameter>("function") } val NON_ABSTRACT_FUNCTION_WITH_NO_BODY by error(PositioningStrategy.DECLARATION_SIGNATURE) { - parameter("function") + parameter>("function") } val PRIVATE_FUNCTION_WITH_NO_BODY by error(PositioningStrategy.VISIBILITY_MODIFIER) { - parameter("function") + parameter>("function") } val NON_MEMBER_FUNCTION_NO_BODY by error(PositioningStrategy.DECLARATION_SIGNATURE) { - parameter("function") + parameter>("function") } val FUNCTION_DECLARATION_WITH_NO_NAME by error(PositioningStrategy.DECLARATION_SIGNATURE) @@ -756,8 +756,8 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { val PROPERTIES_AND_ACCESSORS by object : DiagnosticGroup("Properties & accessors") { val ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS by error(PositioningStrategy.MODALITY_MODIFIER) { - parameter("property") - parameter("containingClass") + parameter>("property") + parameter>("containingClass") } val PRIVATE_PROPERTY_IN_INTERFACE by error(PositioningStrategy.VISIBILITY_MODIFIER) @@ -844,10 +844,10 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { parameter("variable") } val UNINITIALIZED_PARAMETER by error { - parameter>("parameter") + parameter("parameter") } val UNINITIALIZED_ENUM_ENTRY by error { - parameter>("enumEntry") + parameter("enumEntry") } val UNINITIALIZED_ENUM_COMPANION by error(PositioningStrategy.REFERENCE_BY_QUALIFIED) { parameter("enumClass") @@ -856,10 +856,10 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { parameter>("variable") } val VAL_REASSIGNMENT_VIA_BACKING_FIELD by warning { - parameter("property") + parameter("property") } val VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR by error { - parameter("property") + parameter("property") } val CAPTURED_VAL_INITIALIZATION by error { parameter("property") @@ -1099,7 +1099,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { private val exposedVisibilityDiagnosticInit: DiagnosticBuilder.() -> Unit = { parameter("elementVisibility") - parameter("restrictingDeclaration") + parameter("restrictingDeclaration") parameter("restrictingVisibility") } 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 c63ae96434b..695337aaf4c 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,11 +8,12 @@ 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.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClass +import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope import org.jetbrains.kotlin.fir.containingClass import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin import org.jetbrains.kotlin.fir.declarations.FirProperty +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction import org.jetbrains.kotlin.fir.declarations.utils.isAbstract import org.jetbrains.kotlin.fir.declarations.utils.isFinal @@ -22,6 +23,8 @@ import org.jetbrains.kotlin.fir.originalOrSelf import org.jetbrains.kotlin.fir.resolve.toFirRegularClass 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.ensureResolved import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.classId @@ -55,13 +58,15 @@ object FirJvmOverridesBackwardCompatibilityHelper : FirOverridesBackwardCompatib visitedSymbols: MutableSet>, context: CheckerContext ): Boolean { - val fir = symbol.fir - if (fir.isFinal) return false + if (symbol.isFinal) return false if (symbol in visitedSymbols) return true visitedSymbols += symbol - val originalMember = fir.originalOrSelf() + val originalMemberSymbol = symbol.originalOrSelf() + originalMemberSymbol.ensureResolved(FirResolvePhase.BODY_RESOLVE) + @OptIn(SymbolInternals::class) + val originalMember = originalMemberSymbol.fir if (originalMember.annotations.any { it.annotationTypeRef.coneTypeSafe()?.classId == platformDependentAnnotation }) { return true } @@ -81,7 +86,7 @@ object FirJvmOverridesBackwardCompatibilityHelper : FirOverridesBackwardCompatib } val scope = - symbol.dispatchReceiverTypeOrNull()?.toRegularClass(context.session)?.unsubstitutedScope(context) ?: return false + symbol.dispatchReceiverTypeOrNull()?.toRegularClassSymbol(context.session)?.unsubstitutedScope(context) ?: return false val overriddenSymbols = when (originalMember) { is FirSimpleFunction -> scope.getDirectOverriddenFunctions(originalMember.symbol) is FirProperty -> scope.getDirectOverriddenProperties(originalMember.symbol) diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt index 72d7968b16e..a8f46f3bd25 100644 --- a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt @@ -14,21 +14,19 @@ import org.jetbrains.kotlin.descriptors.EffectiveVisibility import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.diagnostics.WhenMissingCase import org.jetbrains.kotlin.fir.analysis.diagnostics.SourceElementPositioningStrategies -import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration -import org.jetbrains.kotlin.fir.declarations.FirClass -import org.jetbrains.kotlin.fir.declarations.FirDeclaration -import org.jetbrains.kotlin.fir.declarations.FirEnumEntry -import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration -import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction -import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.lexer.KtKeywordToken @@ -136,7 +134,7 @@ object FirErrors { val RECURSION_IN_SUPERTYPES by error0() val NOT_A_SUPERTYPE by error0() val SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE by error0() - val QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE by error1() + val QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE by error1>() val SUPERTYPE_INITIALIZED_IN_INTERFACE by error0() val INTERFACE_WITH_SUPERCLASS by error0() val FINAL_SUPERTYPE by error0() @@ -223,15 +221,15 @@ object FirErrors { val EXPERIMENTAL_ANNOTATION_WITH_WRONG_RETENTION by error0() // Exposed visibility - val EXPOSED_TYPEALIAS_EXPANDED_TYPE by error3(SourceElementPositioningStrategies.DECLARATION_NAME) - val EXPOSED_FUNCTION_RETURN_TYPE by error3(SourceElementPositioningStrategies.DECLARATION_NAME) - val EXPOSED_RECEIVER_TYPE by error3() - val EXPOSED_PROPERTY_TYPE by error3(SourceElementPositioningStrategies.DECLARATION_NAME) - val EXPOSED_PROPERTY_TYPE_IN_CONSTRUCTOR by warning3(SourceElementPositioningStrategies.DECLARATION_NAME) - val EXPOSED_PARAMETER_TYPE by error3() - val EXPOSED_SUPER_INTERFACE by error3() - val EXPOSED_SUPER_CLASS by error3() - val EXPOSED_TYPE_PARAMETER_BOUND by error3() + val EXPOSED_TYPEALIAS_EXPANDED_TYPE by error3, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME) + val EXPOSED_FUNCTION_RETURN_TYPE by error3, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME) + val EXPOSED_RECEIVER_TYPE by error3, EffectiveVisibility>() + val EXPOSED_PROPERTY_TYPE by error3, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME) + val EXPOSED_PROPERTY_TYPE_IN_CONSTRUCTOR by warning3, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME) + val EXPOSED_PARAMETER_TYPE by error3, EffectiveVisibility>() + val EXPOSED_SUPER_INTERFACE by error3, EffectiveVisibility>() + val EXPOSED_SUPER_CLASS by error3, EffectiveVisibility>() + val EXPOSED_TYPE_PARAMETER_BOUND by error3, EffectiveVisibility>() // Modifiers val INAPPLICABLE_INFIX_MODIFIER by error0() @@ -274,8 +272,8 @@ object FirErrors { val NAMED_ARGUMENTS_NOT_ALLOWED by error1(SourceElementPositioningStrategies.NAME_OF_NAMED_ARGUMENT) val NON_VARARG_SPREAD by error0() val ARGUMENT_PASSED_TWICE by error0(SourceElementPositioningStrategies.NAME_OF_NAMED_ARGUMENT) - val TOO_MANY_ARGUMENTS by error1() - val NO_VALUE_FOR_PARAMETER by error1(SourceElementPositioningStrategies.VALUE_ARGUMENTS) + val TOO_MANY_ARGUMENTS by error1>() + val NO_VALUE_FOR_PARAMETER by error1(SourceElementPositioningStrategies.VALUE_ARGUMENTS) val NAMED_PARAMETER_NOT_FOUND by error1(SourceElementPositioningStrategies.NAME_OF_NAMED_ARGUMENT) val ASSIGNMENT_TYPE_MISMATCH by error2() val RESULT_TYPE_MISMATCH by error2() @@ -319,7 +317,7 @@ object FirErrors { val ONLY_ONE_CLASS_BOUND_ALLOWED by error0() val REPEATED_BOUND by error0() val CONFLICTING_UPPER_BOUNDS by error1() - val NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER by error2() + val NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER by error2>() val BOUND_ON_TYPE_ALIAS_PARAMETER_NOT_ALLOWED by error0() val REIFIED_TYPE_PARAMETER_NO_INLINE by error0(SourceElementPositioningStrategies.REIFIED_MODIFIER) val TYPE_PARAMETERS_NOT_ALLOWED by error0(SourceElementPositioningStrategies.TYPE_PARAMETERS_LIST) @@ -336,7 +334,7 @@ object FirErrors { val SMARTCAST_IMPOSSIBLE by error3() // Reflection - val EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED by error1(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED) + val EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED by error1>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED) val CALLABLE_REFERENCE_LHS_NOT_A_CLASS by error0() val CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR by error0(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED) val CLASS_LITERAL_LHS_NOT_A_CLASS by error0() @@ -344,34 +342,34 @@ object FirErrors { val EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS by error1() // overrides - val NOTHING_TO_OVERRIDE by error1(SourceElementPositioningStrategies.OVERRIDE_MODIFIER) - val CANNOT_OVERRIDE_INVISIBLE_MEMBER by error2(SourceElementPositioningStrategies.OVERRIDE_MODIFIER) - val DATA_CLASS_OVERRIDE_CONFLICT by error2(SourceElementPositioningStrategies.DATA_MODIFIER) - val CANNOT_WEAKEN_ACCESS_PRIVILEGE by error3(SourceElementPositioningStrategies.VISIBILITY_MODIFIER) - val CANNOT_CHANGE_ACCESS_PRIVILEGE by error3(SourceElementPositioningStrategies.VISIBILITY_MODIFIER) - val OVERRIDING_FINAL_MEMBER by error2(SourceElementPositioningStrategies.OVERRIDE_MODIFIER) - val RETURN_TYPE_MISMATCH_ON_INHERITANCE by error2(SourceElementPositioningStrategies.DECLARATION_NAME) - val PROPERTY_TYPE_MISMATCH_ON_INHERITANCE by error2(SourceElementPositioningStrategies.DECLARATION_NAME) - val VAR_TYPE_MISMATCH_ON_INHERITANCE by error2(SourceElementPositioningStrategies.DECLARATION_NAME) - val RETURN_TYPE_MISMATCH_BY_DELEGATION by error2(SourceElementPositioningStrategies.DECLARATION_NAME) - val PROPERTY_TYPE_MISMATCH_BY_DELEGATION by error2(SourceElementPositioningStrategies.DECLARATION_NAME) - val VAR_OVERRIDDEN_BY_VAL_BY_DELEGATION by error2(SourceElementPositioningStrategies.DECLARATION_NAME) - val CONFLICTING_INHERITED_MEMBERS by error1>(SourceElementPositioningStrategies.DECLARATION_NAME) - val ABSTRACT_MEMBER_NOT_IMPLEMENTED by error2(SourceElementPositioningStrategies.DECLARATION_NAME) - val ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED by error2(SourceElementPositioningStrategies.DECLARATION_NAME) - val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER by error2(SourceElementPositioningStrategies.DECLARATION_NAME) - val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING by warning2(SourceElementPositioningStrategies.DECLARATION_NAME) - val MANY_IMPL_MEMBER_NOT_IMPLEMENTED by error2(SourceElementPositioningStrategies.DECLARATION_NAME) - val MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED by error2(SourceElementPositioningStrategies.DECLARATION_NAME) - val OVERRIDING_FINAL_MEMBER_BY_DELEGATION by error2(SourceElementPositioningStrategies.DECLARATION_NAME) - val DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE by warning2(SourceElementPositioningStrategies.DECLARATION_NAME) - val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error2(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE) - val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error2(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE) - val VAR_TYPE_MISMATCH_ON_OVERRIDE by error2(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE) - val VAR_OVERRIDDEN_BY_VAL by error2(SourceElementPositioningStrategies.VAL_OR_VAR_NODE) + val NOTHING_TO_OVERRIDE by error1>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER) + val CANNOT_OVERRIDE_INVISIBLE_MEMBER by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER) + val DATA_CLASS_OVERRIDE_CONFLICT by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DATA_MODIFIER) + val CANNOT_WEAKEN_ACCESS_PRIVILEGE by error3, Name>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER) + val CANNOT_CHANGE_ACCESS_PRIVILEGE by error3, Name>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER) + val OVERRIDING_FINAL_MEMBER by error2, Name>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER) + val RETURN_TYPE_MISMATCH_ON_INHERITANCE by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) + val PROPERTY_TYPE_MISMATCH_ON_INHERITANCE by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) + val VAR_TYPE_MISMATCH_ON_INHERITANCE by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) + val RETURN_TYPE_MISMATCH_BY_DELEGATION by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) + val PROPERTY_TYPE_MISMATCH_BY_DELEGATION by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) + val VAR_OVERRIDDEN_BY_VAL_BY_DELEGATION by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) + val CONFLICTING_INHERITED_MEMBERS by error1>>(SourceElementPositioningStrategies.DECLARATION_NAME) + val ABSTRACT_MEMBER_NOT_IMPLEMENTED by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) + val ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) + val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) + val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING by warning2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) + val MANY_IMPL_MEMBER_NOT_IMPLEMENTED by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) + val MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) + val OVERRIDING_FINAL_MEMBER_BY_DELEGATION by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) + val DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE by warning2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) + val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE) + val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE) + val VAR_TYPE_MISMATCH_ON_OVERRIDE by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE) + val VAR_OVERRIDDEN_BY_VAL by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.VAL_OR_VAR_NODE) val NON_FINAL_MEMBER_IN_FINAL_CLASS by warning0(SourceElementPositioningStrategies.OPEN_MODIFIER) val NON_FINAL_MEMBER_IN_OBJECT by warning0(SourceElementPositioningStrategies.OPEN_MODIFIER) - val VIRTUAL_MEMBER_HIDDEN by error2(SourceElementPositioningStrategies.DECLARATION_NAME) + val VIRTUAL_MEMBER_HIDDEN by error2, FirRegularClassSymbol>(SourceElementPositioningStrategies.DECLARATION_NAME) // Redeclarations val MANY_COMPANION_OBJECTS by error0(SourceElementPositioningStrategies.COMPANION_OBJECT) @@ -384,11 +382,11 @@ object FirErrors { val LOCAL_INTERFACE_NOT_ALLOWED by error1(SourceElementPositioningStrategies.DECLARATION_NAME) // Functions - val ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS by error2(SourceElementPositioningStrategies.MODALITY_MODIFIER) - val ABSTRACT_FUNCTION_WITH_BODY by error1(SourceElementPositioningStrategies.MODALITY_MODIFIER) - val NON_ABSTRACT_FUNCTION_WITH_NO_BODY by error1(SourceElementPositioningStrategies.DECLARATION_SIGNATURE) - val PRIVATE_FUNCTION_WITH_NO_BODY by error1(SourceElementPositioningStrategies.VISIBILITY_MODIFIER) - val NON_MEMBER_FUNCTION_NO_BODY by error1(SourceElementPositioningStrategies.DECLARATION_SIGNATURE) + val ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS by error2, FirClassSymbol<*>>(SourceElementPositioningStrategies.MODALITY_MODIFIER) + val ABSTRACT_FUNCTION_WITH_BODY by error1>(SourceElementPositioningStrategies.MODALITY_MODIFIER) + val NON_ABSTRACT_FUNCTION_WITH_NO_BODY by error1>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE) + val PRIVATE_FUNCTION_WITH_NO_BODY by error1>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER) + val NON_MEMBER_FUNCTION_NO_BODY by error1>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE) val FUNCTION_DECLARATION_WITH_NO_NAME by error0(SourceElementPositioningStrategies.DECLARATION_SIGNATURE) val ANONYMOUS_FUNCTION_WITH_NAME by error0() val ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE by error0(SourceElementPositioningStrategies.PARAMETER_DEFAULT_VALUE) @@ -407,7 +405,7 @@ object FirErrors { val FUN_INTERFACE_WITH_SUSPEND_FUNCTION by error0(SourceElementPositioningStrategies.FUN_INTERFACE) // Properties & accessors - val ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS by error2(SourceElementPositioningStrategies.MODALITY_MODIFIER) + val ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS by error2, FirClassSymbol<*>>(SourceElementPositioningStrategies.MODALITY_MODIFIER) val PRIVATE_PROPERTY_IN_INTERFACE by error0(SourceElementPositioningStrategies.VISIBILITY_MODIFIER) val ABSTRACT_PROPERTY_WITH_INITIALIZER by error0() val PROPERTY_INITIALIZER_IN_INTERFACE by error0() @@ -456,12 +454,12 @@ object FirErrors { // Control flow diagnostics val UNINITIALIZED_VARIABLE by error1() - val UNINITIALIZED_PARAMETER by error1>() - val UNINITIALIZED_ENUM_ENTRY by error1>() + val UNINITIALIZED_PARAMETER by error1() + val UNINITIALIZED_ENUM_ENTRY by error1() val UNINITIALIZED_ENUM_COMPANION by error1(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED) val VAL_REASSIGNMENT by error1>() - val VAL_REASSIGNMENT_VIA_BACKING_FIELD by warning1() - val VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR by error1() + val VAL_REASSIGNMENT_VIA_BACKING_FIELD by warning1() + val VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR by error1() val CAPTURED_VAL_INITIALIZATION by error1() val CAPTURED_MEMBER_VAL_INITIALIZATION by error1() val SETTER_PROJECTED_OUT by error1(SourceElementPositioningStrategies.ASSIGNMENT_LHS) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt index 290ba6e5717..b90da847e9b 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt @@ -192,7 +192,7 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() { override fun visitFunctionCallNode(node: FunctionCallNode, data: IllegalScopeContext) { val functionSymbol = node.fir.toResolvedCallableSymbol() as? FirFunctionSymbol<*>? - val contractDescription = functionSymbol?.fir?.contractDescription + val contractDescription = functionSymbol?.resolvedContractDescription val callSource = node.fir.explicitReceiver?.source ?: node.fir.source data.checkExpressionForLeakedSymbols(node.fir.explicitReceiver, callSource) { @@ -255,7 +255,7 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() { var dataForNode = visitNode(node, data) val functionSymbol = node.fir.toResolvedCallableSymbol() as? FirFunctionSymbol<*>? - val contractDescription = functionSymbol?.fir?.contractDescription + val contractDescription = functionSymbol?.resolvedContractDescription dataForNode = dataForNode.checkReference(node.fir.explicitReceiver.toQualifiedReference()) { when { @@ -303,9 +303,6 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() { return this?.coneTypeSafe()?.isBuiltinFunctionalType(session) == true } - private val FirFunction.contractDescription: FirContractDescription? - get() = (this as? FirContractDescriptionOwner)?.contractDescription - private fun FirContractDescription?.getParameterCallsEffectDeclaration(index: Int): ConeCallsEffectDeclaration? { val effects = this?.coneEffects val callsEffect = effects?.find { it is ConeCallsEffectDeclaration && it.valueParameterReference.parameterIndex == index } @@ -313,13 +310,13 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() { } private fun FirFunctionCall.getArgumentCallsEffect(arg: FirExpression): EventOccurrencesRange? { - val function = (this.toResolvedCallableSymbol() as? FirFunctionSymbol<*>?)?.fir - val contractDescription = function?.contractDescription + val functionSymbol = (this.toResolvedCallableSymbol() as? FirFunctionSymbol<*>?) + val contractDescription = functionSymbol?.resolvedContractDescription val resolvedArguments = argumentList as? FirResolvedArgumentList - return if (function != null && resolvedArguments != null) { + return if (functionSymbol != null && resolvedArguments != null) { val parameter = resolvedArguments.mapping[arg] - contractDescription.getParameterCallsEffect(function.valueParameters.indexOf(parameter)) + contractDescription.getParameterCallsEffect(functionSymbol.valueParameterSymbols.indexOf(parameter?.symbol)) } else null } 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 a773ecd3545..b6d5853e806 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 @@ -18,9 +18,11 @@ import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.resolve.dfa.cfg.* +import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol +@OptIn(SymbolInternals::class) object FirPropertyInitializationAnalyzer : AbstractFirPropertyInitializationChecker() { override fun analyze( graph: ControlFlowGraph, diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt index a9c4e0d1b8b..aa1780356b0 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.fir.resolve.dfa.cfg.CFGNode import org.jetbrains.kotlin.fir.resolve.dfa.cfg.ControlFlowGraph import org.jetbrains.kotlin.fir.resolve.dfa.cfg.JumpNode import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol +import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.impl.FirPropertyAccessorSymbol import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.types.* @@ -157,8 +158,11 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker() { context: CheckerContext ): MutableTypeStatements? { fun buildTypeStatements(arg: ConeValueParameterReference, exactType: Boolean, type: ConeKotlinType): MutableTypeStatements? { - val fir = function.getParameterSymbol(arg.parameterIndex, context).fir - val realVar = variableStorage.getOrCreateRealVariable(flow, fir.symbol, fir) + val parameterSymbol = function.getParameterSymbol(arg.parameterIndex, context) + + @OptIn(SymbolInternals::class) + val parameter = parameterSymbol.fir + val realVar = variableStorage.getOrCreateRealVariable(flow, parameterSymbol, parameter) ?.takeIf { it.stability == PropertyStability.STABLE_VALUE || // TODO: consider removing the part below diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/ConeTypeCompatibilityChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/ConeTypeCompatibilityChecker.kt index da32ee74e24..a248e43aaf3 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/ConeTypeCompatibilityChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/ConeTypeCompatibilityChecker.kt @@ -11,11 +11,10 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.* import org.jetbrains.kotlin.fir.isPrimitiveType import org.jetbrains.kotlin.fir.languageVersionSettings -import org.jetbrains.kotlin.fir.resolve.calls.fullyExpandedClass import org.jetbrains.kotlin.fir.resolve.getSymbolByLookupTag import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag -import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol +import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.types.Variance @@ -104,7 +103,7 @@ internal object ConeTypeCompatibilityChecker { upperBounds: Set, lowerBounds: Set, compatibilityUpperBound: Compatibility, - checkedTypeParameters: MutableSet = mutableSetOf(), + checkedTypeParameters: MutableSet = mutableSetOf(), ): Compatibility { val upperBoundClasses: Set = upperBounds.mapNotNull { it.toFirClassWithSuperClasses(this) }.toSet() @@ -134,7 +133,7 @@ internal object ConeTypeCompatibilityChecker { // Base types are compatible. Now we check type parameters. - val typeArgumentMapping = mutableMapOf().apply { + val typeArgumentMapping = mutableMapOf().apply { for (type in upperBounds) { collectTypeArgumentMapping(type, this@areCompatible, compatibilityUpperBound) } @@ -277,7 +276,7 @@ internal object ConeTypeCompatibilityChecker { * - type parameter of `Collection` -> upper:[`String`, `Int`], lower:[] * - type parameter of `Iterable` -> upper:[`String`, `Int`], lower:[] */ - private fun MutableMap.collectTypeArgumentMapping( + private fun MutableMap.collectTypeArgumentMapping( coneType: ConeClassLikeType, ctx: ConeInferenceContext, compatibilityUpperBound: Compatibility @@ -300,12 +299,12 @@ internal object ConeTypeCompatibilityChecker { @OptIn(ExperimentalStdlibApi::class) private fun ConeClassLikeType.toTypeArgumentMapping( ctx: ConeInferenceContext, - envMapping: Map = emptyMap(), + envMapping: Map = emptyMap(), ): TypeArgumentMapping? { val typeParameterOwner = getClassLikeElement(ctx) ?: return null - val mapping = buildMap { + val mapping = buildMap { typeArguments.forEachIndexed { index, coneTypeProjection -> - val typeParameter: FirTypeParameterRef = typeParameterOwner.getTypeParameter(index) ?: return@forEachIndexed + val typeParameter = typeParameterOwner.getTypeParameter(index) ?: return@forEachIndexed var boundTypeArgument: BoundTypeArgument = when (coneTypeProjection) { // Ignore star since it doesn't provide any constraints. ConeStarProjection -> return@forEachIndexed @@ -315,7 +314,7 @@ internal object ConeTypeCompatibilityChecker { is ConeKotlinTypeProjectionOut -> BoundTypeArgument(coneTypeProjection.type, Variance.OUT_VARIANCE) is ConeKotlinTypeConflictingProjection -> BoundTypeArgument(coneTypeProjection.type, Variance.INVARIANT) is ConeKotlinType -> - when ((typeParameter as? FirTypeParameter)?.variance) { + when (typeParameter.variance) { Variance.IN_VARIANCE -> BoundTypeArgument(coneTypeProjection.type, Variance.IN_VARIANCE) Variance.OUT_VARIANCE -> BoundTypeArgument(coneTypeProjection.type, Variance.OUT_VARIANCE) else -> BoundTypeArgument(coneTypeProjection.type, Variance.INVARIANT) @@ -323,7 +322,7 @@ internal object ConeTypeCompatibilityChecker { } val coneKotlinType = boundTypeArgument.type if (coneKotlinType is ConeTypeParameterType) { - val envTypeParameter = coneKotlinType.lookupTag.typeParameterSymbol.fir + val envTypeParameter = coneKotlinType.lookupTag.typeParameterSymbol val envTypeArgument = envMapping[envTypeParameter] if (envTypeArgument != null) { boundTypeArgument = envTypeArgument @@ -335,10 +334,10 @@ internal object ConeTypeCompatibilityChecker { return TypeArgumentMapping(typeParameterOwner, mapping) } - private fun MutableMap.collect( + private fun MutableMap.collect( ctx: ConeInferenceContext, - typeParameterOwner: FirClassLikeDeclaration, - parameter: FirTypeParameterRef, + typeParameterOwner: FirClassLikeSymbol<*>, + parameter: FirTypeParameterSymbol, boundTypeArgument: BoundTypeArgument, compatibilityUpperBound: Compatibility, ) { @@ -346,8 +345,8 @@ internal object ConeTypeCompatibilityChecker { // the semantic of type parameter in Enum and KClass are fixed: values of types with incompatible type parameters are always // incompatible. val compatibilityUpperBoundForTypeArg = - if ((ctx.prohibitComparisonOfIncompatibleEnums && typeParameterOwner.symbol.classId == StandardClassIds.Enum) || - (ctx.prohibitComparisonOfIncompatibleClasses && typeParameterOwner.symbol.classId == StandardClassIds.KClass) + if ((ctx.prohibitComparisonOfIncompatibleEnums && typeParameterOwner.classId == StandardClassIds.Enum) || + (ctx.prohibitComparisonOfIncompatibleClasses && typeParameterOwner.classId == StandardClassIds.KClass) ) { compatibilityUpperBound } else { @@ -365,29 +364,29 @@ internal object ConeTypeCompatibilityChecker { } } - private fun FirClassLikeDeclaration.getSuperTypes(): List { + private fun FirClassLikeSymbol<*>.getSuperTypes(): List { return when (this) { - is FirTypeAlias -> listOfNotNull(expandedTypeRef.coneTypeSafe()) - is FirClass -> superTypeRefs.mapNotNull { it.coneTypeSafe() } + is FirTypeAliasSymbol -> listOfNotNull(resolvedExpandedTypeRef.coneTypeSafe()) + is FirClassSymbol<*> -> resolvedSuperTypeRefs.mapNotNull { it.coneTypeSafe() } else -> emptyList() } } - private fun ConeClassLikeType.getClassLikeElement(ctx: ConeInferenceContext): FirClassLikeDeclaration? = - ctx.symbolProvider.getSymbolByLookupTag(lookupTag)?.fir + private fun ConeClassLikeType.getClassLikeElement(ctx: ConeInferenceContext): FirClassLikeSymbol<*>? = + ctx.symbolProvider.getSymbolByLookupTag(lookupTag) - private fun FirClassLikeDeclaration.getTypeParameter(index: Int): FirTypeParameterRef? { + private fun FirClassLikeSymbol<*>.getTypeParameter(index: Int): FirTypeParameterSymbol? { return when (this) { - is FirTypeAlias -> typeParameters[index] - is FirClass -> typeParameters[index] + is FirTypeAliasSymbol -> typeParameterSymbols[index] + is FirClassSymbol<*> -> typeParameterSymbols[index] else -> return null } } /** A class declaration and the arguments bound to the declared type parameters. */ private data class TypeArgumentMapping( - val typeParameterOwner: FirClassLikeDeclaration, - val mapping: Map + val typeParameterOwner: FirClassLikeSymbol<*>, + val mapping: Map ) /** A single bound type argument to a type parameter declared in a class. */ @@ -406,13 +405,13 @@ internal object ConeTypeCompatibilityChecker { private fun ConeClassLikeLookupTag.toFirClassWithSuperClasses( ctx: ConeInferenceContext - ): FirClassWithSuperClasses? = when (val klass = ctx.symbolProvider.getSymbolByLookupTag(this)?.fir) { - is FirTypeAlias -> klass.fullyExpandedClass(ctx.session)?.let { FirClassWithSuperClasses(it, ctx) } - is FirClass -> FirClassWithSuperClasses(klass, ctx) + ): FirClassWithSuperClasses? = when (val klass = ctx.symbolProvider.getSymbolByLookupTag(this)) { + is FirTypeAliasSymbol -> klass.fullyExpandedClass(ctx.session)?.let { FirClassWithSuperClasses(it, ctx) } + is FirClassSymbol<*> -> FirClassWithSuperClasses(klass, ctx) else -> null } - private data class FirClassWithSuperClasses(val firClass: FirClass, val ctx: ConeInferenceContext) { + private data class FirClassWithSuperClasses(val firClass: FirClassSymbol<*>, val ctx: ConeInferenceContext) { val isInterface: Boolean get() = firClass.isInterface val superClasses: Set by lazy { @@ -451,15 +450,15 @@ internal object ConeTypeCompatibilityChecker { firClass.isPrimitiveType() || (ctx.prohibitComparisonOfIncompatibleClasses && firClass.classId == StandardClassIds.KClass) || firClass.classId == StandardClassIds.String || firClass.classId == StandardClassIds.Unit || - (firClass is FirRegularClass && (firClass.isData || firClass.isInline)) + (firClass is FirRegularClassSymbol && (firClass.isData || firClass.isInline)) } - private val FirClass.isFinal: Boolean + private val FirClassSymbol<*>.isFinal: Boolean get() { return when (this) { - is FirAnonymousObject -> true - is FirRegularClass -> status.modality == Modality.FINAL - else -> throw java.lang.IllegalStateException("unknown type of FirClass $this") + is FirAnonymousObjectSymbol -> true + is FirRegularClassSymbol -> modality == Modality.FINAL + else -> error("unknown type of FirClass $this") } } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt index 00488ca8771..d8c41657e27 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt @@ -12,10 +12,13 @@ import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.findArgumentByName import org.jetbrains.kotlin.fir.declarations.getAnnotationByFqName +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.toSymbol +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.ensureResolved import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.FirErrorTypeRef @@ -25,9 +28,14 @@ import org.jetbrains.kotlin.name.Name private val RETENTION_PARAMETER_NAME = Name.identifier("value") private val TARGET_PARAMETER_NAME = Name.identifier("allowedTargets") +@OptIn(SymbolInternals::class) fun FirAnnotationCall.getRetention(session: FirSession): AnnotationRetention { - val annotationClass = (this.annotationTypeRef.coneType as? ConeClassLikeType)?.lookupTag?.toSymbol(session)?.fir as? FirRegularClass - return annotationClass?.getRetention() ?: AnnotationRetention.RUNTIME + val annotationClassSymbol = + (this.annotationTypeRef.coneType as? ConeClassLikeType)?.lookupTag?.toSymbol(session) as? FirRegularClassSymbol + ?: return AnnotationRetention.RUNTIME + annotationClassSymbol.ensureResolved(FirResolvePhase.BODY_RESOLVE) + val annotationClass = annotationClassSymbol.fir + return annotationClass.getRetention() } fun FirRegularClass.getRetention(): AnnotationRetention { @@ -41,10 +49,13 @@ fun FirRegularClass.getRetention(): AnnotationRetention { private val defaultAnnotationTargets = KotlinTarget.DEFAULT_TARGET_SET +@OptIn(SymbolInternals::class) fun FirAnnotationCall.getAllowedAnnotationTargets(session: FirSession): Set { if (annotationTypeRef is FirErrorTypeRef) return KotlinTarget.values().toSet() - val annotationClass = (this.annotationTypeRef.coneType as? ConeClassLikeType) - ?.fullyExpandedType(session)?.lookupTag?.toSymbol(session)?.fir as? FirRegularClass + val annotationClassSymbol = (this.annotationTypeRef.coneType as? ConeClassLikeType) + ?.fullyExpandedType(session)?.lookupTag?.toSymbol(session) ?: return defaultAnnotationTargets + annotationClassSymbol.ensureResolved(FirResolvePhase.BODY_RESOLVE) + val annotationClass = annotationClassSymbol.fir as? FirRegularClass return annotationClass?.getAllowedAnnotationTargets() ?: defaultAnnotationTargets } 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 fa021c57921..51650fcae0a 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,12 +10,15 @@ import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.isConst +import org.jetbrains.kotlin.fir.declarations.utils.modality import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.references.FirErrorNamedReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.scopes.impl.FirIntegerOperatorCall -import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.StandardClassIds @@ -28,9 +31,8 @@ internal fun checkConstantArguments( session: FirSession, ): ConstantArgumentKind? { val expressionSymbol = expression.toResolvedCallableSymbol() - ?.fir val classKindOfParent = (expressionSymbol - ?.getReferencedClass(session) as? FirRegularClass) + ?.getReferencedClassSymbol(session) as? FirRegularClassSymbol) ?.classKind when { @@ -38,9 +40,9 @@ internal fun checkConstantArguments( if (expression.operation == FirOperation.AS) return ConstantArgumentKind.NOT_CONST } expression is FirConstExpression<*> - || expressionSymbol is FirEnumEntry - || (expressionSymbol as? FirMemberDeclaration)?.isConst == true - || expressionSymbol is FirConstructor && classKindOfParent == ClassKind.ANNOTATION_CLASS -> { + || expressionSymbol is FirEnumEntrySymbol + || expressionSymbol?.isConst == true + || expressionSymbol is FirConstructorSymbol && classKindOfParent == ClassKind.ANNOTATION_CLASS -> { //DO NOTHING } classKindOfParent == ClassKind.ENUM_CLASS -> { @@ -81,15 +83,15 @@ internal fun checkConstantArguments( expressionSymbol == null -> { //DO NOTHING } - expressionSymbol is FirField -> { + expressionSymbol is FirFieldSymbol -> { //TODO: fix checking of Java fields initializer if ( - !(expressionSymbol as FirMemberDeclaration).status.isStatic - || (expressionSymbol as FirMemberDeclaration).status.modality != Modality.FINAL + !expressionSymbol.isStatic + || expressionSymbol.modality != Modality.FINAL ) return ConstantArgumentKind.NOT_CONST } - expressionSymbol is FirConstructor -> { + expressionSymbol is FirConstructorSymbol -> { if (expression.typeRef.coneType.isUnsignedType) { (expression as FirFunctionCall).arguments.forEach { argumentExpression -> checkConstantArguments(argumentExpression, session)?.let { return it } @@ -158,9 +160,8 @@ internal fun checkConstantArguments( } } expression is FirQualifiedAccessExpression -> { - when { - (expressionSymbol as FirProperty).isLocal || expressionSymbol.symbol.callableId.className?.isRoot == false -> + (expressionSymbol as FirPropertySymbol).isLocal || expressionSymbol.callableId.className?.isRoot == false -> return ConstantArgumentKind.NOT_CONST expression.typeRef.coneType.classId == StandardClassIds.KClass -> return ConstantArgumentKind.NOT_KCLASS_LITERAL @@ -169,10 +170,11 @@ internal fun checkConstantArguments( expression.dispatchReceiver is FirThisReceiverExpression -> return null } - - return when ((expressionSymbol as? FirProperty)?.initializer) { + @OptIn(SymbolInternals::class) + val property = expressionSymbol.fir as? FirProperty + return when (property?.initializer) { is FirConstExpression<*> -> { - if ((expressionSymbol as? FirVariable)?.isVal == true) + if (property.isVal) ConstantArgumentKind.NOT_CONST_VAL_IN_CONST_EXPRESSION else ConstantArgumentKind.NOT_CONST @@ -189,12 +191,11 @@ internal fun checkConstantArguments( return null } -private fun FirTypedDeclaration?.getReferencedClass(session: FirSession): FirDeclaration? = - this?.returnTypeRef +private fun FirCallableSymbol<*>?.getReferencedClassSymbol(session: FirSession): FirBasedSymbol<*>? = + this?.resolvedReturnTypeRef ?.coneTypeSafe() ?.lookupTag ?.toSymbol(session) - ?.fir private val CONVERSION_NAMES = listOf( "toInt", "toLong", "toShort", "toByte", "toFloat", "toDouble", "toChar", "toBoolean" 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 bab35acaed6..fddd64a9129 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 @@ -22,13 +22,13 @@ import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.inference.isBuiltinFunctionalType import org.jetbrains.kotlin.fir.resolve.symbolProvider import org.jetbrains.kotlin.fir.resolve.toSymbol -import org.jetbrains.kotlin.fir.resolve.transformers.firClassLike import org.jetbrains.kotlin.fir.scopes.FirTypeScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.scopes.impl.multipleDelegatesWithTheSameSignature import org.jetbrains.kotlin.fir.scopes.processOverriddenFunctions import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol +import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.lexer.KtModifierKeywordToken @@ -53,18 +53,24 @@ private val INLINE_ONLY_ANNOTATION_CLASS_ID: ClassId = ClassId.topLevel(FqName(" fun FirClass.unsubstitutedScope(context: CheckerContext): FirTypeScope = this.unsubstitutedScope(context.sessionHolder.session, context.sessionHolder.scopeSession, withForcedTypeCalculator = false) +fun FirClassSymbol<*>.unsubstitutedScope(context: CheckerContext): FirTypeScope = + this.unsubstitutedScope(context.sessionHolder.session, context.sessionHolder.scopeSession, withForcedTypeCalculator = false) + +fun FirTypeRef.toClassLikeSymbol(session: FirSession): FirClassLikeSymbol<*>? { + return coneTypeSafe()?.toSymbol(session) as? FirClassLikeSymbol<*> +} + /** * Returns true if this is a supertype of other. */ -fun FirClass.isSupertypeOf(other: FirClass, session: FirSession): Boolean { +fun FirClassSymbol<*>.isSupertypeOf(other: FirClassSymbol<*>, session: FirSession): Boolean { /** * Hides additional parameters. */ - fun FirClass.isSupertypeOf(other: FirClass, exclude: MutableSet): Boolean { - for (it in other.superTypeRefs) { - val candidate = it.firClassLike(session) - ?.followAllAlias(session) - ?.safeAs() + fun FirClassSymbol<*>.isSupertypeOf(other: FirClassSymbol<*>, exclude: MutableSet>): Boolean { + for (it in other.resolvedSuperTypeRefs) { + val candidate = it.toClassLikeSymbol(session) + ?.fullyExpandedClass(session) as? FirClassSymbol<*> ?: continue if (candidate in exclude) { @@ -89,47 +95,36 @@ fun FirClass.isSupertypeOf(other: FirClass, session: FirSession): Boolean { } /** - * Returns the FirClass associated with this + * Returns the FirRegularClassSymbol associated with this * or null of something goes wrong. */ -fun ConeClassLikeType.toClass(session: FirSession): FirClass? { - return lookupTag.toSymbol(session).safeAs>()?.fir +fun ConeClassLikeType.toRegularClassSymbol(session: FirSession): FirRegularClassSymbol? { + return fullyExpandedType(session).toSymbol(session) as? FirRegularClassSymbol } +fun ConeKotlinType.toRegularClassSymbol(session: FirSession): FirRegularClassSymbol? { + return (this as? ConeClassLikeType)?.toRegularClassSymbol(session) +} + +fun ConeKotlinType.isInlineClass(session: FirSession): Boolean = toRegularClassSymbol(session)?.isInline == true + /** * Returns the FirRegularClass associated with this * or null of something goes wrong. */ -fun ConeClassLikeType.toRegularClass(session: FirSession): FirRegularClass? { - return lookupTag.toSymbol(session).safeAs()?.fir -} - -/** - * Returns the FirRegularClass associated with this - * or null of something goes wrong. - */ -fun ConeKotlinType.toRegularClass(session: FirSession): FirRegularClass? { - return safeAs()?.fullyExpandedType(session)?.toRegularClass(session) -} - -fun ConeKotlinType.isInline(session: FirSession): Boolean = toRegularClass(session)?.isInline == true - -/** - * Returns the FirRegularClass associated with this - * or null of something goes wrong. - */ -fun FirTypeRef.toRegularClass(session: FirSession): FirRegularClass? { - return coneType.toRegularClass(session) +fun FirTypeRef.toRegularClassSymbol(session: FirSession): FirRegularClassSymbol? { + return coneType.toRegularClassSymbol(session) } /** * Returns the ClassLikeDeclaration where the Fir object has been defined * or null if no proper declaration has been found. */ -fun FirDeclaration.getContainingClassSymbol(context: CheckerContext): FirClassLikeSymbol<*>? = - this.safeAs()?.containingClass()?.toSymbol(context.session) +fun FirDeclaration.getContainingClassSymbol(session: FirSession): FirClassLikeSymbol<*>? = + this.safeAs()?.containingClass()?.toSymbol(session) -fun FirBasedSymbol<*>.getContainingClassSymbol(context: CheckerContext): FirClassLikeSymbol<*>? = fir.getContainingClassSymbol(context) +@OptIn(SymbolInternals::class) +fun FirBasedSymbol<*>.getContainingClassSymbol(session: FirSession): FirClassLikeSymbol<*>? = fir.getContainingClassSymbol(session) fun FirClassLikeSymbol<*>.outerClassSymbol(context: CheckerContext): FirClassLikeSymbol<*>? { if (this !is FirClassSymbol<*>) return null @@ -142,14 +137,13 @@ fun FirClassLikeSymbol<*>.outerClassSymbol(context: CheckerContext): FirClassLik * sequence of FirTypeAlias'es points to starting * with `this`. Or null if something goes wrong. */ -fun FirClassLikeDeclaration.followAllAlias(session: FirSession): FirClassLikeDeclaration? { - var it: FirClassLikeDeclaration? = this - - while (it is FirTypeAlias) { - it = it.expandedTypeRef.firClassLike(session) +fun FirClassLikeSymbol<*>.fullyExpandedClass(useSiteSession: FirSession): FirRegularClassSymbol? { + return when (this) { + is FirRegularClassSymbol -> this + is FirTypeAliasSymbol -> (resolvedExpandedTypeRef.coneTypeSafe() + ?.toSymbol(useSiteSession) as? FirClassLikeSymbol<*>)?.fullyExpandedClass(useSiteSession) + else -> null } - - return it } /** @@ -184,7 +178,7 @@ fun FirSimpleFunction.overriddenFunctions( ) val overriddenFunctions = mutableListOf>() - firTypeScope.processFunctionsByName(symbol.fir.name) { } + firTypeScope.processFunctionsByName(symbol.callableId.callableName) { } firTypeScope.processOverriddenFunctions(symbol) { overriddenFunctions.add(it) ProcessorAction.NEXT @@ -268,11 +262,9 @@ fun FirClass.findNonInterfaceSupertype(context: CheckerContext): FirTypeRef? { for (superTypeRef in superTypeRefs) { val lookupTag = superTypeRef.coneType.safeAs()?.lookupTag ?: continue - val fir = lookupTag.toSymbol(context.session) - ?.fir.safeAs() - ?: continue + val symbol = lookupTag.toSymbol(context.session) as? FirClassSymbol<*> ?: continue - if (fir.classKind != ClassKind.INTERFACE) { + if (symbol.classKind != ClassKind.INTERFACE) { return superTypeRef } } @@ -302,13 +294,12 @@ fun ConeKotlinType.canHaveSubtypes(session: FirSession): Boolean { if (this.isMarkedNullable) { return true } - val clazz = toRegularClass(session) ?: return true - if (clazz.isEnumClass || clazz.isExpect || clazz.modality != Modality.FINAL) { + val classSymbol = toRegularClassSymbol(session) ?: return true + if (classSymbol.isEnumClass || classSymbol.isExpect || classSymbol.modality != Modality.FINAL) { return true } - clazz.typeParameters.forEachIndexed { idx, typeParameterRef -> - val typeParameter = typeParameterRef.symbol.fir + classSymbol.typeParameterSymbols.forEachIndexed { idx, typeParameterSymbol -> val typeProjection = typeArguments[idx] if (typeProjection.isStarProjection) { @@ -317,15 +308,15 @@ fun ConeKotlinType.canHaveSubtypes(session: FirSession): Boolean { val argument = typeProjection.type!! //safe because it is not a star - when (typeParameter.variance) { + when (typeParameterSymbol.variance) { Variance.INVARIANT -> when (typeProjection.kind) { ProjectionKind.INVARIANT -> - if (lowerThanBound(session.typeContext, argument, typeParameter) || argument.canHaveSubtypes(session)) { + if (lowerThanBound(session.typeContext, argument, typeParameterSymbol) || argument.canHaveSubtypes(session)) { return true } ProjectionKind.IN -> - if (lowerThanBound(session.typeContext, argument, typeParameter)) { + if (lowerThanBound(session.typeContext, argument, typeParameterSymbol)) { return true } ProjectionKind.OUT -> @@ -337,7 +328,7 @@ fun ConeKotlinType.canHaveSubtypes(session: FirSession): Boolean { } Variance.IN_VARIANCE -> if (typeProjection.kind != ProjectionKind.OUT) { - if (lowerThanBound(session.typeContext, argument, typeParameter)) { + if (lowerThanBound(session.typeContext, argument, typeParameterSymbol)) { return true } } else { @@ -351,7 +342,7 @@ fun ConeKotlinType.canHaveSubtypes(session: FirSession): Boolean { return true } } else { - if (lowerThanBound(session.typeContext, argument, typeParameter)) { + if (lowerThanBound(session.typeContext, argument, typeParameterSymbol)) { return true } } @@ -361,8 +352,8 @@ fun ConeKotlinType.canHaveSubtypes(session: FirSession): Boolean { return false } -private fun lowerThanBound(context: ConeInferenceContext, argument: ConeKotlinType, typeParameter: FirTypeParameter): Boolean { - typeParameter.bounds.forEach { boundTypeRef -> +private fun lowerThanBound(context: ConeInferenceContext, argument: ConeKotlinType, typeParameterSymbol: FirTypeParameterSymbol): Boolean { + typeParameterSymbol.resolvedBounds.forEach { boundTypeRef -> if (argument != boundTypeRef.coneType && argument.isSubtypeOf(context, boundTypeRef.coneType)) { return true } @@ -409,13 +400,17 @@ private fun isSubtypeOfForFunctionalTypeReturningUnit( } fun FirCallableDeclaration.isVisibleInClass(parentClass: FirClass): Boolean { - val classPackage = parentClass.symbol.classId.packageFqName + return symbol.isVisibleInClass(parentClass.symbol) +} + +fun FirCallableSymbol<*>.isVisibleInClass(parentClassSymbol: FirClassSymbol<*>): Boolean { + val classPackage = parentClassSymbol.classId.packageFqName if (visibility == Visibilities.Private || - !visibility.visibleFromPackage(classPackage, symbol.callableId.packageName) + !visibility.visibleFromPackage(classPackage, callableId.packageName) ) return false if ( visibility == Visibilities.Internal && - (moduleData != parentClass.moduleData || parentClass.moduleData in moduleData.friendDependencies) + (moduleData != parentClassSymbol.moduleData || parentClassSymbol.moduleData in moduleData.friendDependencies) ) return false return true } @@ -423,29 +418,34 @@ fun FirCallableDeclaration.isVisibleInClass(parentClass: FirClass): Boolean { /** * Get the [ImplementationStatus] for this member. * - * @param parentClass the contextual class for this query. + * @param parentClassSymbol the contextual class for this query. */ -fun FirCallableDeclaration.getImplementationStatus(sessionHolder: SessionHolder, parentClass: FirClass): ImplementationStatus { - val containingClass = getContainingClass(sessionHolder) - val symbol = this.symbol +fun FirCallableSymbol<*>.getImplementationStatus( + sessionHolder: SessionHolder, + parentClassSymbol: FirClassSymbol<*> +): ImplementationStatus { + val containingClassSymbol = getContainingClassSymbol(sessionHolder.session) + val symbol = this - if (this.multipleDelegatesWithTheSameSignature == true && containingClass == parentClass) { + if (this.multipleDelegatesWithTheSameSignature == true && containingClassSymbol == parentClassSymbol) { return ImplementationStatus.AMBIGUOUSLY_INHERITED } if (symbol is FirIntersectionCallableSymbol) { - if (containingClass === parentClass && symbol.subjectToManyNotImplemented(sessionHolder)) { + if (containingClassSymbol === parentClassSymbol && symbol.subjectToManyNotImplemented(sessionHolder)) { return ImplementationStatus.AMBIGUOUSLY_INHERITED } // In Java 8, non-abstract intersection overrides having abstract symbol from base class // still should be implemented in current class (even when they have default interface implementation) if (symbol.intersections.any { + @OptIn(SymbolInternals::class) val fir = it.fir.unwrapFakeOverrides() - fir.isAbstract && (fir.getContainingClass(sessionHolder) as? FirRegularClass)?.classKind == ClassKind.CLASS + fir.isAbstract && (fir.getContainingClassSymbol(sessionHolder.session) as? FirRegularClassSymbol)?.classKind == ClassKind.CLASS } ) { // Exception from the rule above: interface implementation via delegation if (symbol.intersections.none { + @OptIn(SymbolInternals::class) val fir = it.fir fir.origin == FirDeclarationOrigin.Delegated && !fir.isAbstract } @@ -454,8 +454,8 @@ fun FirCallableDeclaration.getImplementationStatus(sessionHolder: SessionHolder, } } } - if (this is FirSimpleFunction) { - if (parentClass is FirRegularClass && parentClass.isData && matchesDataClassSyntheticMemberSignatures) { + if (this is FirNamedFunctionSymbol) { + if (parentClassSymbol is FirRegularClassSymbol && parentClassSymbol.isData && matchesDataClassSyntheticMemberSignatures) { return ImplementationStatus.INHERITED_OR_SYNTHESIZED } // TODO: suspend function overridden by a Java class in the middle is not properly regarded as an override @@ -465,8 +465,8 @@ fun FirCallableDeclaration.getImplementationStatus(sessionHolder: SessionHolder, } return when { isFinal -> ImplementationStatus.CANNOT_BE_IMPLEMENTED - containingClass === parentClass && origin == FirDeclarationOrigin.Source -> ImplementationStatus.ALREADY_IMPLEMENTED - containingClass is FirRegularClass && containingClass.isExpect -> ImplementationStatus.CANNOT_BE_IMPLEMENTED + containingClassSymbol === parentClassSymbol && origin == FirDeclarationOrigin.Source -> ImplementationStatus.ALREADY_IMPLEMENTED + containingClassSymbol is FirRegularClassSymbol && containingClassSymbol.isExpect -> ImplementationStatus.CANNOT_BE_IMPLEMENTED isAbstract -> ImplementationStatus.NOT_IMPLEMENTED else -> ImplementationStatus.INHERITED_OR_SYNTHESIZED } @@ -478,10 +478,9 @@ private fun FirIntersectionCallableSymbol.subjectToManyNotImplemented(sessionHol var nonAbstractCountInInterface = 0 var abstractCountInInterface = 0 for (intersectionSymbol in intersections) { - val intersection = intersectionSymbol.fir - val containingClass = intersection.getContainingClass(sessionHolder) as? FirRegularClass - val hasInterfaceContainer = containingClass?.classKind == ClassKind.INTERFACE - if (intersection.modality != Modality.ABSTRACT) { + val containingClassSymbol = intersectionSymbol.getContainingClassSymbol(sessionHolder.session) as? FirRegularClassSymbol + val hasInterfaceContainer = containingClassSymbol?.classKind == ClassKind.INTERFACE + if (intersectionSymbol.modality != Modality.ABSTRACT) { if (hasInterfaceContainer) { nonAbstractCountInInterface++ } else { @@ -500,23 +499,26 @@ private fun FirIntersectionCallableSymbol.subjectToManyNotImplemented(sessionHol return false } -private val FirSimpleFunction.matchesDataClassSyntheticMemberSignatures: Boolean - get() = (this.name == OperatorNameConventions.EQUALS && matchesEqualsSignature) || - (this.name == HASHCODE_NAME && matchesHashCodeSignature) || - (this.name == OperatorNameConventions.TO_STRING && matchesToStringSignature) - -private fun FirDeclaration.getContainingClass(sessionHolder: SessionHolder): FirClassLikeDeclaration? = - this.safeAs()?.containingClass()?.toSymbol(sessionHolder.session)?.fir +private val FirNamedFunctionSymbol.matchesDataClassSyntheticMemberSignatures: Boolean + get() { + val name = callableId.callableName + return (name == OperatorNameConventions.EQUALS && matchesEqualsSignature) || + (name == HASHCODE_NAME && matchesHashCodeSignature) || + (name == OperatorNameConventions.TO_STRING && matchesToStringSignature) + } // NB: we intentionally do not check return types -private val FirSimpleFunction.matchesEqualsSignature: Boolean - get() = valueParameters.size == 1 && valueParameters[0].returnTypeRef.coneType.isNullableAny +private val FirNamedFunctionSymbol.matchesEqualsSignature: Boolean + get() { + val valueParameters = valueParameterSymbols + return valueParameters.size == 1 && valueParameters[0].resolvedReturnTypeRef.coneType.isNullableAny + } -private val FirSimpleFunction.matchesHashCodeSignature: Boolean - get() = valueParameters.isEmpty() +private val FirNamedFunctionSymbol.matchesHashCodeSignature: Boolean + get() = valueParameterSymbols.isEmpty() -private val FirSimpleFunction.matchesToStringSignature: Boolean - get() = valueParameters.isEmpty() +private val FirNamedFunctionSymbol.matchesToStringSignature: Boolean + get() = valueParameterSymbols.isEmpty() val Name.isDelegated: Boolean get() = asString().startsWith("<\$\$delegate_") @@ -634,3 +636,42 @@ fun extractArgumentTypeRefAndSource(typeRef: FirTypeRef?, index: Int): FirTypeRe } data class FirTypeRefSource(val typeRef: FirTypeRef?, val source: FirSourceElement?) + +fun FirRegularClassSymbol.collectEnumEntries(): Collection { + assert(classKind == ClassKind.ENUM_CLASS) + return declarationSymbols.filterIsInstance() +} + +val FirClassLikeSymbol<*>.classKind: ClassKind? + get() = (this as? FirClassSymbol<*>)?.classKind + +val FirBasedSymbol<*>.typeParameterSymbols: List? + get() = when (this) { + is FirCallableSymbol<*> -> typeParameterSymbols + is FirClassSymbol<*> -> typeParameterSymbols + is FirTypeAliasSymbol -> typeParameterSymbols + else -> null + } + +/* + * This is phase-safe version of similar function from FirCallCompleter + * + * Expect type is only being added to calls in a position of cast argument: foo() as R + * And that call should be resolved to something materialize()-like: it returns its single generic parameter and doesn't have value parameters + * fun materialize(): T + */ +fun FirFunctionSymbol<*>.isFunctionForExpectTypeFromCastFeature(): Boolean { + val typeParameterSymbol = typeParameterSymbols.singleOrNull() ?: return false + + val returnType = resolvedReturnTypeRef.coneType + + if ((returnType.lowerBoundIfFlexible() as? ConeTypeParameterType)?.lookupTag != typeParameterSymbol.toLookupTag()) return false + + fun FirTypeRef.isBadType() = + coneTypeSafe() + ?.contains { (it.lowerBoundIfFlexible() as? ConeTypeParameterType)?.lookupTag == typeParameterSymbol.toLookupTag() } != false + + if (valueParameterSymbols.any { it.resolvedReturnTypeRef.isBadType() } || resolvedReceiverTypeRef?.isBadType() == true) return false + + return true +} diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirInconsistentTypeParameterHelpers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirInconsistentTypeParameterHelpers.kt index 1f21e7f2fb0..8fead73b936 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirInconsistentTypeParameterHelpers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirInconsistentTypeParameterHelpers.kt @@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.types.AbstractTypeChecker fun checkInconsistentTypeParameters( - firTypeRefClasses: List>, + firTypeRefClasses: List>, context: CheckerContext, reporter: DiagnosticReporter, source: FirSourceElement?, @@ -55,7 +55,7 @@ fun checkInconsistentTypeParameters( } private fun buildDeepSubstitutionMultimap( - firTypeRefClasses: List>, + firTypeRefClasses: List>, context: CheckerContext, ): Map { val result = mutableMapOf() @@ -63,10 +63,10 @@ private fun buildDeepSubstitutionMultimap( val session = context.session val typeContext = session.typeContext - fun fillInDeepSubstitutor(typeArguments: Array?, firClass: FirRegularClass) { + fun fillInDeepSubstitutor(typeArguments: Array?, classSymbol: FirRegularClassSymbol) { if (typeArguments != null) { - val typeParameters = firClass.typeParameters - val count = minOf(typeArguments.size, typeParameters.size) + val typeParameterSymbols = classSymbol.typeParameterSymbols + val count = minOf(typeArguments.size, typeParameterSymbols.size) for (index in 0 until count) { val typeArgument = typeArguments[index] @@ -74,14 +74,14 @@ private fun buildDeepSubstitutionMultimap( val substitutedArgument = ConeSubstitutorByMap(substitution, session).substituteArgument(typeArgument) ?: typeArgument val substitutedType = substitutedArgument.type ?: continue - val typeParameterSymbol = typeParameters[index].symbol + val typeParameterSymbol = typeParameterSymbols[index] substitution[typeParameterSymbol] = substitutedType var classSymbolAndProjections = result[typeParameterSymbol] val projections: MutableList if (classSymbolAndProjections == null) { projections = mutableListOf() - classSymbolAndProjections = ClassSymbolAndProjections(firClass.symbol, projections) + classSymbolAndProjections = ClassSymbolAndProjections(classSymbol, projections) result[typeParameterSymbol] = classSymbolAndProjections } else { projections = classSymbolAndProjections.projections @@ -95,12 +95,12 @@ private fun buildDeepSubstitutionMultimap( } } - for (superTypeRef in firClass.superTypeRefs) { + for (superTypeRef in classSymbol.resolvedSuperTypeRefs) { withSuppressedDiagnostics(superTypeRef, context) { val fullyExpandedType = superTypeRef.coneType.fullyExpandedType(session) - val superTypeClass = fullyExpandedType.toRegularClass(session) - if (!fullyExpandedType.isEnum && superTypeClass != null) { - fillInDeepSubstitutor(fullyExpandedType.typeArguments, superTypeClass) + val superClassSymbol = fullyExpandedType.toRegularClassSymbol(session) + if (!fullyExpandedType.isEnum && superClassSymbol != null) { + fillInDeepSubstitutor(fullyExpandedType.typeArguments, superClassSymbol) } } } @@ -115,4 +115,4 @@ private fun buildDeepSubstitutionMultimap( private data class ClassSymbolAndProjections( val classSymbol: FirRegularClassSymbol, val projections: MutableList -) \ No newline at end of file +) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirSinceKotlinHelpers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirSinceKotlinHelpers.kt index a06db5544a5..62c1b6c9dee 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirSinceKotlinHelpers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirSinceKotlinHelpers.kt @@ -14,6 +14,9 @@ import org.jetbrains.kotlin.fir.expressions.arguments import org.jetbrains.kotlin.fir.languageVersionSettings import org.jetbrains.kotlin.fir.resolve.symbolProvider import org.jetbrains.kotlin.fir.resolve.toSymbol +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.ensureResolved +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.coneType @@ -72,17 +75,23 @@ private fun FirAnnotatedDeclaration.getOwnSinceKotlinVersion(session: FirSession } } + fun FirClassLikeSymbol<*>.consider() { + ensureResolved(FirResolvePhase.BODY_RESOLVE) + @OptIn(SymbolInternals::class) + this.fir.consider() + } + this.consider() if (this is FirConstructor) { val classId = symbol.callableId.classId if (classId != null) { val classSymbol = session.symbolProvider.getClassLikeSymbolByFqName(classId) - classSymbol?.fir?.consider() + classSymbol?.consider() } } if (this is FirTypeAlias) { - (this.expandedTypeRef.coneType as? ConeClassLikeType)?.lookupTag?.toSymbol(session)?.fir?.consider() + (this.expandedTypeRef.coneType as? ConeClassLikeType)?.lookupTag?.toSymbol(session)?.consider() } return result diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirUpperBoundViolatedHelpers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirUpperBoundViolatedHelpers.kt index cb0aca41786..c580bbc0c58 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirUpperBoundViolatedHelpers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirUpperBoundViolatedHelpers.kt @@ -10,10 +10,10 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn -import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap import org.jetbrains.kotlin.fir.resolve.toSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.types.* @@ -47,17 +47,14 @@ fun checkUpperBoundViolated( val typeParameterSymbols = typeParameters ?: if (type is ConeClassLikeType) { val fullyExpandedType = type.fullyExpandedType(context.session) - val prototypeClass = fullyExpandedType.lookupTag.toSymbol(context.session) - ?.fir as? FirRegularClass - ?: return - + val prototypeClassSymbol = fullyExpandedType.lookupTag.toSymbol(context.session) as? FirRegularClassSymbol ?: return if (type != fullyExpandedType) { // special check for type aliases checkUpperBoundViolated( typeRef, context, reporter, - prototypeClass.typeParameters.map { it.symbol }, + prototypeClassSymbol.typeParameterSymbols, fullyExpandedType.typeArguments.toList(), null, isTypeAlias = true, @@ -66,7 +63,7 @@ fun checkUpperBoundViolated( return } - prototypeClass.typeParameters.map { it.symbol } + prototypeClassSymbol.typeParameterSymbols } else { listOf() } @@ -139,7 +136,7 @@ fun checkUpperBoundViolated( if (typeArgument != null && typeArgumentSource != null) { if (!isIgnoreTypeParameters || (typeArgument.typeArguments.isEmpty() && typeArgument !is ConeTypeParameterType)) { val intersection = - typeSystemContext.intersectTypes(typeParameterSymbols[index].fir.bounds.map { it.coneType }) as? ConeKotlinType + typeSystemContext.intersectTypes(typeParameterSymbols[index].resolvedBounds.map { it.coneType }) as? ConeKotlinType if (intersection != null) { val upperBound = substitutor.substituteOrSelf(intersection) if (!AbstractTypeChecker.isSubtypeOf( @@ -162,4 +159,4 @@ fun checkUpperBoundViolated( checkUpperBoundViolated(typeArgumentTypeRef, context, reporter, isIgnoreTypeParameters = isIgnoreTypeParameters) } } -} \ No newline at end of file +} diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationClassDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationClassDeclarationChecker.kt index 344b3c18fb9..d5ce60fa81f 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationClassDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationClassDeclarationChecker.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.* import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.isLocal import org.jetbrains.kotlin.fir.resolve.toSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.StandardClassIds @@ -118,8 +119,7 @@ object FirAnnotationClassDeclarationChecker : FirRegularClassChecker() { } private fun isAllowedClassKind(cone: ConeLookupTagBasedType, session: FirSession): Boolean { - val typeRefClassKind = (cone.lookupTag.toSymbol(session) - ?.fir as? FirRegularClass) + val typeRefClassKind = (cone.lookupTag.toSymbol(session) as? FirRegularClassSymbol) ?.classKind ?: return false diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirClassVarianceChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirClassVarianceChecker.kt index 0343de87806..231030ca886 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirClassVarianceChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirClassVarianceChecker.kt @@ -16,6 +16,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.toSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.types.checker.TypeCheckingProcedure @@ -110,10 +111,10 @@ object FirClassVarianceChecker : FirClassChecker() { ) { if (type is ConeTypeParameterType) { val fullyExpandedType = type.fullyExpandedType(context.session) - val typeParameter = type.lookupTag.typeParameterSymbol.fir + val typeParameterSymbol = type.lookupTag.typeParameterSymbol val resultSource = source ?: typeRef?.source if (resultSource != null && - !typeParameter.variance.allowsPosition(variance) && + !typeParameterSymbol.variance.allowsPosition(variance) && !fullyExpandedType.attributes.contains(CompilerConeAttributes.UnsafeVariance) ) { val factory = @@ -121,8 +122,8 @@ object FirClassVarianceChecker : FirClassChecker() { reporter.reportOn( resultSource, factory, - typeParameter.symbol, - typeParameter.variance, + typeParameterSymbol, + typeParameterSymbol.variance, variance, containingType, context @@ -133,10 +134,10 @@ object FirClassVarianceChecker : FirClassChecker() { if (type is ConeClassLikeType) { val fullyExpandedType = type.fullyExpandedType(context.session) - val declFir = fullyExpandedType.lookupTag.toSymbol(context.session)?.fir - if (declFir is FirClass) { + val classSymbol = fullyExpandedType.lookupTag.toSymbol(context.session) + if (classSymbol is FirClassSymbol<*>) { for ((index, typeArgument) in fullyExpandedType.typeArguments.withIndex()) { - val paramVariance = (declFir.typeParameters.getOrNull(index) as? FirTypeParameter)?.variance ?: continue + val paramVariance = classSymbol.typeParameterSymbols.getOrNull(index)?.variance ?: continue val argVariance = when (typeArgument.kind) { ProjectionKind.IN -> Variance.IN_VARIANCE @@ -147,8 +148,7 @@ object FirClassVarianceChecker : FirClassChecker() { val typeArgumentType = typeArgument.type ?: continue - val projectionKind = TypeCheckingProcedure.getEffectiveProjectionKind(paramVariance, argVariance)!! - val newVariance = when (projectionKind) { + val newVariance = when (TypeCheckingProcedure.getEffectiveProjectionKind(paramVariance, argVariance)!!) { TypeCheckingProcedure.EnrichedProjectionKind.OUT -> variance TypeCheckingProcedure.EnrichedProjectionKind.IN -> variance.opposite() TypeCheckingProcedure.EnrichedProjectionKind.INV -> Variance.INVARIANT diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCommonConstructorDelegationIssuesChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCommonConstructorDelegationIssuesChecker.kt index 066597349dc..124bedd6dc7 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCommonConstructorDelegationIssuesChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCommonConstructorDelegationIssuesChecker.kt @@ -12,14 +12,16 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.declarations.FirConstructor import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.references.FirErrorNamedReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguityError +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.ensureResolved import org.jetbrains.kotlin.utils.addToStdlib.safeAs object FirCommonConstructorDelegationIssuesChecker : FirRegularClassChecker() { override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { - val cyclicConstructors = mutableSetOf() var hasPrimaryConstructor = false @@ -91,8 +93,12 @@ object FirCommonConstructorDelegationIssuesChecker : FirRegularClassChecker() { return null } - private fun FirConstructor.getDelegated(): FirConstructor? = delegatedConstructor - ?.calleeReference.safeAs() - ?.resolvedSymbol - ?.fir as? FirConstructor? + private fun FirConstructor.getDelegated(): FirConstructor? { + this.symbol.ensureResolved(FirResolvePhase.BODY_RESOLVE) + val delegatedConstructorSymbol = delegatedConstructor + ?.calleeReference.safeAs() + ?.resolvedSymbol + @OptIn(SymbolInternals::class) + return delegatedConstructorSymbol?.fir as? FirConstructor + } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsChecker.kt index 12b8a596cf0..43a843655af 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsChecker.kt @@ -17,6 +17,8 @@ import org.jetbrains.kotlin.fir.resolve.firProvider import org.jetbrains.kotlin.fir.scopes.PACKAGE_MEMBER import org.jetbrains.kotlin.fir.scopes.impl.FirPackageMemberScope import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.ensureResolved import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid @@ -76,6 +78,8 @@ object FirConflictsChecker : FirBasicDeclarationChecker() { conflictingFile: FirFile?, session: FirSession ) { + conflictingSymbol.ensureResolved(FirResolvePhase.STATUS) + @OptIn(SymbolInternals::class) val conflicting = conflictingSymbol.fir as? FirDeclaration ?: return if (declaration.moduleData != conflicting.moduleData) return val actualConflictingPresentation = conflictingPresentation ?: presenter.represent(conflicting) @@ -116,6 +120,8 @@ object FirConflictsChecker : FirBasicDeclarationChecker() { ) } packageMemberScope.processClassifiersByNameWithSubstitution(declarationName) { symbol, _ -> + symbol.ensureResolved(FirResolvePhase.STATUS) + @OptIn(SymbolInternals::class) val classWithSameName = symbol.fir as? FirRegularClass classWithSameName?.onConstructors { constructor -> collectExternalConflict( diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCyclicTypeBoundsChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCyclicTypeBoundsChecker.kt index 2b104187aea..c9e3aa92335 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCyclicTypeBoundsChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCyclicTypeBoundsChecker.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeCyclicTypeBound +import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.utils.addToStdlib.safeAs @@ -24,7 +25,7 @@ object FirCyclicTypeBoundsChecker : FirBasicDeclarationChecker() { val processed = mutableSetOf() val cycles = mutableSetOf() val graph = declaration.typeParameters.associate { param -> - param.symbol.name to param.symbol.fir.bounds.flatMap { extractTypeParamNames(it) }.toSet() + param.symbol.name to param.symbol.resolvedBounds.flatMap { extractTypeParamNames(it) }.toSet() } val graphFunc = { name: Name -> graph.getOrDefault(name, emptySet()) } val path = mutableListOf() @@ -51,7 +52,7 @@ object FirCyclicTypeBoundsChecker : FirBasicDeclarationChecker() { .forEach { param -> //for some reason FE 1.0 report differently for class declarations val targets = if (declaration is FirRegularClass) { - param.symbol.fir.originalBounds().filter { cycles.contains(extractTypeParamName(it.coneType)) } + param.symbol.originalBounds().filter { cycles.contains(extractTypeParamName(it.coneType)) } .mapNotNull { it.source } } else { listOf(param.source) @@ -63,7 +64,7 @@ object FirCyclicTypeBoundsChecker : FirBasicDeclarationChecker() { } } - private fun FirTypeParameter.originalBounds() = bounds.flatMap { it.unwrapBound() } + private fun FirTypeParameterSymbol.originalBounds() = resolvedBounds.flatMap { it.unwrapBound() } private fun FirTypeRef.unwrapBound(): List = if (this is FirErrorTypeRef && diagnostic is ConeCyclicTypeBound) { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerUtils.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerUtils.kt index c0c11affca1..1bfcaf995ad 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerUtils.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerUtils.kt @@ -21,7 +21,8 @@ import org.jetbrains.kotlin.fir.containingClassAttr import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor import org.jetbrains.kotlin.fir.declarations.utils.* -import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLookupTagWithFixedSymbol +import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol +import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef import org.jetbrains.kotlin.lexer.KtTokens @@ -192,10 +193,16 @@ internal fun FirRegularClass.isInlineOrValueClass(): Boolean { return isInline || hasModifier(KtTokens.VALUE_KEYWORD) } +internal fun FirRegularClassSymbol.isInlineOrValueClass(): Boolean { + if (this.classKind != ClassKind.CLASS) return false + + return isInline +} + internal val FirDeclaration.isEnumEntryInitializer: Boolean get() { if (this !is FirConstructor || !this.isPrimary) return false - return (containingClassAttr as? ConeClassLookupTagWithFixedSymbol)?.symbol?.fir?.classKind == ClassKind.ENUM_ENTRY + return (containingClassAttr as? ConeClassLookupTagWithFixedSymbol)?.symbol?.classKind == ClassKind.ENUM_ENTRY } // contract: returns(true) implies (this is FirMemberDeclaration<*>) @@ -207,7 +214,20 @@ internal val FirDeclaration.isLocalMember: Boolean else -> false } +internal val FirBasedSymbol<*>.isLocalMember: Boolean + get() = when (this) { + is FirPropertySymbol -> this.isLocal + is FirRegularClassSymbol -> this.isLocal + is FirNamedFunctionSymbol -> this.isLocal + else -> false + } + internal val FirCallableDeclaration.isExtensionMember: Boolean get() { return receiverTypeRef != null && dispatchReceiverType != null } + +internal val FirCallableSymbol<*>.isExtensionMember: Boolean + get() { + return resolvedReceiverTypeRef != null && dispatchReceiverType != null + } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt index d8b924ce57d..3c8c782802c 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt @@ -11,10 +11,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn -import org.jetbrains.kotlin.fir.declarations.FirProperty -import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction -import org.jetbrains.kotlin.fir.declarations.FirValueParameter -import org.jetbrains.kotlin.fir.declarations.FirVariable +import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind import org.jetbrains.kotlin.fir.expressions.* @@ -24,6 +21,9 @@ import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguityError import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeConstraintSystemHasContradiction import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeInapplicableCandidateError import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.ensureResolved +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.types.* @@ -66,8 +66,8 @@ object FirDestructuringDeclarationChecker : FirPropertyChecker() { val originalDestructuringDeclarationOrInitializerSource = originalDestructuringDeclarationOrInitializer.source ?: return val originalDestructuringDeclarationType = when (originalDestructuringDeclarationOrInitializer) { - is FirVariable -> originalDestructuringDeclarationOrInitializer.returnTypeRef.coneTypeSafe() - is FirExpression -> originalDestructuringDeclarationOrInitializer.typeRef.coneTypeSafe() + is FirVariable -> originalDestructuringDeclarationOrInitializer.returnTypeRef.coneType + is FirExpression -> originalDestructuringDeclarationOrInitializer.typeRef.coneType else -> null } ?: return @@ -137,7 +137,7 @@ object FirDestructuringDeclarationChecker : FirPropertyChecker() { reporter.reportOn( source, FirErrors.COMPONENT_FUNCTION_ON_NULLABLE, - (diagnostic.candidate.symbol.fir as FirSimpleFunction).name, + (diagnostic.candidate.symbol as FirNamedFunctionSymbol).callableId.callableName, context ) } @@ -182,5 +182,10 @@ object FirDestructuringDeclarationChecker : FirPropertyChecker() { } private val FirQualifiedAccessExpression.resolvedVariable: FirVariable? - get() = ((calleeReference as? FirResolvedNamedReference)?.resolvedSymbol as? FirVariableSymbol)?.fir as? FirVariable + get() { + val symbol = (calleeReference as? FirResolvedNamedReference)?.resolvedSymbol as? FirVariableSymbol<*> ?: return null + symbol.ensureResolved(FirResolvePhase.BODY_RESOLVE) + @OptIn(SymbolInternals::class) + return symbol.fir + } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityDeclarationChecker.kt index a0c234593c6..fa7d61d5226 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityDeclarationChecker.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.EffectiveVisibility import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClass +import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn @@ -18,7 +18,9 @@ import org.jetbrains.kotlin.fir.declarations.utils.expandedConeType import org.jetbrains.kotlin.fir.declarations.utils.fromPrimaryConstructor import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.toSymbol -import org.jetbrains.kotlin.fir.symbols.ensureResolved +import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.utils.addToStdlib.safeAs @@ -32,6 +34,7 @@ object FirExposedVisibilityDeclarationChecker : FirBasicDeclarationChecker() { is FirProperty -> checkProperty(declaration, reporter, context) is FirFunction -> checkFunction(declaration, reporter, context) is FirRegularClass -> checkClass(declaration, reporter, context) + else -> {} } } @@ -48,22 +51,20 @@ object FirExposedVisibilityDeclarationChecker : FirBasicDeclarationChecker() { val isInterface = declaration.classKind == ClassKind.INTERFACE for (supertypeRef in supertypes) { val supertype = supertypeRef.coneTypeSafe() ?: continue - val clazz = supertype.toRegularClass(context.session) ?: continue - val superIsInterface = clazz.classKind == ClassKind.INTERFACE + val classSymbol = supertype.toRegularClassSymbol(context.session) ?: continue + val superIsInterface = classSymbol.classKind == ClassKind.INTERFACE if (superIsInterface != isInterface) { continue } - val restricting = supertype.findVisibilityExposure(context, classVisibility) - if (restricting != null) { - reporter.reportOn( - supertypeRef.source ?: declaration.source, - if (isInterface) FirErrors.EXPOSED_SUPER_INTERFACE else FirErrors.EXPOSED_SUPER_CLASS, - classVisibility, - restricting, - restricting.effectiveVisibility, - context - ) - } + val (restricting, restrictingVisibility) = supertype.findVisibilityExposure(context, classVisibility) ?: continue + reporter.reportOn( + supertypeRef.source ?: declaration.source, + if (isInterface) FirErrors.EXPOSED_SUPER_INTERFACE else FirErrors.EXPOSED_SUPER_CLASS, + classVisibility, + restricting, + restrictingVisibility, + context + ) } } @@ -72,18 +73,16 @@ object FirExposedVisibilityDeclarationChecker : FirBasicDeclarationChecker() { if (classVisibility == EffectiveVisibility.Local) return for (parameter in declaration.typeParameters) { - for (bound in parameter.symbol.fir.bounds) { - val restricting = bound.coneType.findVisibilityExposure(context, classVisibility) - if (restricting != null) { - reporter.reportOn( - bound.source, - FirErrors.EXPOSED_TYPE_PARAMETER_BOUND, - classVisibility, - restricting, - restricting.effectiveVisibility, - context - ) - } + for (bound in parameter.symbol.resolvedBounds) { + val (restricting, restrictingVisibility) = bound.coneType.findVisibilityExposure(context, classVisibility) ?: continue + reporter.reportOn( + bound.source, + FirErrors.EXPOSED_TYPE_PARAMETER_BOUND, + classVisibility, + restricting, + restrictingVisibility, + context + ) } } } @@ -93,17 +92,15 @@ object FirExposedVisibilityDeclarationChecker : FirBasicDeclarationChecker() { val typeAliasVisibility = declaration.effectiveVisibility if (typeAliasVisibility == EffectiveVisibility.Local) return - val restricting = expandedType?.findVisibilityExposure(context, typeAliasVisibility) - if (restricting != null) { - reporter.reportOn( - declaration.source, - FirErrors.EXPOSED_TYPEALIAS_EXPANDED_TYPE, - typeAliasVisibility, - restricting, - restricting.effectiveVisibility, - context - ) - } + val (restricting, restrictingVisibility) = expandedType?.findVisibilityExposure(context, typeAliasVisibility) ?: return + reporter.reportOn( + declaration.source, + FirErrors.EXPOSED_TYPEALIAS_EXPANDED_TYPE, + typeAliasVisibility, + restricting, + restrictingVisibility, + context + ) } private fun checkFunction(declaration: FirFunction, reporter: DiagnosticReporter, context: CheckerContext) { @@ -111,34 +108,30 @@ object FirExposedVisibilityDeclarationChecker : FirBasicDeclarationChecker() { if (functionVisibility == EffectiveVisibility.Local) return if (declaration !is FirConstructor && declaration !is FirPropertyAccessor) { - val restricting = declaration.returnTypeRef.coneTypeSafe() - ?.findVisibilityExposure(context, functionVisibility) - if (restricting != null) { - reporter.reportOn( - declaration.source, - FirErrors.EXPOSED_FUNCTION_RETURN_TYPE, - functionVisibility, - restricting, - restricting.effectiveVisibility, - context - ) - } - } - declaration.valueParameters.forEachIndexed { i, valueParameter -> - if (i < declaration.valueParameters.size) { - val restricting = - valueParameter.returnTypeRef.coneTypeSafe() - ?.findVisibilityExposure(context, functionVisibility) - if (restricting != null) { + declaration.returnTypeRef.coneTypeSafe() + ?.findVisibilityExposure(context, functionVisibility)?.let { (restricting, restrictingVisibility) -> reporter.reportOn( - valueParameter.source, - FirErrors.EXPOSED_PARAMETER_TYPE, + declaration.source, + FirErrors.EXPOSED_FUNCTION_RETURN_TYPE, functionVisibility, restricting, - restricting.effectiveVisibility, + restrictingVisibility, context ) } + } + declaration.valueParameters.forEachIndexed { i, valueParameter -> + if (i < declaration.valueParameters.size) { + val (restricting, restrictingVisibility) = valueParameter.returnTypeRef.coneTypeSafe() + ?.findVisibilityExposure(context, functionVisibility) ?: return@forEachIndexed + reporter.reportOn( + valueParameter.source, + FirErrors.EXPOSED_PARAMETER_TYPE, + functionVisibility, + restricting, + restrictingVisibility, + context + ) } } checkMemberReceiver(declaration.receiverTypeRef, declaration as? FirCallableDeclaration, reporter, context) @@ -149,24 +142,22 @@ object FirExposedVisibilityDeclarationChecker : FirBasicDeclarationChecker() { val propertyVisibility = declaration.effectiveVisibility if (propertyVisibility == EffectiveVisibility.Local) return - val restricting = - declaration.returnTypeRef.coneTypeSafe() - ?.findVisibilityExposure(context, propertyVisibility) - if (restricting != null) { - val diagnostic = if (declaration.fromPrimaryConstructor == true) { - FirErrors.EXPOSED_PROPERTY_TYPE_IN_CONSTRUCTOR - } else { - FirErrors.EXPOSED_PROPERTY_TYPE + declaration.returnTypeRef.coneTypeSafe() + ?.findVisibilityExposure(context, propertyVisibility)?.let { (restricting, restrictingVisibility) -> + val diagnostic = if (declaration.fromPrimaryConstructor == true) { + FirErrors.EXPOSED_PROPERTY_TYPE_IN_CONSTRUCTOR + } else { + FirErrors.EXPOSED_PROPERTY_TYPE + } + reporter.reportOn( + declaration.source, + diagnostic, + propertyVisibility, + restricting, + restrictingVisibility, + context + ) } - reporter.reportOn( - declaration.source, - diagnostic, - propertyVisibility, - restricting, - restricting.effectiveVisibility, - context - ) - } checkMemberReceiver(declaration.receiverTypeRef, declaration, reporter, context) } @@ -181,35 +172,34 @@ object FirExposedVisibilityDeclarationChecker : FirBasicDeclarationChecker() { val memberVisibility = memberDeclaration.effectiveVisibility if (memberVisibility == EffectiveVisibility.Local) return - val restricting = receiverParameterType.findVisibilityExposure(context, memberVisibility) - if (restricting != null) { - reporter.reportOn( - typeRef.source, - FirErrors.EXPOSED_RECEIVER_TYPE, - memberVisibility, - restricting, - restricting.effectiveVisibility, - context - ) - } + val (restricting, restrictingVisibility) = receiverParameterType.findVisibilityExposure(context, memberVisibility) ?: return + reporter.reportOn( + typeRef.source, + FirErrors.EXPOSED_RECEIVER_TYPE, + memberVisibility, + restricting, + restrictingVisibility, + context + ) } private fun ConeKotlinType.findVisibilityExposure( context: CheckerContext, base: EffectiveVisibility - ): FirMemberDeclaration? { + ): Pair, EffectiveVisibility>? { val type = this as? ConeClassLikeType ?: return null - val fir = type.fullyExpandedType(context.session).lookupTag.toSymbol(context.session)?.let { firSymbol -> - firSymbol.ensureResolved(FirResolvePhase.DECLARATIONS) - firSymbol.fir - } ?: return null + val classSymbol = type.fullyExpandedType(context.session).lookupTag.toSymbol(context.session) ?: return null - if (fir is FirMemberDeclaration) { - val effectiveVisibility = fir.effectiveVisibility + val effectiveVisibility = when (classSymbol) { + is FirRegularClassSymbol -> classSymbol.effectiveVisibility + is FirTypeAliasSymbol -> classSymbol.effectiveVisibility + else -> null + } + if (effectiveVisibility != null) { when (effectiveVisibility.relation(base, context.session.typeContext)) { EffectiveVisibility.Permissiveness.LESS, EffectiveVisibility.Permissiveness.UNKNOWN -> { - return fir + return classSymbol to effectiveVisibility } else -> { } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirFunInterfaceDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirFunInterfaceDeclarationChecker.kt index 1097d8f5b7a..e6729ce3c76 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirFunInterfaceDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirFunInterfaceDeclarationChecker.kt @@ -24,6 +24,8 @@ import org.jetbrains.kotlin.fir.declarations.utils.isSuspend import org.jetbrains.kotlin.fir.languageVersionSettings import org.jetbrains.kotlin.fir.scopes.getFunctions import org.jetbrains.kotlin.fir.scopes.getProperties +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol object FirFunInterfaceDeclarationChecker : FirRegularClassChecker() { @@ -33,16 +35,16 @@ object FirFunInterfaceDeclarationChecker : FirRegularClassChecker() { val scope = declaration.unsubstitutedScope(context) val classSymbol = declaration.symbol - var abstractFunction: FirSimpleFunction? = null + var abstractFunctionSymbol: FirNamedFunctionSymbol? = null for (name in scope.getCallableNames()) { val functions = scope.getFunctions(name) val properties = scope.getProperties(name) for (function in functions) { - if (function.fir.isAbstract) { - if (abstractFunction == null) { - abstractFunction = function.fir + if (function.isAbstract) { + if (abstractFunctionSymbol == null) { + abstractFunctionSymbol = function } else { reporter.reportOn(declaration.source, FUN_INTERFACE_WRONG_COUNT_OF_ABSTRACT_MEMBERS, context) } @@ -50,10 +52,10 @@ object FirFunInterfaceDeclarationChecker : FirRegularClassChecker() { } for (property in properties) { - val firProperty = property.fir as? FirProperty ?: continue + val firProperty = property as? FirPropertySymbol ?: continue if (firProperty.isAbstract) { val source = - if (firProperty.getContainingClassSymbol(context) != classSymbol) + if (firProperty.getContainingClassSymbol(context.session) != classSymbol) declaration.source else firProperty.source @@ -63,33 +65,33 @@ object FirFunInterfaceDeclarationChecker : FirRegularClassChecker() { } } - if (abstractFunction == null) { + if (abstractFunctionSymbol == null) { reporter.reportOn(declaration.source, FUN_INTERFACE_WRONG_COUNT_OF_ABSTRACT_MEMBERS, context) return } - val inFunInterface = abstractFunction.getContainingClassSymbol(context) === classSymbol + val inFunInterface = abstractFunctionSymbol.getContainingClassSymbol(context.session) === classSymbol when { - abstractFunction.typeParameters.isNotEmpty() -> + abstractFunctionSymbol.typeParameterSymbols.isNotEmpty() -> reporter.reportOn( - if (inFunInterface) abstractFunction.source else declaration.source, + if (inFunInterface) abstractFunctionSymbol.source else declaration.source, FUN_INTERFACE_ABSTRACT_METHOD_WITH_TYPE_PARAMETERS, context ) - abstractFunction.isSuspend -> + abstractFunctionSymbol.isSuspend -> if (!context.session.languageVersionSettings.supportsFeature(LanguageFeature.SuspendFunctionsInFunInterfaces)) { reporter.reportOn( - if (inFunInterface) abstractFunction.source else declaration.source, + if (inFunInterface) abstractFunctionSymbol.source else declaration.source, FUN_INTERFACE_WITH_SUSPEND_FUNCTION, context ) } } - abstractFunction.valueParameters.forEach { - if (it.defaultValue != null) { + abstractFunctionSymbol.valueParameterSymbols.forEach { + if (it.hasDefaultValue) { reporter.reportOn( if (inFunInterface) it.source else declaration.source, FUN_INTERFACE_ABSTRACT_METHOD_WITH_DEFAULT_VALUE, 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 d4b00ec8cc8..fd3e2ff9885 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 @@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirFakeSourceElementKind import org.jetbrains.kotlin.fir.FirRealSourceElementKind import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.isInline +import org.jetbrains.kotlin.fir.analysis.checkers.isInlineClass import org.jetbrains.kotlin.fir.analysis.checkers.valOrVarKeyword import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors @@ -23,6 +23,7 @@ import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference +import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.types.FirErrorTypeRef import org.jetbrains.kotlin.fir.types.arrayElementType @@ -70,7 +71,7 @@ object FirFunctionParameterChecker : FirFunctionChecker() { for (varargParameter in varargParameters) { val varargParameterType = varargParameter.returnTypeRef.coneType.arrayElementType() ?: continue if (AbstractTypeChecker.isSubtypeOf(context.session.typeContext, varargParameterType, nullableNothingType) || - (varargParameterType.isInline(context.session) && !varargParameterType.isUnsignedTypeOrNullableUnsignedType) + (varargParameterType.isInlineClass(context.session) && !varargParameterType.isUnsignedTypeOrNullableUnsignedType) // Note: comparing with FE1.0, we skip checking if the type is not primitive because primitive types are not inline. That // is any primitive values are already allowed by the inline check. ) { @@ -95,6 +96,8 @@ object FirFunctionParameterChecker : FirFunctionChecker() { override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression) { val namedReference = qualifiedAccessExpression.calleeReference as? FirResolvedNamedReference ?: return + + @OptIn(SymbolInternals::class) val referredParameter = namedReference.resolvedSymbol.fir as? FirValueParameter ?: return val referredParameterIndex = function.valueParameters.indexOf(referredParameter) // Skip if the referred parameter is not declared in the same function. diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirImplementationMismatchChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirImplementationMismatchChecker.kt index 54790cc893a..851fdc512eb 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirImplementationMismatchChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirImplementationMismatchChecker.kt @@ -69,9 +69,9 @@ object FirImplementationMismatchChecker : FirClassChecker() { symbol: FirCallableSymbol<*>, classScope: FirTypeScope ) { - fun reportTypeMismatch(member1: FirCallableDeclaration, member2: FirCallableDeclaration, isDelegation: Boolean) { + fun reportTypeMismatch(member1: FirCallableSymbol<*>, member2: FirCallableSymbol<*>, isDelegation: Boolean) { val error = when { - member1 is FirProperty && member2 is FirProperty -> { + member1 is FirPropertySymbol && member2 is FirPropertySymbol -> { if (member1.isVar || member2.isVar) { FirErrors.VAR_TYPE_MISMATCH_ON_INHERITANCE } else { @@ -88,13 +88,13 @@ object FirImplementationMismatchChecker : FirClassChecker() { } fun canOverride( - inheritedMember: FirCallableDeclaration, + inheritedMember: FirCallableSymbol<*>, inheritedType: ConeKotlinType, - baseMember: FirCallableDeclaration, + baseMember: FirCallableSymbol<*>, baseType: ConeKotlinType ): Boolean { val inheritedTypeSubstituted = inheritedType.substituteTypeParameters(inheritedMember, baseMember, context) - return if (baseMember is FirProperty && baseMember.isVar) + return if (baseMember is FirPropertySymbol && baseMember.isVar) AbstractTypeChecker.equalTypes(typeCheckerContext, inheritedTypeSubstituted, baseType) else AbstractTypeChecker.isSubtypeOf(typeCheckerContext, inheritedTypeSubstituted, baseType) @@ -102,8 +102,8 @@ object FirImplementationMismatchChecker : FirClassChecker() { val intersectionSymbols = when { //substitution override means simple materialization of single method, so nothing to check - symbol.fir.isSubstitutionOverride -> return - symbol.fir.delegatedWrapperData != null -> { + symbol.isSubstitutionOverride -> return + symbol.delegatedWrapperData != null -> { val allOverridden = classScope.getDirectOverriddenMembers(symbol) //if there is intersection override - take its intersections - they will contain all substitutions //otherwise we get base members with unsubstituted params too @@ -119,26 +119,25 @@ object FirImplementationMismatchChecker : FirClassChecker() { } val withTypes = intersectionSymbols.map { - it.fir to context.returnTypeCalculator.tryCalculateReturnType(it.fir).coneType + it to context.returnTypeCalculator.tryCalculateReturnType(it).coneType } if (withTypes.any { it.second is ConeKotlinErrorType }) return - var delegation: FirCallableDeclaration? = null - val implementations = mutableListOf() + var delegation: FirCallableSymbol<*>? = null + val implementations = mutableListOf>() for (intSymbol in intersectionSymbols) { - val fir = intSymbol.fir - if (fir.delegatedWrapperData?.containingClass?.classId == containingClass.classId) { - delegation = fir + if (intSymbol.delegatedWrapperData?.containingClass?.classId == containingClass.classId) { + delegation = intSymbol break } - if (!(fir as FirCallableMemberDeclaration).isAbstract) { - implementations.add(fir) + if (!intSymbol.isAbstract) { + implementations.add(intSymbol) } } - var someClash: Pair? = null + var someClash: Pair, FirCallableSymbol<*>>? = null val compatible = withTypes.any { (m1, type1) -> withTypes.all { (m2, type2) -> val result = canOverride(m1, type1, m2, type2) @@ -172,15 +171,15 @@ object FirImplementationMismatchChecker : FirClassChecker() { symbol: FirVariableSymbol<*>, classScope: FirTypeScope ) { - if (symbol !is FirPropertySymbol || symbol.fir.isVar) return - if (symbol.fir.delegatedWrapperData == null) return + if (symbol !is FirPropertySymbol || symbol.isVar) return + if (symbol.delegatedWrapperData == null) return val overriddenVar = classScope.getDirectOverriddenProperties(symbol, true) - .find { it.fir.isVar } + .find { it.isVar } ?: return - reporter.reportOn(containingClass.source, FirErrors.VAR_OVERRIDDEN_BY_VAL_BY_DELEGATION, symbol.fir, overriddenVar.fir, context) + reporter.reportOn(containingClass.source, FirErrors.VAR_OVERRIDDEN_BY_VAL_BY_DELEGATION, symbol, overriddenVar, context) } private fun checkConflictingMembers( @@ -190,23 +189,23 @@ object FirImplementationMismatchChecker : FirClassChecker() { scope: FirTypeScope, name: Name ) { - val allFunctions = mutableListOf() + val allFunctions = mutableListOf() scope.processFunctionsByName(name) { sym -> val declaredInThisClass = sym.callableId.classId == containingClass.classId when { sym is FirIntersectionOverrideFunctionSymbol && declaredInThisClass -> - sym.intersections.mapNotNullTo(allFunctions) { (it as? FirNamedFunctionSymbol)?.fir } - !declaredInThisClass -> allFunctions.add(sym.fir) + sym.intersections.mapNotNullTo(allFunctions) { it as? FirNamedFunctionSymbol } + !declaredInThisClass -> allFunctions.add(sym) } } val sameArgumentGroups = allFunctions.groupBy { function -> - function.valueParameters.map { it.returnTypeRef.coneType } + function.valueParameterSymbols.map { it.resolvedReturnTypeRef.coneType } }.values val clashes = sameArgumentGroups.mapNotNull { fs -> fs.zipWithNext().find { (m1, m2) -> - m1.isSuspend != m2.isSuspend || m1.typeParameters.size != m2.typeParameters.size + m1.isSuspend != m2.isSuspend || m1.typeParameterSymbols.size != m2.typeParameterSymbols.size } } @@ -216,17 +215,17 @@ object FirImplementationMismatchChecker : FirClassChecker() { } private fun ConeKotlinType.substituteTypeParameters( - fromDeclaration: FirCallableDeclaration, - toDeclaration: FirCallableDeclaration, + fromDeclaration: FirCallableSymbol<*>, + toDeclaration: FirCallableSymbol<*>, context: CheckerContext ): ConeKotlinType { - val fromParams = (fromDeclaration as? FirTypeParametersOwner)?.typeParameters ?: return this - val toParams = (toDeclaration as? FirTypeParametersOwner)?.typeParameters ?: return this + val fromParams = fromDeclaration.typeParameterSymbols + val toParams = toDeclaration.typeParameterSymbols val substitutionMap = fromParams.zip(toParams) { from, to -> - from.symbol to to.toConeType() + from to to.toConeType() }.toMap() return substitutorByMap(substitutionMap, context.session).substituteOrSelf(this) } -} \ No newline at end of file +} diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirImportsChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirImportsChecker.kt index a6168f94f69..6d417d96240 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirImportsChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirImportsChecker.kt @@ -5,17 +5,18 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration +import org.jetbrains.kotlin.fir.analysis.checkers.collectEnumEntries import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.followAllAlias +import org.jetbrains.kotlin.fir.analysis.checkers.fullyExpandedClass import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.declarations.utils.collectEnumEntries import org.jetbrains.kotlin.fir.declarations.utils.isEnumClass import org.jetbrains.kotlin.fir.declarations.utils.isOperator import org.jetbrains.kotlin.fir.resolve.symbolProvider import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol import org.jetbrains.kotlin.fir.symbols.impl.isStatic @@ -44,9 +45,9 @@ object FirImportsChecker : FirFileChecker() { val fqName = import.importedFqName ?: return if (fqName.isRoot || fqName.parent().isRoot) return val classId = ClassId.topLevel(fqName.parent()) - val classFir = classId.resolveToClass(context) ?: return - if (classFir.isEnumClass && classFir.collectEnumEntries().any { it.name == fqName.shortName() }) { - reporter.reportOn(import.source, FirErrors.CANNOT_ALL_UNDER_IMPORT_FROM_SINGLETON, classFir.name, context) + val classSymbol = classId.resolveToClass(context) ?: return + if (classSymbol.isEnumClass && classSymbol.collectEnumEntries().any { it.callableId.callableName == fqName.shortName() }) { + reporter.reportOn(import.source, FirErrors.CANNOT_ALL_UNDER_IMPORT_FROM_SINGLETON, classSymbol.classId.shortClassName, context) } } @@ -58,10 +59,10 @@ object FirImportsChecker : FirFileChecker() { val classId = (import as? FirResolvedImport)?.resolvedClassId if (classId != null) { - val classFir = classId.resolveToClass(context) ?: return - if (classFir.classKind.isSingleton) return + val classSymbol = classId.resolveToClass(context) ?: return + if (classSymbol.classKind.isSingleton) return - if (!classFir.canBeImported(context, importedName)) { + if (!classSymbol.canBeImported(context, importedName)) { reporter.reportOn(import.source, FirErrors.CANNOT_BE_IMPORTED, importedName, context) } } else { @@ -106,7 +107,7 @@ object FirImportsChecker : FirFileChecker() { classFir.classKind.isSingleton && classFir.hasFunction(context, importedName) { it.isOperator } } else { context.session.symbolProvider.getTopLevelFunctionSymbols(import.packageFqName, importedName).any { - it.fir.isOperator + it.isOperator } } if (illegalRename) { @@ -130,26 +131,30 @@ object FirImportsChecker : FirFileChecker() { } } - private fun ClassId.resolveToClass(context: CheckerContext): FirRegularClass? { + private fun ClassId.resolveToClass(context: CheckerContext): FirRegularClassSymbol? { val classSymbol = context.session.symbolProvider.getClassLikeSymbolByFqName(this) ?: return null return when (classSymbol) { - is FirRegularClassSymbol -> classSymbol.fir - is FirTypeAliasSymbol -> classSymbol.fir.followAllAlias(context.session) as? FirRegularClass + is FirRegularClassSymbol -> classSymbol + is FirTypeAliasSymbol -> classSymbol.fullyExpandedClass(context.session) else -> null } } - private fun FirRegularClass.hasFunction(context: CheckerContext, name: Name, predicate: (FirSimpleFunction) -> Boolean): Boolean { + private fun FirRegularClassSymbol.hasFunction( + context: CheckerContext, + name: Name, + predicate: (FirNamedFunctionSymbol) -> Boolean + ): Boolean { var result = false context.session.declaredMemberScope(this).processFunctionsByName(name) { sym -> if (!result) { - result = predicate(sym.fir) + result = predicate(sym) } } return result } - private fun FirRegularClass.canBeImported( + private fun FirRegularClassSymbol.canBeImported( context: CheckerContext, name: Name ): Boolean { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInapplicableLateinitChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInapplicableLateinitChecker.kt index e4c2f34596f..44c08f49b3a 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInapplicableLateinitChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInapplicableLateinitChecker.kt @@ -50,7 +50,7 @@ object FirInapplicableLateinitChecker : FirPropertyChecker() { } private fun FirProperty.isNullable() = when (val type = returnTypeRef.coneType) { - is ConeTypeParameterType -> type.isNullable || type.lookupTag.typeParameterSymbol.fir.bounds.any { it.coneType.isNullable } + is ConeTypeParameterType -> type.isNullable || type.lookupTag.typeParameterSymbol.resolvedBounds.any { it.coneType.isNullable } else -> type.isNullable } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineClassDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineClassDeclarationChecker.kt index 1272504d295..95d0ad1582a 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineClassDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineClassDeclarationChecker.kt @@ -9,7 +9,7 @@ import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.hasModifier -import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClass +import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn @@ -20,6 +20,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.* import org.jetbrains.kotlin.fir.resolve.calls.isPotentiallyArray import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes +import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.ClassId @@ -47,7 +48,7 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() { } for (supertypeEntry in declaration.superTypeRefs) { - if (supertypeEntry.toRegularClass(context.session)?.isInterface != true) { + if (supertypeEntry.toRegularClassSymbol(context.session)?.isInterface != true) { reporter.reportOnWithSuppression(supertypeEntry, FirErrors.INLINE_CLASS_CANNOT_EXTEND_CLASSES, context) } } @@ -200,16 +201,18 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() { private fun ConeKotlinType.isRecursiveInlineClassType(visited: HashSet, session: FirSession): Boolean { if (!visited.add(this)) return true - val asRegularClass = this.toRegularClass(session) ?: return false + val asRegularClass = this.toRegularClassSymbol(session) ?: return false - return asRegularClass.isInlineOrValueClass() && - asRegularClass.primaryConstructor - ?.takeIf { it.source?.kind is FirRealSourceElementKind } - ?.valueParameters - ?.firstOrNull() - ?.returnTypeRef - ?.coneType - ?.isRecursiveInlineClassType(visited, session) == true + if (!asRegularClass.isInlineOrValueClass()) return false + val primaryConstructor = asRegularClass.declarationSymbols + .firstOrNull { it is FirConstructorSymbol && it.isPrimary } as FirConstructorSymbol? + ?: return false + return primaryConstructor + .valueParameterSymbols + .firstOrNull() + ?.resolvedReturnTypeRef + ?.coneType + ?.isRecursiveInlineClassType(visited, session) == true } private fun FirRegularClass.isSubtypeOfCloneable(session: FirSession): Boolean { 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 006113ab11b..5e650b99d3e 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 @@ -26,9 +26,7 @@ import org.jetbrains.kotlin.fir.resolve.inference.isFunctionalType import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.resolve.transformers.publishedApiEffectiveVisibility import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.isMarkedNullable import org.jetbrains.kotlin.fir.types.toSymbol @@ -53,16 +51,16 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { reporter: DiagnosticReporter ) { val body = function.body ?: return - val inlinableParameters = function.valueParameters.filter { + val inalienableParameters = function.valueParameters.filter { if (it.isNoinline) return@filter false val type = it.returnTypeRef.coneType !type.isMarkedNullable && type.isFunctionalType(context.session) { kind -> !kind.isReflectType } - } + }.map { it.symbol } val visitor = Visitor( function, effectiveVisibility, - inlinableParameters, + inalienableParameters, context.session, reporter ) @@ -72,7 +70,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { private class Visitor( val inlineFunction: FirFunction, val inlineFunEffectiveVisibility: EffectiveVisibility, - val inlinableParameters: List, + val inalienableParameters: List, val session: FirSession, val reporter: DiagnosticReporter ) : FirDefaultVisitor() { @@ -100,7 +98,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { override fun visitVariableAssignment(variableAssignment: FirVariableAssignment, data: CheckerContext) { val propertySymbol = variableAssignment.calleeReference.toResolvedCallableSymbol() as? FirPropertySymbol ?: return - val setterSymbol = propertySymbol.fir.setter?.symbol ?: return + val setterSymbol = propertySymbol.setterSymbol ?: return checkQualifiedAccess(variableAssignment, setterSymbol, data) } @@ -118,16 +116,16 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { targetSymbol: FirBasedSymbol<*>?, context: CheckerContext ) { - val calledFunction = (targetSymbol as? FirNamedFunctionSymbol)?.fir ?: return + val calledFunctionSymbol = targetSymbol as? FirNamedFunctionSymbol ?: return val argumentMapping = functionCall.resolvedArgumentMapping ?: return for ((wrappedArgument, valueParameter) in argumentMapping) { val argument = wrappedArgument.unwrapArgument() val resolvedArgumentSymbol = argument.toResolvedCallableSymbol() as? FirVariableSymbol<*> ?: continue - val valueParameterOfOriginalInlineFunction = inlinableParameters.firstOrNull { it == resolvedArgumentSymbol.fir } + val valueParameterOfOriginalInlineFunction = inalienableParameters.firstOrNull { it == resolvedArgumentSymbol } if (valueParameterOfOriginalInlineFunction != null) { val factory = when { - calledFunction.isInline -> when { + calledFunctionSymbol.isInline -> when { valueParameter.isNoinline -> FirErrors.USAGE_IS_NOT_INLINABLE valueParameter.isCrossinline && !valueParameterOfOriginalInlineFunction.isCrossinline -> FirErrors.NON_LOCAL_RETURN_NOT_ALLOWED @@ -135,7 +133,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { } else -> FirErrors.USAGE_IS_NOT_INLINABLE } - reporter.reportOn(argument.source, factory, valueParameterOfOriginalInlineFunction.symbol, context) + reporter.reportOn(argument.source, factory, valueParameterOfOriginalInlineFunction, context) } } } @@ -147,13 +145,12 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { context: CheckerContext ) { val receiverSymbol = receiverExpression.toResolvedCallableSymbol() ?: return - if (receiverSymbol.fir in inlinableParameters) { - val valueParameter = receiverSymbol.fir as FirValueParameter + if (receiverSymbol in inalienableParameters) { if (!isInvokeOrInlineExtension(targetSymbol)) { reporter.reportOn( qualifiedAccessExpression.source, FirErrors.USAGE_IS_NOT_INLINABLE, - valueParameter.symbol, + receiverSymbol, context ) } @@ -162,10 +159,9 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { private fun isInvokeOrInlineExtension(targetSymbol: FirBasedSymbol<*>?): Boolean { if (targetSymbol !is FirNamedFunctionSymbol) return false - val function = targetSymbol.fir - if (function.isInline) return true - return function.name == OperatorNameConventions.INVOKE && - function.dispatchReceiverType?.isBuiltinFunctionalType(session) == true + if (targetSymbol.isInline) return true + return targetSymbol.name == OperatorNameConventions.INVOKE && + targetSymbol.dispatchReceiverType?.isBuiltinFunctionalType(session) == true } private fun checkQualifiedAccess( @@ -174,16 +170,14 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { context: CheckerContext ) { val source = qualifiedAccess.source ?: return - if (targetSymbol == null) return - val targetFir = targetSymbol.fir as? FirCallableDeclaration + if (targetSymbol !is FirCallableSymbol<*>) return - if (targetSymbol.fir in inlinableParameters) { + if (targetSymbol in inalienableParameters) { if (!qualifiedAccess.partOfCall(context)) { - val valueParameter = targetSymbol.fir as FirValueParameter - reporter.reportOn(source, FirErrors.USAGE_IS_NOT_INLINABLE, valueParameter.symbol, context) + reporter.reportOn(source, FirErrors.USAGE_IS_NOT_INLINABLE, targetSymbol, context) } } - checkVisibilityAndAccess(qualifiedAccess, targetFir, source, context) + checkVisibilityAndAccess(qualifiedAccess, targetSymbol, source, context) checkRecursion(targetSymbol, source, context) } @@ -199,7 +193,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { private fun checkVisibilityAndAccess( accessExpression: FirQualifiedAccess, - calledDeclaration: FirCallableDeclaration?, + calledDeclaration: FirCallableSymbol<*>?, source: FirSourceElement, context: CheckerContext ) { @@ -221,7 +215,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { reporter.reportOn( source, FirErrors.NON_PUBLIC_CALL_FROM_PUBLIC_INLINE, - calledDeclaration.symbol, + calledDeclaration, inlineFunction.symbol, context ) @@ -232,7 +226,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { } } - val isConstructorCall = calledDeclaration is FirConstructor + val isConstructorCall = calledDeclaration is FirConstructorSymbol if ( isInlineFunPublicOrPublishedApi && inlineFunEffectiveVisibility.toVisibility() !== Visibilities.Protected && @@ -243,12 +237,12 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { prohibitProtectedCallFromInline -> FirErrors.PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR else -> FirErrors.PROTECTED_CALL_FROM_PUBLIC_INLINE } - reporter.reportOn(source, factory, calledDeclaration.symbol, inlineFunction.symbol, context) + reporter.reportOn(source, factory, calledDeclaration, inlineFunction.symbol, context) } } private fun checkPrivateClassMemberAccess( - calledDeclaration: FirCallableDeclaration, + calledDeclaration: FirCallableSymbol<*>, source: FirSourceElement, context: CheckerContext ) { @@ -257,7 +251,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { reporter.reportOn( source, FirErrors.PRIVATE_CLASS_MEMBER_FROM_INLINE, - calledDeclaration.symbol, + calledDeclaration, inlineFunction.symbol, context ) @@ -266,7 +260,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { } private fun checkSuperCalls( - calledDeclaration: FirCallableDeclaration, + calledDeclaration: FirCallableSymbol<*>, callExpression: FirQualifiedAccess, context: CheckerContext ) { @@ -278,7 +272,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { reporter.reportOn( callExpression.dispatchReceiver.source, FirErrors.SUPER_CALL_FROM_PUBLIC_INLINE, - calledDeclaration.symbol, + calledDeclaration, context ) } @@ -286,12 +280,12 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { } private fun FirBasedSymbol<*>.isDefinedInInlineFunction(): Boolean { - return when (val fir = this.fir) { - is FirAnonymousFunction -> true - is FirMemberDeclaration -> fir.isLocalMember - is FirAnonymousObject -> true - is FirRegularClass -> fir.classId.isLocal - else -> error("Unknown callable declaration type: ${fir.render()}") + return when (val symbol = this) { + is FirAnonymousFunctionSymbol -> true + is FirCallableSymbol<*> -> symbol.isLocalMember + is FirAnonymousObjectSymbol -> true + is FirRegularClassSymbol -> symbol.classId.isLocal + else -> error("Unknown callable declaration type: $symbol") } } @@ -305,13 +299,13 @@ object FirInlineDeclarationChecker : FirFunctionChecker() { } } - private fun FirCallableDeclaration.isInsidePrivateClass(): Boolean { - val containingClass = this.containingClass()?.toSymbol(session)?.fir ?: return false + private fun FirCallableSymbol<*>.isInsidePrivateClass(): Boolean { + val containingClassSymbol = this.containingClass()?.toSymbol(session) ?: return false - val containingClassVisibility = when (containingClass) { - is FirAnonymousObject -> return false - is FirRegularClass -> containingClass.visibility - is FirTypeAlias -> containingClass.visibility + val containingClassVisibility = when (containingClassSymbol) { + is FirAnonymousObjectSymbol -> return false + is FirRegularClassSymbol -> containingClassSymbol.visibility + is FirTypeAliasSymbol -> containingClassSymbol.visibility } return containingClassVisibility == Visibilities.Private || containingClassVisibility == Visibilities.PrivateToThis } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirKClassWithIncorrectTypeArgumentChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirKClassWithIncorrectTypeArgumentChecker.kt index 640f093eb04..0ef224d8346 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirKClassWithIncorrectTypeArgumentChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirKClassWithIncorrectTypeArgumentChecker.kt @@ -12,11 +12,11 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.declarations.FirFile -import org.jetbrains.kotlin.fir.declarations.FirTypeParameter import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeTypeParameterInQualifiedAccess import org.jetbrains.kotlin.fir.resolve.inference.inferenceComponents import org.jetbrains.kotlin.fir.resolve.inference.isKClassType import org.jetbrains.kotlin.fir.scopes.impl.toConeType +import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.* // See FE1.0 [KClassWithIncorrectTypeArgumentChecker] @@ -45,7 +45,7 @@ object FirKClassWithIncorrectTypeArgumentChecker : FirFileChecker() { val typeArgument = (returnType.typeArguments[0] as ConeKotlinTypeProjection).type typeArgument.typeParameterFromError?.let { - reporter.reportOn(source, FirErrors.KCLASS_WITH_NULLABLE_TYPE_PARAMETER_IN_SIGNATURE, it.symbol, context) + reporter.reportOn(source, FirErrors.KCLASS_WITH_NULLABLE_TYPE_PARAMETER_IN_SIGNATURE, it, context) } } @@ -58,14 +58,14 @@ object FirKClassWithIncorrectTypeArgumentChecker : FirFileChecker() { } } ?: return false with(context) { - argumentType.typeParameterFromError?.let { typeParameter -> - return typeParameter.toConeType().isNullableType() + argumentType.typeParameterFromError?.let { typeParameterSymbol -> + return typeParameterSymbol.toConeType().isNullableType() } return argumentType is ConeKotlinErrorType || argumentType.isNullableType() } } - private val ConeKotlinType.typeParameterFromError: FirTypeParameter? - get() = ((this as? ConeKotlinErrorType)?.diagnostic as? ConeTypeParameterInQualifiedAccess)?.symbol?.fir + private val ConeKotlinType.typeParameterFromError: FirTypeParameterSymbol? + get() = ((this as? ConeKotlinErrorType)?.diagnostic as? ConeTypeParameterInQualifiedAccess)?.symbol } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirMemberFunctionsChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirMemberFunctionsChecker.kt index 4f586cb00ed..a58578e4d8c 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirMemberFunctionsChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirMemberFunctionsChecker.kt @@ -35,6 +35,7 @@ object FirMemberFunctionsChecker : FirClassChecker() { ) { val source = function.source ?: return if (source.kind is FirFakeSourceElementKind) return + val functionSymbol = function.symbol // If multiple (potentially conflicting) modality modifiers are specified, not all modifiers are recorded at `status`. // So, our source of truth should be the full modifier list retrieved from the source. val modifierList = source.getModifierList() @@ -45,13 +46,13 @@ object FirMemberFunctionsChecker : FirClassChecker() { reporter.reportOn( source, FirErrors.ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, - function, - containingDeclaration, + functionSymbol, + containingDeclaration.symbol, context ) } if (function.hasBody) { - reporter.reportOn(source, FirErrors.ABSTRACT_FUNCTION_WITH_BODY, function, context) + reporter.reportOn(source, FirErrors.ABSTRACT_FUNCTION_WITH_BODY, functionSymbol, context) } } val isInsideExpectClass = isInsideExpectClass(containingDeclaration, context) @@ -59,13 +60,13 @@ object FirMemberFunctionsChecker : FirClassChecker() { if (!function.hasBody) { if (containingDeclaration.isInterface) { if (Visibilities.isPrivate(function.visibility)) { - reporter.reportOn(source, FirErrors.PRIVATE_FUNCTION_WITH_NO_BODY, function, context) + reporter.reportOn(source, FirErrors.PRIVATE_FUNCTION_WITH_NO_BODY, functionSymbol, context) } if (!isInsideExpectClass && !hasAbstractModifier && hasOpenModifier) { reporter.reportOn(source, FirErrors.REDUNDANT_OPEN_IN_INTERFACE, context) } } else if (!isInsideExpectClass && !hasAbstractModifier && !function.isExternal) { - reporter.reportOn(source, FirErrors.NON_ABSTRACT_FUNCTION_WITH_NO_BODY, function, context) + reporter.reportOn(source, FirErrors.NON_ABSTRACT_FUNCTION_WITH_NO_BODY, functionSymbol, context) } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirMemberPropertiesChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirMemberPropertiesChecker.kt index 65b72ffa9f8..0f7400c104f 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirMemberPropertiesChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirMemberPropertiesChecker.kt @@ -39,7 +39,7 @@ object FirMemberPropertiesChecker : FirClassChecker() { mutableMapOf().withDefault { EventOccurrencesRange.ZERO } // If all member properties have its own initializer, we don't need to collect property initialization info at all. - if (memberPropertySymbols.any { it.fir.initializer == null }) { + if (memberPropertySymbols.any { !it.hasInitializer }) { collectPropertyInitialization(declaration, memberPropertySymbols, initializedInConstructor, initializedInInitOrOtherProperty) } @@ -137,7 +137,7 @@ object FirMemberPropertiesChecker : FirClassChecker() { collectInfoFromGraph(graph, initializedInInitOrOtherProperty, EventOccurrencesRange::plus) } - val propertyInitGraphs = memberPropertySymbols.mapNotNull { it.fir.controlFlowGraphReference?.controlFlowGraph } + val propertyInitGraphs = memberPropertySymbols.mapNotNull { it.controlFlowGraphReference?.controlFlowGraph } for (graph in propertyInitGraphs) { collectInfoFromGraph(graph, initializedInInitOrOtherProperty, EventOccurrencesRange::plus) } @@ -187,8 +187,8 @@ object FirMemberPropertiesChecker : FirClassChecker() { reporter.reportOn( it, FirErrors.ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS, - property, - containingDeclaration, + property.symbol, + containingDeclaration.symbol, context ) return diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirNotImplementedOverrideChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirNotImplementedOverrideChecker.kt index 3d99f48377d..9b3854547cd 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirNotImplementedOverrideChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirNotImplementedOverrideChecker.kt @@ -22,7 +22,6 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MANY_IMPL_MEMBER_ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OVERRIDING_FINAL_MEMBER_BY_DELEGATION import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.containingClass -import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.utils.* @@ -48,6 +47,7 @@ object FirNotImplementedOverrideChecker : FirClassChecker() { if (declaration is FirRegularClass && declaration.isExpect) return val classKind = declaration.classKind if (classKind == ClassKind.ANNOTATION_CLASS || classKind == ClassKind.ENUM_CLASS) return + val classSymbol = declaration.symbol val classScope = declaration.unsubstitutedScope(context) @@ -59,23 +59,21 @@ object FirNotImplementedOverrideChecker : FirClassChecker() { val invisibleSymbols = mutableListOf>() fun collectSymbol(symbol: FirCallableSymbol<*>) { - val fir = symbol.fir - - val delegatedWrapperData = fir.delegatedWrapperData + val delegatedWrapperData = symbol.delegatedWrapperData if (delegatedWrapperData != null) { val directOverriddenMembers = classScope.getDirectOverriddenMembers( symbol, unwrapIntersectionAndSubstitutionOverride = true ) - val delegatedTo = delegatedWrapperData.wrapped.unwrapFakeOverrides() + val delegatedTo = delegatedWrapperData.wrapped.unwrapFakeOverrides().symbol - if (symbol.fir.multipleDelegatesWithTheSameSignature == true) { + if (symbol.multipleDelegatesWithTheSameSignature == true) { manyImplementationsDelegationSymbols.add(symbol) } - val firstFinal = directOverriddenMembers.firstOrNull { it.fir.isFinal } - val firstOpen = directOverriddenMembers.firstOrNull { it.fir.isOpen && delegatedTo != it.unwrapFakeOverrides().fir } + val firstFinal = directOverriddenMembers.firstOrNull { it.isFinal } + val firstOpen = directOverriddenMembers.firstOrNull { it.isOpen && delegatedTo != it.unwrapFakeOverrides() } when { firstFinal != null -> @@ -87,10 +85,10 @@ object FirNotImplementedOverrideChecker : FirClassChecker() { return } - when (fir.getImplementationStatus(context.sessionHolder, declaration)) { + when (symbol.getImplementationStatus(context.sessionHolder, classSymbol)) { ImplementationStatus.AMBIGUOUSLY_INHERITED -> notImplementedIntersectionSymbols.add(symbol) ImplementationStatus.NOT_IMPLEMENTED -> when { - fir.isVisibleInClass(declaration) -> notImplementedSymbols.add(symbol) + symbol.isVisibleInClass(classSymbol) -> notImplementedSymbols.add(symbol) else -> invisibleSymbols.add(symbol) } else -> { @@ -105,32 +103,32 @@ object FirNotImplementedOverrideChecker : FirClassChecker() { } if (!canHaveAbstractDeclarations && notImplementedSymbols.isNotEmpty()) { - val notImplemented = notImplementedSymbols.first().unwrapFakeOverrides().fir + val notImplemented = notImplementedSymbols.first().unwrapFakeOverrides() if (notImplemented.isFromInterfaceOrEnum(context)) { - reporter.reportOn(source, ABSTRACT_MEMBER_NOT_IMPLEMENTED, declaration, notImplemented, context) + reporter.reportOn(source, ABSTRACT_MEMBER_NOT_IMPLEMENTED, classSymbol, notImplemented, context) } else { - reporter.reportOn(source, ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED, declaration, notImplemented, context) + reporter.reportOn(source, ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED, classSymbol, notImplemented, context) } } if (!canHaveAbstractDeclarations && invisibleSymbols.isNotEmpty()) { - val invisible = invisibleSymbols.first().fir + val invisible = invisibleSymbols.first() if (context.session.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitInvisibleAbstractMethodsInSuperclasses)) { - reporter.reportOn(source, INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER, declaration, invisible, context) + reporter.reportOn(source, INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER, classSymbol, invisible, context) } else { - reporter.reportOn(source, INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING, declaration, invisible, context) + reporter.reportOn(source, INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING, classSymbol, invisible, context) } } manyImplementationsDelegationSymbols.firstOrNull()?.let { - reporter.reportOn(source, MANY_IMPL_MEMBER_NOT_IMPLEMENTED, declaration, it.fir, context) + reporter.reportOn(source, MANY_IMPL_MEMBER_NOT_IMPLEMENTED, classSymbol, it, context) } delegationOverrideOfFinal.firstOrNull()?.let { (delegated, final) -> reporter.reportOn( source, OVERRIDING_FINAL_MEMBER_BY_DELEGATION, - delegated.fir, - final.fir, + delegated, + final, context ) } @@ -139,33 +137,32 @@ object FirNotImplementedOverrideChecker : FirClassChecker() { reporter.reportOn( source, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, - delegated.fir, - open.fir, + delegated, + open, context ) } if (manyImplementationsDelegationSymbols.isEmpty() && notImplementedIntersectionSymbols.isNotEmpty()) { val notImplementedIntersectionSymbol = notImplementedIntersectionSymbols.first() - val notImplementedIntersection = notImplementedIntersectionSymbol.fir val intersections = (notImplementedIntersectionSymbol as FirIntersectionCallableSymbol).intersections if (intersections.any { - (it.containingClass()?.toSymbol(context.session)?.fir as? FirRegularClass)?.classKind == ClassKind.CLASS + (it.containingClass()?.toSymbol(context.session) as? FirRegularClassSymbol)?.classKind == ClassKind.CLASS } ) { - reporter.reportOn(source, MANY_IMPL_MEMBER_NOT_IMPLEMENTED, declaration, notImplementedIntersection, context) + reporter.reportOn(source, MANY_IMPL_MEMBER_NOT_IMPLEMENTED, classSymbol, notImplementedIntersectionSymbol, context) } else { reporter.reportOn( source, FirErrors.MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED, - declaration, - notImplementedIntersection, + classSymbol, + notImplementedIntersectionSymbol, context ) } } } - private fun FirCallableDeclaration.isFromInterfaceOrEnum(context: CheckerContext): Boolean = - (getContainingClassSymbol(context) as? FirRegularClassSymbol)?.let { it.isInterface || it.isEnumClass } == true + private fun FirCallableSymbol<*>.isFromInterfaceOrEnum(context: CheckerContext): Boolean = + (getContainingClassSymbol(context.session) as? FirRegularClassSymbol)?.let { it.isInterface || it.isEnumClass } == true } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt index 394bb2385df..539443a4a34 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt @@ -16,23 +16,25 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.overridesBackwardCompatibilityHelper import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.utils.isFinal import org.jetbrains.kotlin.fir.declarations.utils.isOverride +import org.jetbrains.kotlin.fir.declarations.utils.modality import org.jetbrains.kotlin.fir.declarations.utils.visibility import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap -import org.jetbrains.kotlin.fir.resolve.toFirRegularClass +import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.scopes.FirTypeScope import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenProperties import org.jetbrains.kotlin.fir.scopes.impl.toConeType -import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.ensureResolved +import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.ConeKotlinErrorType import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.upperBoundIfFlexible import org.jetbrains.kotlin.types.AbstractTypeChecker import org.jetbrains.kotlin.types.AbstractTypeCheckerContext -import org.jetbrains.kotlin.utils.addToStdlib.safeAs object FirOverrideChecker : FirClassChecker() { override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) { @@ -45,45 +47,45 @@ object FirOverrideChecker : FirClassChecker() { for (it in declaration.declarations) { if (it is FirSimpleFunction || it is FirProperty) { - checkMember(it as FirCallableDeclaration, declaration, reporter, typeCheckerContext, firTypeScope, context) + checkMember((it as FirCallableDeclaration).symbol, declaration, reporter, typeCheckerContext, firTypeScope, context) } } } - private fun FirTypeScope.retrieveDirectOverriddenOf(member: FirCallableDeclaration): List> { - return when (member) { - is FirSimpleFunction -> { - processFunctionsByName(member.name) {} - getDirectOverriddenFunctions(member.symbol) + private fun FirTypeScope.retrieveDirectOverriddenOf(memberSymbol: FirCallableSymbol<*>): List> { + return when (memberSymbol) { + is FirNamedFunctionSymbol -> { + processFunctionsByName(memberSymbol.name) {} + getDirectOverriddenFunctions(memberSymbol) } - is FirProperty -> { - processPropertiesByName(member.name) {} - getDirectOverriddenProperties(member.symbol) + is FirPropertySymbol -> { + processPropertiesByName(memberSymbol.name) {} + getDirectOverriddenProperties(memberSymbol) } - else -> throw IllegalArgumentException("unexpected member kind $member") + else -> throw IllegalArgumentException("unexpected member kind $memberSymbol") } } private fun ConeKotlinType.substituteAllTypeParameters( - overrideDeclaration: FirCallableDeclaration, - baseDeclaration: FirCallableDeclaration, + overrideDeclaration: FirCallableSymbol<*>, + baseDeclaration: FirCallableSymbol<*>, context: CheckerContext ): ConeKotlinType { - if (overrideDeclaration.typeParameters.isEmpty()) { + val overrideTypeParameters = overrideDeclaration.typeParameterSymbols + if (overrideTypeParameters.isEmpty()) { return this } - val parametersOwner = baseDeclaration.safeAs() - ?: return this + val baseTypeParameters = baseDeclaration.typeParameterSymbols val map = mutableMapOf() - val size = minOf(overrideDeclaration.typeParameters.size, parametersOwner.typeParameters.size) + val size = minOf(overrideTypeParameters.size, baseTypeParameters.size) for (it in 0 until size) { - val to = overrideDeclaration.typeParameters[it] - val from = parametersOwner.typeParameters[it] + val to = overrideTypeParameters[it] + val from = baseTypeParameters[it] - map[from.symbol] = to.toConeType() + map[from] = to.toConeType() } return substitutorByMap(map, context.session).substituteOrSelf(this) @@ -91,32 +93,32 @@ object FirOverrideChecker : FirClassChecker() { private fun checkModality( overriddenSymbols: List>, - ): FirCallableDeclaration? { + ): FirCallableSymbol<*>? { for (overridden in overriddenSymbols) { - val modality = (overridden.fir as FirMemberDeclaration).status.modality + val modality = overridden.modality val isEffectivelyFinal = modality == null || modality == Modality.FINAL if (isEffectivelyFinal) { - return overridden.fir + return overridden } } return null } - private fun FirProperty.checkMutability( + private fun FirPropertySymbol.checkMutability( overriddenSymbols: List>, - ): FirMemberDeclaration? { + ): FirCallableSymbol<*>? { if (isVar) return null - return overriddenSymbols.find { (it.fir as? FirProperty)?.isVar == true }?.fir as? FirMemberDeclaration? + return overriddenSymbols.find { (it as? FirPropertySymbol)?.isVar == true } } - private fun FirCallableDeclaration.checkVisibility( + private fun FirCallableSymbol<*>.checkVisibility( containingClass: FirClass, reporter: DiagnosticReporter, overriddenSymbols: List>, context: CheckerContext ) { val visibilities = overriddenSymbols.map { - it to (it.fir as FirMemberDeclaration).visibility + it to it.visibility }.sortedBy { pair -> // Regard `null` compare as Int.MIN so that we can report CANNOT_CHANGE_... first deterministically Visibilities.compare(visibility, pair.second) ?: Int.MIN_VALUE @@ -125,10 +127,10 @@ object FirOverrideChecker : FirClassChecker() { for ((overridden, overriddenVisibility) in visibilities) { val compare = Visibilities.compare(visibility, overriddenVisibility) if (compare == null) { - reporter.reportCannotChangeAccessPrivilege(this, overridden.fir, context) + reporter.reportCannotChangeAccessPrivilege(this, overridden, context) return } else if (compare < 0) { - reporter.reportCannotWeakenAccessPrivilege(this, overridden.fir, context) + reporter.reportCannotWeakenAccessPrivilege(this, overridden, context) return } } @@ -137,45 +139,47 @@ object FirOverrideChecker : FirClassChecker() { val containingDeclarations = context.containingDeclarations + containingClass val visibilityChecker = context.session.visibilityChecker val hasVisibleBase = overriddenSymbols.any { - val fir = it.fir as? FirCallableDeclaration ?: return@any true + it.ensureResolved(FirResolvePhase.STATUS) + @OptIn(SymbolInternals::class) + val fir = it.fir visibilityChecker.isVisible(fir, context.session, file, containingDeclarations, null) } if (!hasVisibleBase) { //NB: Old FE reports this in an attempt to override private member, //while the new FE doesn't treat super's private members as overridable, so you won't get them here //instead you will get NOTHING_TO_OVERRIDE, which seems acceptable - reporter.reportOn(source, FirErrors.CANNOT_OVERRIDE_INVISIBLE_MEMBER, this, overriddenSymbols.first().fir, context) + reporter.reportOn(source, FirErrors.CANNOT_OVERRIDE_INVISIBLE_MEMBER, this, overriddenSymbols.first(), context) } } // See [OverrideResolver#isReturnTypeOkForOverride] - private fun FirCallableDeclaration.checkReturnType( + private fun FirCallableSymbol<*>.checkReturnType( overriddenSymbols: List>, typeCheckerContext: AbstractTypeCheckerContext, context: CheckerContext, - ): FirMemberDeclaration? { - val overridingReturnType = returnTypeRef.coneType + ): FirCallableSymbol<*>? { + val overridingReturnType = resolvedReturnTypeRef.coneType // Don't report *_ON_OVERRIDE diagnostics according to an error return type. That should be reported separately. if (overridingReturnType is ConeKotlinErrorType) { return null } - val bounds = overriddenSymbols.map { context.returnTypeCalculator.tryCalculateReturnType(it.fir).coneType.upperBoundIfFlexible() } + val bounds = overriddenSymbols.map { context.returnTypeCalculator.tryCalculateReturnType(it).coneType.upperBoundIfFlexible() } for (it in bounds.indices) { - val overriddenDeclaration = overriddenSymbols[it].fir + val overriddenDeclaration = overriddenSymbols[it] val overriddenReturnType = bounds[it].substituteAllTypeParameters(this, overriddenDeclaration, context) val isReturnTypeOkForOverride = - if (overriddenDeclaration is FirProperty && overriddenDeclaration.isVar) + if (overriddenDeclaration is FirPropertySymbol && overriddenDeclaration.isVar) AbstractTypeChecker.equalTypes(typeCheckerContext, overridingReturnType, overriddenReturnType) else AbstractTypeChecker.isSubtypeOf(typeCheckerContext, overridingReturnType, overriddenReturnType) if (!isReturnTypeOkForOverride) { - return overriddenDeclaration as? FirMemberDeclaration + return overriddenDeclaration } } @@ -183,12 +187,12 @@ object FirOverrideChecker : FirClassChecker() { } private fun checkMember( - member: FirCallableDeclaration, + member: FirCallableSymbol<*>, containingClass: FirClass, reporter: DiagnosticReporter, typeCheckerContext: AbstractTypeCheckerContext, firTypeScope: FirTypeScope, - context: CheckerContext, + context: CheckerContext ) { val overriddenMemberSymbols = firTypeScope.retrieveDirectOverriddenOf(member) @@ -200,15 +204,29 @@ object FirOverrideChecker : FirClassChecker() { } val kind = member.source?.kind // Only report if the current member has real source or it's a member property declared inside the primary constructor. + + if (kind is FirFakeSourceElementKind.DataClassGeneratedMembers) { + overriddenMemberSymbols.find { it.isFinal }?.let { base -> + reporter.reportOn( + containingClass.source, + FirErrors.DATA_CLASS_OVERRIDE_CONFLICT, + member, + base, + context + ) + } + return + } + if (kind !is FirRealSourceElementKind && kind !is FirFakeSourceElementKind.PropertyFromParameter) return val overridden = overriddenMemberSymbols.first().originalOrSelf() - val originalContainigClass = overridden.containingClass()?.toFirRegularClass(context.session) ?: return + val originalContainingClassSymbol = overridden.containingClass()?.toSymbol(context.session) as? FirRegularClassSymbol ?: return reporter.reportOn( member.source, FirErrors.VIRTUAL_MEMBER_HIDDEN, member, - originalContainigClass, + originalContainingClassSymbol, context ) return @@ -223,7 +241,7 @@ object FirOverrideChecker : FirClassChecker() { reporter.reportOverridingFinalMember(member, it, context) } - if (member is FirProperty) { + if (member is FirPropertySymbol) { member.checkMutability(overriddenMemberSymbols)?.let { reporter.reportVarOverriddenByVal(member, it, context) } @@ -237,8 +255,8 @@ object FirOverrideChecker : FirClassChecker() { context = context, ) ?: return when (member) { - is FirSimpleFunction -> reporter.reportReturnTypeMismatchOnFunction(member, restriction, context) - is FirProperty -> { + is FirNamedFunctionSymbol -> reporter.reportReturnTypeMismatchOnFunction(member, restriction, context) + is FirPropertySymbol -> { if (member.isVar) { reporter.reportTypeMismatchOnVariable(member, restriction, context) } else { @@ -248,15 +266,13 @@ object FirOverrideChecker : FirClassChecker() { } } - @Suppress("UNUSED_PARAMETER") // TODO: delete me after implementing body - private fun DiagnosticReporter.reportNothingToOverride(declaration: FirMemberDeclaration, context: CheckerContext) { - // TODO: not ready yet, e.g., Collections - // reportOn(declaration.source, FirErrors.NOTHING_TO_OVERRIDE, declaration, context) + private fun DiagnosticReporter.reportNothingToOverride(declaration: FirCallableSymbol<*>, context: CheckerContext) { + reportOn(declaration.source, FirErrors.NOTHING_TO_OVERRIDE, declaration, context) } private fun DiagnosticReporter.reportOverridingFinalMember( - overriding: FirMemberDeclaration, - overridden: FirCallableDeclaration, + overriding: FirCallableSymbol<*>, + overridden: FirCallableSymbol<*>, context: CheckerContext ) { overridden.containingClass()?.let { containingClass -> @@ -265,16 +281,16 @@ object FirOverrideChecker : FirClassChecker() { } private fun DiagnosticReporter.reportVarOverriddenByVal( - overriding: FirMemberDeclaration, - overridden: FirMemberDeclaration, + overriding: FirCallableSymbol<*>, + overridden: FirCallableSymbol<*>, context: CheckerContext ) { reportOn(overriding.source, FirErrors.VAR_OVERRIDDEN_BY_VAL, overriding, overridden, context) } private fun DiagnosticReporter.reportCannotWeakenAccessPrivilege( - overriding: FirMemberDeclaration, - overridden: FirCallableDeclaration, + overriding: FirCallableSymbol<*>, + overridden: FirCallableSymbol<*>, context: CheckerContext ) { val containingClass = overridden.containingClass() ?: return @@ -289,8 +305,8 @@ object FirOverrideChecker : FirClassChecker() { } private fun DiagnosticReporter.reportCannotChangeAccessPrivilege( - overriding: FirMemberDeclaration, - overridden: FirCallableDeclaration, + overriding: FirCallableSymbol<*>, + overridden: FirCallableSymbol<*>, context: CheckerContext ) { val containingClass = overridden.containingClass() ?: return @@ -305,24 +321,24 @@ object FirOverrideChecker : FirClassChecker() { } private fun DiagnosticReporter.reportReturnTypeMismatchOnFunction( - overriding: FirMemberDeclaration, - overridden: FirMemberDeclaration, + overriding: FirCallableSymbol<*>, + overridden: FirCallableSymbol<*>, context: CheckerContext ) { reportOn(overriding.source, FirErrors.RETURN_TYPE_MISMATCH_ON_OVERRIDE, overriding, overridden, context) } private fun DiagnosticReporter.reportTypeMismatchOnProperty( - overriding: FirMemberDeclaration, - overridden: FirMemberDeclaration, + overriding: FirCallableSymbol<*>, + overridden: FirCallableSymbol<*>, context: CheckerContext ) { reportOn(overriding.source, FirErrors.PROPERTY_TYPE_MISMATCH_ON_OVERRIDE, overriding, overridden, context) } private fun DiagnosticReporter.reportTypeMismatchOnVariable( - overriding: FirMemberDeclaration, - overridden: FirMemberDeclaration, + overriding: FirCallableSymbol<*>, + overridden: FirCallableSymbol<*>, context: CheckerContext ) { reportOn(overriding.source, FirErrors.VAR_TYPE_MISMATCH_ON_OVERRIDE, overriding, overridden, context) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPrimaryConstructorSuperTypeChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPrimaryConstructorSuperTypeChecker.kt index 85b7496e8d8..99e73d17d1b 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPrimaryConstructorSuperTypeChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPrimaryConstructorSuperTypeChecker.kt @@ -9,7 +9,7 @@ import org.jetbrains.kotlin.KtNodeTypes import org.jetbrains.kotlin.fir.FirFakeSourceElementKind import org.jetbrains.kotlin.fir.analysis.checkers.SourceNavigator import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClass +import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn @@ -65,9 +65,9 @@ object FirPrimaryConstructorSuperTypeChecker : FirRegularClassChecker() { // No need to check implicit call to the constructor of `kotlin.Any`. val constructedTypeRef = delegatedConstructorCall.constructedTypeRef if (constructedTypeRef is FirImplicitAnyTypeRef) return - val superClass = constructedTypeRef.coneType.toRegularClass(context.session) ?: return + val superClassSymbol = constructedTypeRef.coneType.toRegularClassSymbol(context.session) ?: return // Subclassing a singleton should be reported as SINGLETON_IN_SUPERTYPE - if (superClass.classKind.isSingleton) return + if (superClassSymbol.classKind.isSingleton) return if (regularClass.isEffectivelyExpect(containingClass, context) || regularClass.isEffectivelyExternal(containingClass, context) ) { @@ -75,7 +75,7 @@ object FirPrimaryConstructorSuperTypeChecker : FirRegularClassChecker() { } val delegatedCallSource = delegatedConstructorCall.source ?: return if (delegatedCallSource.kind !is FirFakeSourceElementKind) return - if (superClass.symbol.classId == StandardClassIds.Enum) return + if (superClassSymbol.classId == StandardClassIds.Enum) return if (delegatedCallSource.elementType != KtNodeTypes.SUPER_TYPE_CALL_ENTRY) { reporter.reportOn(constructedTypeRef.source, FirErrors.SUPERTYPE_NOT_INITIALIZED, context) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirProjectionRelationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirProjectionRelationChecker.kt index 04b4a944246..8612c6dfada 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirProjectionRelationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirProjectionRelationChecker.kt @@ -13,9 +13,9 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.fullyExpandedType +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.types.Variance -import org.jetbrains.kotlin.utils.addToStdlib.safeAs object FirProjectionRelationChecker : FirBasicDeclarationChecker() { override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { @@ -49,8 +49,8 @@ object FirProjectionRelationChecker : FirBasicDeclarationChecker() { ) { val type = typeRef.coneTypeSafe() val fullyExpandedType = type?.fullyExpandedType(context.session) ?: return - val declaration = fullyExpandedType.toSymbol(context.session)?.fir.safeAs() ?: return - val typeParameters = declaration.typeParameters + val declaration = fullyExpandedType.toSymbol(context.session) as? FirRegularClassSymbol ?: return + val typeParameters = declaration.typeParameterSymbols val typeArguments = type.typeArguments val size = minOf(typeParameters.size, typeArguments.size) @@ -60,9 +60,7 @@ object FirProjectionRelationChecker : FirBasicDeclarationChecker() { val actual = typeArguments[it] val fullyExpandedProjection = fullyExpandedType.typeArguments[it] - val protoVariance = proto.safeAs() - ?.symbol?.fir - ?.variance + val protoVariance = proto.variance val projectionRelation = if (fullyExpandedProjection is ConeKotlinTypeConflictingProjection || actual is ConeKotlinTypeProjectionIn && protoVariance == Variance.OUT_VARIANCE || diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirSealedSupertypeChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirSealedSupertypeChecker.kt index 705626dab89..0d1f97a5444 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirSealedSupertypeChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirSealedSupertypeChecker.kt @@ -11,12 +11,12 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.declarations.FirClass -import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.utils.classId +import org.jetbrains.kotlin.fir.declarations.utils.modality import org.jetbrains.kotlin.fir.resolve.symbolProvider +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.classId import org.jetbrains.kotlin.fir.types.coneType -import org.jetbrains.kotlin.utils.addToStdlib.safeAs object FirSealedSupertypeChecker : FirClassChecker() { override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) { @@ -36,11 +36,9 @@ object FirSealedSupertypeChecker : FirClassChecker() { continue } - val fir = context.session.symbolProvider.getClassLikeSymbolByFqName(classId) - ?.fir.safeAs() - ?: continue + val classSymbol = context.session.symbolProvider.getClassLikeSymbolByFqName(classId) as? FirRegularClassSymbol ?: continue - if (fir.status.modality == Modality.SEALED && declaration.classId.packageFqName != fir.classId.packageFqName) { + if (classSymbol.modality == Modality.SEALED && declaration.classId.packageFqName != classSymbol.classId.packageFqName) { reporter.reportOn(it.source, FirErrors.SEALED_SUPERTYPE, context) continue } @@ -55,11 +53,9 @@ object FirSealedSupertypeChecker : FirClassChecker() { continue } - val fir = context.session.symbolProvider.getClassLikeSymbolByFqName(classId) - ?.fir.safeAs() - ?: continue + val classSymbol = context.session.symbolProvider.getClassLikeSymbolByFqName(classId) as? FirRegularClassSymbol ?: continue - if (fir.status.modality == Modality.SEALED) { + if (classSymbol.modality == Modality.SEALED) { reporter.reportOn(it.source, FirErrors.SEALED_SUPERTYPE_IN_LOCAL_CLASS, context) return } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirSupertypesChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirSupertypesChecker.kt index c5cd1950166..2f5eeccc3b7 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirSupertypesChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirSupertypesChecker.kt @@ -47,13 +47,13 @@ object FirSupertypesChecker : FirClassChecker() { extensionFunctionSupertypeReported = true } val lookupTag = coneType.safeAs()?.lookupTag ?: return@withSuppressedDiagnostics - val superTypeFir = lookupTag.toSymbol(context.session)?.fir + val superTypeSymbol = lookupTag.toSymbol(context.session) - if (superTypeFir is FirRegularClass) { - if (!superClassSymbols.add(superTypeFir.symbol)) { + if (superTypeSymbol is FirRegularClassSymbol) { + if (!superClassSymbols.add(superTypeSymbol)) { reporter.reportOn(superTypeRef.source, FirErrors.SUPERTYPE_APPEARS_TWICE, context) } - if (superTypeFir.classKind != ClassKind.INTERFACE) { + if (superTypeSymbol.classKind != ClassKind.INTERFACE) { if (classAppeared) { reporter.reportOn(superTypeRef.source, FirErrors.MANY_CLASSES_IN_SUPERTYPE_LIST, context) } else { @@ -64,8 +64,8 @@ object FirSupertypesChecker : FirClassChecker() { interfaceWithSuperclassReported = true } } - val isObject = superTypeFir.classKind == ClassKind.OBJECT - if (!finalSupertypeReported && !isObject && superTypeFir.modality == Modality.FINAL) { + val isObject = superTypeSymbol.classKind == ClassKind.OBJECT + if (!finalSupertypeReported && !isObject && superTypeSymbol.modality == Modality.FINAL) { reporter.reportOn(superTypeRef.source, FirErrors.FINAL_SUPERTYPE, context) finalSupertypeReported = true } @@ -93,7 +93,7 @@ object FirSupertypesChecker : FirClassChecker() { checkDelegationNotToInterface(declaration, context, reporter) if (declaration is FirRegularClass && declaration.superTypeRefs.size > 1) { - checkInconsistentTypeParameters(listOf(Pair(null, declaration)), context, reporter, declaration.source, true) + checkInconsistentTypeParameters(listOf(Pair(null, declaration.symbol)), context, reporter, declaration.source, true) } } @@ -148,7 +148,7 @@ object FirSupertypesChecker : FirClassChecker() { coneType: ConeKotlinType, context: CheckerContext ) { - if (symbol is FirRegularClassSymbol && symbol.fir.classKind == ClassKind.INTERFACE) { + if (symbol is FirRegularClassSymbol && symbol.classKind == ClassKind.INTERFACE) { for (typeArgument in fullyExpandedType.typeArguments) { if (typeArgument.isConflictingOrNotInvariant) { reporter.reportOn(superTypeRef.source, FirErrors.EXPANDED_TYPE_CANNOT_BE_INHERITED, coneType, context) @@ -169,8 +169,8 @@ object FirSupertypesChecker : FirClassChecker() { subDeclaration.name.isSpecial && subDeclaration.name.isDelegated ) { - val subDeclFir = subDeclaration.returnTypeRef.toRegularClass(context.session) - if (subDeclFir is FirRegularClass && subDeclFir.classKind != ClassKind.INTERFACE) { + val delegatedClassSymbol = subDeclaration.returnTypeRef.toRegularClassSymbol(context.session) + if (delegatedClassSymbol != null && delegatedClassSymbol.classKind != ClassKind.INTERFACE) { reporter.reportOn(subDeclaration.returnTypeRef.source, FirErrors.DELEGATION_NOT_TO_INTERFACE, context) } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTopLevelFunctionsChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTopLevelFunctionsChecker.kt index 8bb71a9b82a..b59d1f59d77 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTopLevelFunctionsChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTopLevelFunctionsChecker.kt @@ -35,7 +35,7 @@ object FirTopLevelFunctionsChecker : FirFileChecker() { if (function.hasModifier(KtTokens.ABSTRACT_KEYWORD)) return if (function.isExternal) return if (!function.hasBody && !function.isExpect) { - reporter.reportOn(source, FirErrors.NON_MEMBER_FUNCTION_NO_BODY, function, context) + reporter.reportOn(source, FirErrors.NON_MEMBER_FUNCTION_NO_BODY, function.symbol, context) } checkExpectDeclarationVisibilityAndBody(function, source, reporter, context) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeConstraintsChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeConstraintsChecker.kt index 499f1d33429..accfcf509f6 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeConstraintsChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeConstraintsChecker.kt @@ -24,7 +24,7 @@ object FirTypeConstraintsChecker : FirBasicDeclarationChecker() { constraint.source, FirErrors.NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER, constraint.name, - declaration, + declaration.symbol, context ) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeParameterBoundsChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeParameterBoundsChecker.kt index 4fb2a96b7f7..1f81055363e 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeParameterBoundsChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeParameterBoundsChecker.kt @@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.isOverride +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.types.model.KotlinTypeMarker @@ -55,7 +56,7 @@ object FirTypeParameterBoundsChecker : FirTypeParameterChecker() { if (containingDeclaration is FirSimpleFunction && containingDeclaration.isOverride) return if (containingDeclaration is FirProperty && containingDeclaration.isOverride) return - declaration.symbol.fir.bounds.forEach { bound -> + declaration.symbol.resolvedBounds.forEach { bound -> if (!bound.coneType.canHaveSubtypes(context.session)) { reporter.reportOn(bound.source, FirErrors.FINAL_UPPER_BOUND, bound.coneType, context) } @@ -63,7 +64,7 @@ object FirTypeParameterBoundsChecker : FirTypeParameterChecker() { } private fun checkExtensionFunctionTypeBound(declaration: FirTypeParameter, context: CheckerContext, reporter: DiagnosticReporter) { - declaration.symbol.fir.bounds.forEach { bound -> + declaration.symbol.resolvedBounds.forEach { bound -> if (bound.isExtensionFunctionType(context.session)) { reporter.reportOn(bound.source, FirErrors.UPPER_BOUND_IS_EXTENSION_FUNCTION_TYPE, context) } @@ -107,13 +108,13 @@ object FirTypeParameterBoundsChecker : FirTypeParameterChecker() { } private fun checkBoundUniqueness(declaration: FirTypeParameter, context: CheckerContext, reporter: DiagnosticReporter) { - val seenClasses = mutableSetOf() + val seenClasses = mutableSetOf() val allNonErrorBounds = declaration.bounds.filter { it !is FirErrorTypeRef } val uniqueBounds = allNonErrorBounds.distinctBy { it.coneType.classId ?: it.coneType } uniqueBounds.forEach { bound -> - bound.coneType.toRegularClass(context.session)?.let { clazz -> - if (classKinds.contains(clazz.classKind) && seenClasses.add(clazz) && seenClasses.size > 1) { + bound.coneType.toRegularClassSymbol(context.session)?.let { symbol -> + if (classKinds.contains(symbol.classKind) && seenClasses.add(symbol) && seenClasses.size > 1) { reporter.reportOn(bound.source, FirErrors.ONLY_ONE_CLASS_BOUND_ALLOWED, context) } } @@ -163,19 +164,19 @@ object FirTypeParameterBoundsChecker : FirTypeParameterChecker() { ) { if (declaration.bounds.size <= 1) return - val firTypeRefClasses = mutableListOf>() - val firRegularClassesSet = mutableSetOf() + val firTypeRefClasses = mutableListOf>() + val firRegularClassesSet = mutableSetOf() for (bound in declaration.bounds) { - val firRegularClass = bound.toRegularClass(context.session) - if (firRegularClassesSet.contains(firRegularClass)) { + val classSymbol = bound.toRegularClassSymbol(context.session) + if (firRegularClassesSet.contains(classSymbol)) { // no need to throw INCONSISTENT_TYPE_PARAMETER_BOUNDS diagnostics here because REPEATED_BOUNDS diagnostic is already exist return } - if (firRegularClass != null) { - firRegularClassesSet.add(firRegularClass) - firTypeRefClasses.add(Pair(bound, firRegularClass)) + if (classSymbol != null) { + firRegularClassesSet.add(classSymbol) + firTypeRefClasses.add(Pair(bound, classSymbol)) } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCallableReferenceChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCallableReferenceChecker.kt index 5c15d0383e3..52fa3c26835 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCallableReferenceChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCallableReferenceChecker.kt @@ -7,22 +7,21 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.fir.FirFakeSourceElementKind +import org.jetbrains.kotlin.fir.analysis.checkers.classKind import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.declaration.isExtensionMember import org.jetbrains.kotlin.fir.analysis.checkers.declaration.isLocalMember +import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn -import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration -import org.jetbrains.kotlin.fir.declarations.FirConstructor import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess import org.jetbrains.kotlin.fir.expressions.FirGetClassCall import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference -import org.jetbrains.kotlin.fir.resolve.getContainingClass -import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol +import org.jetbrains.kotlin.fir.symbols.impl.* object FirCallableReferenceChecker : FirQualifiedAccessExpressionChecker() { override fun check(expression: FirQualifiedAccessExpression, context: CheckerContext, reporter: DiagnosticReporter) { @@ -45,19 +44,21 @@ object FirCallableReferenceChecker : FirQualifiedAccessExpressionChecker() { val source = reference.source ?: return if (source.kind is FirFakeSourceElementKind) return - val referredDeclaration = reference.resolvedSymbol.fir - if (referredDeclaration is FirConstructor && referredDeclaration.getContainingClass(context.session)?.classKind == ClassKind.ANNOTATION_CLASS) { + val referredSymbol = reference.resolvedSymbol + if (referredSymbol is FirConstructorSymbol && referredSymbol.getContainingClassSymbol(context.session)?.classKind == ClassKind.ANNOTATION_CLASS) { reporter.reportOn(source, FirErrors.CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR, context) } - if ((referredDeclaration as? FirCallableDeclaration)?.isExtensionMember == true && - !referredDeclaration.isLocalMember + if ((referredSymbol as? FirCallableSymbol<*>)?.isExtensionMember == true && + !referredSymbol.isLocalMember ) { - reporter.reportOn(source, FirErrors.EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED, referredDeclaration, context) + reporter.reportOn(source, FirErrors.EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED, referredSymbol, context) } // The counterpart in FE 1.0 checks if the given descriptor is VariableDescriptor yet not PropertyDescriptor. // Here, we explicitly check if the referred declaration/symbol is value parameter, local variable, or backing field. - if (referredDeclaration is FirValueParameter || - (referredDeclaration is FirProperty && (referredDeclaration.isLocal || reference.resolvedSymbol is FirBackingFieldSymbol)) + if ( + referredSymbol is FirValueParameterSymbol || + (referredSymbol is FirPropertySymbol && referredSymbol.isLocal) || + reference.resolvedSymbol is FirBackingFieldSymbol ) { // TODO: we can't set positioning strategy to meta error. Should report on reference expression, not entire reference access. reporter.reportOn(source, FirErrors.UNSUPPORTED, "References to variables aren't supported yet", context) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCatchParameterChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCatchParameterChecker.kt index 6b2cba50ee3..d7d74c88aa6 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCatchParameterChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCatchParameterChecker.kt @@ -31,7 +31,7 @@ object FirCatchParameterChecker : FirTryExpressionChecker() { val coneType = catchParameter.returnTypeRef.coneType if (coneType is ConeTypeParameterType) { - val isReified = coneType.lookupTag.typeParameterSymbol.fir.isReified + val isReified = coneType.lookupTag.typeParameterSymbol.isReified if (isReified) { reporter.reportOn(source, FirErrors.REIFIED_TYPE_IN_CATCH_CLAUSE, context) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt index 53bf9408465..c69ab7884c5 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt @@ -11,12 +11,15 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.getChild +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirTypeParameter import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.resolve.inference.inferenceComponents import org.jetbrains.kotlin.fir.scopes.impl.toConeType +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.ensureResolved import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.lexer.KtTokens.QUEST @@ -63,7 +66,7 @@ object FirClassLiteralChecker : FirGetClassCallChecker() { } argument.safeAsTypeParameterSymbol?.let { - if (!it.fir.isReified) { + if (!it.isReified) { // E.g., fun foo(): Any = T::class reporter.reportOn(source, FirErrors.TYPE_PARAMETER_AS_REIFIED, it, context) } @@ -72,7 +75,10 @@ object FirClassLiteralChecker : FirGetClassCallChecker() { if (argument !is FirResolvedQualifier) return // TODO: differentiate RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS if (argument.typeArguments.isNotEmpty() && !argument.typeRef.coneType.isAllowedInClassLiteral(context)) { - val typeParameters = (argument.symbol?.fir as? FirTypeParameterRefsOwner)?.typeParameters + val symbol = argument.symbol + symbol?.ensureResolved(FirResolvePhase.TYPES) + @OptIn(SymbolInternals::class) + val typeParameters = (symbol?.fir as? FirTypeParameterRefsOwner)?.typeParameters // Among type parameter references, only count actual type parameter while discarding [FirOuterClassTypeParameterRef] val expectedTypeArgumentSize = typeParameters?.filterIsInstance()?.size ?: 0 if (expectedTypeArgumentSize != argument.typeArguments.size) { @@ -85,7 +91,7 @@ object FirClassLiteralChecker : FirGetClassCallChecker() { private fun ConeKotlinType.isNullableTypeParameter(context: ConeInferenceContext): Boolean { if (this !is ConeTypeParameterType) return false - val typeParameter = lookupTag.typeParameterSymbol.fir + val typeParameter = lookupTag.typeParameterSymbol with(context) { return !typeParameter.isReified && // E.g., fun f2(t: T): Any = t::class @@ -120,7 +126,7 @@ object FirClassLiteralChecker : FirGetClassCallChecker() { } else typeArguments.isEmpty() } - is ConeTypeParameterType -> this.lookupTag.typeParameterSymbol.fir.isReified + is ConeTypeParameterType -> this.lookupTag.typeParameterSymbol.isReified else -> false } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirConstructorCallChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirConstructorCallChecker.kt index 9bbd58f9558..22fdc5e7034 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirConstructorCallChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirConstructorCallChecker.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClass +import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn @@ -23,7 +23,7 @@ object FirConstructorCallChecker : FirFunctionCallChecker() { override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) { val constructorSymbol = (expression.calleeReference as? FirResolvedNamedReference)?.resolvedSymbol as? FirConstructorSymbol ?: return - val declarationClass = constructorSymbol.fir.returnTypeRef.coneType.toRegularClass(context.session) + val declarationClass = constructorSymbol.resolvedReturnTypeRef.coneType.toRegularClassSymbol(context.session) if (declarationClass != null) { if (declarationClass.isAbstract && declarationClass.classKind == ClassKind.CLASS) { 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 5d9fd7d70f6..e8782d03ce1 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 @@ -5,17 +5,24 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression -import org.jetbrains.kotlin.fir.* +import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirFakeSourceElementKind +import org.jetbrains.kotlin.fir.FirRealSourceElementKind +import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClass +import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn -import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.Deprecation +import org.jetbrains.kotlin.fir.declarations.DeprecationLevelValue +import org.jetbrains.kotlin.fir.declarations.getDeprecation import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirResolvable import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference +import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol import org.jetbrains.kotlin.utils.addToStdlib.safeAs object FirDeprecationChecker : FirBasicExpressionChecker() { @@ -30,39 +37,38 @@ object FirDeprecationChecker : FirBasicExpressionChecker() { if (expression is FirAnnotationCall) return //checked by FirDeprecatedTypeChecker val resolvable = expression as? FirResolvable ?: return val reference = resolvable.calleeReference as? FirResolvedNamedReference ?: return - val referencedFir = reference.resolvedSymbol.fir - if (referencedFir !is FirAnnotatedDeclaration) return + val referencedSymbol = reference.resolvedSymbol - reportDeprecationIfNeeded(expression.source, referencedFir, expression, context, reporter) + reportDeprecationIfNeeded(expression.source, referencedSymbol, expression, context, reporter) } internal fun reportDeprecationIfNeeded( source: FirSourceElement?, - referencedFir: FirAnnotatedDeclaration, + referencedSymbol: FirBasedSymbol<*>, callSite: FirElement?, context: CheckerContext, reporter: DiagnosticReporter ) { - val deprecation = getWorstDeprecation(callSite, referencedFir, context) ?: return + val deprecation = getWorstDeprecation(callSite, referencedSymbol, context) ?: return val diagnostic = when (deprecation.level) { DeprecationLevelValue.ERROR, DeprecationLevelValue.HIDDEN -> FirErrors.DEPRECATION_ERROR DeprecationLevelValue.WARNING -> FirErrors.DEPRECATION } - reporter.reportOn(source, diagnostic, referencedFir.symbol, deprecation.message ?: "", context) + reporter.reportOn(source, diagnostic, referencedSymbol, deprecation.message ?: "", context) } private fun getWorstDeprecation( callSite: FirElement?, - fir: FirAnnotatedDeclaration, + symbol: FirBasedSymbol<*>, context: CheckerContext ): Deprecation? { val deprecationInfos = listOfNotNull( - fir.getDeprecation(callSite), - fir.safeAs()?.returnTypeRef - ?.toRegularClass(context.session) + symbol.getDeprecation(callSite), + symbol.safeAs() + ?.resolvedReturnTypeRef + ?.toRegularClassSymbol(context.session) ?.getDeprecation(callSite) ) return deprecationInfos.maxOrNull() } - } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirForLoopChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirForLoopChecker.kt index ad346f6872a..5aa474b2db5 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirForLoopChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirForLoopChecker.kt @@ -133,9 +133,8 @@ object FirForLoopChecker : FirBlockChecker() { is FirResolvedNamedReference -> { val symbol = calleeReference.resolvedSymbol if (symbol is FirNamedFunctionSymbol) { - val function = symbol.fir - if (!function.isOperator) { - reporter.reportOn(reportSource, OPERATOR_MODIFIER_REQUIRED, symbol, function.name.asString(), context) + if (!symbol.isOperator) { + reporter.reportOn(reportSource, OPERATOR_MODIFIER_REQUIRED, symbol, symbol.name.asString(), context) // Don't return true as we want to report other errors } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirFunInterfaceConstructorReferenceChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirFunInterfaceConstructorReferenceChecker.kt index 7153e24c438..2998a422f49 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirFunInterfaceConstructorReferenceChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirFunInterfaceConstructorReferenceChecker.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClass +import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.FUN_INTERFACE_CONSTRUCTOR_REFERENCE import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn @@ -15,17 +15,18 @@ import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction import org.jetbrains.kotlin.fir.declarations.utils.isFun import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol object FirFunInterfaceConstructorReferenceChecker : FirQualifiedAccessExpressionChecker() { override fun check(expression: FirQualifiedAccessExpression, context: CheckerContext, reporter: DiagnosticReporter) { if (expression !is FirCallableReferenceAccess || expression is FirGetClassCall) return val reference = expression.calleeReference as? FirResolvedNamedReference ?: return - val referredDeclaration = reference.resolvedSymbol.fir + val referredSymbol = reference.resolvedSymbol - if (referredDeclaration is FirSimpleFunction && - referredDeclaration.origin == FirDeclarationOrigin.SamConstructor && - referredDeclaration.returnTypeRef.toRegularClass(context.session)?.isFun == true + if (referredSymbol is FirNamedFunctionSymbol && + referredSymbol.origin == FirDeclarationOrigin.SamConstructor && + referredSymbol.resolvedReturnTypeRef.toRegularClassSymbol(context.session)?.isFun == true ) { reporter.reportOn(reference.source, FUN_INTERFACE_CONSTRUCTOR_REFERENCE, context) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNotASupertypeChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNotASupertypeChecker.kt index 9426018775b..399a4a69a86 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNotASupertypeChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNotASupertypeChecker.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.isSupertypeOf -import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClass +import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn @@ -22,13 +22,13 @@ object FirNotASupertypeChecker : FirQualifiedAccessExpressionChecker() { override fun check(expression: FirQualifiedAccessExpression, context: CheckerContext, reporter: DiagnosticReporter) { val superReference = expression.calleeReference.safeAs()?.takeIf { it.hadExplicitTypeInSource() } - val targetClass = superReference + val targetClassSymbol = superReference ?.superTypeRef - ?.toRegularClass(context.session) + ?.toRegularClassSymbol(context.session) ?: return val surrounding = context.findClosestClass(superReference.labelName) ?: return - if (!targetClass.isSupertypeOf(surrounding, context.session)) { + if (!targetClassSymbol.isSupertypeOf(surrounding.symbol, context.session)) { reporter.reportOn(expression.source, FirErrors.NOT_A_SUPERTYPE, context) } } 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 index 181731d42a2..c1e3ff7aabb 100644 --- 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 @@ -36,7 +36,7 @@ object FirOptInAnnotationCallChecker : FirAnnotationCallChecker() { val annotationClasses = expression.findArgumentByName(OptInNames.USE_EXPERIMENTAL_ANNOTATION_CLASS) for (classSymbol in annotationClasses?.extractClassesFromArgument().orEmpty()) { with(FirOptInUsageBaseChecker) { - if (classSymbol.fir.loadExperimentalityForMarkerAnnotation() == null) { + if (classSymbol.loadExperimentalityForMarkerAnnotation() == null) { reporter.reportOn( expression.source, FirErrors.USE_EXPERIMENTAL_ARGUMENT_IS_NOT_MARKER, @@ -64,4 +64,4 @@ object FirOptInAnnotationCallChecker : FirAnnotationCallChecker() { reporter.reportOn(element, FirErrors.EXPERIMENTAL_IS_NOT_ENABLED, context) } } -} \ No newline at end of file +} 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 04873bd9b26..cd3a52e5085 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 @@ -8,15 +8,25 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.findArgumentByName import org.jetbrains.kotlin.fir.declarations.getAnnotationByFqName +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.expressions.FirConstExpression import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.ensureResolved +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.checkers.Experimentality import org.jetbrains.kotlin.resolve.checkers.OptInNames -object FirOptInUsageBaseChecker { - internal fun FirRegularClass.loadExperimentalityForMarkerAnnotation(): Experimentality? { +internal object FirOptInUsageBaseChecker { + fun FirRegularClassSymbol.loadExperimentalityForMarkerAnnotation(): Experimentality? { + ensureResolved(FirResolvePhase.BODY_RESOLVE) + @OptIn(SymbolInternals::class) + return fir.loadExperimentalityForMarkerAnnotation() + } + + private fun FirRegularClass.loadExperimentalityForMarkerAnnotation(): Experimentality? { val experimental = getAnnotationByFqName(OptInNames.REQUIRES_OPT_IN_FQ_NAME) ?: return null val levelArgument = experimental.findArgumentByName(LEVEL) as? FirQualifiedAccessExpression @@ -34,4 +44,4 @@ object FirOptInUsageBaseChecker { ERROR(Experimentality.Severity.ERROR), DEFAULT(Experimentality.DEFAULT_SEVERITY) } -} \ No newline at end of file +} diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirQualifiedSupertypeExtendedByOtherSupertypeChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirQualifiedSupertypeExtendedByOtherSupertypeChecker.kt index 69b68a0e5ba..e76698a16ec 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirQualifiedSupertypeExtendedByOtherSupertypeChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirQualifiedSupertypeExtendedByOtherSupertypeChecker.kt @@ -7,15 +7,15 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.findClosestClassOrObject -import org.jetbrains.kotlin.fir.analysis.checkers.followAllAlias +import org.jetbrains.kotlin.fir.analysis.checkers.fullyExpandedClass import org.jetbrains.kotlin.fir.analysis.checkers.isSupertypeOf +import org.jetbrains.kotlin.fir.analysis.checkers.toClassLikeSymbol import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn -import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.references.FirSuperReference -import org.jetbrains.kotlin.fir.resolve.transformers.firClassLike +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.utils.addToStdlib.safeAs object FirQualifiedSupertypeExtendedByOtherSupertypeChecker : FirQualifiedAccessExpressionChecker() { @@ -26,8 +26,8 @@ object FirQualifiedSupertypeExtendedByOtherSupertypeChecker : FirQualifiedAccess ?: return val explicitType = superReference.superTypeRef - .firClassLike(context.session) - ?.followAllAlias(context.session).safeAs() + .toClassLikeSymbol(context.session) + ?.fullyExpandedClass(context.session) as? FirClassSymbol<*> ?: return val surroundingType = context.findClosestClassOrObject() @@ -37,11 +37,11 @@ object FirQualifiedSupertypeExtendedByOtherSupertypeChecker : FirQualifiedAccess // have `explicitType` as their supertype or // equal to it var count = 0 - var candidate: FirClass? = null + var candidate: FirClassSymbol<*>? = null for (it in surroundingType.superTypeRefs) { - val that = it.firClassLike(context.session) - ?.followAllAlias(context.session).safeAs() + val that = it.toClassLikeSymbol(context.session) + ?.fullyExpandedClass(context.session) as? FirClassSymbol<*> ?: continue val isSupertype = explicitType.isSupertypeOf(that, context.session) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSealedClassConstructorCallChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSealedClassConstructorCallChecker.kt index a04fa758590..53037f36aae 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSealedClassConstructorCallChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSealedClassConstructorCallChecker.kt @@ -10,29 +10,30 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn -import org.jetbrains.kotlin.fir.declarations.FirConstructor -import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.utils.modality import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference +import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.toSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.utils.addToStdlib.safeAs object FirSealedClassConstructorCallChecker : FirQualifiedAccessExpressionChecker() { override fun check(expression: FirQualifiedAccessExpression, context: CheckerContext, reporter: DiagnosticReporter) { - val constructorFir = expression.calleeReference.safeAs() - ?.resolvedSymbol - ?.fir.safeAs() + val constructorSymbol = expression.calleeReference.safeAs() + ?.resolvedSymbol as? FirConstructorSymbol ?: return - val typeFir = constructorFir.returnTypeRef.coneType + val typeSymbol = constructorSymbol.resolvedReturnTypeRef.coneType + .fullyExpandedType(context.session) .safeAs() - ?.lookupTag?.toSymbol(context.session) - ?.fir as? FirRegularClass + ?.lookupTag?.toSymbol(context.session) as? FirRegularClassSymbol ?: return - if (typeFir.status.modality == Modality.SEALED) { + if (typeSymbol.modality == Modality.SEALED) { reporter.reportOn(expression.source, FirErrors.SEALED_CLASS_CONSTRUCTOR_CALL, context) } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirStandaloneQualifierChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirStandaloneQualifierChecker.kt index 556abc8c447..8044ff40fb6 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirStandaloneQualifierChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirStandaloneQualifierChecker.kt @@ -26,7 +26,7 @@ object FirStandaloneQualifierChecker : FirResolvedQualifierChecker() { when (val symbol = expression.symbol) { is FirRegularClassSymbol -> { - if (symbol.fir.classKind == ClassKind.OBJECT) return + if (symbol.classKind == ClassKind.OBJECT) return reporter.reportOn(expression.source, FirErrors.NO_COMPANION_OBJECT, symbol, context) } null -> { @@ -34,4 +34,4 @@ object FirStandaloneQualifierChecker : FirResolvedQualifierChecker() { } } } -} \ No newline at end of file +} diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuperclassNotAccessibleFromInterfaceChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuperclassNotAccessibleFromInterfaceChecker.kt index b33b6772320..b524594d90d 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuperclassNotAccessibleFromInterfaceChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuperclassNotAccessibleFromInterfaceChecker.kt @@ -29,9 +29,9 @@ object FirSuperclassNotAccessibleFromInterfaceChecker : FirQualifiedAccessExpres if (closestClass.classKind == ClassKind.INTERFACE) { val containingClassSymbol = - expression.toResolvedCallableSymbol()?.getContainingClassSymbol(context) as? FirRegularClassSymbol ?: return + expression.toResolvedCallableSymbol()?.getContainingClassSymbol(context.session) as? FirRegularClassSymbol ?: return - if (containingClassSymbol.classKind == ClassKind.CLASS) { + if (containingClassSymbol.source != null && containingClassSymbol.classKind == ClassKind.CLASS) { reporter.reportOn(expression.explicitReceiver?.source, FirErrors.SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE, context) } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUninitializedEnumChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUninitializedEnumChecker.kt index 7d353353837..81e36cbba4e 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUninitializedEnumChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUninitializedEnumChecker.kt @@ -18,8 +18,10 @@ import org.jetbrains.kotlin.fir.declarations.utils.isCompanion import org.jetbrains.kotlin.fir.declarations.utils.isEnumClass import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference +import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.ensureResolved import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol @@ -73,7 +75,7 @@ object FirUninitializedEnumChecker : FirQualifiedAccessExpressionChecker() { val reference = expression.calleeReference as? FirResolvedNamedReference ?: return val calleeSymbol = reference.resolvedSymbol - val calleeContainingClassSymbol = calleeSymbol.getContainingClassSymbol(context) as? FirRegularClassSymbol ?: return + val calleeContainingClassSymbol = calleeSymbol.getContainingClassSymbol(context.session) as? FirRegularClassSymbol ?: return // We're looking for members/entries/companion object in an enum class or members in companion object of an enum class. val calleeIsInsideEnum = calleeContainingClassSymbol.isEnumClass val calleeIsInsideEnumCompanion = @@ -103,7 +105,7 @@ object FirUninitializedEnumChecker : FirQualifiedAccessExpressionChecker() { // INSTANCE(EnumCompanion2.foo()) // } // find an accessed context within the same enum class. - it.getContainingClassSymbol(context) == enumClassSymbol + it.getContainingClassSymbol(context.session) == enumClassSymbol }?.symbol ?: return val enumMemberProperties = enumClassSymbol.declarationSymbols.filterIsInstance() @@ -142,7 +144,7 @@ object FirUninitializedEnumChecker : FirQualifiedAccessExpressionChecker() { if (calleeContainingClassSymbol == enumClassSymbol.companionObjectSymbol) { // Uninitialized from the point of view of members or enum entries of that enum class if (accessedContext in enumMemberProperties || accessedContext in enumEntries) { - if (calleeSymbol is FirProperty) { + if (calleeSymbol is FirPropertySymbol) { // From KT-11769 // enum class Fruit(...) { // APPLE(...); @@ -151,7 +153,7 @@ object FirUninitializedEnumChecker : FirQualifiedAccessExpressionChecker() { // } // val score = ... common // } - reporter.reportOn(source, FirErrors.UNINITIALIZED_VARIABLE, calleeSymbol.symbol, context) + reporter.reportOn(source, FirErrors.UNINITIALIZED_VARIABLE, calleeSymbol, context) } else { // enum class EnumCompanion2(...) { // INSTANCE(foo()) @@ -219,11 +221,13 @@ object FirUninitializedEnumChecker : FirQualifiedAccessExpressionChecker() { private val FirPropertySymbol.lazyDelegation: FirAnonymousFunction? get() { ensureResolved(FirResolvePhase.BODY_RESOLVE) - if (fir.delegate == null || fir.delegate !is FirFunctionCall) return null - val delegateCall = fir.delegate as FirFunctionCall - val callee = - (delegateCall.calleeReference as? FirResolvedNamedReference)?.resolvedSymbol?.fir as? FirSimpleFunction ?: return null - if (callee.symbol.callableId.asSingleFqName().asString() != "kotlin.lazy") return null + @OptIn(SymbolInternals::class) + val property = this.fir + if (property.delegate == null || property.delegate !is FirFunctionCall) return null + val delegateCall = property.delegate as FirFunctionCall + val calleeSymbol = + (delegateCall.calleeReference as? FirResolvedNamedReference)?.resolvedSymbol as? FirNamedFunctionSymbol ?: return null + if (calleeSymbol.callableId.asSingleFqName().asString() != "kotlin.lazy") return null val lazyCallArgument = delegateCall.argumentList.arguments.singleOrNull() as? FirLambdaArgumentExpression ?: return null return (lazyCallArgument.expression as? FirAnonymousFunctionExpression)?.anonymousFunction } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUpperBoundViolatedExpressionChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUpperBoundViolatedExpressionChecker.kt index 6e8ffc614d8..e5a6382e42d 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUpperBoundViolatedExpressionChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUpperBoundViolatedExpressionChecker.kt @@ -10,15 +10,17 @@ import org.jetbrains.kotlin.fir.analysis.checkers.checkUpperBoundViolated import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.declarations.FirConstructor -import org.jetbrains.kotlin.fir.declarations.FirRegularClass -import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression +import org.jetbrains.kotlin.fir.expressions.toResolvedCallableSymbol import org.jetbrains.kotlin.fir.references.FirErrorNamedReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeInapplicableCandidateError -import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol +import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance +import org.jetbrains.kotlin.fir.types.toSymbol import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability -import org.jetbrains.kotlin.utils.addToStdlib.safeAs object FirUpperBoundViolatedExpressionChecker : FirQualifiedAccessExpressionChecker() { override fun check(expression: FirQualifiedAccessExpression, context: CheckerContext, reporter: DiagnosticReporter) { @@ -27,9 +29,9 @@ object FirUpperBoundViolatedExpressionChecker : FirQualifiedAccessExpressionChec // it may be the called function declaration // or the class declaration val calleReference = expression.calleeReference - var calleeFir: FirTypeParameterRefsOwner? = null + var calleeSymbol: FirCallableSymbol<*>? = null if (calleReference is FirResolvedNamedReference) { - calleeFir = calleReference.safeAs()?.resolvedSymbol?.fir as? FirTypeParameterRefsOwner + calleeSymbol = calleReference.toResolvedCallableSymbol() } else if (calleReference is FirErrorNamedReference) { val diagnostic = calleReference.diagnostic if (diagnostic is ConeInapplicableCandidateError && @@ -37,19 +39,19 @@ object FirUpperBoundViolatedExpressionChecker : FirQualifiedAccessExpressionChec ) { return } - calleeFir = calleReference.candidateSymbol?.fir as? FirTypeParameterRefsOwner + calleeSymbol = calleReference.candidateSymbol as? FirCallableSymbol<*> } var typeArguments: List? = null var typeArgumentRefsAndSources: List? = null - val typeParameters = if (calleeFir is FirConstructor) { + val typeParameters = if (calleeSymbol is FirConstructorSymbol) { typeArgumentRefsAndSources = expression.typeArguments.map { FirTypeRefSource((it as? FirTypeProjectionWithVariance)?.typeRef, it.source) } - val prototypeClass = calleeFir.dispatchReceiverType?.toSymbol(context.session)?.fir.safeAs() - prototypeClass?.typeParameters?.map { it.symbol } + val prototypeClass = calleeSymbol.dispatchReceiverType?.toSymbol(context.session) as? FirRegularClassSymbol + prototypeClass?.typeParameterSymbols } else { typeArguments = expression.typeArguments - calleeFir?.typeParameters?.map { it.symbol } + calleeSymbol?.typeParameterSymbols } checkUpperBoundViolated( 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 ea181225553..a672f355f4c 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 @@ -6,13 +6,13 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.checkers.isFunctionForExpectTypeFromCastFeature import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn -import org.jetbrains.kotlin.fir.declarations.FirFunction import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.resolve.fullyExpandedType -import org.jetbrains.kotlin.fir.resolve.inference.isFunctionForExpectTypeFromCastFeature +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.types.AbstractTypeChecker @@ -68,8 +68,8 @@ object FirUselessTypeOperationCallChecker : FirTypeOperatorCallChecker() { ): Boolean { return if (shouldCheckForExactType) { if (arg is FirFunctionCall) { - val function = arg.toResolvedCallableSymbol()?.fir as? FirFunction - if (function != null && function.isFunctionForExpectTypeFromCastFeature()) return false + val functionSymbol = arg.toResolvedCallableSymbol() as? FirFunctionSymbol<*> + if (functionSymbol != null && functionSymbol.isFunctionForExpectTypeFromCastFeature()) return false } isExactTypeCast(context, candidateType, targetType) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirValReassignmentChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirValReassignmentChecker.kt index f36a52d19f4..717b119e1c1 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirValReassignmentChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirValReassignmentChecker.kt @@ -12,11 +12,11 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor -import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment import org.jetbrains.kotlin.fir.languageVersionSettings import org.jetbrains.kotlin.fir.references.FirBackingFieldReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference +import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol object FirValReassignmentChecker : FirVariableAssignmentChecker() { override fun check(expression: FirVariableAssignment, context: CheckerContext, reporter: DiagnosticReporter) { @@ -30,16 +30,16 @@ object FirValReassignmentChecker : FirVariableAssignmentChecker() { reporter: DiagnosticReporter ) { val backingFieldReference = expression.lValue as? FirBackingFieldReference ?: return - val property = backingFieldReference.resolvedSymbol.fir - if (property.isVar) return - val closestGetter = context.findClosest { it.isGetter } ?: return - if (property.getter != closestGetter) return + val propertySymbol = backingFieldReference.resolvedSymbol + if (propertySymbol.isVar) return + val closestGetter = context.findClosest { it.isGetter }?.symbol ?: return + if (propertySymbol.getterSymbol != closestGetter) return backingFieldReference.source?.let { if (context.session.languageVersionSettings.supportsFeature(LanguageFeature.RestrictionOfValReassignmentViaBackingField)) { - reporter.reportOn(it, FirErrors.VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR, property.symbol, context) + reporter.reportOn(it, FirErrors.VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR, propertySymbol, context) } else { - reporter.reportOn(it, FirErrors.VAL_REASSIGNMENT_VIA_BACKING_FIELD, property.symbol, context) + reporter.reportOn(it, FirErrors.VAL_REASSIGNMENT_VIA_BACKING_FIELD, propertySymbol, context) } } } @@ -49,7 +49,7 @@ object FirValReassignmentChecker : FirVariableAssignmentChecker() { context: CheckerContext, reporter: DiagnosticReporter ) { - val valueParameter = (expression.lValue as? FirResolvedNamedReference)?.resolvedSymbol?.fir as? FirValueParameter ?: return - reporter.reportOn(expression.lValue.source, FirErrors.VAL_REASSIGNMENT, valueParameter.symbol, context) + val valueParameter = (expression.lValue as? FirResolvedNamedReference)?.resolvedSymbol as? FirValueParameterSymbol ?: return + reporter.reportOn(expression.lValue.source, FirErrors.VAL_REASSIGNMENT, valueParameter, context) } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/CanBeValChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/CanBeValChecker.kt index 05e34dfd3ff..6c47c98644c 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/CanBeValChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/CanBeValChecker.kt @@ -39,7 +39,7 @@ object CanBeValChecker : AbstractFirPropertyInitializationChecker() { graph.traverse(TraverseDirection.Forward, reporterVisitor) for (property in unprocessedProperties) { - val source = property.fir.source + val source = property.source if (source is FirFakeSourceElement) continue if (source?.elementType == KtNodeTypes.DESTRUCTURING_DECLARATION) continue propertiesCharacteristics[property] = EventOccurrencesRange.ZERO @@ -50,7 +50,7 @@ object CanBeValChecker : AbstractFirPropertyInitializationChecker() { var lastDestructuredVariables = 0 for ((symbol, value) in propertiesCharacteristics) { - val source = symbol.fir.source + val source = symbol.source if (source?.elementType == KtNodeTypes.DESTRUCTURING_DECLARATION) { lastDestructuringSource = source lastDestructuredVariables = symbol.getDestructuringChildrenCount() ?: continue @@ -67,14 +67,14 @@ object CanBeValChecker : AbstractFirPropertyInitializationChecker() { destructuringCanBeVal = false } lastDestructuredVariables-- - } else if (canBeVal(symbol, value) && symbol.fir.delegate == null) { + } else if (canBeVal(symbol, value) && !symbol.hasDelegate) { reporter.reportOn(source, FirErrors.CAN_BE_VAL, context) } } } private fun canBeVal(symbol: FirPropertySymbol, value: EventOccurrencesRange) = - value in canBeValOccurrenceRanges && symbol.fir.isVar + value in canBeValOccurrenceRanges && symbol.isVar private class UninitializedPropertyReporter( val data: Map, PathAwarePropertyInitializationInfo>, @@ -106,7 +106,7 @@ object CanBeValChecker : AbstractFirPropertyInitializationChecker() { } private fun FirPropertySymbol.getDestructuringChildrenCount(): Int? { - val source = fir.source ?: return null + val source = source ?: return null return source.lighterASTNode.getChildren(source.treeStructure).count { it?.tokenType == KtNodeTypes.DESTRUCTURING_DECLARATION_ENTRY } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantVisibilityModifierSyntaxChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantVisibilityModifierSyntaxChecker.kt index 85d65c37820..26dba22763e 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantVisibilityModifierSyntaxChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantVisibilityModifierSyntaxChecker.kt @@ -75,7 +75,7 @@ object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker { - val classSymbol = this.getContainingClassSymbol(context) + val classSymbol = this.getContainingClassSymbol(context.session) if ( classSymbol is FirRegularClassSymbol && (classSymbol.isEnumClass || classSymbol.isSealed) @@ -99,30 +99,16 @@ object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker 0) { - visibility = currentVisibility - } + val currentVisibility = func.visibility + val compareResult = Visibilities.compare(currentVisibility, visibility) + if (compareResult != null && compareResult > 0) { + visibility = currentVisibility } } return visibility } - private fun FirFunction.visibility(): Visibility? { - (symbol.fir as? FirMemberDeclaration)?.visibility?.let { - return it - } - - (symbol.fir as? FirPropertyAccessor)?.visibility?.let { - return it - } - - return null - } - private val CheckerContext.containingPropertyVisibility get() = (this.containingDeclarations.last() as? FirProperty)?.visibility } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt index 5f2eb479956..87d3c59d489 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt @@ -19,6 +19,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.isIterator import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.utils.isLocal import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirFunctionCall @@ -26,13 +27,15 @@ import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.resolve.dfa.cfg.* import org.jetbrains.kotlin.fir.resolve.inference.isFunctionalType +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.ensureResolved import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.types.coneType object UnusedChecker : FirControlFlowChecker() { override fun analyze(graph: ControlFlowGraph, reporter: DiagnosticReporter, context: CheckerContext) { - if (graph.declaration?.getContainingClassSymbol(context)?.takeIf { !it.isLocal } != null) return + if (graph.declaration?.getContainingClassSymbol(context.session)?.takeIf { !it.isLocal } != null) return val (properties, _) = LocalPropertyAndCapturedWriteCollector.collect(graph) if (properties.isEmpty()) return @@ -69,7 +72,10 @@ object UnusedChecker : FirControlFlowChecker() { for (dataPerLabel in dataPerNode.values) { val data = dataPerLabel[variableSymbol] ?: continue - val variableSource = variableSymbol.fir.source.takeIf { it?.elementType != KtNodeTypes.DESTRUCTURING_DECLARATION } + variableSymbol.ensureResolved(FirResolvePhase.BODY_RESOLVE) + @OptIn(SymbolInternals::class) + val variable = variableSymbol.fir + val variableSource = variable.source.takeIf { it?.elementType != KtNodeTypes.DESTRUCTURING_DECLARATION } when { data == VariableStatus.UNUSED -> { if ((node.fir.initializer as? FirFunctionCall)?.isIterator != true) { @@ -78,7 +84,7 @@ object UnusedChecker : FirControlFlowChecker() { } } data.isRedundantInit -> { - val source = variableSymbol.fir.initializer?.source + val source = variable.initializer?.source reporter.reportOn(source, FirErrors.VARIABLE_INITIALIZER_IS_REDUNDANT, context) break } @@ -276,7 +282,7 @@ object UnusedChecker : FirControlFlowChecker() { val reference = node.fir.calleeReference as? FirResolvedNamedReference ?: return dataForNode val functionSymbol = reference.resolvedSymbol as? FirFunctionSymbol<*> ?: return dataForNode val symbol = if (functionSymbol.callableId.callableName.identifier == "invoke") { - localProperties.find { it.fir.name == reference.name && it.fir.returnTypeRef.coneType.isFunctionalType(session) } + localProperties.find { it.name == reference.name && it.resolvedReturnTypeRef.coneType.isFunctionalType(session) } } else null symbol ?: return dataForNode @@ -307,6 +313,9 @@ object UnusedChecker : FirControlFlowChecker() { } } - private val FirPropertySymbol.isLoopIterator - get() = fir.initializer?.source?.kind == FirFakeSourceElementKind.DesugaredForLoop + private val FirPropertySymbol.isLoopIterator: Boolean + get() { + @OptIn(SymbolInternals::class) + return fir.initializer?.source?.kind == FirFakeSourceElementKind.DesugaredForLoop + } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirDeprecatedTypeChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirDeprecatedTypeChecker.kt index be63b4a6eb5..13a9a944988 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirDeprecatedTypeChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirDeprecatedTypeChecker.kt @@ -16,15 +16,12 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.coneTypeSafe object FirDeprecatedTypeChecker : FirTypeRefChecker() { - override fun check(typeRef: FirTypeRef, context: CheckerContext, reporter: DiagnosticReporter) { if (context.findClosest() != null) return val resolved = typeRef.coneTypeSafe() ?: return val symbol = resolved.lookupTag.toSymbol(context.session) ?: return - val referencedFir = symbol.fir - FirDeprecationChecker.reportDeprecationIfNeeded(typeRef.source, referencedFir, null, context, reporter) + FirDeprecationChecker.reportDeprecationIfNeeded(typeRef.source, symbol, null, context, reporter) } - -} \ No newline at end of file +} diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt index b2356365f4f..220156bb29a 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics -import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages import org.jetbrains.kotlin.diagnostics.rendering.LanguageFeatureMessageRenderer import org.jetbrains.kotlin.diagnostics.rendering.Renderers.RENDER_POSITION_VARIANCE import org.jetbrains.kotlin.diagnostics.rendering.Renderers.commaSeparated @@ -15,7 +14,6 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.DECL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.FIR import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.FQ_NAMES_IN_TYPES import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.FUNCTION_PARAMETERS -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.NAME import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.NOT_RENDERED import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.NULLABLE_STRING import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.RENDER_CLASS_OR_OBJECT @@ -474,7 +472,7 @@ class FirDefaultErrorMessages { map.put( QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE, "Explicitly qualified supertype is extended by another supertype ''{0}''", - TO_STRING + SYMBOL ) map.put(SUPERTYPE_INITIALIZED_IN_INTERFACE, "Interfaces cannot initialize supertypes") map.put(INTERFACE_WITH_SUPERCLASS, "An interface cannot inherit from a class") @@ -670,7 +668,7 @@ class FirDefaultErrorMessages { map.put(NON_VARARG_SPREAD, "The spread operator (*foo) may only be applied in a vararg position") map.put(TOO_MANY_ARGUMENTS, "Too many arguments for {0}", FQ_NAMES_IN_TYPES) map.put(ARGUMENT_PASSED_TWICE, "An argument is already passed for this parameter") - map.put(NO_VALUE_FOR_PARAMETER, "No value passed for parameter ''{0}''", NAME) + map.put(NO_VALUE_FOR_PARAMETER, "No value passed for parameter ''{0}''", DECLARATION_NAME) map.put(NAMED_PARAMETER_NOT_FOUND, "Cannot find a parameter with this name: {0}", TO_STRING) map.put(MANY_LAMBDA_EXPRESSION_ARGUMENTS, "Only one lambda expression is allowed outside a parenthesized argument list") map.put(SPREAD_OF_NULLABLE, "The spread operator (*foo) may not be applied to an argument of nullable type") @@ -798,7 +796,7 @@ class FirDefaultErrorMessages { NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER, "{0} does not refer to a type parameter of {1}", TO_STRING, - NAME + DECLARATION_NAME ) map.put(BOUND_ON_TYPE_ALIAS_PARAMETER_NOT_ALLOWED, "Bounds are not allowed on type alias parameters") @@ -826,7 +824,7 @@ class FirDefaultErrorMessages { map.put( EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED, "''{0}'' is a member and an extension at the same time. References to such elements are not allowed", - NAME + DECLARATION_NAME ) map.put(CALLABLE_REFERENCE_LHS_NOT_A_CLASS, "Left-hand side of a callable reference cannot be a type parameter") map.put(CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR, "Annotation class cannot be instantiated") @@ -872,20 +870,20 @@ class FirDefaultErrorMessages { FQ_NAMES_IN_TYPES ) - map.put(OVERRIDING_FINAL_MEMBER, "''{0}'' in ''{1}'' is final and cannot be overridden", NAME, TO_STRING) + map.put(OVERRIDING_FINAL_MEMBER, "''{0}'' in ''{1}'' is final and cannot be overridden", DECLARATION_NAME, TO_STRING) map.put( CANNOT_WEAKEN_ACCESS_PRIVILEGE, "Cannot weaken access privilege ''{0}'' for ''{1}'' in ''{2}''", VISIBILITY, - NAME, + DECLARATION_NAME, TO_STRING ) map.put( CANNOT_CHANGE_ACCESS_PRIVILEGE, "Cannot change access privilege ''{0}'' for ''{1}'' in ''{2}''", VISIBILITY, - NAME, + DECLARATION_NAME, TO_STRING ) @@ -893,25 +891,25 @@ class FirDefaultErrorMessages { ABSTRACT_MEMBER_NOT_IMPLEMENTED, "{0} is not abstract and does not implement abstract member {1}", RENDER_CLASS_OR_OBJECT, - NAME + DECLARATION_NAME ) map.put( ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED, "{0} is not abstract and does not implement abstract base class member {1}", RENDER_CLASS_OR_OBJECT, - NAME + DECLARATION_NAME ) map.put( MANY_IMPL_MEMBER_NOT_IMPLEMENTED, "{0} must override {1} because it inherits many implementations of it", RENDER_CLASS_OR_OBJECT, - NAME + DECLARATION_NAME ) map.put( MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED, "{0} must override {1} because it inherits multiple interface methods of it", RENDER_CLASS_OR_OBJECT, - NAME + DECLARATION_NAME ) map.put( @@ -964,49 +962,49 @@ class FirDefaultErrorMessages { map.put( RETURN_TYPE_MISMATCH_ON_INHERITANCE, "''{0}'' clashes with ''{1}'': return types are incompatible", - NAME, - NAME + DECLARATION_NAME, + DECLARATION_NAME ) map.put( PROPERTY_TYPE_MISMATCH_ON_INHERITANCE, "''{0}'' clashes with ''{1}'': property types are incompatible", - NAME, - NAME + DECLARATION_NAME, + DECLARATION_NAME ) map.put( VAR_TYPE_MISMATCH_ON_INHERITANCE, "''{0}'' clashes with ''{1}'': property types do not match", - NAME, - NAME + DECLARATION_NAME, + DECLARATION_NAME ) map.put( RETURN_TYPE_MISMATCH_BY_DELEGATION, "Type of ''{0}'' is not a subtype of overridden by delegation ''{1}''", - NAME, - NAME + DECLARATION_NAME, + DECLARATION_NAME ) map.put( PROPERTY_TYPE_MISMATCH_BY_DELEGATION, "Type of property ''{0}'' is not a subtype of overridden by delegation ''{1}''", - NAME, - NAME + DECLARATION_NAME, + DECLARATION_NAME ) map.put( VAR_OVERRIDDEN_BY_VAL_BY_DELEGATION, "Val-property ''{0}'' implicitly overrides a var-property ''{1}'' by delegation", - NAME, - NAME + DECLARATION_NAME, + DECLARATION_NAME ) map.put( CONFLICTING_INHERITED_MEMBERS, "{0} inherits conflicting members: {1}", - commaSeparated(NAME) + commaSeparated(DECLARATION_NAME) ) // Redeclarations @@ -1032,7 +1030,7 @@ class FirDefaultErrorMessages { ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, "Abstract function ''{0}'' in non-abstract class ''{1}''", DECLARATION_NAME, - NAME + DECLARATION_NAME ) map.put(ABSTRACT_FUNCTION_WITH_BODY, "A function ''{0}'' with body cannot be abstract", DECLARATION_NAME) map.put(NON_ABSTRACT_FUNCTION_WITH_NO_BODY, "Function ''{0}'' without a body must be abstract", DECLARATION_NAME) @@ -1068,7 +1066,7 @@ class FirDefaultErrorMessages { ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS, "Abstract property ''{0}'' in non-abstract class ''{1}''", DECLARATION_NAME, - NAME + DECLARATION_NAME ) map.put(PRIVATE_PROPERTY_IN_INTERFACE, "Abstract property in an interface cannot be private") 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 99ed2822894..d9739c88ccc 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 @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics +import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.diagnostics.WhenMissingCase import org.jetbrains.kotlin.diagnostics.rendering.Renderer @@ -14,10 +15,8 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.classId import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.render @@ -50,43 +49,33 @@ object FirDiagnosticRenderers { } val VARIABLE_NAME = Renderer { symbol: FirVariableSymbol<*> -> - symbol.fir.name.asString() + symbol.name.asString() } val FIR = Renderer { element: FirElement -> element.render() } - val NAME = Renderer { element: FirElement -> - when (element) { - is FirMemberDeclaration -> DECLARATION_NAME.render(element) - is FirCallableDeclaration -> element.symbol.callableId.callableName.asString() - else -> "???" - } - } - val VISIBILITY = Renderer { visibility: Visibility -> visibility.externalDisplayName } - val DECLARATION_NAME = Renderer { declaration: FirMemberDeclaration -> - val name = when (declaration) { - is FirProperty -> declaration.name - is FirSimpleFunction -> declaration.name - is FirRegularClass -> declaration.name - is FirTypeAlias -> declaration.name - is FirEnumEntry -> declaration.name - is FirField -> declaration.name - is FirValueParameter -> declaration.name - is FirConstructor -> return@Renderer "constructor" + val DECLARATION_NAME = Renderer { symbol: FirBasedSymbol<*> -> + val name = when (symbol) { + is FirCallableSymbol<*> -> symbol.name + is FirClassLikeSymbol<*> -> symbol.classId.shortClassName else -> return@Renderer "???" } name.asString() } - val RENDER_CLASS_OR_OBJECT = Renderer { firClass: FirClass -> - val name = firClass.classId.relativeClassName.asString() - val classOrObject = if (firClass is FirRegularClass) "Class" else "Object" + val RENDER_CLASS_OR_OBJECT = Renderer { classSymbol: FirClassSymbol<*> -> + val name = classSymbol.classId.relativeClassName.asString() + val classOrObject = when (classSymbol.classKind) { + ClassKind.OBJECT -> "Object" + ClassKind.INTERFACE -> "Interface" + else -> "Class" + } "$classOrObject $name" } @@ -95,8 +84,9 @@ object FirDiagnosticRenderers { t.render() } - val FQ_NAMES_IN_TYPES = Renderer { element: FirElement -> - element.render(mode = FirRenderer.RenderMode.WithFqNamesExceptAnnotationAndBody) + val FQ_NAMES_IN_TYPES = Renderer { symbol: FirBasedSymbol<*> -> + @OptIn(SymbolInternals::class) + symbol.fir.render(mode = FirRenderer.RenderMode.WithFqNamesExceptAnnotationAndBody) } val AMBIGUOUS_CALLS = Renderer { candidates: Collection> -> diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt index 9f4749f0c63..0c0dc655884 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt @@ -9,7 +9,6 @@ import org.jetbrains.kotlin.KtNodeTypes import org.jetbrains.kotlin.fir.FirFakeSourceElementKind import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.analysis.getChild -import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction import org.jetbrains.kotlin.fir.declarations.utils.isInfix import org.jetbrains.kotlin.fir.declarations.utils.isOperator import org.jetbrains.kotlin.fir.diagnostics.* @@ -21,6 +20,7 @@ import org.jetbrains.kotlin.fir.resolve.inference.model.ConeArgumentConstraintPo import org.jetbrains.kotlin.fir.resolve.inference.model.ConeExpectedTypeConstraintPosition import org.jetbrains.kotlin.fir.resolve.inference.model.ConeLambdaArgumentConstraintPosition import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.lexer.KtTokens @@ -29,7 +29,6 @@ import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability import org.jetbrains.kotlin.resolve.calls.tower.isSuccess import org.jetbrains.kotlin.utils.addIfNotNull import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstance -import org.jetbrains.kotlin.utils.addToStdlib.safeAs private fun ConeDiagnostic.toFirDiagnostic( source: FirSourceElement, @@ -63,10 +62,10 @@ private fun ConeDiagnostic.toFirDiagnostic( is ConeOperatorAmbiguityError -> FirErrors.ASSIGN_OPERATOR_AMBIGUITY.createOn(source, this.candidates) is ConeVariableExpectedError -> FirErrors.VARIABLE_EXPECTED.createOn(source) is ConeValReassignmentError -> when (val symbol = this.variable) { - is FirBackingFieldSymbol -> FirErrors.VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR.createOn(source, symbol.fir.symbol) + is FirBackingFieldSymbol -> FirErrors.VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR.createOn(source, symbol) else -> FirErrors.VAL_REASSIGNMENT.createOn(source, symbol) } - is ConeUnexpectedTypeArgumentsError -> FirErrors.TYPE_ARGUMENTS_NOT_ALLOWED.createOn(this.source as? FirSourceElement ?: source) + is ConeUnexpectedTypeArgumentsError -> FirErrors.TYPE_ARGUMENTS_NOT_ALLOWED.createOn(this.source ?: source) is ConeIllegalAnnotationError -> FirErrors.NOT_AN_ANNOTATION_CLASS.createOn(source, this.name.asString()) is ConeWrongNumberOfTypeArgumentsError -> FirErrors.WRONG_NUMBER_OF_TYPE_ARGUMENTS.createOn(qualifiedAccessSource ?: source, this.desiredCount, this.type) @@ -109,13 +108,13 @@ private fun mapUnsafeCallError( return FirErrors.UNSAFE_IMPLICIT_INVOKE_CALL.createOn(source, rootCause.actualType) } - val candidateFunction = candidate.symbol.fir as? FirSimpleFunction - val candidateFunctionName = candidateFunction?.name + val candidateFunctionSymbol = candidate.symbol as? FirNamedFunctionSymbol + val candidateFunctionName = candidateFunctionSymbol?.name val receiverExpression = candidate.callInfo.explicitReceiver val singleArgument = candidate.callInfo.argumentList.arguments.singleOrNull() if (receiverExpression != null && singleArgument != null && (source.elementType == KtNodeTypes.OPERATION_REFERENCE || source.elementType == KtNodeTypes.BINARY_EXPRESSION) && - (candidateFunction?.isOperator == true || candidateFunction?.isInfix == true) + (candidateFunctionSymbol?.isOperator == true || candidateFunctionSymbol?.isInfix == true) ) { // For augmented assignment operations (e.g., `a += b`), the source is the entire binary expression (BINARY_EXPRESSION). // TODO: No need to check for source.elementType == BINARY_EXPRESSION if we use operator as callee reference source @@ -174,8 +173,8 @@ private fun mapInapplicableCandidateError( ) is NonVarargSpread -> FirErrors.NON_VARARG_SPREAD.createOn(rootCause.argument.source?.getChild(KtTokens.MUL, depth = 1)!!) is ArgumentPassedTwice -> FirErrors.ARGUMENT_PASSED_TWICE.createOn(rootCause.argument.source) - is TooManyArguments -> FirErrors.TOO_MANY_ARGUMENTS.createOn(rootCause.argument.source ?: source, rootCause.function) - is NoValueForParameter -> FirErrors.NO_VALUE_FOR_PARAMETER.createOn(qualifiedAccessSource ?: source, rootCause.valueParameter) + is TooManyArguments -> FirErrors.TOO_MANY_ARGUMENTS.createOn(rootCause.argument.source ?: source, rootCause.function.symbol) + is NoValueForParameter -> FirErrors.NO_VALUE_FOR_PARAMETER.createOn(qualifiedAccessSource ?: source, rootCause.valueParameter.symbol) is NameNotFound -> FirErrors.NAMED_PARAMETER_NOT_FOUND.createOn( rootCause.argument.source ?: source, rootCause.argument.name.asString() @@ -184,7 +183,7 @@ private fun mapInapplicableCandidateError( is ManyLambdaExpressionArguments -> FirErrors.MANY_LAMBDA_EXPRESSION_ARGUMENTS.createOn(rootCause.argument.source ?: source) is InfixCallOfNonInfixFunction -> FirErrors.INFIX_MODIFIER_REQUIRED.createOn(source, rootCause.function) is OperatorCallOfNonOperatorFunction -> - FirErrors.OPERATOR_MODIFIER_REQUIRED.createOn(source, rootCause.function, rootCause.function.fir.name.asString()) + FirErrors.OPERATOR_MODIFIER_REQUIRED.createOn(source, rootCause.function, rootCause.function.name.asString()) is UnstableSmartCast -> FirErrors.SMARTCAST_IMPOSSIBLE.createOn( rootCause.argument.source, rootCause.targetType, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/deprecationUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/deprecationUtils.kt index f3528372cf9..3302e1517a8 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/deprecationUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/deprecationUtils.kt @@ -12,6 +12,10 @@ import org.jetbrains.kotlin.fir.FirAnnotationContainer import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.references.FirNamedReference +import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.utils.addIfNotNull @@ -26,10 +30,10 @@ private val LEVEL_NAME = Name.identifier("level") private val JAVA_ORIGINS = setOf(FirDeclarationOrigin.Java, FirDeclarationOrigin.Enhancement) -fun FirAnnotatedDeclaration.getDeprecation(callSite: FirElement?): Deprecation? { +fun FirBasedSymbol<*>.getDeprecation(callSite: FirElement?): Deprecation? { val deprecationInfos = mutableListOf() when (this) { - is FirProperty -> + is FirPropertySymbol -> if (callSite is FirVariableAssignment) { deprecationInfos.addIfNotNull( getDeprecationForCallSite(AnnotationUseSiteTarget.PROPERTY_SETTER, AnnotationUseSiteTarget.PROPERTY) @@ -75,12 +79,12 @@ fun List.getDeprecationInfosFromAnnotations(currentVersion: A return DeprecationsPerUseSite.fromMap(deprecationByUseSite) } -private fun FirAnnotatedDeclaration.getDeprecationForCallSite( +private fun FirBasedSymbol<*>.getDeprecationForCallSite( vararg sites: AnnotationUseSiteTarget ): Deprecation? { val deprecations = when (this) { - is FirCallableDeclaration -> deprecation - is FirClassLikeDeclaration -> deprecation + is FirCallableSymbol<*> -> deprecation + is FirClassLikeSymbol<*> -> deprecation else -> null } return (deprecations ?: EmptyDeprecationsPerUseSite).forUseSite(*sites) 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 276d5a2e813..db2f05b1806 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 @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.calls import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirFunction +import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.lookupTracker @@ -197,7 +198,7 @@ fun Candidate.resolveSubCallArgument( * It's important to extract type from argument neither from symbol, because of symbol contains * placeholder type with value 0, but argument contains type with proper literal value */ - val type: ConeKotlinType = context.returnTypeCalculator.tryCalculateReturnType(candidate.symbol.firUnsafe()).type + val type: ConeKotlinType = context.returnTypeCalculator.tryCalculateReturnType(candidate.symbol.fir as FirTypedDeclaration).type val argumentType = candidate.substitutor.substituteOrSelf(type) resolvePlainArgumentType( csBuilder, 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 32c83d175f3..a2408192f5f 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 @@ -297,8 +297,8 @@ internal object CheckCallModifiers : CheckerStage() { internal object CheckDeprecatedSinceKotlin : ResolutionStage() { override suspend fun check(candidate: Candidate, callInfo: CallInfo, sink: CheckerSink, context: ResolutionContext) { - val fir = (candidate.symbol as? FirCallableSymbol<*>)?.fir ?: return - val deprecation = fir.getDeprecation(callInfo.callSite) + val symbol = candidate.symbol as? FirCallableSymbol<*> ?: return + val deprecation = symbol.getDeprecation(callInfo.callSite) if (deprecation != null && deprecation.level == DeprecationLevelValue.HIDDEN) { sink.yieldDiagnostic(HiddenCandidate) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirInvokeResolveTowerExtension.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirInvokeResolveTowerExtension.kt index ca9c25afa32..d897e9d501f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirInvokeResolveTowerExtension.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirInvokeResolveTowerExtension.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.fir.resolve.calls.tower +import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier import org.jetbrains.kotlin.fir.expressions.builder.FirQualifiedAccessExpressionBuilder @@ -284,7 +285,7 @@ private fun BodyResolveComponents.createExplicitReceiverForInvokeByCallable( candidate ) dispatchReceiver = candidate.dispatchReceiverExpression() - this.typeRef = returnTypeCalculator.tryCalculateReturnType(symbol.firUnsafe()) + this.typeRef = returnTypeCalculator.tryCalculateReturnType(symbol.fir as FirTypedDeclaration) if (!invokeBuiltinExtensionMode) { extensionReceiver = extensionReceiverExpression diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt index 842770f4811..56ed0eb3bba 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt @@ -308,7 +308,7 @@ private fun Candidate.isFunctionForExpectTypeFromCastFeature(): Boolean { // Expect type is only being added to calls in a position of cast argument: foo() as R // And that call should be resolved to something materialize()-like: it returns its single generic parameter and doesn't have value parameters // fun materialize(): T -fun FirFunction.isFunctionForExpectTypeFromCastFeature(): Boolean { +internal fun FirFunction.isFunctionForExpectTypeFromCastFeature(): Boolean { val typeParameter = typeParameters.singleOrNull() ?: return false val returnType = returnTypeRef.coneTypeSafe() ?: return false diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt index ed3e81c948c..e174ff19c4a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt @@ -17,6 +17,8 @@ import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope +import org.jetbrains.kotlin.fir.symbols.ensureResolved +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.toEffectiveVisibility import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.types.ConeClassLikeType @@ -278,3 +280,9 @@ private fun FirDeclaration.hasOwnBodyOrAccessorBody(): Boolean { private object PublishedApiEffectiveVisibilityKey : FirDeclarationDataKey() var FirDeclaration.publishedApiEffectiveVisibility: EffectiveVisibility? by FirDeclarationDataRegistry.data(PublishedApiEffectiveVisibilityKey) + +inline val FirCallableSymbol<*>.publishedApiEffectiveVisibility: EffectiveVisibility? + get() { + ensureResolved(FirResolvePhase.STATUS) + return fir.publishedApiEffectiveVisibility + } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt index 7c5db72dbb9..c56fb1072ac 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt @@ -571,7 +571,7 @@ class SupertypeComputationSession { } } -fun FirTypeRef.firClassLike(session: FirSession): FirClassLikeDeclaration? { +internal fun FirTypeRef.firClassLike(session: FirSession): FirClassLikeDeclaration? { val type = coneTypeSafe() ?: return null return type.lookupTag.toSymbol(session)?.fir } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt index 0489f4ceaa1..da1faef1f77 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt @@ -10,11 +10,16 @@ import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef interface ReturnTypeCalculator { fun tryCalculateReturnType(declaration: FirTypedDeclaration): FirResolvedTypeRef + + fun tryCalculateReturnType(symbol: FirCallableSymbol<*>): FirResolvedTypeRef { + return tryCalculateReturnType(symbol.fir) + } } class ReturnTypeCalculatorForFullBodyResolve : ReturnTypeCalculator { 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 518f4975bbb..826d43eb920 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 @@ -110,7 +110,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform } is FirDelegateFieldReference -> { val delegateFieldSymbol = callee.resolvedSymbol - qualifiedAccessExpression.resultType = delegateFieldSymbol.delegate.typeRef + qualifiedAccessExpression.resultType = delegateFieldSymbol.fir.delegate!!.typeRef qualifiedAccessExpression } is FirResolvedNamedReference, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FirKotlinScopeProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FirKotlinScopeProvider.kt index 536c858b704..d731aa15606 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FirKotlinScopeProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FirKotlinScopeProvider.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap import org.jetbrains.kotlin.fir.scopes.impl.* import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.* @@ -93,6 +94,14 @@ fun FirClass.unsubstitutedScope( return scope } +fun FirClassSymbol<*>.unsubstitutedScope( + useSiteSession: FirSession, + scopeSession: ScopeSession, + withForcedTypeCalculator: Boolean +): FirTypeScope { + return fir.unsubstitutedScope(useSiteSession, scopeSession, withForcedTypeCalculator) +} + fun FirClass.scopeForClass( substitutor: ConeSubstitutor, useSiteSession: FirSession, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDeclaredMemberScopeProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDeclaredMemberScopeProvider.kt index 9bc2fcd49d5..e5b59f16caf 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDeclaredMemberScopeProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDeclaredMemberScopeProvider.kt @@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.classId import org.jetbrains.kotlin.fir.resolve.declaredMemberScopeProvider import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider import org.jetbrains.kotlin.fir.scopes.FirScope +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.utils.getOrPutNullable @@ -63,6 +64,10 @@ fun FirSession.declaredMemberScope(klass: FirClass): FirClassDeclaredMemberScope .declaredMemberScope(klass, useLazyNestedClassifierScope = false, existingNames = null, symbolProvider = null) } +fun FirSession.declaredMemberScope(klass: FirClassSymbol<*>): FirClassDeclaredMemberScope { + return declaredMemberScope(klass.fir) +} + fun FirSession.declaredMemberScopeWithLazyNestedScope( klass: FirClass, existingNames: List, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDelegatedMemberScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDelegatedMemberScope.kt index f9c0dadad4a..a73c0ac08e0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDelegatedMemberScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDelegatedMemberScope.kt @@ -202,6 +202,9 @@ private object MultipleDelegatesWithTheSameSignatureKey : FirDeclarationDataKey( var FirCallableDeclaration.multipleDelegatesWithTheSameSignature: Boolean? by FirDeclarationDataRegistry.data(MultipleDelegatesWithTheSameSignatureKey) +val FirCallableSymbol<*>.multipleDelegatesWithTheSameSignature: Boolean? + get() = fir.multipleDelegatesWithTheSameSignature + private object DelegatedWrapperDataKey : FirDeclarationDataKey() class DelegatedWrapperData( val wrapped: D, @@ -211,6 +214,9 @@ class DelegatedWrapperData( var D.delegatedWrapperData: DelegatedWrapperData? by FirDeclarationDataRegistry.data(DelegatedWrapperDataKey) +val FirCallableSymbol.delegatedWrapperData: DelegatedWrapperData? + get() = fir.delegatedWrapperData + // From the definition of function interfaces in the Java specification (pt. 9.8): // "methods that are members of I that do not have the same signature as any public instance method of the class Object" diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt index f8a7fb8fa64..99030e2fa5a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt @@ -16,6 +16,7 @@ import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl import org.jetbrains.kotlin.name.Name @@ -49,4 +50,6 @@ class FirNestedClassifierScope(val klass: FirClass, val useSiteSession: FirSessi override fun getCallableNames(): Set = emptySet() } -fun FirTypeParameterRef.toConeType(): ConeKotlinType = ConeTypeParameterTypeImpl(ConeTypeParameterLookupTag(symbol), isNullable = false) +fun FirTypeParameterRef.toConeType(): ConeKotlinType = symbol.toConeType() + +fun FirTypeParameterSymbol.toConeType(): ConeKotlinType = ConeTypeParameterTypeImpl(ConeTypeParameterLookupTag(this), isNullable = false) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/ClassMembers.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/ClassMembers.kt index 24e3e0dfb5c..749ed76122c 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/ClassMembers.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/ClassMembers.kt @@ -39,9 +39,13 @@ private object ContainingClassKey : FirDeclarationDataKey() var FirCallableDeclaration.containingClassAttr: ConeClassLikeLookupTag? by FirDeclarationDataRegistry.data(ContainingClassKey) var FirRegularClass.containingClassForLocalAttr: ConeClassLikeLookupTag? by FirDeclarationDataRegistry.data(ContainingClassKey) -val FirCallableDeclaration.isIntersectionOverride get() = origin == FirDeclarationOrigin.IntersectionOverride -val FirCallableDeclaration.isSubstitutionOverride get() = origin == FirDeclarationOrigin.SubstitutionOverride -val FirCallableDeclaration.isSubstitutionOrIntersectionOverride get() = isSubstitutionOverride || isIntersectionOverride +val FirCallableDeclaration.isIntersectionOverride: Boolean get() = origin == FirDeclarationOrigin.IntersectionOverride +val FirCallableDeclaration.isSubstitutionOverride: Boolean get() = origin == FirDeclarationOrigin.SubstitutionOverride +val FirCallableDeclaration.isSubstitutionOrIntersectionOverride: Boolean get() = isSubstitutionOverride || isIntersectionOverride + +val FirCallableSymbol<*>.isIntersectionOverride: Boolean get() = origin == FirDeclarationOrigin.IntersectionOverride +val FirCallableSymbol<*>.isSubstitutionOverride: Boolean get() = origin == FirDeclarationOrigin.SubstitutionOverride +val FirCallableSymbol<*>.isSubstitutionOrIntersectionOverride: Boolean get() = isSubstitutionOverride || isIntersectionOverride inline val D.originalForSubstitutionOverride: D? get() = if (isSubstitutionOverride) originalForSubstitutionOverrideAttr else null diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/Primitives.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/Primitives.kt index 18db501d4ec..76e33308cb0 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/Primitives.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/Primitives.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.utils.classId import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl import org.jetbrains.kotlin.name.ClassId @@ -57,6 +58,22 @@ fun FirClass.isPrimitiveNumberType(): Boolean = classId in PRIMITIVE_NUMBER_CLAS fun FirClass.isPrimitiveUnsignedNumberType(): Boolean = classId in PRIMITIVE_UNSIGNED_NUMBER_CLASS_IDS fun FirClass.isPrimitiveNumberOrUnsignedNumberType(): Boolean = isPrimitiveNumberType() || isPrimitiveUnsignedNumberType() +// --------------------------- symbols --------------------------- + +fun FirClassSymbol<*>.isDouble(): Boolean = classId == StandardClassIds.Double +fun FirClassSymbol<*>.isFloat(): Boolean = classId == StandardClassIds.Float +fun FirClassSymbol<*>.isLong(): Boolean = classId == StandardClassIds.Long +fun FirClassSymbol<*>.isInt(): Boolean = classId == StandardClassIds.Int +fun FirClassSymbol<*>.isShort(): Boolean = classId == StandardClassIds.Short +fun FirClassSymbol<*>.isByte(): Boolean = classId == StandardClassIds.Byte +fun FirClassSymbol<*>.isBoolean(): Boolean = classId == StandardClassIds.Boolean +fun FirClassSymbol<*>.isChar(): Boolean = classId == StandardClassIds.Char + +fun FirClassSymbol<*>.isPrimitiveType(): Boolean = isPrimitiveNumberOrUnsignedNumberType() || isBoolean() || isByte() || isShort() || isChar() +fun FirClassSymbol<*>.isPrimitiveNumberType(): Boolean = classId in PRIMITIVE_NUMBER_CLASS_IDS +fun FirClassSymbol<*>.isPrimitiveUnsignedNumberType(): Boolean = classId in PRIMITIVE_UNSIGNED_NUMBER_CLASS_IDS +fun FirClassSymbol<*>.isPrimitiveNumberOrUnsignedNumberType(): Boolean = isPrimitiveNumberType() || isPrimitiveUnsignedNumberType() + private val PRIMITIVE_NUMBER_CLASS_IDS: Set = setOf( StandardClassIds.Double, StandardClassIds.Float, StandardClassIds.Long, StandardClassIds.Int, StandardClassIds.Short, StandardClassIds.Byte diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirSymbolStatusUtils.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirSymbolStatusUtils.kt index a2dac5e4b1b..7980dcb72f5 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirSymbolStatusUtils.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirSymbolStatusUtils.kt @@ -9,6 +9,7 @@ import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.fir.FirRenderer import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.render +import org.jetbrains.kotlin.fir.symbols.ensureResolved import org.jetbrains.kotlin.fir.symbols.impl.* // ---------------------- callables with status ---------------------- diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/CommonDiagnostics.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/CommonDiagnostics.kt index f8cbd715b02..e3ba576f5fc 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/CommonDiagnostics.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/CommonDiagnostics.kt @@ -5,6 +5,8 @@ package org.jetbrains.kotlin.fir.diagnostics -class ConeUnexpectedTypeArgumentsError(override val reason: String, val source: Any? = null) : ConeDiagnostic() +import org.jetbrains.kotlin.fir.FirSourceElement + +class ConeUnexpectedTypeArgumentsError(override val reason: String, val source: FirSourceElement? = null) : ConeDiagnostic() class ConeIntermediateDiagnostic(override val reason: String) : ConeDiagnostic() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt index 69dd6728a18..4b77e22a6d1 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt @@ -20,6 +20,12 @@ sealed class FirClassLikeSymbol( ) : FirClassifierSymbol() { abstract override fun toLookupTag(): ConeClassLikeLookupTag + val deprecation: DeprecationsPerUseSite? + get() { + ensureResolved(FirResolvePhase.STATUS) + return fir.deprecation + } + override fun toString(): String = "${this::class.simpleName} ${classId.asString()}" } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFunctionSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFunctionSymbol.kt index bbdc6168262..2cd92148005 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFunctionSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFunctionSymbol.kt @@ -47,7 +47,10 @@ class FirIntersectionOverrideFunctionSymbol( class FirConstructorSymbol( callableId: CallableId -) : FirFunctionSymbol(callableId) +) : FirFunctionSymbol(callableId) { + val isPrimary: Boolean + get() = fir.isPrimary +} open class FirAccessorSymbol( callableId: CallableId, diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt index cb02460fe04..c96a1b03f7d 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt @@ -22,6 +22,7 @@ import org.jetbrains.kotlin.fir.expressions.FirSafeCallExpression import org.jetbrains.kotlin.fir.references.FirNamedReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol +import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol @@ -45,6 +46,7 @@ import org.jetbrains.kotlin.test.utils.AbstractTwoAttributesMetaInfoProcessor import org.jetbrains.kotlin.util.OperatorNameConventions import org.jetbrains.kotlin.utils.addIfNotNull +@OptIn(SymbolInternals::class) class FirDiagnosticsHandler(testServices: TestServices) : FirAnalysisHandler(testServices) { companion object { private val allowedKindsForDebugInfo = setOf( diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirScopeDumpHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirScopeDumpHandler.kt index eaf31d6c604..ce4c4fe6d53 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirScopeDumpHandler.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirScopeDumpHandler.kt @@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.symbolProvider import org.jetbrains.kotlin.fir.scopes.* import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol +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.types.render @@ -31,6 +32,7 @@ import org.jetbrains.kotlin.test.utils.withExtension import org.jetbrains.kotlin.util.SmartPrinter import org.jetbrains.kotlin.util.withIndent +@OptIn(SymbolInternals::class) class FirScopeDumpHandler(testServices: TestServices) : FirAnalysisHandler(testServices) { private val dumper = MultiModuleInfoDumperImpl() diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt index 96804f0cb06..2dc81af0d57 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt @@ -25,6 +25,7 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.dfa.cfg.FirControlFlowGraphRenderVisitor import org.jetbrains.kotlin.fir.resolve.transformers.createAllCompilerResolveProcessors import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol +import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol @@ -55,6 +56,7 @@ import java.io.File * After that you can run action `XDot` in editor with source of test (or with cfg dump) * and it will opens xdot with dump for that test */ +@OptIn(SymbolInternals::class) abstract class AbstractFirDiagnosticsTest : AbstractFirBaseDiagnosticsTest() { companion object { const val DUMP_CFG_DIRECTIVE = "DUMP_CFG" diff --git a/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/HLDiagnosticConverter.kt b/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/HLDiagnosticConverter.kt index fe9a8f2ee24..e890cfe76c6 100644 --- a/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/HLDiagnosticConverter.kt +++ b/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/HLDiagnosticConverter.kt @@ -137,7 +137,7 @@ private object FirToKtConversionCreator { private val typeMapping: Map, HLFunctionCallConversion> = mapOf( FirBasedSymbol::class to HLFunctionCallConversion( - "firSymbolBuilder.buildSymbol({0}.fir as FirDeclaration)", + "firSymbolBuilder.buildSymbol({0}.fir)", KtSymbol::class.createType(), importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration") ), @@ -145,6 +145,10 @@ private object FirToKtConversionCreator { "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0})", KtClassLikeSymbol::class.createType() ), + FirClassSymbol::class to HLFunctionCallConversion( + "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}.fir)", + KtClassLikeSymbol::class.createType() + ), FirRegularClass::class to HLFunctionCallConversion( "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}) as KtNamedClassOrObjectSymbol", KtNamedClassOrObjectSymbol::class.createType(), @@ -174,6 +178,15 @@ private object FirToKtConversionCreator { KtSymbol::class.createType(), importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration") ), + FirValueParameterSymbol::class to HLFunctionCallConversion( + "firSymbolBuilder.buildSymbol({0}.fir)", + KtSymbol::class.createType(), + importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration") + ), + FirEnumEntrySymbol::class to HLFunctionCallConversion( + "firSymbolBuilder.buildSymbol({0}.fir)", + KtSymbol::class.createType(), + ), FirClassLikeSymbol::class to HLFunctionCallConversion( "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}.fir as FirClass)", KtClassLikeSymbol::class.createType(), @@ -194,6 +207,11 @@ private object FirToKtConversionCreator { KtCallableSymbol::class.createType(), importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration") ), + FirCallableSymbol::class to HLFunctionCallConversion( + "firSymbolBuilder.callableBuilder.buildCallableSymbol({0}.fir)", + KtCallableSymbol::class.createType(), + importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration") + ), FirTypeParameterSymbol::class to HLFunctionCallConversion( "firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol({0}.fir)", KtTypeParameterSymbol::class.createType(), @@ -217,6 +235,11 @@ private object FirToKtConversionCreator { KtVariableSymbol::class.createType(), importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirProperty") ), + FirBackingFieldSymbol::class to HLFunctionCallConversion( + "firSymbolBuilder.variableLikeBuilder.buildVariableSymbol({0}.fir)", + KtVariableSymbol::class.createType(), + importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirProperty") + ), FirVariableSymbol::class to HLFunctionCallConversion( "firSymbolBuilder.variableLikeBuilder.buildVariableLikeSymbol({0}.fir)", KtVariableLikeSymbol::class.createType(), diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirReferenceShortener.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirReferenceShortener.kt index b4ced0967b4..54c5768a15f 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirReferenceShortener.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirReferenceShortener.kt @@ -10,7 +10,7 @@ import com.intellij.openapi.util.TextRange import com.intellij.psi.SmartPsiElementPointer import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.fir.* -import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClass +import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirResolvedImport @@ -242,7 +242,7 @@ private class FirShorteningContext(val firResolveState: FirModuleResolveState) { } fun getRegularClass(typeRef: FirTypeRef): FirRegularClass? { - return typeRef.toRegularClass(firSession) + return typeRef.toRegularClassSymbol(firSession)?.fir } fun toClassSymbol(classId: ClassId) = diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt index f2767c226a5..419b3f6e12e 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt @@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction import org.jetbrains.kotlin.fir.declarations.FirTypeParameter import org.jetbrains.kotlin.fir.declarations.FirVariable import org.jetbrains.kotlin.fir.psi -import org.jetbrains.kotlin.idea.frontend.api.symbols.KtNamedClassOrObjectSymbol import org.jetbrains.kotlin.psi.KtAnnotationEntry import org.jetbrains.kotlin.psi.KtArrayAccessExpression import org.jetbrains.kotlin.psi.KtBinaryExpression @@ -230,7 +229,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.INVISIBLE_REFERENCE) { firDiagnostic -> InvisibleReferenceImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) @@ -280,7 +279,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.DEPRECATION_ERROR) { firDiagnostic -> DeprecationErrorImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), firDiagnostic.b, firDiagnostic as FirPsiDiagnostic, token, @@ -288,7 +287,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.DEPRECATION) { firDiagnostic -> DeprecationImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), firDiagnostic.b, firDiagnostic as FirPsiDiagnostic, token, @@ -365,7 +364,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE) { firDiagnostic -> QualifiedSupertypeExtendedByOtherSupertypeImpl( - firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) @@ -872,7 +871,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.EXPOSED_TYPEALIAS_EXPANDED_TYPE) { firDiagnostic -> ExposedTypealiasExpandedTypeImpl( firDiagnostic.a, - firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.b.fir), firDiagnostic.c, firDiagnostic as FirPsiDiagnostic, token, @@ -881,7 +880,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.EXPOSED_FUNCTION_RETURN_TYPE) { firDiagnostic -> ExposedFunctionReturnTypeImpl( firDiagnostic.a, - firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.b.fir), firDiagnostic.c, firDiagnostic as FirPsiDiagnostic, token, @@ -890,7 +889,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.EXPOSED_RECEIVER_TYPE) { firDiagnostic -> ExposedReceiverTypeImpl( firDiagnostic.a, - firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.b.fir), firDiagnostic.c, firDiagnostic as FirPsiDiagnostic, token, @@ -899,7 +898,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.EXPOSED_PROPERTY_TYPE) { firDiagnostic -> ExposedPropertyTypeImpl( firDiagnostic.a, - firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.b.fir), firDiagnostic.c, firDiagnostic as FirPsiDiagnostic, token, @@ -908,7 +907,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.EXPOSED_PROPERTY_TYPE_IN_CONSTRUCTOR) { firDiagnostic -> ExposedPropertyTypeInConstructorImpl( firDiagnostic.a, - firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.b.fir), firDiagnostic.c, firDiagnostic as FirPsiDiagnostic, token, @@ -917,7 +916,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.EXPOSED_PARAMETER_TYPE) { firDiagnostic -> ExposedParameterTypeImpl( firDiagnostic.a, - firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.b.fir), firDiagnostic.c, firDiagnostic as FirPsiDiagnostic, token, @@ -926,7 +925,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.EXPOSED_SUPER_INTERFACE) { firDiagnostic -> ExposedSuperInterfaceImpl( firDiagnostic.a, - firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.b.fir), firDiagnostic.c, firDiagnostic as FirPsiDiagnostic, token, @@ -935,7 +934,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.EXPOSED_SUPER_CLASS) { firDiagnostic -> ExposedSuperClassImpl( firDiagnostic.a, - firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.b.fir), firDiagnostic.c, firDiagnostic as FirPsiDiagnostic, token, @@ -944,7 +943,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.EXPOSED_TYPE_PARAMETER_BOUND) { firDiagnostic -> ExposedTypeParameterBoundImpl( firDiagnostic.a, - firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.b.fir), firDiagnostic.c, firDiagnostic as FirPsiDiagnostic, token, @@ -1111,7 +1110,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.NONE_APPLICABLE) { firDiagnostic -> NoneApplicableImpl( firDiagnostic.a.map { firBasedSymbol -> - firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration) + firSymbolBuilder.buildSymbol(firBasedSymbol.fir) }, firDiagnostic as FirPsiDiagnostic, token, @@ -1119,7 +1118,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.INAPPLICABLE_CANDIDATE) { firDiagnostic -> InapplicableCandidateImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) @@ -1195,14 +1194,14 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.TOO_MANY_ARGUMENTS) { firDiagnostic -> TooManyArgumentsImpl( - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.NO_VALUE_FOR_PARAMETER) { firDiagnostic -> NoValueForParameterImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) @@ -1252,7 +1251,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.OVERLOAD_RESOLUTION_AMBIGUITY) { firDiagnostic -> OverloadResolutionAmbiguityImpl( firDiagnostic.a.map { firBasedSymbol -> - firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration) + firSymbolBuilder.buildSymbol(firBasedSymbol.fir) }, firDiagnostic as FirPsiDiagnostic, token, @@ -1261,7 +1260,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.ASSIGN_OPERATOR_AMBIGUITY) { firDiagnostic -> AssignOperatorAmbiguityImpl( firDiagnostic.a.map { firBasedSymbol -> - firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration) + firSymbolBuilder.buildSymbol(firBasedSymbol.fir) }, firDiagnostic as FirPsiDiagnostic, token, @@ -1270,7 +1269,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.ITERATOR_AMBIGUITY) { firDiagnostic -> IteratorAmbiguityImpl( firDiagnostic.a.map { firBasedSymbol -> - firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration) + firSymbolBuilder.buildSymbol(firBasedSymbol.fir) }, firDiagnostic as FirPsiDiagnostic, token, @@ -1279,7 +1278,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.HAS_NEXT_FUNCTION_AMBIGUITY) { firDiagnostic -> HasNextFunctionAmbiguityImpl( firDiagnostic.a.map { firBasedSymbol -> - firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration) + firSymbolBuilder.buildSymbol(firBasedSymbol.fir) }, firDiagnostic as FirPsiDiagnostic, token, @@ -1288,7 +1287,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.NEXT_AMBIGUITY) { firDiagnostic -> NextAmbiguityImpl( firDiagnostic.a.map { firBasedSymbol -> - firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration) + firSymbolBuilder.buildSymbol(firBasedSymbol.fir) }, firDiagnostic as FirPsiDiagnostic, token, @@ -1480,7 +1479,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER) { firDiagnostic -> NameInConstraintIsNotATypeParameterImpl( firDiagnostic.a, - firSymbolBuilder.buildSymbol(firDiagnostic.b), + firSymbolBuilder.buildSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) @@ -1589,7 +1588,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED) { firDiagnostic -> ExtensionInClassReferenceNotAllowedImpl( - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) @@ -1627,23 +1626,23 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.NOTHING_TO_OVERRIDE) { firDiagnostic -> NothingToOverrideImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.CANNOT_OVERRIDE_INVISIBLE_MEMBER) { firDiagnostic -> CannotOverrideInvisibleMemberImpl( - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.DATA_CLASS_OVERRIDE_CONFLICT) { firDiagnostic -> DataClassOverrideConflictImpl( - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) @@ -1651,7 +1650,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.CANNOT_WEAKEN_ACCESS_PRIVILEGE) { firDiagnostic -> CannotWeakenAccessPrivilegeImpl( firDiagnostic.a, - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic.c, firDiagnostic as FirPsiDiagnostic, token, @@ -1660,7 +1659,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.CANNOT_CHANGE_ACCESS_PRIVILEGE) { firDiagnostic -> CannotChangeAccessPrivilegeImpl( firDiagnostic.a, - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic.c, firDiagnostic as FirPsiDiagnostic, token, @@ -1668,7 +1667,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.OVERRIDING_FINAL_MEMBER) { firDiagnostic -> OverridingFinalMemberImpl( - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), firDiagnostic.b, firDiagnostic as FirPsiDiagnostic, token, @@ -1676,56 +1675,56 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.RETURN_TYPE_MISMATCH_ON_INHERITANCE) { firDiagnostic -> ReturnTypeMismatchOnInheritanceImpl( - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.PROPERTY_TYPE_MISMATCH_ON_INHERITANCE) { firDiagnostic -> PropertyTypeMismatchOnInheritanceImpl( - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.VAR_TYPE_MISMATCH_ON_INHERITANCE) { firDiagnostic -> VarTypeMismatchOnInheritanceImpl( - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.RETURN_TYPE_MISMATCH_BY_DELEGATION) { firDiagnostic -> ReturnTypeMismatchByDelegationImpl( - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.PROPERTY_TYPE_MISMATCH_BY_DELEGATION) { firDiagnostic -> PropertyTypeMismatchByDelegationImpl( - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.VAR_OVERRIDDEN_BY_VAL_BY_DELEGATION) { firDiagnostic -> VarOverriddenByValByDelegationImpl( - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.CONFLICTING_INHERITED_MEMBERS) { firDiagnostic -> ConflictingInheritedMembersImpl( - firDiagnostic.a.map { firCallableDeclaration -> - firSymbolBuilder.callableBuilder.buildCallableSymbol(firCallableDeclaration as FirCallableDeclaration) + firDiagnostic.a.map { firCallableSymbol -> + firSymbolBuilder.callableBuilder.buildCallableSymbol(firCallableSymbol.fir) }, firDiagnostic as FirPsiDiagnostic, token, @@ -1733,96 +1732,96 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.ABSTRACT_MEMBER_NOT_IMPLEMENTED) { firDiagnostic -> AbstractMemberNotImplementedImpl( - firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED) { firDiagnostic -> AbstractClassMemberNotImplementedImpl( - firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER) { firDiagnostic -> InvisibleAbstractMemberFromSuperImpl( - firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING) { firDiagnostic -> InvisibleAbstractMemberFromSuperWarningImpl( - firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.MANY_IMPL_MEMBER_NOT_IMPLEMENTED) { firDiagnostic -> ManyImplMemberNotImplementedImpl( - firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED) { firDiagnostic -> ManyInterfacesMemberNotImplementedImpl( - firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.OVERRIDING_FINAL_MEMBER_BY_DELEGATION) { firDiagnostic -> OverridingFinalMemberByDelegationImpl( - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE) { firDiagnostic -> DelegatedMemberHidesSupertypeOverrideImpl( - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration), - firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.RETURN_TYPE_MISMATCH_ON_OVERRIDE) { firDiagnostic -> ReturnTypeMismatchOnOverrideImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration), - firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.PROPERTY_TYPE_MISMATCH_ON_OVERRIDE) { firDiagnostic -> PropertyTypeMismatchOnOverrideImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration), - firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.VAR_TYPE_MISMATCH_ON_OVERRIDE) { firDiagnostic -> VarTypeMismatchOnOverrideImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration), - firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.VAR_OVERRIDDEN_BY_VAL) { firDiagnostic -> VarOverriddenByValImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration), - firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) @@ -1841,8 +1840,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.VIRTUAL_MEMBER_HIDDEN) { firDiagnostic -> VirtualMemberHiddenImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration), - firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.b) as KtNamedClassOrObjectSymbol, + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) @@ -1856,7 +1855,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.CONFLICTING_OVERLOADS) { firDiagnostic -> ConflictingOverloadsImpl( firDiagnostic.a.map { firBasedSymbol -> - firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration) + firSymbolBuilder.buildSymbol(firBasedSymbol.fir) }, firDiagnostic as FirPsiDiagnostic, token, @@ -1865,7 +1864,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.REDECLARATION) { firDiagnostic -> RedeclarationImpl( firDiagnostic.a.map { firBasedSymbol -> - firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration) + firSymbolBuilder.buildSymbol(firBasedSymbol.fir) }, firDiagnostic as FirPsiDiagnostic, token, @@ -1893,36 +1892,36 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS) { firDiagnostic -> AbstractFunctionInNonAbstractClassImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration), - firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.b), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.ABSTRACT_FUNCTION_WITH_BODY) { firDiagnostic -> AbstractFunctionWithBodyImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.NON_ABSTRACT_FUNCTION_WITH_NO_BODY) { firDiagnostic -> NonAbstractFunctionWithNoBodyImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.PRIVATE_FUNCTION_WITH_NO_BODY) { firDiagnostic -> PrivateFunctionWithNoBodyImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.NON_MEMBER_FUNCTION_NO_BODY) { firDiagnostic -> NonMemberFunctionNoBodyImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) @@ -2014,8 +2013,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS) { firDiagnostic -> AbstractPropertyInNonAbstractClassImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration), - firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.b), + firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a.fir), + firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) @@ -2261,7 +2260,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert ComponentFunctionAmbiguityImpl( firDiagnostic.a, firDiagnostic.b.map { firBasedSymbol -> - firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration) + firSymbolBuilder.buildSymbol(firBasedSymbol.fir) }, firDiagnostic as FirPsiDiagnostic, token, @@ -2292,14 +2291,14 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.UNINITIALIZED_PARAMETER) { firDiagnostic -> UninitializedParameterImpl( - firSymbolBuilder.variableLikeBuilder.buildVariableLikeSymbol(firDiagnostic.a.fir), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.UNINITIALIZED_ENUM_ENTRY) { firDiagnostic -> UninitializedEnumEntryImpl( - firSymbolBuilder.variableLikeBuilder.buildVariableLikeSymbol(firDiagnostic.a.fir), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) @@ -2355,7 +2354,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.WRONG_INVOCATION_KIND) { firDiagnostic -> WrongInvocationKindImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), firDiagnostic.b, firDiagnostic.c, firDiagnostic as FirPsiDiagnostic, @@ -2364,7 +2363,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.LEAKED_IN_PLACE_LAMBDA) { firDiagnostic -> LeakedInPlaceLambdaImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) @@ -2573,7 +2572,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.HAS_NEXT_FUNCTION_NONE_APPLICABLE) { firDiagnostic -> HasNextFunctionNoneApplicableImpl( firDiagnostic.a.map { firBasedSymbol -> - firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration) + firSymbolBuilder.buildSymbol(firBasedSymbol.fir) }, firDiagnostic as FirPsiDiagnostic, token, @@ -2582,7 +2581,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert add(FirErrors.NEXT_NONE_APPLICABLE) { firDiagnostic -> NextNoneApplicableImpl( firDiagnostic.a.map { firBasedSymbol -> - firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration) + firSymbolBuilder.buildSymbol(firBasedSymbol.fir) }, firDiagnostic as FirPsiDiagnostic, token, @@ -2601,7 +2600,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert DelegateSpecialFunctionAmbiguityImpl( firDiagnostic.a, firDiagnostic.b.map { firBasedSymbol -> - firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration) + firSymbolBuilder.buildSymbol(firBasedSymbol.fir) }, firDiagnostic as FirPsiDiagnostic, token, @@ -2611,7 +2610,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert DelegateSpecialFunctionNoneApplicableImpl( firDiagnostic.a, firDiagnostic.b.map { firBasedSymbol -> - firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration) + firSymbolBuilder.buildSymbol(firBasedSymbol.fir) }, firDiagnostic as FirPsiDiagnostic, token, @@ -2793,68 +2792,68 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert } add(FirErrors.USAGE_IS_NOT_INLINABLE) { firDiagnostic -> UsageIsNotInlinableImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.NON_LOCAL_RETURN_NOT_ALLOWED) { firDiagnostic -> NonLocalReturnNotAllowedImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.RECURSION_IN_INLINE) { firDiagnostic -> RecursionInInlineImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.NON_PUBLIC_CALL_FROM_PUBLIC_INLINE) { firDiagnostic -> NonPublicCallFromPublicInlineImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration), - firSymbolBuilder.buildSymbol(firDiagnostic.b.fir as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), + firSymbolBuilder.buildSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE) { firDiagnostic -> ProtectedConstructorCallFromPublicInlineImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration), - firSymbolBuilder.buildSymbol(firDiagnostic.b.fir as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), + firSymbolBuilder.buildSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR) { firDiagnostic -> ProtectedCallFromPublicInlineErrorImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration), - firSymbolBuilder.buildSymbol(firDiagnostic.b.fir as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), + firSymbolBuilder.buildSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.PROTECTED_CALL_FROM_PUBLIC_INLINE) { firDiagnostic -> ProtectedCallFromPublicInlineImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration), - firSymbolBuilder.buildSymbol(firDiagnostic.b.fir as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), + firSymbolBuilder.buildSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.PRIVATE_CLASS_MEMBER_FROM_INLINE) { firDiagnostic -> PrivateClassMemberFromInlineImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration), - firSymbolBuilder.buildSymbol(firDiagnostic.b.fir as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), + firSymbolBuilder.buildSymbol(firDiagnostic.b.fir), firDiagnostic as FirPsiDiagnostic, token, ) } add(FirErrors.SUPER_CALL_FROM_PUBLIC_INLINE) { firDiagnostic -> SuperCallFromPublicInlineImpl( - firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration), + firSymbolBuilder.buildSymbol(firDiagnostic.a.fir), firDiagnostic as FirPsiDiagnostic, token, ) diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt index ba26dbf4e13..ee3dd5a6dd1 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt @@ -17,7 +17,6 @@ import org.jetbrains.kotlin.idea.frontend.api.diagnostics.KtDiagnosticWithPsi import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtClassLikeSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionLikeSymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.KtNamedClassOrObjectSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtTypeParameterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtVariableLikeSymbol @@ -278,7 +277,7 @@ sealed class KtFirDiagnostic : KtDiagnosticWithPsi { abstract class QualifiedSupertypeExtendedByOtherSupertype : KtFirDiagnostic() { override val diagnosticClass get() = QualifiedSupertypeExtendedByOtherSupertype::class - abstract val otherSuperType: KtClassLikeSymbol + abstract val otherSuperType: KtSymbol } abstract class SupertypeInitializedInInterface : KtFirDiagnostic() { @@ -1152,7 +1151,7 @@ sealed class KtFirDiagnostic : KtDiagnosticWithPsi { abstract class NothingToOverride : KtFirDiagnostic() { override val diagnosticClass get() = NothingToOverride::class - abstract val declaration: KtSymbol + abstract val declaration: KtCallableSymbol } abstract class CannotOverrideInvisibleMember : KtFirDiagnostic() { @@ -1278,26 +1277,26 @@ sealed class KtFirDiagnostic : KtDiagnosticWithPsi { abstract class ReturnTypeMismatchOnOverride : KtFirDiagnostic() { override val diagnosticClass get() = ReturnTypeMismatchOnOverride::class - abstract val function: KtSymbol - abstract val superFunction: KtSymbol + abstract val function: KtCallableSymbol + abstract val superFunction: KtCallableSymbol } abstract class PropertyTypeMismatchOnOverride : KtFirDiagnostic() { override val diagnosticClass get() = PropertyTypeMismatchOnOverride::class - abstract val property: KtSymbol - abstract val superProperty: KtSymbol + abstract val property: KtCallableSymbol + abstract val superProperty: KtCallableSymbol } abstract class VarTypeMismatchOnOverride : KtFirDiagnostic() { override val diagnosticClass get() = VarTypeMismatchOnOverride::class - abstract val variable: KtSymbol - abstract val superVariable: KtSymbol + abstract val variable: KtCallableSymbol + abstract val superVariable: KtCallableSymbol } abstract class VarOverriddenByVal : KtFirDiagnostic() { override val diagnosticClass get() = VarOverriddenByVal::class - abstract val overridingDeclaration: KtSymbol - abstract val overriddenDeclaration: KtSymbol + abstract val overridingDeclaration: KtCallableSymbol + abstract val overriddenDeclaration: KtCallableSymbol } abstract class NonFinalMemberInFinalClass : KtFirDiagnostic() { @@ -1310,8 +1309,8 @@ sealed class KtFirDiagnostic : KtDiagnosticWithPsi { abstract class VirtualMemberHidden : KtFirDiagnostic() { override val diagnosticClass get() = VirtualMemberHidden::class - abstract val declared: KtSymbol - abstract val overriddenContainer: KtNamedClassOrObjectSymbol + abstract val declared: KtCallableSymbol + abstract val overriddenContainer: KtClassLikeSymbol } abstract class ManyCompanionObjects : KtFirDiagnostic() { @@ -1344,28 +1343,28 @@ sealed class KtFirDiagnostic : KtDiagnosticWithPsi { abstract class AbstractFunctionInNonAbstractClass : KtFirDiagnostic() { override val diagnosticClass get() = AbstractFunctionInNonAbstractClass::class - abstract val function: KtSymbol + abstract val function: KtCallableSymbol abstract val containingClass: KtClassLikeSymbol } abstract class AbstractFunctionWithBody : KtFirDiagnostic() { override val diagnosticClass get() = AbstractFunctionWithBody::class - abstract val function: KtSymbol + abstract val function: KtCallableSymbol } abstract class NonAbstractFunctionWithNoBody : KtFirDiagnostic() { override val diagnosticClass get() = NonAbstractFunctionWithNoBody::class - abstract val function: KtSymbol + abstract val function: KtCallableSymbol } abstract class PrivateFunctionWithNoBody : KtFirDiagnostic() { override val diagnosticClass get() = PrivateFunctionWithNoBody::class - abstract val function: KtSymbol + abstract val function: KtCallableSymbol } abstract class NonMemberFunctionNoBody : KtFirDiagnostic() { override val diagnosticClass get() = NonMemberFunctionNoBody::class - abstract val function: KtSymbol + abstract val function: KtCallableSymbol } abstract class FunctionDeclarationWithNoName : KtFirDiagnostic() { @@ -1427,7 +1426,7 @@ sealed class KtFirDiagnostic : KtDiagnosticWithPsi { abstract class AbstractPropertyInNonAbstractClass : KtFirDiagnostic() { override val diagnosticClass get() = AbstractPropertyInNonAbstractClass::class - abstract val property: KtSymbol + abstract val property: KtCallableSymbol abstract val containingClass: KtClassLikeSymbol } @@ -1617,12 +1616,12 @@ sealed class KtFirDiagnostic : KtDiagnosticWithPsi { abstract class UninitializedParameter : KtFirDiagnostic() { override val diagnosticClass get() = UninitializedParameter::class - abstract val parameter: KtVariableLikeSymbol + abstract val parameter: KtSymbol } abstract class UninitializedEnumEntry : KtFirDiagnostic() { override val diagnosticClass get() = UninitializedEnumEntry::class - abstract val enumEntry: KtVariableLikeSymbol + abstract val enumEntry: KtSymbol } abstract class UninitializedEnumCompanion : KtFirDiagnostic() { diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt index 7a82c7c6f42..869f1406839 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt @@ -18,7 +18,6 @@ import org.jetbrains.kotlin.idea.frontend.api.fir.utils.weakRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtClassLikeSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionLikeSymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.KtNamedClassOrObjectSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtTypeParameterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtVariableLikeSymbol @@ -422,7 +421,7 @@ internal class SuperclassNotAccessibleFromInterfaceImpl( } internal class QualifiedSupertypeExtendedByOtherSupertypeImpl( - override val otherSuperType: KtClassLikeSymbol, + override val otherSuperType: KtSymbol, firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, ) : KtFirDiagnostic.QualifiedSupertypeExtendedByOtherSupertype(), KtAbstractFirDiagnostic { @@ -1854,7 +1853,7 @@ internal class ExpressionOfNullableTypeInClassLiteralLhsImpl( } internal class NothingToOverrideImpl( - override val declaration: KtSymbol, + override val declaration: KtCallableSymbol, firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, ) : KtFirDiagnostic.NothingToOverride(), KtAbstractFirDiagnostic { @@ -2043,8 +2042,8 @@ internal class DelegatedMemberHidesSupertypeOverrideImpl( } internal class ReturnTypeMismatchOnOverrideImpl( - override val function: KtSymbol, - override val superFunction: KtSymbol, + override val function: KtCallableSymbol, + override val superFunction: KtCallableSymbol, firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, ) : KtFirDiagnostic.ReturnTypeMismatchOnOverride(), KtAbstractFirDiagnostic { @@ -2052,8 +2051,8 @@ internal class ReturnTypeMismatchOnOverrideImpl( } internal class PropertyTypeMismatchOnOverrideImpl( - override val property: KtSymbol, - override val superProperty: KtSymbol, + override val property: KtCallableSymbol, + override val superProperty: KtCallableSymbol, firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, ) : KtFirDiagnostic.PropertyTypeMismatchOnOverride(), KtAbstractFirDiagnostic { @@ -2061,8 +2060,8 @@ internal class PropertyTypeMismatchOnOverrideImpl( } internal class VarTypeMismatchOnOverrideImpl( - override val variable: KtSymbol, - override val superVariable: KtSymbol, + override val variable: KtCallableSymbol, + override val superVariable: KtCallableSymbol, firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, ) : KtFirDiagnostic.VarTypeMismatchOnOverride(), KtAbstractFirDiagnostic { @@ -2070,8 +2069,8 @@ internal class VarTypeMismatchOnOverrideImpl( } internal class VarOverriddenByValImpl( - override val overridingDeclaration: KtSymbol, - override val overriddenDeclaration: KtSymbol, + override val overridingDeclaration: KtCallableSymbol, + override val overriddenDeclaration: KtCallableSymbol, firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, ) : KtFirDiagnostic.VarOverriddenByVal(), KtAbstractFirDiagnostic { @@ -2093,8 +2092,8 @@ internal class NonFinalMemberInObjectImpl( } internal class VirtualMemberHiddenImpl( - override val declared: KtSymbol, - override val overriddenContainer: KtNamedClassOrObjectSymbol, + override val declared: KtCallableSymbol, + override val overriddenContainer: KtClassLikeSymbol, firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, ) : KtFirDiagnostic.VirtualMemberHidden(), KtAbstractFirDiagnostic { @@ -2148,7 +2147,7 @@ internal class LocalInterfaceNotAllowedImpl( } internal class AbstractFunctionInNonAbstractClassImpl( - override val function: KtSymbol, + override val function: KtCallableSymbol, override val containingClass: KtClassLikeSymbol, firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, @@ -2157,7 +2156,7 @@ internal class AbstractFunctionInNonAbstractClassImpl( } internal class AbstractFunctionWithBodyImpl( - override val function: KtSymbol, + override val function: KtCallableSymbol, firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, ) : KtFirDiagnostic.AbstractFunctionWithBody(), KtAbstractFirDiagnostic { @@ -2165,7 +2164,7 @@ internal class AbstractFunctionWithBodyImpl( } internal class NonAbstractFunctionWithNoBodyImpl( - override val function: KtSymbol, + override val function: KtCallableSymbol, firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, ) : KtFirDiagnostic.NonAbstractFunctionWithNoBody(), KtAbstractFirDiagnostic { @@ -2173,7 +2172,7 @@ internal class NonAbstractFunctionWithNoBodyImpl( } internal class PrivateFunctionWithNoBodyImpl( - override val function: KtSymbol, + override val function: KtCallableSymbol, firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, ) : KtFirDiagnostic.PrivateFunctionWithNoBody(), KtAbstractFirDiagnostic { @@ -2181,7 +2180,7 @@ internal class PrivateFunctionWithNoBodyImpl( } internal class NonMemberFunctionNoBodyImpl( - override val function: KtSymbol, + override val function: KtCallableSymbol, firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, ) : KtFirDiagnostic.NonMemberFunctionNoBody(), KtAbstractFirDiagnostic { @@ -2288,7 +2287,7 @@ internal class FunInterfaceWithSuspendFunctionImpl( } internal class AbstractPropertyInNonAbstractClassImpl( - override val property: KtSymbol, + override val property: KtCallableSymbol, override val containingClass: KtClassLikeSymbol, firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, @@ -2607,7 +2606,7 @@ internal class UninitializedVariableImpl( } internal class UninitializedParameterImpl( - override val parameter: KtVariableLikeSymbol, + override val parameter: KtSymbol, firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, ) : KtFirDiagnostic.UninitializedParameter(), KtAbstractFirDiagnostic { @@ -2615,7 +2614,7 @@ internal class UninitializedParameterImpl( } internal class UninitializedEnumEntryImpl( - override val enumEntry: KtVariableLikeSymbol, + override val enumEntry: KtSymbol, firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, ) : KtFirDiagnostic.UninitializedEnumEntry(), KtAbstractFirDiagnostic { diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirOverrideInfoProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirOverrideInfoProvider.kt index d63d406a099..64b88091694 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirOverrideInfoProvider.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirOverrideInfoProvider.kt @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.originalForSubstitutionOverride import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.SessionHolderImpl import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession import org.jetbrains.kotlin.idea.frontend.api.components.KtOverrideInfoProvider import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession @@ -49,8 +50,8 @@ class KtFirOverrideInfoProvider( return memberSymbol.firRef.withFir { memberFir -> if (memberFir !is FirCallableDeclaration) return@withFir null parentClassSymbol.firRef.withFir inner@{ parentClassFir -> - if (parentClassFir !is FirClass) return@inner null - memberFir.getImplementationStatus(SessionHolderImpl(firAnalysisSession.rootModuleSession, ScopeSession()), parentClassFir) + if (parentClassSymbol !is FirClassSymbol<*>) return@inner null + memberFir.symbol.getImplementationStatus(SessionHolderImpl(firAnalysisSession.rootModuleSession, ScopeSession()), parentClassSymbol) } } }