azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FIR] Fix all illegal usages of symbol.fir in checkers module

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2021-07-07 15:54:50 +03:00
committed by teamcityserver
parent e94d75d433
commit 22a4da024b
96 changed files with 1301 additions and 1077 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/AbstractFirLoadBinariesTest.kt
+2
View File
@@ -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),
compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt
+2
View File
@@ -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
compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/JavaClassRendering.kt
+2
View File
@@ -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)
compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt
+65 -65
View File
@@ -134,7 +134,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
val NOT_A_SUPERTYPE by error<PsiElement>()
val SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE by error<PsiElement>()
val QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE by error<KtTypeReference> {
parameter<FirClass>("otherSuperType")
parameter<Symbol>("otherSuperType")
}
val SUPERTYPE_INITIALIZED_IN_INTERFACE by error<KtTypeReference>()
val INTERFACE_WITH_SUPERCLASS by error<KtTypeReference>()
@@ -384,10 +384,10 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
val NON_VARARG_SPREAD by error<LeafPsiElement>()
val ARGUMENT_PASSED_TWICE by error<KtValueArgument>(PositioningStrategy.NAME_OF_NAMED_ARGUMENT)
val TOO_MANY_ARGUMENTS by error<PsiElement> {
parameter<FirCallableDeclaration>("function")
parameter<FirCallableSymbol<*>>("function")
}
val NO_VALUE_FOR_PARAMETER by error<KtElement>(PositioningStrategy.VALUE_ARGUMENTS) {
parameter<FirValueParameter>("violatedParameter")
parameter<FirValueParameterSymbol>("violatedParameter")
}
val NAMED_PARAMETER_NOT_FOUND by error<KtValueArgument>(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<KtSimpleNameExpression> {
parameter<Name>("typeParameterName")
parameter<FirDeclaration>("typeParametersOwner")
parameter<Symbol>("typeParametersOwner")
}
val BOUND_ON_TYPE_ALIAS_PARAMETER_NOT_ALLOWED by error<KtTypeReference>()
@@ -556,7 +556,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
val REFLECTION by object : DiagnosticGroup("Reflection") {
val EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED by error<KtExpression>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
parameter<FirCallableDeclaration>("referencedDeclaration")
parameter<FirCallableSymbol<*>>("referencedDeclaration")
}
val CALLABLE_REFERENCE_LHS_NOT_A_CLASS by error<KtExpression>()
val CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR by error<KtExpression>(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<KtModifierListOwner>(PositioningStrategy.OVERRIDE_MODIFIER) {
parameter<FirMemberDeclaration>("declaration")
parameter<FirCallableSymbol<*>>("declaration")
}
val CANNOT_OVERRIDE_INVISIBLE_MEMBER by error<KtNamedDeclaration>(PositioningStrategy.OVERRIDE_MODIFIER) {
parameter<FirCallableDeclaration>("overridingMember")
parameter<FirCallableDeclaration>("baseMember")
parameter<FirCallableSymbol<*>>("overridingMember")
parameter<FirCallableSymbol<*>>("baseMember")
}
val DATA_CLASS_OVERRIDE_CONFLICT by error<KtClassOrObject>(PositioningStrategy.DATA_MODIFIER) {
parameter<FirCallableDeclaration>("overridingMember")
parameter<FirCallableDeclaration>("baseMember")
parameter<FirCallableSymbol<*>>("overridingMember")
parameter<FirCallableSymbol<*>>("baseMember")
}
val CANNOT_WEAKEN_ACCESS_PRIVILEGE by error<KtModifierListOwner>(PositioningStrategy.VISIBILITY_MODIFIER) {
parameter<Visibility>("overridingVisibility")
parameter<FirCallableDeclaration>("overridden")
parameter<FirCallableSymbol<*>>("overridden")
parameter<Name>("containingClassName")
}
val CANNOT_CHANGE_ACCESS_PRIVILEGE by error<KtModifierListOwner>(PositioningStrategy.VISIBILITY_MODIFIER) {
parameter<Visibility>("overridingVisibility")
parameter<FirCallableDeclaration>("overridden")
parameter<FirCallableSymbol<*>>("overridden")
parameter<Name>("containingClassName")
}
val OVERRIDING_FINAL_MEMBER by error<KtNamedDeclaration>(PositioningStrategy.OVERRIDE_MODIFIER) {
parameter<FirCallableDeclaration>("overriddenDeclaration")
parameter<FirCallableSymbol<*>>("overriddenDeclaration")
parameter<Name>("containingClassName")
}
val RETURN_TYPE_MISMATCH_ON_INHERITANCE by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
parameter<FirCallableDeclaration>("conflictingDeclaration1")
parameter<FirCallableDeclaration>("conflictingDeclaration2")
parameter<FirCallableSymbol<*>>("conflictingDeclaration1")
parameter<FirCallableSymbol<*>>("conflictingDeclaration2")
}
val PROPERTY_TYPE_MISMATCH_ON_INHERITANCE by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
parameter<FirCallableDeclaration>("conflictingDeclaration1")
parameter<FirCallableDeclaration>("conflictingDeclaration2")
parameter<FirCallableSymbol<*>>("conflictingDeclaration1")
parameter<FirCallableSymbol<*>>("conflictingDeclaration2")
}
val VAR_TYPE_MISMATCH_ON_INHERITANCE by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
parameter<FirCallableDeclaration>("conflictingDeclaration1")
parameter<FirCallableDeclaration>("conflictingDeclaration2")
parameter<FirCallableSymbol<*>>("conflictingDeclaration1")
parameter<FirCallableSymbol<*>>("conflictingDeclaration2")
}
val RETURN_TYPE_MISMATCH_BY_DELEGATION by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
parameter<FirCallableDeclaration>("delegateDeclaration")
parameter<FirCallableDeclaration>("baseDeclaration")
parameter<FirCallableSymbol<*>>("delegateDeclaration")
parameter<FirCallableSymbol<*>>("baseDeclaration")
}
val PROPERTY_TYPE_MISMATCH_BY_DELEGATION by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
parameter<FirCallableDeclaration>("delegateDeclaration")
parameter<FirCallableDeclaration>("baseDeclaration")
parameter<FirCallableSymbol<*>>("delegateDeclaration")
parameter<FirCallableSymbol<*>>("baseDeclaration")
}
val VAR_OVERRIDDEN_BY_VAL_BY_DELEGATION by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
parameter<FirCallableDeclaration>("delegateDeclaration")
parameter<FirCallableDeclaration>("baseDeclaration")
parameter<FirCallableSymbol<*>>("delegateDeclaration")
parameter<FirCallableSymbol<*>>("baseDeclaration")
}
val CONFLICTING_INHERITED_MEMBERS by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
parameter<List<FirCallableDeclaration>>("conflictingDeclarations")
parameter<List<FirCallableSymbol<*>>>("conflictingDeclarations")
}
val ABSTRACT_MEMBER_NOT_IMPLEMENTED by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
parameter<FirClass>("classOrObject")
parameter<FirCallableDeclaration>("missingDeclaration")
parameter<FirClassSymbol<*>>("classOrObject")
parameter<FirCallableSymbol<*>>("missingDeclaration")
}
val ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
parameter<FirClass>("classOrObject")
parameter<FirCallableDeclaration>("missingDeclaration")
parameter<FirClassSymbol<*>>("classOrObject")
parameter<FirCallableSymbol<*>>("missingDeclaration")
}
val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
parameter<FirClass>("classOrObject")
parameter<FirCallableDeclaration>("invisibleDeclaration")
parameter<FirClassSymbol<*>>("classOrObject")
parameter<FirCallableSymbol<*>>("invisibleDeclaration")
}
val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING by warning<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
parameter<FirClass>("classOrObject")
parameter<FirCallableDeclaration>("invisibleDeclaration")
parameter<FirClassSymbol<*>>("classOrObject")
parameter<FirCallableSymbol<*>>("invisibleDeclaration")
}
val MANY_IMPL_MEMBER_NOT_IMPLEMENTED by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
parameter<FirClass>("classOrObject")
parameter<FirCallableDeclaration>("missingDeclaration")
parameter<FirClassSymbol<*>>("classOrObject")
parameter<FirCallableSymbol<*>>("missingDeclaration")
}
val MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
parameter<FirClass>("classOrObject")
parameter<FirCallableDeclaration>("missingDeclaration")
parameter<FirClassSymbol<*>>("classOrObject")
parameter<FirCallableSymbol<*>>("missingDeclaration")
}
val OVERRIDING_FINAL_MEMBER_BY_DELEGATION by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
parameter<FirCallableDeclaration>("delegatedDeclaration")
parameter<FirCallableDeclaration>("overriddenDeclaration")
parameter<FirCallableSymbol<*>>("delegatedDeclaration")
parameter<FirCallableSymbol<*>>("overriddenDeclaration")
}
val DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE by warning<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
parameter<FirCallableDeclaration>("delegatedDeclaration")
parameter<FirCallableDeclaration>("overriddenDeclaration")
parameter<FirCallableSymbol<*>>("delegatedDeclaration")
parameter<FirCallableSymbol<*>>("overriddenDeclaration")
}
val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error<KtNamedDeclaration>(PositioningStrategy.DECLARATION_RETURN_TYPE) {
parameter<FirMemberDeclaration>("function")
parameter<FirMemberDeclaration>("superFunction")
parameter<FirCallableSymbol<*>>("function")
parameter<FirCallableSymbol<*>>("superFunction")
}
val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error<KtNamedDeclaration>(PositioningStrategy.DECLARATION_RETURN_TYPE) {
parameter<FirMemberDeclaration>("property")
parameter<FirMemberDeclaration>("superProperty")
parameter<FirCallableSymbol<*>>("property")
parameter<FirCallableSymbol<*>>("superProperty")
}
val VAR_TYPE_MISMATCH_ON_OVERRIDE by error<KtNamedDeclaration>(PositioningStrategy.DECLARATION_RETURN_TYPE) {
parameter<FirMemberDeclaration>("variable")
parameter<FirMemberDeclaration>("superVariable")
parameter<FirCallableSymbol<*>>("variable")
parameter<FirCallableSymbol<*>>("superVariable")
}
val VAR_OVERRIDDEN_BY_VAL by error<KtNamedDeclaration>(PositioningStrategy.VAL_OR_VAR_NODE) {
parameter<FirMemberDeclaration>("overridingDeclaration")
parameter<FirMemberDeclaration>("overriddenDeclaration")
parameter<FirCallableSymbol<*>>("overridingDeclaration")
parameter<FirCallableSymbol<*>>("overriddenDeclaration")
}
val NON_FINAL_MEMBER_IN_FINAL_CLASS by warning<KtNamedDeclaration>(PositioningStrategy.OPEN_MODIFIER)
val NON_FINAL_MEMBER_IN_OBJECT by warning<KtNamedDeclaration>(PositioningStrategy.OPEN_MODIFIER)
val VIRTUAL_MEMBER_HIDDEN by error<KtNamedDeclaration>(PositioningStrategy.DECLARATION_NAME) {
parameter<FirMemberDeclaration>("declared")
parameter<FirRegularClass>("overriddenContainer")
parameter<FirCallableSymbol<*>>("declared")
parameter<FirRegularClassSymbol>("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<KtFunction>(PositioningStrategy.MODALITY_MODIFIER) {
parameter<FirMemberDeclaration>("function")
parameter<FirClass>("containingClass")
parameter<FirCallableSymbol<*>>("function")
parameter<FirClassSymbol<*>>("containingClass")
}
val ABSTRACT_FUNCTION_WITH_BODY by error<KtFunction>(PositioningStrategy.MODALITY_MODIFIER) {
parameter<FirMemberDeclaration>("function")
parameter<FirCallableSymbol<*>>("function")
}
val NON_ABSTRACT_FUNCTION_WITH_NO_BODY by error<KtFunction>(PositioningStrategy.DECLARATION_SIGNATURE) {
parameter<FirMemberDeclaration>("function")
parameter<FirCallableSymbol<*>>("function")
}
val PRIVATE_FUNCTION_WITH_NO_BODY by error<KtFunction>(PositioningStrategy.VISIBILITY_MODIFIER) {
parameter<FirMemberDeclaration>("function")
parameter<FirCallableSymbol<*>>("function")
}
val NON_MEMBER_FUNCTION_NO_BODY by error<KtFunction>(PositioningStrategy.DECLARATION_SIGNATURE) {
parameter<FirMemberDeclaration>("function")
parameter<FirCallableSymbol<*>>("function")
}
val FUNCTION_DECLARATION_WITH_NO_NAME by error<KtFunction>(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<KtModifierListOwner>(PositioningStrategy.MODALITY_MODIFIER) {
parameter<FirMemberDeclaration>("property")
parameter<FirClass>("containingClass")
parameter<FirCallableSymbol<*>>("property")
parameter<FirClassSymbol<*>>("containingClass")
}
val PRIVATE_PROPERTY_IN_INTERFACE by error<KtProperty>(PositioningStrategy.VISIBILITY_MODIFIER)
@@ -844,10 +844,10 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
parameter<FirPropertySymbol>("variable")
}
val UNINITIALIZED_PARAMETER by error<KtSimpleNameExpression> {
parameter<FirVariableSymbol<FirValueParameter>>("parameter")
parameter<FirValueParameterSymbol>("parameter")
}
val UNINITIALIZED_ENUM_ENTRY by error<KtSimpleNameExpression> {
parameter<FirVariableSymbol<FirEnumEntry>>("enumEntry")
parameter<FirEnumEntrySymbol>("enumEntry")
}
val UNINITIALIZED_ENUM_COMPANION by error<KtSimpleNameExpression>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
parameter<FirRegularClassSymbol>("enumClass")
@@ -856,10 +856,10 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
parameter<FirVariableSymbol<*>>("variable")
}
val VAL_REASSIGNMENT_VIA_BACKING_FIELD by warning<KtExpression> {
parameter<FirPropertySymbol>("property")
parameter<FirBackingFieldSymbol>("property")
}
val VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR by error<KtExpression> {
parameter<FirPropertySymbol>("property")
parameter<FirBackingFieldSymbol>("property")
}
val CAPTURED_VAL_INITIALIZATION by error<KtExpression> {
parameter<FirPropertySymbol>("property")
@@ -1099,7 +1099,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
private val exposedVisibilityDiagnosticInit: DiagnosticBuilder.() -> Unit = {
parameter<EffectiveVisibility>("elementVisibility")
parameter<FirMemberDeclaration>("restrictingDeclaration")
parameter<Symbol>("restrictingDeclaration")
parameter<EffectiveVisibility>("restrictingVisibility")
}
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/FirJvmOverridesBackwardCompatibilityHelper.kt
+10 -5
View File
@@ -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<FirCallableSymbol<*>>,
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<ConeClassLikeType>()?.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)
compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
+55 -57
View File
@@ -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<PsiElement>()
val NOT_A_SUPERTYPE by error0<PsiElement>()
val SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE by error0<PsiElement>()
val QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE by error1<KtTypeReference, FirClass>()
val QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE by error1<KtTypeReference, FirBasedSymbol<*>>()
val SUPERTYPE_INITIALIZED_IN_INTERFACE by error0<KtTypeReference>()
val INTERFACE_WITH_SUPERCLASS by error0<KtTypeReference>()
val FINAL_SUPERTYPE by error0<KtTypeReference>()
@@ -223,15 +221,15 @@ object FirErrors {
val EXPERIMENTAL_ANNOTATION_WITH_WRONG_RETENTION by error0<KtAnnotationEntry>()
// Exposed visibility
val EXPOSED_TYPEALIAS_EXPANDED_TYPE by error3<KtNamedDeclaration, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
val EXPOSED_FUNCTION_RETURN_TYPE by error3<KtNamedDeclaration, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
val EXPOSED_RECEIVER_TYPE by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>()
val EXPOSED_PROPERTY_TYPE by error3<KtNamedDeclaration, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
val EXPOSED_PROPERTY_TYPE_IN_CONSTRUCTOR by warning3<KtNamedDeclaration, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
val EXPOSED_PARAMETER_TYPE by error3<KtParameter, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>()
val EXPOSED_SUPER_INTERFACE by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>()
val EXPOSED_SUPER_CLASS by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>()
val EXPOSED_TYPE_PARAMETER_BOUND by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>()
val EXPOSED_TYPEALIAS_EXPANDED_TYPE by error3<KtNamedDeclaration, EffectiveVisibility, FirBasedSymbol<*>, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
val EXPOSED_FUNCTION_RETURN_TYPE by error3<KtNamedDeclaration, EffectiveVisibility, FirBasedSymbol<*>, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
val EXPOSED_RECEIVER_TYPE by error3<KtTypeReference, EffectiveVisibility, FirBasedSymbol<*>, EffectiveVisibility>()
val EXPOSED_PROPERTY_TYPE by error3<KtNamedDeclaration, EffectiveVisibility, FirBasedSymbol<*>, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
val EXPOSED_PROPERTY_TYPE_IN_CONSTRUCTOR by warning3<KtNamedDeclaration, EffectiveVisibility, FirBasedSymbol<*>, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
val EXPOSED_PARAMETER_TYPE by error3<KtParameter, EffectiveVisibility, FirBasedSymbol<*>, EffectiveVisibility>()
val EXPOSED_SUPER_INTERFACE by error3<KtTypeReference, EffectiveVisibility, FirBasedSymbol<*>, EffectiveVisibility>()
val EXPOSED_SUPER_CLASS by error3<KtTypeReference, EffectiveVisibility, FirBasedSymbol<*>, EffectiveVisibility>()
val EXPOSED_TYPE_PARAMETER_BOUND by error3<KtTypeReference, EffectiveVisibility, FirBasedSymbol<*>, EffectiveVisibility>()
// Modifiers
val INAPPLICABLE_INFIX_MODIFIER by error0<PsiElement>()
@@ -274,8 +272,8 @@ object FirErrors {
val NAMED_ARGUMENTS_NOT_ALLOWED by error1<KtValueArgument, ForbiddenNamedArgumentsTarget>(SourceElementPositioningStrategies.NAME_OF_NAMED_ARGUMENT)
val NON_VARARG_SPREAD by error0<LeafPsiElement>()
val ARGUMENT_PASSED_TWICE by error0<KtValueArgument>(SourceElementPositioningStrategies.NAME_OF_NAMED_ARGUMENT)
val TOO_MANY_ARGUMENTS by error1<PsiElement, FirCallableDeclaration>()
val NO_VALUE_FOR_PARAMETER by error1<KtElement, FirValueParameter>(SourceElementPositioningStrategies.VALUE_ARGUMENTS)
val TOO_MANY_ARGUMENTS by error1<PsiElement, FirCallableSymbol<*>>()
val NO_VALUE_FOR_PARAMETER by error1<KtElement, FirValueParameterSymbol>(SourceElementPositioningStrategies.VALUE_ARGUMENTS)
val NAMED_PARAMETER_NOT_FOUND by error1<KtValueArgument, String>(SourceElementPositioningStrategies.NAME_OF_NAMED_ARGUMENT)
val ASSIGNMENT_TYPE_MISMATCH by error2<KtExpression, ConeKotlinType, ConeKotlinType>()
val RESULT_TYPE_MISMATCH by error2<KtExpression, ConeKotlinType, ConeKotlinType>()
@@ -319,7 +317,7 @@ object FirErrors {
val ONLY_ONE_CLASS_BOUND_ALLOWED by error0<KtTypeReference>()
val REPEATED_BOUND by error0<KtTypeReference>()
val CONFLICTING_UPPER_BOUNDS by error1<KtNamedDeclaration, FirTypeParameterSymbol>()
val NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER by error2<KtSimpleNameExpression, Name, FirDeclaration>()
val NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER by error2<KtSimpleNameExpression, Name, FirBasedSymbol<*>>()
val BOUND_ON_TYPE_ALIAS_PARAMETER_NOT_ALLOWED by error0<KtTypeReference>()
val REIFIED_TYPE_PARAMETER_NO_INLINE by error0<KtTypeParameter>(SourceElementPositioningStrategies.REIFIED_MODIFIER)
val TYPE_PARAMETERS_NOT_ALLOWED by error0<KtDeclaration>(SourceElementPositioningStrategies.TYPE_PARAMETERS_LIST)
@@ -336,7 +334,7 @@ object FirErrors {
val SMARTCAST_IMPOSSIBLE by error3<KtExpression, ConeKotlinType, FirExpression, String>()
// Reflection
val EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED by error1<KtExpression, FirCallableDeclaration>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED by error1<KtExpression, FirCallableSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val CALLABLE_REFERENCE_LHS_NOT_A_CLASS by error0<KtExpression>()
val CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR by error0<KtExpression>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val CLASS_LITERAL_LHS_NOT_A_CLASS by error0<KtExpression>()
@@ -344,34 +342,34 @@ object FirErrors {
val EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS by error1<PsiElement, ConeKotlinType>()
// overrides
val NOTHING_TO_OVERRIDE by error1<KtModifierListOwner, FirMemberDeclaration>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER)
val CANNOT_OVERRIDE_INVISIBLE_MEMBER by error2<KtNamedDeclaration, FirCallableDeclaration, FirCallableDeclaration>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER)
val DATA_CLASS_OVERRIDE_CONFLICT by error2<KtClassOrObject, FirCallableDeclaration, FirCallableDeclaration>(SourceElementPositioningStrategies.DATA_MODIFIER)
val CANNOT_WEAKEN_ACCESS_PRIVILEGE by error3<KtModifierListOwner, Visibility, FirCallableDeclaration, Name>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
val CANNOT_CHANGE_ACCESS_PRIVILEGE by error3<KtModifierListOwner, Visibility, FirCallableDeclaration, Name>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
val OVERRIDING_FINAL_MEMBER by error2<KtNamedDeclaration, FirCallableDeclaration, Name>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER)
val RETURN_TYPE_MISMATCH_ON_INHERITANCE by error2<KtClassOrObject, FirCallableDeclaration, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
val PROPERTY_TYPE_MISMATCH_ON_INHERITANCE by error2<KtClassOrObject, FirCallableDeclaration, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
val VAR_TYPE_MISMATCH_ON_INHERITANCE by error2<KtClassOrObject, FirCallableDeclaration, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
val RETURN_TYPE_MISMATCH_BY_DELEGATION by error2<KtClassOrObject, FirCallableDeclaration, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
val PROPERTY_TYPE_MISMATCH_BY_DELEGATION by error2<KtClassOrObject, FirCallableDeclaration, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
val VAR_OVERRIDDEN_BY_VAL_BY_DELEGATION by error2<KtClassOrObject, FirCallableDeclaration, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
val CONFLICTING_INHERITED_MEMBERS by error1<KtClassOrObject, List<FirCallableDeclaration>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val ABSTRACT_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClass, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
val ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClass, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER by error2<KtClassOrObject, FirClass, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING by warning2<KtClassOrObject, FirClass, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
val MANY_IMPL_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClass, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
val MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClass, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
val OVERRIDING_FINAL_MEMBER_BY_DELEGATION by error2<KtClassOrObject, FirCallableDeclaration, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
val DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE by warning2<KtClassOrObject, FirCallableDeclaration, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error2<KtNamedDeclaration, FirMemberDeclaration, FirMemberDeclaration>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error2<KtNamedDeclaration, FirMemberDeclaration, FirMemberDeclaration>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
val VAR_TYPE_MISMATCH_ON_OVERRIDE by error2<KtNamedDeclaration, FirMemberDeclaration, FirMemberDeclaration>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
val VAR_OVERRIDDEN_BY_VAL by error2<KtNamedDeclaration, FirMemberDeclaration, FirMemberDeclaration>(SourceElementPositioningStrategies.VAL_OR_VAR_NODE)
val NOTHING_TO_OVERRIDE by error1<KtModifierListOwner, FirCallableSymbol<*>>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER)
val CANNOT_OVERRIDE_INVISIBLE_MEMBER by error2<KtNamedDeclaration, FirCallableSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER)
val DATA_CLASS_OVERRIDE_CONFLICT by error2<KtClassOrObject, FirCallableSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DATA_MODIFIER)
val CANNOT_WEAKEN_ACCESS_PRIVILEGE by error3<KtModifierListOwner, Visibility, FirCallableSymbol<*>, Name>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
val CANNOT_CHANGE_ACCESS_PRIVILEGE by error3<KtModifierListOwner, Visibility, FirCallableSymbol<*>, Name>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
val OVERRIDING_FINAL_MEMBER by error2<KtNamedDeclaration, FirCallableSymbol<*>, Name>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER)
val RETURN_TYPE_MISMATCH_ON_INHERITANCE by error2<KtClassOrObject, FirCallableSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val PROPERTY_TYPE_MISMATCH_ON_INHERITANCE by error2<KtClassOrObject, FirCallableSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val VAR_TYPE_MISMATCH_ON_INHERITANCE by error2<KtClassOrObject, FirCallableSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val RETURN_TYPE_MISMATCH_BY_DELEGATION by error2<KtClassOrObject, FirCallableSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val PROPERTY_TYPE_MISMATCH_BY_DELEGATION by error2<KtClassOrObject, FirCallableSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val VAR_OVERRIDDEN_BY_VAL_BY_DELEGATION by error2<KtClassOrObject, FirCallableSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val CONFLICTING_INHERITED_MEMBERS by error1<KtClassOrObject, List<FirCallableSymbol<*>>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val ABSTRACT_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClassSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClassSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER by error2<KtClassOrObject, FirClassSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING by warning2<KtClassOrObject, FirClassSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val MANY_IMPL_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClassSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClassSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val OVERRIDING_FINAL_MEMBER_BY_DELEGATION by error2<KtClassOrObject, FirCallableSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE by warning2<KtClassOrObject, FirCallableSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error2<KtNamedDeclaration, FirCallableSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error2<KtNamedDeclaration, FirCallableSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
val VAR_TYPE_MISMATCH_ON_OVERRIDE by error2<KtNamedDeclaration, FirCallableSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
val VAR_OVERRIDDEN_BY_VAL by error2<KtNamedDeclaration, FirCallableSymbol<*>, FirCallableSymbol<*>>(SourceElementPositioningStrategies.VAL_OR_VAR_NODE)
val NON_FINAL_MEMBER_IN_FINAL_CLASS by warning0<KtNamedDeclaration>(SourceElementPositioningStrategies.OPEN_MODIFIER)
val NON_FINAL_MEMBER_IN_OBJECT by warning0<KtNamedDeclaration>(SourceElementPositioningStrategies.OPEN_MODIFIER)
val VIRTUAL_MEMBER_HIDDEN by error2<KtNamedDeclaration, FirMemberDeclaration, FirRegularClass>(SourceElementPositioningStrategies.DECLARATION_NAME)
val VIRTUAL_MEMBER_HIDDEN by error2<KtNamedDeclaration, FirCallableSymbol<*>, FirRegularClassSymbol>(SourceElementPositioningStrategies.DECLARATION_NAME)
// Redeclarations
val MANY_COMPANION_OBJECTS by error0<KtObjectDeclaration>(SourceElementPositioningStrategies.COMPANION_OBJECT)
@@ -384,11 +382,11 @@ object FirErrors {
val LOCAL_INTERFACE_NOT_ALLOWED by error1<KtNamedDeclaration, Name>(SourceElementPositioningStrategies.DECLARATION_NAME)
// Functions
val ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS by error2<KtFunction, FirMemberDeclaration, FirClass>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
val ABSTRACT_FUNCTION_WITH_BODY by error1<KtFunction, FirMemberDeclaration>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
val NON_ABSTRACT_FUNCTION_WITH_NO_BODY by error1<KtFunction, FirMemberDeclaration>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
val PRIVATE_FUNCTION_WITH_NO_BODY by error1<KtFunction, FirMemberDeclaration>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
val NON_MEMBER_FUNCTION_NO_BODY by error1<KtFunction, FirMemberDeclaration>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
val ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS by error2<KtFunction, FirCallableSymbol<*>, FirClassSymbol<*>>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
val ABSTRACT_FUNCTION_WITH_BODY by error1<KtFunction, FirCallableSymbol<*>>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
val NON_ABSTRACT_FUNCTION_WITH_NO_BODY by error1<KtFunction, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
val PRIVATE_FUNCTION_WITH_NO_BODY by error1<KtFunction, FirCallableSymbol<*>>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
val NON_MEMBER_FUNCTION_NO_BODY by error1<KtFunction, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
val FUNCTION_DECLARATION_WITH_NO_NAME by error0<KtFunction>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
val ANONYMOUS_FUNCTION_WITH_NAME by error0<KtFunction>()
val ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE by error0<KtParameter>(SourceElementPositioningStrategies.PARAMETER_DEFAULT_VALUE)
@@ -407,7 +405,7 @@ object FirErrors {
val FUN_INTERFACE_WITH_SUSPEND_FUNCTION by error0<KtDeclaration>(SourceElementPositioningStrategies.FUN_INTERFACE)
// Properties & accessors
val ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS by error2<KtModifierListOwner, FirMemberDeclaration, FirClass>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
val ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS by error2<KtModifierListOwner, FirCallableSymbol<*>, FirClassSymbol<*>>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
val PRIVATE_PROPERTY_IN_INTERFACE by error0<KtProperty>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
val ABSTRACT_PROPERTY_WITH_INITIALIZER by error0<KtExpression>()
val PROPERTY_INITIALIZER_IN_INTERFACE by error0<KtExpression>()
@@ -456,12 +454,12 @@ object FirErrors {
// Control flow diagnostics
val UNINITIALIZED_VARIABLE by error1<KtSimpleNameExpression, FirPropertySymbol>()
val UNINITIALIZED_PARAMETER by error1<KtSimpleNameExpression, FirVariableSymbol<FirValueParameter>>()
val UNINITIALIZED_ENUM_ENTRY by error1<KtSimpleNameExpression, FirVariableSymbol<FirEnumEntry>>()
val UNINITIALIZED_PARAMETER by error1<KtSimpleNameExpression, FirValueParameterSymbol>()
val UNINITIALIZED_ENUM_ENTRY by error1<KtSimpleNameExpression, FirEnumEntrySymbol>()
val UNINITIALIZED_ENUM_COMPANION by error1<KtSimpleNameExpression, FirRegularClassSymbol>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val VAL_REASSIGNMENT by error1<KtExpression, FirVariableSymbol<*>>()
val VAL_REASSIGNMENT_VIA_BACKING_FIELD by warning1<KtExpression, FirPropertySymbol>()
val VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR by error1<KtExpression, FirPropertySymbol>()
val VAL_REASSIGNMENT_VIA_BACKING_FIELD by warning1<KtExpression, FirBackingFieldSymbol>()
val VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR by error1<KtExpression, FirBackingFieldSymbol>()
val CAPTURED_VAL_INITIALIZATION by error1<KtExpression, FirPropertySymbol>()
val CAPTURED_MEMBER_VAL_INITIALIZATION by error1<KtExpression, FirPropertySymbol>()
val SETTER_PROJECTED_OUT by error1<KtBinaryExpression, FirPropertySymbol>(SourceElementPositioningStrategies.ASSIGNMENT_LHS)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt
+6 -9
View File
@@ -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<ConeKotlinType>()?.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
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirPropertyInitializationAnalyzer.kt
+2
View File
@@ -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,
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt
+6 -2
View File
@@ -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
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/ConeTypeCompatibilityChecker.kt
+33 -34
View File
@@ -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<ConeClassLikeType>,
lowerBounds: Set<ConeClassLikeType>,
compatibilityUpperBound: Compatibility,
checkedTypeParameters: MutableSet<FirTypeParameterRef> = mutableSetOf(),
checkedTypeParameters: MutableSet<FirTypeParameterSymbol> = mutableSetOf(),
): Compatibility {
val upperBoundClasses: Set<FirClassWithSuperClasses> = 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<FirTypeParameterRef, BoundTypeArguments>().apply {
val typeArgumentMapping = mutableMapOf<FirTypeParameterSymbol, BoundTypeArguments>().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<FirTypeParameterRef, BoundTypeArguments>.collectTypeArgumentMapping(
private fun MutableMap<FirTypeParameterSymbol, BoundTypeArguments>.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<FirTypeParameterRef, BoundTypeArgument> = emptyMap(),
envMapping: Map<FirTypeParameterSymbol, BoundTypeArgument> = emptyMap(),
): TypeArgumentMapping? {
val typeParameterOwner = getClassLikeElement(ctx) ?: return null
val mapping = buildMap<FirTypeParameterRef, BoundTypeArgument> {
val mapping = buildMap<FirTypeParameterSymbol, BoundTypeArgument> {
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<FirTypeParameterRef, BoundTypeArguments>.collect(
private fun MutableMap<FirTypeParameterSymbol, BoundTypeArguments>.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<ConeClassLikeType> {
private fun FirClassLikeSymbol<*>.getSuperTypes(): List<ConeClassLikeType> {
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<FirTypeParameterRef, BoundTypeArgument>
val typeParameterOwner: FirClassLikeSymbol<*>,
val mapping: Map<FirTypeParameterSymbol, BoundTypeArgument>
)
/** 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<FirClassWithSuperClasses> 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")
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt
+15 -4
View File
@@ -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<KotlinTarget> {
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
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt
+19 -18
View File
@@ -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<ConeLookupTagBasedType>()
?.lookupTag
?.toSymbol(session)
?.fir
private val CONVERSION_NAMES = listOf(
"toInt", "toLong", "toShort", "toByte", "toFloat", "toDouble", "toChar", "toBoolean"
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt
+128 -87
View File
@@ -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<ConeClassLikeType>()?.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<FirClass>): Boolean {
for (it in other.superTypeRefs) {
val candidate = it.firClassLike(session)
?.followAllAlias(session)
?.safeAs<FirClass>()
fun FirClassSymbol<*>.isSupertypeOf(other: FirClassSymbol<*>, exclude: MutableSet<FirClassSymbol<*>>): 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<FirClassSymbol<*>>()?.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<FirRegularClassSymbol>()?.fir
}
/**
* Returns the FirRegularClass associated with this
* or null of something goes wrong.
*/
fun ConeKotlinType.toRegularClass(session: FirSession): FirRegularClass? {
return safeAs<ConeClassLikeType>()?.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<FirCallableDeclaration>()?.containingClass()?.toSymbol(context.session)
fun FirDeclaration.getContainingClassSymbol(session: FirSession): FirClassLikeSymbol<*>? =
this.safeAs<FirCallableDeclaration>()?.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<ConeClassLikeType>()
?.toSymbol(useSiteSession) as? FirClassLikeSymbol<*>)?.fullyExpandedClass(useSiteSession)
else -> null
}
return it
}
/**
@@ -184,7 +178,7 @@ fun FirSimpleFunction.overriddenFunctions(
)
val overriddenFunctions = mutableListOf<FirFunctionSymbol<*>>()
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<ConeClassLikeType>()?.lookupTag ?: continue
val fir = lookupTag.toSymbol(context.session)
?.fir.safeAs<FirClass>()
?: 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<FirCallableDeclaration>()?.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<FirEnumEntrySymbol> {
assert(classKind == ClassKind.ENUM_CLASS)
return declarationSymbols.filterIsInstance<FirEnumEntrySymbol>()
}
val FirClassLikeSymbol<*>.classKind: ClassKind?
get() = (this as? FirClassSymbol<*>)?.classKind
val FirBasedSymbol<*>.typeParameterSymbols: List<FirTypeParameterSymbol>?
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 <T> 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<ConeKotlinType>()
?.contains { (it.lowerBoundIfFlexible() as? ConeTypeParameterType)?.lookupTag == typeParameterSymbol.toLookupTag() } != false
if (valueParameterSymbols.any { it.resolvedReturnTypeRef.isBadType() } || resolvedReceiverTypeRef?.isBadType() == true) return false
return true
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirInconsistentTypeParameterHelpers.kt
+12 -12
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.types.AbstractTypeChecker
fun checkInconsistentTypeParameters(
firTypeRefClasses: List<Pair<FirTypeRef?, FirRegularClass>>,
firTypeRefClasses: List<Pair<FirTypeRef?, FirRegularClassSymbol>>,
context: CheckerContext,
reporter: DiagnosticReporter,
source: FirSourceElement?,
@@ -55,7 +55,7 @@ fun checkInconsistentTypeParameters(
}
private fun buildDeepSubstitutionMultimap(
firTypeRefClasses: List<Pair<FirTypeRef?, FirRegularClass>>,
firTypeRefClasses: List<Pair<FirTypeRef?, FirRegularClassSymbol>>,
context: CheckerContext,
): Map<FirTypeParameterSymbol, ClassSymbolAndProjections> {
val result = mutableMapOf<FirTypeParameterSymbol, ClassSymbolAndProjections>()
@@ -63,10 +63,10 @@ private fun buildDeepSubstitutionMultimap(
val session = context.session
val typeContext = session.typeContext
fun fillInDeepSubstitutor(typeArguments: Array<out ConeTypeProjection>?, firClass: FirRegularClass) {
fun fillInDeepSubstitutor(typeArguments: Array<out ConeTypeProjection>?, 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<ConeKotlinType>
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<ConeKotlinType>
)
)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirSinceKotlinHelpers.kt
+11 -2
View File
@@ -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
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirUpperBoundViolatedHelpers.kt
+6 -9
View File
@@ -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)
}
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationClassDeclarationChecker.kt
+2 -2
View File
@@ -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
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirClassVarianceChecker.kt
+9 -9
View File
@@ -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
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCommonConstructorDelegationIssuesChecker.kt
+11 -5
View File
@@ -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<FirConstructor>()
var hasPrimaryConstructor = false
@@ -91,8 +93,12 @@ object FirCommonConstructorDelegationIssuesChecker : FirRegularClassChecker() {
return null
}
private fun FirConstructor.getDelegated(): FirConstructor? = delegatedConstructor
?.calleeReference.safeAs<FirResolvedNamedReference>()
?.resolvedSymbol
?.fir as? FirConstructor?
private fun FirConstructor.getDelegated(): FirConstructor? {
this.symbol.ensureResolved(FirResolvePhase.BODY_RESOLVE)
val delegatedConstructorSymbol = delegatedConstructor
?.calleeReference.safeAs<FirResolvedNamedReference>()
?.resolvedSymbol
@OptIn(SymbolInternals::class)
return delegatedConstructorSymbol?.fir as? FirConstructor
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsChecker.kt
+6
View File
@@ -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(
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCyclicTypeBoundsChecker.kt
+4 -3
View File
@@ -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<Name>()
val cycles = mutableSetOf<Name>()
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<Name>()
@@ -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<FirTypeRef> =
if (this is FirErrorTypeRef && diagnostic is ConeCyclicTypeBound) {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerUtils.kt
+22 -2
View File
@@ -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
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt
+13 -8
View File
@@ -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<ConeKotlinType>()
is FirExpression -> originalDestructuringDeclarationOrInitializer.typeRef.coneTypeSafe<ConeKotlinType>()
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
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityDeclarationChecker.kt
+86 -96
View File
@@ -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<ConeClassLikeType>() ?: 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<ConeKotlinType>()
?.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<ConeKotlinType>()
?.findVisibilityExposure(context, functionVisibility)
if (restricting != null) {
declaration.returnTypeRef.coneTypeSafe<ConeKotlinType>()
?.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<ConeKotlinType>()
?.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<ConeKotlinType>()
?.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<ConeKotlinType>()
?.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<FirBasedSymbol<*>, 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 -> {
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirFunInterfaceDeclarationChecker.kt
+16 -14
View File
@@ -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,
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirFunctionParameterChecker.kt
+5 -2
View File
@@ -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.
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirImplementationMismatchChecker.kt
+30 -31
View File
@@ -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<FirCallableDeclaration>()
var delegation: FirCallableSymbol<*>? = null
val implementations = mutableListOf<FirCallableSymbol<*>>()
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<FirCallableDeclaration, FirCallableDeclaration>? = null
var someClash: Pair<FirCallableSymbol<*>, 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<FirSimpleFunction>()
val allFunctions = mutableListOf<FirNamedFunctionSymbol>()
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)
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirImportsChecker.kt
+20 -15
View File
@@ -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 {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInapplicableLateinitChecker.kt
+1 -1
View File
@@ -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
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineClassDeclarationChecker.kt
+14 -11
View File
@@ -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<ConeKotlinType>, 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 {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt
+39 -45
View File
@@ -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<FirValueParameter>,
val inalienableParameters: List<FirValueParameterSymbol>,
val session: FirSession,
val reporter: DiagnosticReporter
) : FirDefaultVisitor<Unit, CheckerContext>() {
@@ -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
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirKClassWithIncorrectTypeArgumentChecker.kt
+6 -6
View File
@@ -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
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirMemberFunctionsChecker.kt
+6 -5
View File
@@ -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)
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirMemberPropertiesChecker.kt
+4 -4
View File
@@ -39,7 +39,7 @@ object FirMemberPropertiesChecker : FirClassChecker() {
mutableMapOf<FirPropertySymbol, EventOccurrencesRange>().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
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirNotImplementedOverrideChecker.kt
+25 -28
View File
@@ -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<FirCallableSymbol<*>>()
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
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt
+83 -67
View File
@@ -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<FirCallableSymbol<*>> {
return when (member) {
is FirSimpleFunction -> {
processFunctionsByName(member.name) {}
getDirectOverriddenFunctions(member.symbol)
private fun FirTypeScope.retrieveDirectOverriddenOf(memberSymbol: FirCallableSymbol<*>): List<FirCallableSymbol<*>> {
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<FirTypeParametersOwner>()
?: return this
val baseTypeParameters = baseDeclaration.typeParameterSymbols
val map = mutableMapOf<FirTypeParameterSymbol, ConeKotlinType>()
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<FirCallableSymbol<*>>,
): 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<FirCallableSymbol<*>>,
): 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<FirCallableSymbol<*>>,
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<FirCallableSymbol<*>>,
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)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPrimaryConstructorSuperTypeChecker.kt
+4 -4
View File
@@ -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)
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirProjectionRelationChecker.kt
+4 -6
View File
@@ -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<ConeClassLikeType>()
val fullyExpandedType = type?.fullyExpandedType(context.session) ?: return
val declaration = fullyExpandedType.toSymbol(context.session)?.fir.safeAs<FirRegularClass>() ?: 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<FirTypeParameterRef>()
?.symbol?.fir
?.variance
val protoVariance = proto.variance
val projectionRelation = if (fullyExpandedProjection is ConeKotlinTypeConflictingProjection ||
actual is ConeKotlinTypeProjectionIn && protoVariance == Variance.OUT_VARIANCE ||
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirSealedSupertypeChecker.kt
+6 -10
View File
@@ -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<FirRegularClass>()
?: 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<FirRegularClass>()
?: 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
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirSupertypesChecker.kt
+10 -10
View File
@@ -47,13 +47,13 @@ object FirSupertypesChecker : FirClassChecker() {
extensionFunctionSupertypeReported = true
}
val lookupTag = coneType.safeAs<ConeClassLikeType>()?.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)
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTopLevelFunctionsChecker.kt
+1 -1
View File
@@ -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)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeConstraintsChecker.kt
+1 -1
View File
@@ -24,7 +24,7 @@ object FirTypeConstraintsChecker : FirBasicDeclarationChecker() {
constraint.source,
FirErrors.NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER,
constraint.name,
declaration,
declaration.symbol,
context
)
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeParameterBoundsChecker.kt
+13 -12
View File
@@ -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<FirRegularClass>()
val seenClasses = mutableSetOf<FirRegularClassSymbol>()
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<Pair<FirTypeRef, FirRegularClass>>()
val firRegularClassesSet = mutableSetOf<FirRegularClass>()
val firTypeRefClasses = mutableListOf<Pair<FirTypeRef, FirRegularClassSymbol>>()
val firRegularClassesSet = mutableSetOf<FirRegularClassSymbol>()
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))
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCallableReferenceChecker.kt
+12 -11
View File
@@ -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)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCatchParameterChecker.kt
+1 -1
View File
@@ -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)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt
+10 -4
View File
@@ -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 <T: Any> 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<FirTypeParameter>()?.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 <T> 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
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirConstructorCallChecker.kt
+2 -2
View File
@@ -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) {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirDeprecationChecker.kt
+20 -14
View File
@@ -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<FirConstructor>()?.returnTypeRef
?.toRegularClass(context.session)
symbol.getDeprecation(callSite),
symbol.safeAs<FirConstructorSymbol>()
?.resolvedReturnTypeRef
?.toRegularClassSymbol(context.session)
?.getDeprecation(callSite)
)
return deprecationInfos.maxOrNull()
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirForLoopChecker.kt
+2 -3
View File
@@ -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
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirFunInterfaceConstructorReferenceChecker.kt
+6 -5
View File
@@ -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)
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNotASupertypeChecker.kt
+4 -4
View File
@@ -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<FirSuperReference>()?.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)
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInAnnotationCallChecker.kt
+2 -2
View File
@@ -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)
}
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt
+13 -3
View File
@@ -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)
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirQualifiedSupertypeExtendedByOtherSupertypeChecker.kt
+8 -8
View File
@@ -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<FirClass>()
.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<FirClass>()
val that = it.toClassLikeSymbol(context.session)
?.fullyExpandedClass(context.session) as? FirClassSymbol<*>
?: continue
val isSupertype = explicitType.isSupertypeOf(that, context.session)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSealedClassConstructorCallChecker.kt
+10 -9
View File
@@ -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<FirResolvedNamedReference>()
?.resolvedSymbol
?.fir.safeAs<FirConstructor>()
val constructorSymbol = expression.calleeReference.safeAs<FirResolvedNamedReference>()
?.resolvedSymbol as? FirConstructorSymbol
?: return
val typeFir = constructorFir.returnTypeRef.coneType
val typeSymbol = constructorSymbol.resolvedReturnTypeRef.coneType
.fullyExpandedType(context.session)
.safeAs<ConeClassLikeType>()
?.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)
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirStandaloneQualifierChecker.kt
+2 -2
View File
@@ -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() {
}
}
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuperclassNotAccessibleFromInterfaceChecker.kt
+2 -2
View File
@@ -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)
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUninitializedEnumChecker.kt
+13 -9
View File
@@ -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<FirPropertySymbol>()
@@ -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
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUpperBoundViolatedExpressionChecker.kt
+13 -11
View File
@@ -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<FirResolvedNamedReference>()?.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<Any>? = null
var typeArgumentRefsAndSources: List<FirTypeRefSource?>? = 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<FirRegularClass>()
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(
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUselessTypeOperationCallChecker.kt
+4 -4
View File
@@ -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)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirValReassignmentChecker.kt
+9 -9
View File
@@ -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<FirPropertyAccessor> { it.isGetter } ?: return
if (property.getter != closestGetter) return
val propertySymbol = backingFieldReference.resolvedSymbol
if (propertySymbol.isVar) return
val closestGetter = context.findClosest<FirPropertyAccessor> { 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)
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/CanBeValChecker.kt
+5 -5
View File
@@ -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<CFGNode<*>, 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
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantVisibilityModifierSyntaxChecker.kt
+5 -19
View File
@@ -75,7 +75,7 @@ object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<Fi
}
this is FirConstructor -> {
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<Fi
val overriddenFunctions = function.overriddenFunctions(currentClass, context)
var visibility: Visibility = Visibilities.Private
for (func in overriddenFunctions) {
val currentVisibility = func.fir.visibility()
if (currentVisibility != null) {
val compareResult = Visibilities.compare(currentVisibility, visibility)
if (compareResult != null && compareResult > 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
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt
+15 -6
View File
@@ -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
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirDeprecatedTypeChecker.kt
+2 -5
View File
@@ -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<FirPropertyAccessor>() != null) return
val resolved = typeRef.coneTypeSafe<ConeClassLikeType>() ?: 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)
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt
+26 -28
View File
@@ -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")
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt
+18 -28
View File
@@ -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<FirBasedSymbol<*>> ->
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt
+9 -10
View File
@@ -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,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/deprecationUtils.kt
+9 -5
View File
@@ -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<Deprecation>()
when (this) {
is FirProperty ->
is FirPropertySymbol ->
if (callSite is FirVariableAssignment) {
deprecationInfos.addIfNotNull(
getDeprecationForCallSite(AnnotationUseSiteTarget.PROPERTY_SETTER, AnnotationUseSiteTarget.PROPERTY)
@@ -75,12 +79,12 @@ fun List<FirAnnotationCall>.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)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt
+2 -1
View File
@@ -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,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt
+2 -2
View File
@@ -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)
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirInvokeResolveTowerExtension.kt
+2 -1
View File
@@ -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
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt
+1 -1
View File
@@ -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 <T> materialize(): T
fun FirFunction.isFunctionForExpectTypeFromCastFeature(): Boolean {
internal fun FirFunction.isFunctionForExpectTypeFromCastFeature(): Boolean {
val typeParameter = typeParameters.singleOrNull() ?: return false
val returnType = returnTypeRef.coneTypeSafe<ConeKotlinType>() ?: return false
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt
+8
View File
@@ -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
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt
+1 -1
View File
@@ -571,7 +571,7 @@ class SupertypeComputationSession {
}
}
fun FirTypeRef.firClassLike(session: FirSession): FirClassLikeDeclaration? {
internal fun FirTypeRef.firClassLike(session: FirSession): FirClassLikeDeclaration? {
val type = coneTypeSafe<ConeClassLikeType>() ?: return null
return type.lookupTag.toSymbol(session)?.fir
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt
+5
View File
@@ -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 {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt
+1 -1
View File
@@ -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,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FirKotlinScopeProvider.kt
+9
View File
@@ -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,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDeclaredMemberScopeProvider.kt
+5
View File
@@ -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<Name>,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDelegatedMemberScope.kt
+6
View File
@@ -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<D : FirCallableDeclaration>(
val wrapped: D,
@@ -211,6 +214,9 @@ class DelegatedWrapperData<D : FirCallableDeclaration>(
var <D : FirCallableDeclaration>
D.delegatedWrapperData: DelegatedWrapperData<D>? by FirDeclarationDataRegistry.data(DelegatedWrapperDataKey)
val <D : FirCallableDeclaration> FirCallableSymbol<out D>.delegatedWrapperData: DelegatedWrapperData<D>?
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"
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt
+4 -1
View File
@@ -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<Name> = 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)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/ClassMembers.kt
+7 -3
View File
@@ -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 <reified D : FirCallableDeclaration> D.originalForSubstitutionOverride: D?
get() = if (isSubstitutionOverride) originalForSubstitutionOverrideAttr else null
compiler/fir/tree/src/org/jetbrains/kotlin/fir/Primitives.kt
+17
View File
@@ -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<ClassId> = setOf(
StandardClassIds.Double, StandardClassIds.Float, StandardClassIds.Long, StandardClassIds.Int,
StandardClassIds.Short, StandardClassIds.Byte
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirSymbolStatusUtils.kt
+1
View File
@@ -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 ----------------------
compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/CommonDiagnostics.kt
+3 -1
View File
@@ -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()
compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt
+6
View File
@@ -20,6 +20,12 @@ sealed class FirClassLikeSymbol<D : FirClassLikeDeclaration>(
) : FirClassifierSymbol<D>() {
abstract override fun toLookupTag(): ConeClassLikeLookupTag
val deprecation: DeprecationsPerUseSite?
get() {
ensureResolved(FirResolvePhase.STATUS)
return fir.deprecation
}
override fun toString(): String = "${this::class.simpleName} ${classId.asString()}"
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFunctionSymbol.kt
+4 -1
View File
@@ -47,7 +47,10 @@ class FirIntersectionOverrideFunctionSymbol(
class FirConstructorSymbol(
callableId: CallableId
) : FirFunctionSymbol<FirConstructor>(callableId)
) : FirFunctionSymbol<FirConstructor>(callableId) {
val isPrimary: Boolean
get() = fir.isPrimary
}
open class FirAccessorSymbol(
callableId: CallableId,
compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt
+2
View File
@@ -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(
compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirScopeDumpHandler.kt
+2
View File
@@ -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()
compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt
+2
View File
@@ -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"
idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/HLDiagnosticConverter.kt
+24 -1
View File
@@ -137,7 +137,7 @@ private object FirToKtConversionCreator {
private val typeMapping: Map<KClass<*>, 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(),
idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirReferenceShortener.kt
+2 -2
View File
@@ -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) =
idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt
+105 -106
View File
@@ -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,
)
idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt
+20 -21
View File
@@ -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<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
abstract class QualifiedSupertypeExtendedByOtherSupertype : KtFirDiagnostic<KtTypeReference>() {
override val diagnosticClass get() = QualifiedSupertypeExtendedByOtherSupertype::class
abstract val otherSuperType: KtClassLikeSymbol
abstract val otherSuperType: KtSymbol
}
abstract class SupertypeInitializedInInterface : KtFirDiagnostic<KtTypeReference>() {
@@ -1152,7 +1151,7 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
abstract class NothingToOverride : KtFirDiagnostic<KtModifierListOwner>() {
override val diagnosticClass get() = NothingToOverride::class
abstract val declaration: KtSymbol
abstract val declaration: KtCallableSymbol
}
abstract class CannotOverrideInvisibleMember : KtFirDiagnostic<KtNamedDeclaration>() {
@@ -1278,26 +1277,26 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
abstract class ReturnTypeMismatchOnOverride : KtFirDiagnostic<KtNamedDeclaration>() {
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<KtNamedDeclaration>() {
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<KtNamedDeclaration>() {
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<KtNamedDeclaration>() {
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<KtNamedDeclaration>() {
@@ -1310,8 +1309,8 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
abstract class VirtualMemberHidden : KtFirDiagnostic<KtNamedDeclaration>() {
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<KtObjectDeclaration>() {
@@ -1344,28 +1343,28 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
abstract class AbstractFunctionInNonAbstractClass : KtFirDiagnostic<KtFunction>() {
override val diagnosticClass get() = AbstractFunctionInNonAbstractClass::class
abstract val function: KtSymbol
abstract val function: KtCallableSymbol
abstract val containingClass: KtClassLikeSymbol
}
abstract class AbstractFunctionWithBody : KtFirDiagnostic<KtFunction>() {
override val diagnosticClass get() = AbstractFunctionWithBody::class
abstract val function: KtSymbol
abstract val function: KtCallableSymbol
}
abstract class NonAbstractFunctionWithNoBody : KtFirDiagnostic<KtFunction>() {
override val diagnosticClass get() = NonAbstractFunctionWithNoBody::class
abstract val function: KtSymbol
abstract val function: KtCallableSymbol
}
abstract class PrivateFunctionWithNoBody : KtFirDiagnostic<KtFunction>() {
override val diagnosticClass get() = PrivateFunctionWithNoBody::class
abstract val function: KtSymbol
abstract val function: KtCallableSymbol
}
abstract class NonMemberFunctionNoBody : KtFirDiagnostic<KtFunction>() {
override val diagnosticClass get() = NonMemberFunctionNoBody::class
abstract val function: KtSymbol
abstract val function: KtCallableSymbol
}
abstract class FunctionDeclarationWithNoName : KtFirDiagnostic<KtFunction>() {
@@ -1427,7 +1426,7 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
abstract class AbstractPropertyInNonAbstractClass : KtFirDiagnostic<KtModifierListOwner>() {
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<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
abstract class UninitializedParameter : KtFirDiagnostic<KtSimpleNameExpression>() {
override val diagnosticClass get() = UninitializedParameter::class
abstract val parameter: KtVariableLikeSymbol
abstract val parameter: KtSymbol
}
abstract class UninitializedEnumEntry : KtFirDiagnostic<KtSimpleNameExpression>() {
override val diagnosticClass get() = UninitializedEnumEntry::class
abstract val enumEntry: KtVariableLikeSymbol
abstract val enumEntry: KtSymbol
}
abstract class UninitializedEnumCompanion : KtFirDiagnostic<KtSimpleNameExpression>() {
idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt
+20 -21
View File
@@ -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<KtTypeReference> {
@@ -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<KtModifierListOwner> {
@@ -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<KtNamedDeclaration> {
@@ -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<KtNamedDeclaration> {
@@ -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<KtNamedDeclaration> {
@@ -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<KtNamedDeclaration> {
@@ -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<KtNamedDeclaration> {
@@ -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<KtFunction> {
@@ -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<KtFunction> {
@@ -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<KtFunction> {
@@ -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<KtFunction> {
@@ -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<KtSimpleNameExpression> {
@@ -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<KtSimpleNameExpression> {
idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirOverrideInfoProvider.kt
+3 -2
View File
@@ -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)
}
}
}