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

[FIR] Add symbol to all declarations. Get rid of FirSymbolOwner

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2021-06-20 11:42:52 +03:00
parent 39cd1c8504
commit b3e5c6e079
254 changed files with 1305 additions and 1297 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/java/JavaClassRendering.kt
+1 -1
View File
@@ -26,7 +26,7 @@ fun renderJavaClass(renderer: FirRenderer, javaClass: FirJavaClass, session: Fir
renderer.visitMemberDeclaration(javaClass)
renderer.renderSupertypes(javaClass)
renderer.renderInBraces {
val renderedDeclarations = mutableListOf<FirDeclaration>()
val renderedDeclarations = mutableListOf<FirDeclaration<*>>()
fun renderAndCache(symbol: FirCallableSymbol<*>) {
val enhanced = symbol.fir
compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt
+3 -3
View File
@@ -51,8 +51,8 @@ fun main(args: Array<String>) {
val declarationPackage = "$basePackage.checkers.declaration"
generateCheckersComponents(generationPath, declarationPackage, "FirDeclarationChecker") {
alias<FirDeclaration>("BasicDeclarationChecker")
alias<FirMemberDeclaration>("MemberDeclarationChecker")
alias<FirDeclaration<*>>("BasicDeclarationChecker")
alias<FirMemberDeclaration<*>>("MemberDeclarationChecker")
alias<FirFunction<*>>("FunctionChecker")
alias<FirSimpleFunction>("SimpleFunctionChecker")
alias<FirProperty>("PropertyChecker")
@@ -61,7 +61,7 @@ fun main(args: Array<String>) {
alias<FirConstructor>("ConstructorChecker")
alias<FirFile>("FileChecker")
alias<FirTypeParameter>("FirTypeParameterChecker")
alias<FirAnnotatedDeclaration>("FirAnnotatedDeclarationChecker")
alias<FirAnnotatedDeclaration<*>>("FirAnnotatedDeclarationChecker")
additional(
fieldName = "controlFlowAnalyserCheckers",
compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt
+18 -18
View File
@@ -482,7 +482,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<FirDeclaration<*>>("typeParametersOwner")
}
val BOUND_ON_TYPE_ALIAS_PARAMETER_NOT_ALLOWED by error<KtTypeReference>()
@@ -554,7 +554,7 @@ 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<FirMemberDeclaration<*>>("declaration")
}
val CANNOT_WEAKEN_ACCESS_PRIVILEGE by error<KtModifierListOwner>(PositioningStrategy.VISIBILITY_MODIFIER) {
@@ -607,25 +607,25 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
}
val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error<KtNamedDeclaration>(PositioningStrategy.DECLARATION_RETURN_TYPE) {
parameter<FirMemberDeclaration>("function")
parameter<FirMemberDeclaration>("superFunction")
parameter<FirMemberDeclaration<*>>("function")
parameter<FirMemberDeclaration<*>>("superFunction")
}
val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error<KtNamedDeclaration>(PositioningStrategy.DECLARATION_RETURN_TYPE) {
parameter<FirMemberDeclaration>("property")
parameter<FirMemberDeclaration>("superProperty")
parameter<FirMemberDeclaration<*>>("property")
parameter<FirMemberDeclaration<*>>("superProperty")
}
val VAR_TYPE_MISMATCH_ON_OVERRIDE by error<KtNamedDeclaration>(PositioningStrategy.DECLARATION_RETURN_TYPE) {
parameter<FirMemberDeclaration>("variable")
parameter<FirMemberDeclaration>("superVariable")
parameter<FirMemberDeclaration<*>>("variable")
parameter<FirMemberDeclaration<*>>("superVariable")
}
val VAR_OVERRIDDEN_BY_VAL by error<KtNamedDeclaration>(PositioningStrategy.VAL_OR_VAR_NODE) {
parameter<FirMemberDeclaration>("overridingDeclaration")
parameter<FirMemberDeclaration>("overriddenDeclaration")
parameter<FirMemberDeclaration<*>>("overridingDeclaration")
parameter<FirMemberDeclaration<*>>("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<FirMemberDeclaration<*>>("declared")
parameter<FirRegularClass>("overriddenContainer")
}
}
@@ -652,21 +652,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<FirMemberDeclaration<*>>("function")
parameter<FirClass<*>>("containingClass")
}
val ABSTRACT_FUNCTION_WITH_BODY by error<KtFunction>(PositioningStrategy.MODALITY_MODIFIER) {
parameter<FirMemberDeclaration>("function")
parameter<FirMemberDeclaration<*>>("function")
}
val NON_ABSTRACT_FUNCTION_WITH_NO_BODY by error<KtFunction>(PositioningStrategy.DECLARATION_SIGNATURE) {
parameter<FirMemberDeclaration>("function")
parameter<FirMemberDeclaration<*>>("function")
}
val PRIVATE_FUNCTION_WITH_NO_BODY by error<KtFunction>(PositioningStrategy.VISIBILITY_MODIFIER) {
parameter<FirMemberDeclaration>("function")
parameter<FirMemberDeclaration<*>>("function")
}
val NON_MEMBER_FUNCTION_NO_BODY by error<KtFunction>(PositioningStrategy.DECLARATION_SIGNATURE) {
parameter<FirMemberDeclaration>("function")
parameter<FirMemberDeclaration<*>>("function")
}
val FUNCTION_DECLARATION_WITH_NO_NAME by error<KtFunction>(PositioningStrategy.DECLARATION_SIGNATURE)
@@ -696,7 +696,7 @@ 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<FirMemberDeclaration<*>>("property")
parameter<FirClass<*>>("containingClass")
}
val PRIVATE_PROPERTY_IN_INTERFACE by error<KtProperty>(PositioningStrategy.VISIBILITY_MODIFIER)
@@ -1032,7 +1032,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
private val exposedVisibilityDiagnosticInit: DiagnosticBuilder.() -> Unit = {
parameter<EffectiveVisibility>("elementVisibility")
parameter<FirMemberDeclaration>("restrictingDeclaration")
parameter<FirMemberDeclaration<*>>("restrictingDeclaration")
parameter<EffectiveVisibility>("restrictingVisibility")
}
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/JvmDeclarationCheckers.kt
+2 -1
View File
@@ -5,7 +5,8 @@
package org.jetbrains.kotlin.fir.analysis.jvm.checkers
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.*
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.DeclarationCheckers
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirMemberDeclarationChecker
import org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration.FirJvmExternalDeclarationChecker
object JvmDeclarationCheckers : DeclarationCheckers() {
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmExternalDeclarationChecker.kt
+1 -1
View File
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.lexer.KtTokens
object FirJvmExternalDeclarationChecker : FirMemberDeclarationChecker() {
override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
if (!declaration.isExternal) return
val source = declaration.source ?: return
if (source.kind is FirFakeSourceElementKind) return
compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerAliases.kt
+3 -3
View File
@@ -22,8 +22,8 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
typealias FirBasicDeclarationChecker = FirDeclarationChecker<FirDeclaration>
typealias FirMemberDeclarationChecker = FirDeclarationChecker<FirMemberDeclaration>
typealias FirBasicDeclarationChecker = FirDeclarationChecker<FirDeclaration<*>>
typealias FirMemberDeclarationChecker = FirDeclarationChecker<FirMemberDeclaration<*>>
typealias FirFunctionChecker = FirDeclarationChecker<FirFunction<*>>
typealias FirSimpleFunctionChecker = FirDeclarationChecker<FirSimpleFunction>
typealias FirPropertyChecker = FirDeclarationChecker<FirProperty>
@@ -32,4 +32,4 @@ typealias FirRegularClassChecker = FirDeclarationChecker<FirRegularClass>
typealias FirConstructorChecker = FirDeclarationChecker<FirConstructor>
typealias FirFileChecker = FirDeclarationChecker<FirFile>
typealias FirTypeParameterChecker = FirDeclarationChecker<FirTypeParameter>
typealias FirAnnotatedDeclarationChecker = FirDeclarationChecker<FirAnnotatedDeclaration>
typealias FirAnnotatedDeclarationChecker = FirDeclarationChecker<FirAnnotatedDeclaration<*>>
compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
+22 -22
View File
@@ -218,15 +218,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, 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>()
// Modifiers
val INAPPLICABLE_INFIX_MODIFIER by error0<PsiElement>()
@@ -313,7 +313,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, FirDeclaration<*>>()
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)
@@ -338,7 +338,7 @@ 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 NOTHING_TO_OVERRIDE by error1<KtModifierListOwner, FirMemberDeclaration<*>>(SourceElementPositioningStrategies.OVERRIDE_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)
@@ -350,13 +350,13 @@ object FirErrors {
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 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 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, FirMemberDeclaration<*>, FirRegularClass>(SourceElementPositioningStrategies.DECLARATION_NAME)
// Redeclarations
val MANY_COMPANION_OBJECTS by error0<KtObjectDeclaration>(SourceElementPositioningStrategies.COMPANION_OBJECT)
@@ -369,11 +369,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, 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 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)
@@ -392,7 +392,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, FirMemberDeclaration<*>, FirClass<*>>(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>()
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/FirCheckersResolveProcessor.kt
+2 -3
View File
@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollector
import org.jetbrains.kotlin.fir.analysis.collectors.FirDiagnosticsCollector
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporterFactory
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
@@ -30,9 +29,9 @@ class FirCheckersRunnerTransformer(private val diagnosticCollector: AbstractDiag
return element
}
override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration {
override fun transformFile(file: FirFile, data: Nothing?): FirFile {
val reporter = DiagnosticReporterFactory.createReporter()
diagnosticCollector.collectDiagnostics(file, reporter)
return file
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt
+1 -1
View File
@@ -11,10 +11,10 @@ import org.jetbrains.kotlin.fir.analysis.cfa.FirPropertyInitializationAnalyzer
import org.jetbrains.kotlin.fir.analysis.cfa.FirReturnsImpliesAnalyzer
import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.*
import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirReservedUnderscoreDeclarationChecker
import org.jetbrains.kotlin.fir.analysis.checkers.syntax.FirDelegationInInterfaceSyntaxChecker
import org.jetbrains.kotlin.fir.analysis.checkers.syntax.FirFunctionTypeParametersSyntaxChecker
import org.jetbrains.kotlin.fir.analysis.checkers.syntax.FirTypeParameterSyntaxChecker
import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirReservedUnderscoreDeclarationChecker
object CommonDeclarationCheckers : DeclarationCheckers() {
override val basicDeclarationCheckers: Set<FirBasicDeclarationChecker>
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/ExtendedDeclarationCheckers.kt
+4 -1
View File
@@ -7,7 +7,10 @@ package org.jetbrains.kotlin.fir.analysis.checkers
import org.jetbrains.kotlin.fir.analysis.cfa.AbstractFirPropertyInitializationChecker
import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.*
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.DeclarationCheckers
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirMemberDeclarationChecker
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirSimpleFunctionChecker
import org.jetbrains.kotlin.fir.analysis.checkers.extended.*
object ExtendedDeclarationCheckers : DeclarationCheckers() {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt
+2 -2
View File
@@ -60,11 +60,11 @@ fun FirRegularClass.getAllowedAnnotationTargets(): Set<KotlinTarget> {
}
}
fun FirAnnotatedDeclaration.getRetentionAnnotation(): FirAnnotationCall? {
fun FirAnnotatedDeclaration<*>.getRetentionAnnotation(): FirAnnotationCall? {
return getAnnotationByFqName(StandardNames.FqNames.retention)
}
fun FirAnnotatedDeclaration.getTargetAnnotation(): FirAnnotationCall? {
fun FirAnnotatedDeclaration<*>.getTargetAnnotation(): FirAnnotationCall? {
return getAnnotationByFqName(StandardNames.FqNames.target)
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt
+4 -5
View File
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.analysis.checkers
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
@@ -39,7 +38,7 @@ internal fun checkConstantArguments(
}
expression is FirConstExpression<*>
|| expressionSymbol is FirEnumEntry
|| (expressionSymbol as? FirMemberDeclaration)?.isConst == true
|| (expressionSymbol as? FirMemberDeclaration<*>)?.isConst == true
|| expressionSymbol is FirConstructor && classKindOfParent == ClassKind.ANNOTATION_CLASS -> {
//DO NOTHING
}
@@ -84,8 +83,8 @@ internal fun checkConstantArguments(
expressionSymbol is FirField -> {
//TODO: fix checking of Java fields initializer
if (
!(expressionSymbol as FirMemberDeclaration).status.isStatic
|| (expressionSymbol as FirMemberDeclaration).status.modality != Modality.FINAL
!(expressionSymbol as FirMemberDeclaration<*>).status.isStatic
|| (expressionSymbol as FirMemberDeclaration<*>).status.modality != Modality.FINAL
)
return ConstantArgumentKind.NOT_CONST
}
@@ -189,7 +188,7 @@ internal fun checkConstantArguments(
return null
}
private fun FirTypedDeclaration?.getReferencedClass(session: FirSession): FirSymbolOwner<*>? =
private fun FirTypedDeclaration<*>?.getReferencedClass(session: FirSession): FirDeclaration<*>? =
this?.returnTypeRef
?.coneTypeSafe<ConeLookupTagBasedType>()
?.lookupTag
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirDeclarationInspector.kt
+7 -7
View File
@@ -8,8 +8,8 @@ package org.jetbrains.kotlin.fir.analysis.checkers
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.name.CallableId
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.name.CallableId
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name
@@ -218,7 +218,7 @@ private val NO_NAME_PROVIDED = Name.special("<no name provided>")
// explicitly.
// - see tests with `fun () {}`.
// you can't redeclare something that has no name.
private fun FirDeclaration.isCollectable() = when (this) {
private fun FirDeclaration<*>.isCollectable() = when (this) {
is FirSimpleFunction -> source?.kind !is FirFakeSourceElementKind && name != NO_NAME_PROVIDED
is FirRegularClass -> name != NO_NAME_PROVIDED
else -> true
@@ -230,10 +230,10 @@ private fun FirDeclaration.isCollectable() = when (this) {
open class FirDeclarationInspector(
protected val presenter: FirDeclarationPresenter = FirDefaultDeclarationPresenter()
) {
val otherDeclarations = mutableMapOf<String, MutableList<FirDeclaration>>()
val otherDeclarations = mutableMapOf<String, MutableList<FirDeclaration<*>>>()
val functionDeclarations = mutableMapOf<String, MutableList<FirSimpleFunction>>()
fun collect(declaration: FirDeclaration) {
fun collect(declaration: FirDeclaration<*>) {
when {
!declaration.isCollectable() -> {}
declaration is FirSimpleFunction -> collectFunction(presenter.represent(declaration), declaration)
@@ -243,7 +243,7 @@ open class FirDeclarationInspector(
}
}
protected open fun collectNonFunctionDeclaration(key: String, declaration: FirDeclaration): MutableList<FirDeclaration> =
protected open fun collectNonFunctionDeclaration(key: String, declaration: FirDeclaration<*>): MutableList<FirDeclaration<*>> =
otherDeclarations.getOrPut(key) {
mutableListOf()
}.also {
@@ -257,11 +257,11 @@ open class FirDeclarationInspector(
it.add(declaration)
}
fun contains(declaration: FirDeclaration) = when (declaration) {
fun contains(declaration: FirDeclaration<*>) = when (declaration) {
is FirSimpleFunction -> presenter.represent(declaration) in functionDeclarations
is FirRegularClass -> presenter.represent(declaration) in otherDeclarations
is FirTypeAlias -> presenter.represent(declaration) in otherDeclarations
is FirProperty -> presenter.represent(declaration) in otherDeclarations
else -> false
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt
+10 -10
View File
@@ -12,9 +12,6 @@ import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.diagnostics.*
import org.jetbrains.kotlin.fir.analysis.diagnostics.modalityModifier
import org.jetbrains.kotlin.fir.analysis.diagnostics.overrideModifier
import org.jetbrains.kotlin.fir.analysis.diagnostics.visibilityModifier
import org.jetbrains.kotlin.fir.analysis.getChild
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.FirExpression
@@ -35,7 +32,10 @@ import org.jetbrains.kotlin.fir.symbols.impl.*
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.name.*
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.psi.KtModifierList
import org.jetbrains.kotlin.psi.KtParameter.VAL_VAR_TOKEN_SET
import org.jetbrains.kotlin.psi.psiUtil.visibilityModifierType
@@ -134,7 +134,7 @@ inline fun <reified T : Any> FirQualifiedAccessExpression.getDeclaration(): T? {
* Returns the ClassLikeDeclaration where the Fir object has been defined
* or null if no proper declaration has been found.
*/
fun FirSymbolOwner<*>.getContainingClass(context: CheckerContext): FirClassLikeDeclaration<*>? =
fun FirDeclaration<*>.getContainingClass(context: CheckerContext): FirClassLikeDeclaration<*>? =
this.safeAs<FirCallableMemberDeclaration<*>>()?.containingClass()?.toSymbol(context.session)?.fir
fun FirClassLikeSymbol<*>.outerClass(context: CheckerContext): FirClassLikeSymbol<*>? {
@@ -232,9 +232,9 @@ fun FirClass<*>.modality(): Modality? {
}
/**
* returns implicit modality by FirMemberDeclaration
* returns implicit modality by FirMemberDeclaration<*>
*/
fun FirMemberDeclaration.implicitModality(context: CheckerContext): Modality {
fun FirMemberDeclaration<*>.implicitModality(context: CheckerContext): Modality {
if (this is FirRegularClass && (this.classKind == ClassKind.CLASS || this.classKind == ClassKind.OBJECT)) {
if (this.classKind == ClassKind.INTERFACE) return Modality.ABSTRACT
return Modality.FINAL
@@ -263,7 +263,7 @@ fun FirMemberDeclaration.implicitModality(context: CheckerContext): Modality {
return Modality.FINAL
}
private fun FirDeclaration.hasBody(): Boolean = when (this) {
private fun FirDeclaration<*>.hasBody(): Boolean = when (this) {
is FirSimpleFunction -> this.body != null && this.body !is FirEmptyExpressionBlock
is FirProperty -> this.setter?.body !is FirEmptyExpressionBlock? || this.getter?.body !is FirEmptyExpressionBlock?
else -> false
@@ -379,7 +379,7 @@ private fun lowerThanBound(context: ConeInferenceContext, argument: ConeKotlinTy
return false
}
fun FirMemberDeclaration.isInlineOnly(): Boolean = isInline && hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID)
fun FirMemberDeclaration<*>.isInlineOnly(): Boolean = isInline && hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID)
fun isSubtypeForTypeMismatch(context: ConeInferenceContext, subtype: ConeKotlinType, supertype: ConeKotlinType): Boolean {
val subtypeFullyExpanded = subtype.fullyExpandedType(context.session)
@@ -508,7 +508,7 @@ private val FirSimpleFunction.matchesDataClassSyntheticMemberSignatures: Boolean
(this.name == HASHCODE_NAME && matchesHashCodeSignature) ||
(this.name == OperatorNameConventions.TO_STRING && matchesToStringSignature)
private fun FirSymbolOwner<*>.getContainingClass(sessionHolder: SessionHolder): FirClassLikeDeclaration<*>? =
private fun FirDeclaration<*>.getContainingClass(sessionHolder: SessionHolder): FirClassLikeDeclaration<*>? =
this.safeAs<FirCallableMemberDeclaration<*>>()?.containingClass()?.toSymbol(sessionHolder.session)?.fir
// NB: we intentionally do not check return types
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirSinceKotlinHelpers.kt
+4 -4
View File
@@ -40,7 +40,7 @@ private data class FirSinceKotlinValue(
val wasExperimentalMarkerClasses: List<FirRegularClassSymbol>
)
fun FirAnnotatedDeclaration.checkSinceKotlinVersionAccessibility(context: CheckerContext): FirSinceKotlinAccessibility {
fun FirAnnotatedDeclaration<*>.checkSinceKotlinVersionAccessibility(context: CheckerContext): FirSinceKotlinAccessibility {
val value = getOwnSinceKotlinVersion(context.session)
val version = value?.apiVersion
val languageVersionSettings = context.session.languageVersionSettings
@@ -59,11 +59,11 @@ fun FirAnnotatedDeclaration.checkSinceKotlinVersionAccessibility(context: Checke
return FirSinceKotlinAccessibility.NotAccessible(version)
}
private fun FirAnnotatedDeclaration.getOwnSinceKotlinVersion(session: FirSession): FirSinceKotlinValue? {
private fun FirAnnotatedDeclaration<*>.getOwnSinceKotlinVersion(session: FirSession): FirSinceKotlinValue? {
var result: FirSinceKotlinValue? = null
// TODO: use-site targeted annotations
fun FirAnnotatedDeclaration.consider() {
fun FirAnnotatedDeclaration<*>.consider() {
val sinceKotlinSingleArgument = getAnnotationByFqName(SINCE_KOTLIN_FQ_NAME)?.arguments?.singleOrNull()
val apiVersion = ((sinceKotlinSingleArgument as? FirConstExpression<*>)?.value as? String)?.let(ApiVersion.Companion::parse)
if (apiVersion != null) {
@@ -90,7 +90,7 @@ private fun FirAnnotatedDeclaration.getOwnSinceKotlinVersion(session: FirSession
return result
}
private fun FirAnnotatedDeclaration.loadWasExperimentalMarkerClasses(): List<FirRegularClassSymbol> {
private fun FirAnnotatedDeclaration<*>.loadWasExperimentalMarkerClasses(): List<FirRegularClassSymbol> {
val wasExperimental = getAnnotationByFqName(OptInNames.WAS_EXPERIMENTAL_FQ_NAME) ?: return emptyList()
val annotationClasses = wasExperimental.findArgumentByName(OptInNames.WAS_EXPERIMENTAL_ANNOTATION_CLASS) ?: return emptyList()
return annotationClasses.extractClassesFromArgument()
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/context/CheckerContext.kt
+2 -2
View File
@@ -22,7 +22,7 @@ abstract class CheckerContext {
// Context
abstract val implicitReceiverStack: ImplicitReceiverStack
abstract val containingDeclarations: List<FirDeclaration>
abstract val containingDeclarations: List<FirDeclaration<*>>
abstract val qualifiedAccessOrAnnotationCalls: List<FirStatement>
abstract val getClassCalls: List<FirGetClassCall>
@@ -62,7 +62,7 @@ abstract class CheckerContext {
* the closest setter, while we want to keep searching for a getter.
*/
inline fun <reified T : FirDeclaration> CheckerContext.findClosest(check: (T) -> Boolean = { true }): T? {
inline fun <reified T : FirDeclaration<*>> CheckerContext.findClosest(check: (T) -> Boolean = { true }): T? {
for (it in containingDeclarations.asReversed()) {
return (it as? T)?.takeIf(check) ?: continue
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/context/PersistentCheckerContext.kt
+2 -2
View File
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.name.Name
class PersistentCheckerContext private constructor(
override val implicitReceiverStack: PersistentImplicitReceiverStack,
override val containingDeclarations: PersistentList<FirDeclaration>,
override val containingDeclarations: PersistentList<FirDeclaration<*>>,
override val qualifiedAccessOrAnnotationCalls: PersistentList<FirStatement>,
override val getClassCalls: PersistentList<FirGetClassCall>,
override val sessionHolder: SessionHolder,
@@ -58,7 +58,7 @@ class PersistentCheckerContext private constructor(
)
}
fun addDeclaration(declaration: FirDeclaration): PersistentCheckerContext {
fun addDeclaration(declaration: FirDeclaration<*>): PersistentCheckerContext {
return PersistentCheckerContext(
implicitReceiverStack,
containingDeclarations.add(declaration),
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationChecker.kt
+7 -5
View File
@@ -19,7 +19,9 @@ import org.jetbrains.kotlin.fir.expressions.argumentMapping
import org.jetbrains.kotlin.fir.resolve.fqName
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.psi.KtDestructuringDeclaration
import org.jetbrains.kotlin.psi.KtDestructuringDeclarationEntry
import org.jetbrains.kotlin.psi.KtLambdaExpression
import org.jetbrains.kotlin.resolve.AnnotationTargetList
import org.jetbrains.kotlin.resolve.AnnotationTargetLists
@@ -28,7 +30,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
private val deprecatedSinceKotlinClassId = FqName("kotlin.DeprecatedSinceKotlin")
override fun check(
declaration: FirAnnotatedDeclaration,
declaration: FirAnnotatedDeclaration<*>,
context: CheckerContext,
reporter: DiagnosticReporter
) {
@@ -54,7 +56,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
}
private fun checkAnnotationTarget(
declaration: FirAnnotatedDeclaration,
declaration: FirAnnotatedDeclaration<*>,
annotation: FirAnnotationCall,
context: CheckerContext,
reporter: DiagnosticReporter
@@ -106,7 +108,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
}
private fun checkAnnotationUseSiteTarget(
annotated: FirAnnotatedDeclaration,
annotated: FirAnnotatedDeclaration<*>,
annotation: FirAnnotationCall,
target: AnnotationUseSiteTarget,
context: CheckerContext,
@@ -195,7 +197,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
}
}
private fun getActualTargetList(annotated: FirDeclaration): AnnotationTargetList {
private fun getActualTargetList(annotated: FirDeclaration<*>): AnnotationTargetList {
return when (annotated) {
is FirRegularClass -> {
AnnotationTargetList(
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationClassDeclarationChecker.kt
+3 -4
View File
@@ -12,15 +12,14 @@ import org.jetbrains.kotlin.descriptors.ClassKind.ENUM_CLASS
import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.analysis.checkers.*
import org.jetbrains.kotlin.fir.analysis.checkers.checkConstantArguments
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.diagnostics.*
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.resolve.toSymbol
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.name.StandardClassIds.primitiveArrayTypeByElementType
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.name.StandardClassIds.primitiveArrayTypeByElementType
import org.jetbrains.kotlin.name.StandardClassIds.unsignedArrayTypeByElementType
object FirAnnotationClassDeclarationChecker : FirRegularClassChecker() {
@@ -44,7 +43,7 @@ object FirAnnotationClassDeclarationChecker : FirRegularClassChecker() {
}
}
private fun checkAnnotationClassMember(member: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
private fun checkAnnotationClassMember(member: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
when {
member is FirConstructor && member.isPrimary -> {
for (parameter in member.valueParameters) {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirClassVarianceChecker.kt
+3 -2
View File
@@ -6,7 +6,8 @@
package org.jetbrains.kotlin.fir.analysis.checkers.declaration
import org.jetbrains.kotlin.descriptors.Visibilities
import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.checkers.extractArgumentTypeRefAndSource
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -28,7 +29,7 @@ object FirClassVarianceChecker : FirClassChecker() {
}
for (member in declaration.declarations) {
if (member is FirMemberDeclaration) {
if (member is FirMemberDeclaration<*>) {
if (Visibilities.isPrivate(member.status.visibility)) {
continue
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsChecker.kt
+19 -24
View File
@@ -28,9 +28,9 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
private class DeclarationInspector : FirDeclarationInspector() {
val declarationConflictingSymbols: HashMap<FirDeclaration, SmartSet<FirBasedSymbol<*>>> = hashMapOf()
val declarationConflictingSymbols: HashMap<FirDeclaration<*>, SmartSet<FirBasedSymbol<*>>> = hashMapOf()
override fun collectNonFunctionDeclaration(key: String, declaration: FirDeclaration): MutableList<FirDeclaration> =
override fun collectNonFunctionDeclaration(key: String, declaration: FirDeclaration<*>): MutableList<FirDeclaration<*>> =
super.collectNonFunctionDeclaration(key, declaration).also {
collectLocalConflicts(declaration, it)
}
@@ -40,30 +40,26 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
collectLocalConflicts(declaration, it)
}
private fun collectLocalConflicts(declaration: FirDeclaration, conflicting: List<FirDeclaration>) {
private fun collectLocalConflicts(declaration: FirDeclaration<*>, conflicting: List<FirDeclaration<*>>) {
val localConflicts = SmartSet.create<FirBasedSymbol<*>>()
for (otherDeclaration in conflicting) {
if (otherDeclaration is FirSymbolOwner<*>) {
if (otherDeclaration != declaration && declaration is FirSymbolOwner<*> &&
!isExpectAndActual(declaration, otherDeclaration)
) {
localConflicts.add(otherDeclaration.symbol)
declarationConflictingSymbols.getOrPut(otherDeclaration) { SmartSet.create() }.add(declaration.symbol)
}
if (otherDeclaration != declaration && !isExpectAndActual(declaration, otherDeclaration)) {
localConflicts.add(otherDeclaration.symbol)
declarationConflictingSymbols.getOrPut(otherDeclaration) { SmartSet.create() }.add(declaration.symbol)
}
}
declarationConflictingSymbols[declaration] = localConflicts
}
private fun isExpectAndActual(declaration1: FirDeclaration, declaration2: FirDeclaration): Boolean {
if (declaration1 !is FirMemberDeclaration) return false
if (declaration2 !is FirMemberDeclaration) return false
private fun isExpectAndActual(declaration1: FirDeclaration<*>, declaration2: FirDeclaration<*>): Boolean {
if (declaration1 !is FirMemberDeclaration<*>) return false
if (declaration2 !is FirMemberDeclaration<*>) return false
return (declaration1.status.isExpect && declaration2.status.isActual) ||
(declaration1.status.isActual && declaration2.status.isExpect)
}
private fun areCompatibleMainFunctions(
declaration1: FirDeclaration, file1: FirFile, declaration2: FirDeclaration, file2: FirFile?
declaration1: FirDeclaration<*>, file1: FirFile, declaration2: FirDeclaration<*>, file2: FirFile?
): Boolean {
// TODO: proper main function detector
if (declaration1 !is FirSimpleFunction || declaration2 !is FirSimpleFunction) return false
@@ -72,7 +68,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
}
private fun collectExternalConflict(
declaration: FirDeclaration,
declaration: FirDeclaration<*>,
declarationPresentation: String,
containingFile: FirFile,
conflictingSymbol: FirBasedSymbol<*>,
@@ -93,16 +89,15 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
if (containingFile == actualConflictingFile) return // TODO: rewrite local decls checker to the same logic and then remove the check
if (areCompatibleMainFunctions(declaration, containingFile, conflicting, actualConflictingFile)) return
if (isExpectAndActual(declaration, conflicting)) return
if (conflicting is FirMemberDeclaration && !(conflicting is FirSymbolOwner<*> &&
session.visibilityChecker.isVisible(conflicting, session, containingFile, emptyList(), null))
) {
return
}
if (
conflicting is FirMemberDeclaration<*> &&
!session.visibilityChecker.isVisible(conflicting, session, containingFile, emptyList(), null)
) return
declarationConflictingSymbols.getOrPut(declaration) { SmartSet.create() }.add(conflictingSymbol)
}
fun collectWithExternalConflicts(
declaration: FirDeclaration,
declaration: FirDeclaration<*>,
containingFile: FirFile,
session: FirSession,
packageMemberScope: FirPackageMemberScope
@@ -205,7 +200,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
}
}
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
val inspector = DeclarationInspector()
when (declaration) {
@@ -243,7 +238,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
}
}
private fun FirDeclarationPresenter.represent(declaration: FirDeclaration): String? =
private fun FirDeclarationPresenter.represent(declaration: FirDeclaration<*>): String? =
when (declaration) {
is FirSimpleFunction -> represent(declaration)
is FirRegularClass -> represent(declaration)
@@ -272,7 +267,7 @@ class FirNameConflictsTracker : FirNameConflictsTrackerComponent() {
}
}
private fun FirDeclaration.onConstructors(action: (ctor: FirConstructor) -> Unit) {
private fun FirDeclaration<*>.onConstructors(action: (ctor: FirConstructor) -> Unit) {
class ClassConstructorVisitor : FirVisitorVoid() {
override fun visitElement(element: FirElement) {}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCyclicTypeBoundsChecker.kt
+1 -1
View File
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs
object FirCyclicTypeBoundsChecker : FirMemberDeclarationChecker() {
override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration is FirConstructor || declaration is FirTypeAlias) return
val processed = mutableSetOf<Name>()
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationChecker.kt
+2 -2
View File
@@ -7,8 +7,8 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
abstract class FirDeclarationChecker<in D : FirDeclaration> {
abstract class FirDeclarationChecker<in D : FirDeclaration<*>> {
abstract fun check(declaration: D, context: CheckerContext, reporter: DiagnosticReporter)
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerUtils.kt
+6 -6
View File
@@ -42,7 +42,7 @@ private inline fun isInsideSpecificClass(
context.containingDeclarations.asReversed().any { it is FirRegularClass && predicate.invoke(it) }
}
internal fun FirMemberDeclaration.isEffectivelyExpect(
internal fun FirMemberDeclaration<*>.isEffectivelyExpect(
containingClass: FirRegularClass?,
context: CheckerContext,
): Boolean {
@@ -51,7 +51,7 @@ internal fun FirMemberDeclaration.isEffectivelyExpect(
return containingClass != null && isInsideExpectClass(containingClass, context)
}
internal fun FirMemberDeclaration.isEffectivelyExternal(
internal fun FirMemberDeclaration<*>.isEffectivelyExternal(
containingClass: FirRegularClass?,
context: CheckerContext,
): Boolean {
@@ -75,7 +75,7 @@ internal fun FirMemberDeclaration.isEffectivelyExternal(
// TODO: check class too
internal fun checkExpectDeclarationVisibilityAndBody(
declaration: FirMemberDeclaration,
declaration: FirMemberDeclaration<*>,
source: FirSourceElement,
reporter: DiagnosticReporter,
context: CheckerContext
@@ -191,14 +191,14 @@ internal fun FirRegularClass.isInlineOrValueClass(): Boolean {
return isInline || hasModifier(KtTokens.VALUE_KEYWORD)
}
internal val FirDeclaration.isEnumEntryInitializer: Boolean
internal val FirDeclaration<*>.isEnumEntryInitializer: Boolean
get() {
if (this !is FirConstructor || !this.isPrimary) return false
return (containingClassAttr as? ConeClassLookupTagWithFixedSymbol)?.symbol?.fir?.classKind == ClassKind.ENUM_ENTRY
}
// contract: returns(true) implies (this is FirMemberDeclaration)
internal val FirDeclaration.isLocalMember: Boolean
// contract: returns(true) implies (this is FirMemberDeclaration<*>)
internal val FirDeclaration<*>.isLocalMember: Boolean
get() = when (this) {
is FirProperty -> this.isLocal
is FirRegularClass -> this.isLocal
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityDeclarationChecker.kt
+4 -4
View File
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs
// TODO: check why coneTypeSafe is necessary at some points inside
object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
when (declaration) {
is FirTypeAlias -> checkTypeAlias(declaration, reporter, context)
is FirProperty -> checkProperty(declaration, reporter, context)
@@ -103,7 +103,7 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
}
private fun checkFunction(declaration: FirFunction<*>, reporter: DiagnosticReporter, context: CheckerContext) {
val functionVisibility = (declaration as FirMemberDeclaration).effectiveVisibility
val functionVisibility = (declaration as FirMemberDeclaration<*>).effectiveVisibility
if (functionVisibility == EffectiveVisibility.Local) return
if (declaration !is FirConstructor) {
@@ -193,14 +193,14 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
private fun ConeKotlinType.findVisibilityExposure(
context: CheckerContext,
base: EffectiveVisibility
): FirMemberDeclaration? {
): FirMemberDeclaration<*>? {
val type = this as? ConeClassLikeType ?: return null
val fir = type.fullyExpandedType(context.session).lookupTag.toSymbol(context.session)?.let { firSymbol ->
firSymbol.ensureResolved(FirResolvePhase.DECLARATIONS, context.session)
firSymbol.fir
} ?: return null
if (fir is FirMemberDeclaration) {
if (fir is FirMemberDeclaration<*>) {
val effectiveVisibility = fir.effectiveVisibility
when (effectiveVisibility.relation(base, context.session.typeContext)) {
EffectiveVisibility.Permissiveness.LESS,
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirImportsChecker.kt
+2 -2
View File
@@ -57,7 +57,7 @@ object FirImportsChecker : FirFileChecker() {
if (classId != null) {
val classFir = classId.resolveToClass(context) ?: return
if (classFir.classKind.isSingleton) return
if (!classFir.canBeImported(context, importedName)) {
reporter.reportOn(import.source, FirErrors.CANNOT_BE_IMPORTED, importedName, context)
}
@@ -167,4 +167,4 @@ object FirImportsChecker : FirFileChecker() {
return hasStatic || !hasIllegal
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInfixFunctionDeclarationChecker.kt
+1 -1
View File
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
import org.jetbrains.kotlin.fir.declarations.isInfix
object FirInfixFunctionDeclarationChecker : FirMemberDeclarationChecker() {
override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration is FirSimpleFunction && declaration.isInfix) {
if (declaration.valueParameters.size != 1 || !hasExtensionOrDispatchReceiver(declaration, context)) {
reporter.reportOn(declaration.source, FirErrors.INAPPLICABLE_INFIX_MODIFIER, context)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt
+2 -2
View File
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
import org.jetbrains.kotlin.util.OperatorNameConventions
object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
if (!declaration.isInline) return
// local inline functions are prohibited
if (declaration.isLocalMember) return
@@ -283,7 +283,7 @@ object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
private fun FirBasedSymbol<*>.isDefinedInInlineFunction(): Boolean {
return when (val fir = this.fir) {
is FirAnonymousFunction -> true
is FirMemberDeclaration -> fir.isLocalMember
is FirMemberDeclaration<*> -> fir.isLocalMember
is FirAnonymousObject -> true
is FirRegularClass -> fir.classId.isLocal
else -> error("Unknown callable declaration type: ${fir.render()}")
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirModifierChecker.kt
+4 -4
View File
@@ -107,7 +107,7 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
secondModifier: FirModifier<*>,
reporter: DiagnosticReporter,
reportedNodes: MutableSet<FirModifier<*>>,
owner: FirDeclaration?,
owner: FirDeclaration<*>?,
context: CheckerContext
) {
val firstToken = firstModifier.token
@@ -137,7 +137,7 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
private fun checkModifiers(
list: FirModifierList,
owner: FirDeclaration,
owner: FirDeclaration<*>,
reporter: DiagnosticReporter,
context: CheckerContext
) {
@@ -156,7 +156,7 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
}
}
private fun isDeclarationMappedToSourceCorrectly(declaration: FirDeclaration, source: FirSourceElement): Boolean =
private fun isDeclarationMappedToSourceCorrectly(declaration: FirDeclaration<*>, source: FirSourceElement): Boolean =
when (source.elementType) {
KtNodeTypes.CLASS -> declaration is FirClass<*>
KtNodeTypes.OBJECT_DECLARATION -> declaration is FirClass<*>
@@ -166,7 +166,7 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
else -> true
}
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration is FirFile) return
val source = declaration.source ?: return
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt
+18 -18
View File
@@ -90,8 +90,8 @@ object FirOverrideChecker : FirClassChecker() {
overriddenSymbols: List<FirCallableSymbol<*>>,
): FirCallableDeclaration<*>? {
for (overridden in overriddenSymbols) {
if (overridden.fir !is FirMemberDeclaration) continue
val modality = (overridden.fir as FirMemberDeclaration).status.modality
if (overridden.fir !is FirMemberDeclaration<*>) continue
val modality = (overridden.fir as FirMemberDeclaration<*>).status.modality
val isEffectivelyFinal = modality == null || modality == Modality.FINAL
if (isEffectivelyFinal) {
return overridden.fir
@@ -102,7 +102,7 @@ object FirOverrideChecker : FirClassChecker() {
private fun FirProperty.checkMutability(
overriddenSymbols: List<FirCallableSymbol<*>>,
): FirMemberDeclaration? {
): FirMemberDeclaration<*>? {
if (isVar) return null
return overriddenSymbols.find { (it.fir as? FirProperty)?.isVar == true }?.fir?.safeAs()
}
@@ -113,8 +113,8 @@ object FirOverrideChecker : FirClassChecker() {
context: CheckerContext
) {
val visibilities = overriddenSymbols.mapNotNull {
if (it.fir !is FirMemberDeclaration) return@mapNotNull null
it to (it.fir as FirMemberDeclaration).visibility
if (it.fir !is FirMemberDeclaration<*>) return@mapNotNull null
it to (it.fir as FirMemberDeclaration<*>).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
@@ -137,7 +137,7 @@ object FirOverrideChecker : FirClassChecker() {
overriddenSymbols: List<FirCallableSymbol<*>>,
typeCheckerContext: AbstractTypeCheckerContext,
context: CheckerContext,
): FirMemberDeclaration? {
): FirMemberDeclaration<*>? {
val overridingReturnType = returnTypeRef.coneType
// Don't report *_ON_OVERRIDE diagnostics according to an error return type. That should be reported separately.
@@ -232,13 +232,13 @@ object FirOverrideChecker : FirClassChecker() {
}
@Suppress("UNUSED_PARAMETER") // TODO: delete me after implementing body
private fun DiagnosticReporter.reportNothingToOverride(declaration: FirMemberDeclaration, context: CheckerContext) {
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.reportOverridingFinalMember(
overriding: FirMemberDeclaration,
overriding: FirMemberDeclaration<*>,
overridden: FirCallableDeclaration<*>,
context: CheckerContext
) {
@@ -248,15 +248,15 @@ object FirOverrideChecker : FirClassChecker() {
}
private fun DiagnosticReporter.reportVarOverriddenByVal(
overriding: FirMemberDeclaration,
overridden: FirMemberDeclaration,
overriding: FirMemberDeclaration<*>,
overridden: FirMemberDeclaration<*>,
context: CheckerContext
) {
reportOn(overriding.source, FirErrors.VAR_OVERRIDDEN_BY_VAL, overriding, overridden, context)
}
private fun DiagnosticReporter.reportCannotWeakenAccessPrivilege(
overriding: FirMemberDeclaration,
overriding: FirMemberDeclaration<*>,
overridden: FirCallableDeclaration<*>,
context: CheckerContext
) {
@@ -272,7 +272,7 @@ object FirOverrideChecker : FirClassChecker() {
}
private fun DiagnosticReporter.reportCannotChangeAccessPrivilege(
overriding: FirMemberDeclaration,
overriding: FirMemberDeclaration<*>,
overridden: FirCallableDeclaration<*>,
context: CheckerContext
) {
@@ -288,24 +288,24 @@ object FirOverrideChecker : FirClassChecker() {
}
private fun DiagnosticReporter.reportReturnTypeMismatchOnFunction(
overriding: FirMemberDeclaration,
overridden: FirMemberDeclaration,
overriding: FirMemberDeclaration<*>,
overridden: FirMemberDeclaration<*>,
context: CheckerContext
) {
reportOn(overriding.source, FirErrors.RETURN_TYPE_MISMATCH_ON_OVERRIDE, overriding, overridden, context)
}
private fun DiagnosticReporter.reportTypeMismatchOnProperty(
overriding: FirMemberDeclaration,
overridden: FirMemberDeclaration,
overriding: FirMemberDeclaration<*>,
overridden: FirMemberDeclaration<*>,
context: CheckerContext
) {
reportOn(overriding.source, FirErrors.PROPERTY_TYPE_MISMATCH_ON_OVERRIDE, overriding, overridden, context)
}
private fun DiagnosticReporter.reportTypeMismatchOnVariable(
overriding: FirMemberDeclaration,
overridden: FirMemberDeclaration,
overriding: FirMemberDeclaration<*>,
overridden: FirMemberDeclaration<*>,
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/FirProjectionRelationChecker.kt
+1 -1
View File
@@ -18,7 +18,7 @@ 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) {
override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration is FirPropertyAccessor) {
return
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirSealedSupertypeChecker.kt
+1 -1
View File
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.utils.addToStdlib.safeAs
object FirSealedSupertypeChecker : FirMemberDeclarationChecker() {
override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration is FirClass<*>) {
// only the file declaration is present
if (declaration.classId.isLocal) {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirThrowableSubclassChecker.kt
+2 -2
View File
@@ -38,6 +38,6 @@ object FirThrowableSubclassChecker : FirClassChecker() {
private fun FirClass<*>.hasGenericOuterDeclaration(context: CheckerContext) =
classId.isLocal && context.containingDeclarations.anyIsGeneric()
private fun Collection<FirDeclaration>.anyIsGeneric() =
private fun Collection<FirDeclaration<*>>.anyIsGeneric() =
any { it is FirTypeParameterRefsOwner && it.typeParameters.isNotEmpty() }
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeAliasChecker.kt
+2 -2
View File
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
import org.jetbrains.kotlin.fir.types.*
object FirTypeAliasChecker : FirMemberDeclarationChecker() {
override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration !is FirTypeAlias) return
if (context.containingDeclarations.lastOrNull() !is FirFile) {
@@ -57,4 +57,4 @@ object FirTypeAliasChecker : FirMemberDeclarationChecker() {
)
}
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeConstraintsChecker.kt
+1 -1
View File
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.getDanglingTypeConstraintsOrEmpty
object FirTypeConstraintsChecker : FirBasicDeclarationChecker() {
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration !is FirTypeParameterRefsOwner) return
//basically we transfer errors, which were discovered in ast parsers
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeParameterBoundsChecker.kt
+3 -3
View File
@@ -34,7 +34,7 @@ object FirTypeParameterBoundsChecker : FirTypeParameterChecker() {
checkFinalUpperBounds(declaration, containingDeclaration, context, reporter)
checkExtensionFunctionTypeBound(declaration, context, reporter)
if (containingDeclaration.safeAs<FirMemberDeclaration>()?.isInlineOnly() != true) {
if (containingDeclaration.safeAs<FirMemberDeclaration<*>>()?.isInlineOnly() != true) {
checkOnlyOneTypeParameterBound(declaration, context, reporter)
}
@@ -47,7 +47,7 @@ object FirTypeParameterBoundsChecker : FirTypeParameterChecker() {
private fun checkFinalUpperBounds(
declaration: FirTypeParameter,
containingDeclaration: FirDeclaration,
containingDeclaration: FirDeclaration<*>,
context: CheckerContext,
reporter: DiagnosticReporter
) {
@@ -71,7 +71,7 @@ object FirTypeParameterBoundsChecker : FirTypeParameterChecker() {
private fun checkTypeAliasBound(
declaration: FirTypeParameter,
containingDeclaration: FirDeclaration,
containingDeclaration: FirDeclaration<*>,
context: CheckerContext,
reporter: DiagnosticReporter
) {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirUpperBoundViolatedDeclarationChecker.kt
+2 -2
View File
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.declarations.*
object FirUpperBoundViolatedDeclarationChecker : FirBasicDeclarationChecker() {
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration is FirClass<*>) {
for (typeParameter in declaration.typeParameters) {
if (typeParameter is FirTypeParameter) {
@@ -36,4 +36,4 @@ object FirUpperBoundViolatedDeclarationChecker : FirBasicDeclarationChecker() {
}
}
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCallableReferenceChecker.kt
+1 -1
View File
@@ -47,7 +47,7 @@ object FirCallableReferenceChecker : FirQualifiedAccessExpressionChecker() {
reporter.reportOn(source, FirErrors.CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR, context)
}
if ((referredDeclaration as? FirCallableMemberDeclaration<*>)?.isExtensionMember == true &&
(referredDeclaration as? FirMemberDeclaration)?.isLocalMember == false
(referredDeclaration as? FirMemberDeclaration<*>)?.isLocalMember == false
) {
reporter.reportOn(source, FirErrors.EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED, referredDeclaration, context)
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionAnnotationChecker.kt
+2 -2
View File
@@ -22,7 +22,7 @@ object FirExpressionAnnotationChecker : FirBasicExpressionChecker() {
override fun check(expression: FirStatement, context: CheckerContext, reporter: DiagnosticReporter) {
// Declarations are checked separately
// See KT-33658 about annotations on non-expression statements
if (expression is FirDeclaration ||
if (expression is FirDeclaration<*> ||
expression !is FirExpression ||
expression is FirBlock && expression.source?.kind == FirFakeSourceElementKind.DesugaredForLoop
) return
@@ -34,4 +34,4 @@ object FirExpressionAnnotationChecker : FirBasicExpressionChecker() {
}
}
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirReservedUnderscoreCheckers.kt
+2 -2
View File
@@ -112,7 +112,7 @@ object FirReservedUnderscoreExpressionChecker : FirBasicExpressionChecker() {
}
object FirReservedUnderscoreDeclarationChecker : FirBasicDeclarationChecker() {
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
if (
declaration is FirClass<*> ||
declaration is FirFunction<*> ||
@@ -141,7 +141,7 @@ object FirReservedUnderscoreDeclarationChecker : FirBasicDeclarationChecker() {
}
private fun reportIfUnderscore(
declaration: FirDeclaration,
declaration: FirDeclaration<*>,
context: CheckerContext,
reporter: DiagnosticReporter,
isSingleUnderscoreAllowed: Boolean = false
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUninitializedEnumChecker.kt
+1 -2
View File
@@ -6,7 +6,6 @@
package org.jetbrains.kotlin.fir.analysis.checkers.expression
import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.isEnumEntryInitializer
import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClass
@@ -98,7 +97,7 @@ object FirUninitializedEnumChecker : FirQualifiedAccessExpressionChecker() {
// INSTANCE(EnumCompanion2.foo())
// }
// find an accessed context within the same enum class.
(it as? FirSymbolOwner<*>)?.getContainingClass(context) == enumClass
it.getContainingClass(context) == enumClass
} ?: return
val enumMemberProperties = enumClass.declarations.filterIsInstance<FirProperty>()
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantExplicitTypeChecker.kt
+2 -2
View File
@@ -17,14 +17,14 @@ import org.jetbrains.kotlin.fir.declarations.FirProperty
import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.references.FirNamedReference
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.types.ConstantValueKind
object RedundantExplicitTypeChecker : FirMemberDeclarationChecker() {
override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration !is FirProperty) return
if (!declaration.isLocal) return
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantModalityModifierSyntaxChecker.kt
+3 -3
View File
@@ -21,13 +21,13 @@ import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
import org.jetbrains.kotlin.fir.declarations.modality
import org.jetbrains.kotlin.psi.KtDeclaration
object RedundantModalityModifierSyntaxChecker : FirDeclarationSyntaxChecker<FirMemberDeclaration, KtDeclaration>() {
object RedundantModalityModifierSyntaxChecker : FirDeclarationSyntaxChecker<FirMemberDeclaration<*>, KtDeclaration>() {
override fun isApplicable(element: FirMemberDeclaration, source: FirSourceElement): Boolean =
override fun isApplicable(element: FirMemberDeclaration<*>, source: FirSourceElement): Boolean =
source.kind !is FirFakeSourceElementKind
override fun checkLightTree(
element: FirMemberDeclaration,
element: FirMemberDeclaration<*>,
source: FirSourceElement,
context: CheckerContext,
reporter: DiagnosticReporter
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantSetterParameterTypeChecker.kt
+1 -1
View File
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.FirProperty
import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
object RedundantSetterParameterTypeChecker : FirMemberDeclarationChecker() {
override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration !is FirProperty) return
val setter = declaration.setter ?: return
if (setter is FirDefaultPropertyAccessor) return
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantVisibilityModifierSyntaxChecker.kt
+6 -6
View File
@@ -22,10 +22,10 @@ import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
import org.jetbrains.kotlin.psi.KtDeclaration
object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<FirDeclaration, KtDeclaration>() {
object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<FirDeclaration<*>, KtDeclaration>() {
override fun checkLightTree(
element: FirDeclaration,
element: FirDeclaration<*>,
source: FirSourceElement,
context: CheckerContext,
reporter: DiagnosticReporter
@@ -33,14 +33,14 @@ object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<Fi
if (element is FirConstructor && source.kind is FirFakeSourceElementKind) return
if (source is FirFakeSourceElement) return
if (
element !is FirMemberDeclaration
element !is FirMemberDeclaration<*>
&& !(element is FirPropertyAccessor && element.visibility == context.containingPropertyVisibility)
) return
val visibilityModifier = source.treeStructure.visibilityModifier(source.lighterASTNode)
val explicitVisibility = (visibilityModifier?.tokenType as? KtModifierKeywordToken)?.toVisibilityOrNull()
val implicitVisibility = element.implicitVisibility(context)
val containingMemberDeclaration = context.findClosest<FirMemberDeclaration>()
val containingMemberDeclaration = context.findClosest<FirMemberDeclaration<*>>()
val redundantVisibility = when {
explicitVisibility == implicitVisibility -> implicitVisibility
@@ -59,7 +59,7 @@ object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<Fi
reporter.reportOn(source, FirErrors.REDUNDANT_VISIBILITY_MODIFIER, context)
}
private fun FirDeclaration.implicitVisibility(context: CheckerContext): Visibility {
private fun FirDeclaration<*>.implicitVisibility(context: CheckerContext): Visibility {
return when {
this is FirPropertyAccessor && isSetter && status.isOverride -> this.visibility
@@ -105,7 +105,7 @@ object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<Fi
}
private fun FirFunction<*>.visibility(): Visibility? {
(symbol.fir as? FirMemberDeclaration)?.visibility?.let {
(symbol.fir as? FirMemberDeclaration<*>)?.visibility?.let {
return it
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt
+1 -2
View File
@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.KtNodeTypes
import org.jetbrains.kotlin.fir.FirAnnotationContainer
import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.analysis.cfa.*
import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
@@ -32,7 +31,7 @@ import org.jetbrains.kotlin.fir.types.coneType
object UnusedChecker : FirControlFlowChecker() {
override fun analyze(graph: ControlFlowGraph, reporter: DiagnosticReporter, context: CheckerContext) {
if ((graph.declaration as? FirSymbolOwner<*>)?.getContainingClass(context)?.takeIf {
if (graph.declaration?.getContainingClass(context)?.takeIf {
!it.symbol.classId.isLocal
} != null
) return
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/syntax/FirSyntaxChecker.kt
+1 -1
View File
@@ -48,7 +48,7 @@ interface FirSyntaxChecker<in D : FirElement, P : PsiElement> {
fun checkLightTree(element: D, source: FirSourceElement, context: CheckerContext, reporter: DiagnosticReporter)
}
abstract class FirDeclarationSyntaxChecker<in D : FirDeclaration, P : PsiElement> :
abstract class FirDeclarationSyntaxChecker<in D : FirDeclaration<*>, P : PsiElement> :
FirDeclarationChecker<D>(),
FirSyntaxChecker<D, P> {
final override fun check(declaration: D, context: CheckerContext, reporter: DiagnosticReporter) {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollector.kt
+10 -6
View File
@@ -5,22 +5,26 @@
package org.jetbrains.kotlin.fir.analysis.collectors
import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.analysis.collectors.components.*
import org.jetbrains.kotlin.fir.FirAnnotationContainer
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.analysis.collectors.components.AbstractDiagnosticCollectorComponent
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirVarargArgumentsExpression
import org.jetbrains.kotlin.fir.expressions.arguments
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.SessionHolder
import org.jetbrains.kotlin.fir.types.ConeClassLikeType
import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.fir.types.*
abstract class AbstractDiagnosticCollector(
override val session: FirSession,
override val scopeSession: ScopeSession = ScopeSession(),
protected val createComponents: (DiagnosticReporter) -> List<AbstractDiagnosticCollectorComponent>,
) : SessionHolder {
fun collectDiagnostics(firDeclaration: FirDeclaration, reporter: DiagnosticReporter) {
fun collectDiagnostics(firDeclaration: FirDeclaration<*>, reporter: DiagnosticReporter) {
val components = createComponents(reporter)
val visitor = createVisitor(components)
firDeclaration.accept(visitor, null)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollectorVisitor.kt
+6 -6
View File
@@ -24,8 +24,8 @@ abstract class AbstractDiagnosticCollectorVisitor(
@set:PrivateForInline var context: PersistentCheckerContext,
) : FirDefaultVisitor<Unit, Nothing?>() {
protected open fun shouldVisitDeclaration(declaration: FirDeclaration) = true
protected open fun onDeclarationExit(declaration: FirDeclaration) {}
protected open fun shouldVisitDeclaration(declaration: FirDeclaration<*>) = true
protected open fun onDeclarationExit(declaration: FirDeclaration<*>) {}
protected open fun visitNestedElements(element: FirElement) {
element.acceptChildren(this, null)
@@ -204,7 +204,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
}
protected inline fun visitWithDeclaration(
declaration: FirDeclaration,
declaration: FirDeclaration<*>,
block: () -> Unit = { visitNestedElements(declaration) }
) {
if (shouldVisitDeclaration(declaration)) {
@@ -216,7 +216,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
}
}
private fun visitWithDeclarationAndReceiver(declaration: FirDeclaration, labelName: Name?, receiverTypeRef: FirTypeRef?) {
private fun visitWithDeclarationAndReceiver(declaration: FirDeclaration<*>, labelName: Name?, receiverTypeRef: FirTypeRef?) {
visitWithDeclaration(declaration) {
withLabelAndReceiverType(
labelName,
@@ -265,7 +265,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
@OptIn(PrivateForInline::class)
inline fun <R> withDeclaration(declaration: FirDeclaration, block: () -> R): R {
inline fun <R> withDeclaration(declaration: FirDeclaration<*>, block: () -> R): R {
val existingContext = context
context = context.addDeclaration(declaration)
try {
@@ -279,7 +279,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
@OptIn(PrivateForInline::class)
inline fun <R> withLabelAndReceiverType(
labelName: Name?,
owner: FirDeclaration,
owner: FirDeclaration<*>,
type: ConeKotlinType?,
block: () -> R
): R {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/DeclarationCheckersDiagnosticComponent.kt
+1 -2
View File
@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.DeclarationCheckers
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirDeclarationChecker
import org.jetbrains.kotlin.fir.analysis.checkersComponent
import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollector
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.declarations.*
@@ -78,7 +77,7 @@ class DeclarationCheckersDiagnosticComponent(
checkers.allBasicDeclarationCheckers.check(anonymousInitializer, data, reporter)
}
private fun <D : FirDeclaration> Collection<FirDeclarationChecker<D>>.check(
private fun <D : FirDeclaration<*>> Collection<FirDeclarationChecker<D>>.check(
declaration: D,
context: CheckerContext,
reporter: DiagnosticReporter
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt
+2 -2
View File
@@ -58,7 +58,7 @@ object FirDiagnosticRenderers {
val NAME = Renderer { element: FirElement ->
when (element) {
is FirMemberDeclaration -> DECLARATION_NAME.render(element)
is FirMemberDeclaration<*> -> DECLARATION_NAME.render(element)
is FirCallableDeclaration<*> -> element.symbol.callableId.callableName.asString()
else -> "???"
}
@@ -68,7 +68,7 @@ object FirDiagnosticRenderers {
visibility.externalDisplayName
}
val DECLARATION_NAME = Renderer { declaration: FirMemberDeclaration ->
val DECLARATION_NAME = Renderer { declaration: FirMemberDeclaration<*> ->
val name = when (declaration) {
is FirProperty -> declaration.name
is FirSimpleFunction -> declaration.name
compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt
+8 -8
View File
@@ -376,9 +376,9 @@ class MultiModuleHtmlFirDump(private val outputRoot: File) {
visitElement(regularClass)
}
fun indexDeclaration(symbolOwner: FirSymbolOwner<*>) {
symbols[symbolOwner.symbol] = location
symbolIds[symbolOwner.symbol] = symbolCounter++
fun indexDeclaration(declaration: FirDeclaration<*>) {
symbols[declaration.symbol] = location
symbolIds[declaration.symbol] = symbolCounter++
}
override fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>) {
@@ -912,7 +912,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
}
}
private fun FlowContent.generate(memberDeclaration: FirMemberDeclaration) {
private fun FlowContent.generate(memberDeclaration: FirMemberDeclaration<*>) {
when (memberDeclaration) {
is FirEnumEntry -> generate(memberDeclaration)
is FirRegularClass -> generate(memberDeclaration)
@@ -1524,7 +1524,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
is FirConstExpression<*> -> generate(expression)
is FirReturnExpression -> {
span("return-label") {
symbolRef((expression.target.labeledElement as? FirSymbolOwner<*>)?.symbol) {
symbolRef(expression.target.labeledElement.symbol) {
+"^"
+(expression.target.labelName ?: "")
}
@@ -1682,7 +1682,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
}
}
private fun FlowContent.generateDeclarations(declarations: List<FirDeclaration>) {
private fun FlowContent.generateDeclarations(declarations: List<FirDeclaration<*>>) {
if (declarations.isNotEmpty()) {
+" {"
br
@@ -1767,10 +1767,10 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
}
}
private fun FlowContent.generate(declaration: FirDeclaration) {
private fun FlowContent.generate(declaration: FirDeclaration<*>) {
when (declaration) {
is FirAnonymousInitializer -> generate(declaration)
is FirMemberDeclaration -> generate(declaration)
is FirMemberDeclaration<*> -> generate(declaration)
else -> unsupported(declaration)
}
}
compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJvmModuleVisibilityChecker.kt
+1 -1
View File
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
import org.jetbrains.kotlin.fir.moduleData
class FirJvmModuleVisibilityChecker(private val session: FirSession) : FirModuleVisibilityChecker {
override fun isInFriendModule(declaration: FirMemberDeclaration): Boolean {
override fun isInFriendModule(declaration: FirMemberDeclaration<*>): Boolean {
val useSiteModuleData = session.moduleData
val declarationModuleData = declaration.moduleData
return useSiteModuleData == declarationModuleData || declarationModuleData in useSiteModuleData.friendDependencies
compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt
+3 -3
View File
@@ -191,11 +191,11 @@ fun deserializeClassToSymbol(
addCloneForArrayIfNeeded(classId, context.dispatchReceiver)
addSerializableIfNeeded(classId)
declarations.sortWith(object : Comparator<FirDeclaration> {
override fun compare(a: FirDeclaration, b: FirDeclaration): Int {
declarations.sortWith(object : Comparator<FirDeclaration<*>> {
override fun compare(a: FirDeclaration<*>, b: FirDeclaration<*>): Int {
// Reorder members based on their type and name only.
// See FE 1.0's [DeserializedMemberScope#addMembers].
if (a is FirMemberDeclaration && b is FirMemberDeclaration) {
if (a is FirMemberDeclaration<*> && b is FirMemberDeclaration<*>) {
return FirMemberDeclarationComparator.TypeAndNameComparator.compare(a, b)
}
return 0
compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt
+5 -5
View File
@@ -58,7 +58,7 @@ import org.jetbrains.kotlin.types.TypeApproximatorConfiguration
class FirElementSerializer private constructor(
private val session: FirSession,
private val scopeSession: ScopeSession,
private val containingDeclaration: FirDeclaration?,
private val containingDeclaration: FirDeclaration<*>?,
private val typeParameters: Interner<FirTypeParameter>,
private val extension: FirSerializerExtension,
private val typeTable: MutableTypeTable,
@@ -681,7 +681,7 @@ class FirElementSerializer private constructor(
}
is ConeTypeParameterType -> {
val typeParameter = type.lookupTag.typeParameterSymbol.fir
if (typeParameter in (containingDeclaration as? FirMemberDeclaration)?.typeParameters ?: emptyList()) {
if (typeParameter in (containingDeclaration as? FirMemberDeclaration<*>)?.typeParameters ?: emptyList()) {
builder.typeParameterName = getSimpleNameIndex(typeParameter.name)
} else {
builder.typeParameter = getTypeParameterId(typeParameter)
@@ -820,7 +820,7 @@ class FirElementSerializer private constructor(
)
}
private fun createChildSerializer(declaration: FirDeclaration): FirElementSerializer =
private fun createChildSerializer(declaration: FirDeclaration<*>): FirElementSerializer =
FirElementSerializer(
session, scopeSession, declaration, Interner(typeParameters), extension,
typeTable, versionRequirementTable, serializeTypeTableToFunction = false,
@@ -832,7 +832,7 @@ class FirElementSerializer private constructor(
private fun useTypeTable(): Boolean = extension.shouldUseTypeTable()
private fun FirDeclaration.hasInlineClassTypesInSignature(): Boolean {
private fun FirDeclaration<*>.hasInlineClassTypesInSignature(): Boolean {
// TODO
return false
}
@@ -927,7 +927,7 @@ class FirElementSerializer private constructor(
}
private fun normalizeVisibility(declaration: FirMemberDeclaration): Visibility {
private fun normalizeVisibility(declaration: FirMemberDeclaration<*>): Visibility {
return declaration.visibility.normalize()
}
compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmKotlinMangler.kt
+10 -10
View File
@@ -12,28 +12,28 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.signaturer.FirMangler
@NoMutableState
class FirJvmKotlinMangler(private val session: FirSession) : AbstractKotlinMangler<FirDeclaration>(), FirMangler {
class FirJvmKotlinMangler(private val session: FirSession) : AbstractKotlinMangler<FirDeclaration<*>>(), FirMangler {
override val FirDeclaration.mangleString: String
override val FirDeclaration<*>.mangleString: String
get() = getMangleComputer(MangleMode.FULL).computeMangle(this)
override val FirDeclaration.signatureString: String
override val FirDeclaration<*>.signatureString: String
get() = getMangleComputer(MangleMode.SIGNATURE).computeMangle(this)
override val FirDeclaration.fqnString: String
override val FirDeclaration<*>.fqnString: String
get() = getMangleComputer(MangleMode.FQNAME).computeMangle(this)
override fun FirDeclaration.isExported(): Boolean = true
override fun FirDeclaration<*>.isExported(): Boolean = true
override fun getExportChecker(): KotlinExportChecker<FirDeclaration> {
return object : KotlinExportChecker<FirDeclaration> {
override fun check(declaration: FirDeclaration, type: SpecialDeclarationType): Boolean = true
override fun getExportChecker(): KotlinExportChecker<FirDeclaration<*>> {
return object : KotlinExportChecker<FirDeclaration<*>> {
override fun check(declaration: FirDeclaration<*>, type: SpecialDeclarationType): Boolean = true
override fun FirDeclaration.isPlatformSpecificExported(): Boolean = true
override fun FirDeclaration<*>.isPlatformSpecificExported(): Boolean = true
}
}
override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer<FirDeclaration> {
override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer<FirDeclaration<*>> {
return FirJvmMangleComputer(StringBuilder(256), mode, session)
}
}
compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmMangleComputer.kt
+10 -10
View File
@@ -12,8 +12,8 @@ import org.jetbrains.kotlin.backend.common.serialization.mangle.collectForMangle
import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.resolve.firProvider
import org.jetbrains.kotlin.fir.resolve.symbolProvider
import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
import org.jetbrains.kotlin.fir.resolve.symbolProvider
import org.jetbrains.kotlin.fir.resolve.toSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
@@ -29,9 +29,9 @@ open class FirJvmMangleComputer(
private val builder: StringBuilder,
private val mode: MangleMode,
private val session: FirSession
) : FirVisitor<Unit, Boolean>(), KotlinMangleComputer<FirDeclaration> {
) : FirVisitor<Unit, Boolean>(), KotlinMangleComputer<FirDeclaration<*>> {
private val typeParameterContainer = ArrayList<FirMemberDeclaration>(4)
private val typeParameterContainer = ArrayList<FirMemberDeclaration<*>>(4)
private var isRealExpect = false
@@ -79,7 +79,7 @@ open class FirJvmMangleComputer(
}
}
private fun FirDeclaration.visitParent() {
private fun FirDeclaration<*>.visitParent() {
val (parentPackageFqName, parentClassId) = when (this) {
is FirCallableMemberDeclaration<*> -> this.containingClass()?.classId?.let { it.packageFqName to it } ?: return
is FirClassLikeDeclaration<*> -> this.symbol.classId.let { it.packageFqName to it.outerClassId }
@@ -98,7 +98,7 @@ open class FirJvmMangleComputer(
}
}
private fun FirDeclaration.mangleSimpleDeclaration(name: String) {
private fun FirDeclaration<*>.mangleSimpleDeclaration(name: String) {
val l = builder.length
visitParent()
@@ -109,11 +109,11 @@ open class FirJvmMangleComputer(
builder.appendName(name)
}
private fun FirFunction<*>.mangleFunction(isCtor: Boolean, isStatic: Boolean, container: FirDeclaration) {
private fun FirFunction<*>.mangleFunction(isCtor: Boolean, isStatic: Boolean, container: FirDeclaration<*>) {
isRealExpect = isRealExpect || (this as? FirMemberDeclaration)?.isExpect == true
isRealExpect = isRealExpect || (this as? FirMemberDeclaration<*>)?.isExpect == true
if (container is FirMemberDeclaration) {
if (container is FirMemberDeclaration<*>) {
typeParameterContainer.add(container)
}
visitParent()
@@ -164,7 +164,7 @@ open class FirJvmMangleComputer(
}
}
private fun FirTypeParameter.effectiveParent(): FirMemberDeclaration {
private fun FirTypeParameter.effectiveParent(): FirMemberDeclaration<*> {
for (parent in typeParameterContainer) {
if (this in parent.typeParameters) {
return parent
@@ -315,7 +315,7 @@ open class FirJvmMangleComputer(
override fun visitConstructor(constructor: FirConstructor, data: Boolean) =
constructor.mangleFunction(isCtor = true, isStatic = false, constructor)
override fun computeMangle(declaration: FirDeclaration): String {
override fun computeMangle(declaration: FirDeclaration<*>): String {
declaration.accept(this, true)
return builder.toString()
}
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt
+3 -3
View File
@@ -161,7 +161,7 @@ class Fir2IrConverter(
return irClass
}
private fun delegatedMembers(irClass: IrClass): List<FirDeclaration> {
private fun delegatedMembers(irClass: IrClass): List<FirDeclaration<*>> {
return irClass.declarations.filter {
it.origin == IrDeclarationOrigin.DELEGATED_MEMBER
}.mapNotNull {
@@ -172,7 +172,7 @@ class Fir2IrConverter(
// Sort declarations so that all non-synthetic declarations are before synthetic ones.
// This is needed because converting synthetic fields for implementation delegation needs to know
// existing declarations in the class to avoid adding redundant delegated members.
private fun syntheticPropertiesLast(declarations: List<FirDeclaration>): Iterable<FirDeclaration> {
private fun syntheticPropertiesLast(declarations: List<FirDeclaration<*>>): Iterable<FirDeclaration<*>> {
return declarations.sortedBy { it !is FirField && it.isSynthetic }
}
@@ -196,7 +196,7 @@ class Fir2IrConverter(
}
private fun processMemberDeclaration(
declaration: FirDeclaration,
declaration: FirDeclaration<*>,
containingClass: FirClass<*>?,
parent: IrDeclarationParent
): IrDeclaration? {
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt
+3 -3
View File
@@ -97,7 +97,7 @@ class Fir2IrDeclarationStorage(
// For pure fields (from Java) only
private val fieldToPropertyCache = ConcurrentHashMap<Pair<FirField, IrDeclarationParent>, IrProperty>()
private val delegatedReverseCache = ConcurrentHashMap<IrDeclaration, FirDeclaration>()
private val delegatedReverseCache = ConcurrentHashMap<IrDeclaration, FirDeclaration<*>>()
private val fieldCache = ConcurrentHashMap<FirField, IrField>()
@@ -411,7 +411,7 @@ class Fir2IrDeclarationStorage(
delegatedReverseCache[irFunction] = function
}
fun originalDeclarationForDelegated(irDeclaration: IrDeclaration): FirDeclaration? = delegatedReverseCache[irDeclaration]
fun originalDeclarationForDelegated(irDeclaration: IrDeclaration): FirDeclaration<*>? = delegatedReverseCache[irDeclaration]
internal fun declareIrSimpleFunction(
signature: IdSignature?,
@@ -1266,7 +1266,7 @@ class Fir2IrDeclarationStorage(
}
private fun IrMutableAnnotationContainer.convertAnnotationsFromLibrary(firAnnotationContainer: FirAnnotationContainer) {
if ((firAnnotationContainer as? FirDeclaration)?.isFromLibrary == true ||
if ((firAnnotationContainer as? FirDeclaration<*>)?.isFromLibrary == true ||
(firAnnotationContainer is FirCallableMemberDeclaration<*> && firAnnotationContainer.isSubstitutionOrIntersectionOverride)
) {
annotationGenerator.generate(this, firAnnotationContainer)
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrSignatureComposer.kt
+1 -1
View File
@@ -11,6 +11,6 @@ import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
import org.jetbrains.kotlin.ir.util.IdSignature
interface Fir2IrSignatureComposer {
fun composeSignature(declaration: FirDeclaration, containingClass: ConeClassLikeLookupTag? = null): IdSignature?
fun composeSignature(declaration: FirDeclaration<*>, containingClass: ConeClassLikeLookupTag? = null): IdSignature?
fun composeAccessorSignature(property: FirProperty, isSetter: Boolean, containingClass: ConeClassLikeLookupTag? = null): IdSignature?
}
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt
+1 -1
View File
@@ -86,7 +86,7 @@ class Fir2IrVisitor(
}
}
private fun FirDeclaration.toIrDeclaration(): IrDeclaration =
private fun FirDeclaration<*>.toIrDeclaration(): IrDeclaration =
accept(this@Fir2IrVisitor, null) as IrDeclaration
// ==================================================================================
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirMetadataSource.kt
+1 -1
View File
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.ir.declarations.MetadataSource
import org.jetbrains.kotlin.name.Name
sealed class FirMetadataSource : MetadataSource {
abstract val fir: FirDeclaration
abstract val fir: FirDeclaration<*>
val declarationSiteSession: FirSession
get() = fir.moduleData.session
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AdapterGenerator.kt
+9 -4
View File
@@ -7,7 +7,9 @@ package org.jetbrains.kotlin.fir.backend.generators
import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.fir.backend.*
import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
import org.jetbrains.kotlin.fir.backend.Fir2IrConversionScope
import org.jetbrains.kotlin.fir.backend.FirMetadataSource
import org.jetbrains.kotlin.fir.backend.convertWithOffsets
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.*
@@ -32,7 +34,10 @@ import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.types.IrSimpleType
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.types.isUnit
import org.jetbrains.kotlin.ir.types.typeOrNull
import org.jetbrains.kotlin.ir.util.*
import org.jetbrains.kotlin.name.Name
@@ -172,7 +177,7 @@ internal class AdapterGenerator(
): IrSimpleFunction {
val returnType = type.arguments.last().typeOrNull!!
val parameterTypes = type.arguments.dropLast(1).map { it.typeOrNull!! }
val firMemberAdaptee = firAdaptee as FirMemberDeclaration
val firMemberAdaptee = firAdaptee as FirMemberDeclaration<*>
return irFactory.createFunction(
startOffset, endOffset,
IrDeclarationOrigin.ADAPTER_FOR_CALLABLE_REFERENCE,
@@ -292,7 +297,7 @@ internal class AdapterGenerator(
boundDispatchReceiver != null -> irCall.dispatchReceiver = receiverValue
boundExtensionReceiver != null -> irCall.extensionReceiver = receiverValue
}
} else if (callableReferenceAccess.explicitReceiver is FirResolvedQualifier && ((firAdaptee as? FirMemberDeclaration)?.isStatic != true)) {
} else if (callableReferenceAccess.explicitReceiver is FirResolvedQualifier && ((firAdaptee as? FirMemberDeclaration<*>)?.isStatic != true)) {
// Unbound callable reference 'A::foo'
val adaptedReceiverParameter = adapterFunction.valueParameters[0]
val adaptedReceiverValue = IrGetValueImpl(
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DataClassMembersGenerator.kt
+4 -4
View File
@@ -58,10 +58,10 @@ import org.jetbrains.kotlin.util.OperatorNameConventions.TO_STRING
@OptIn(ObsoleteDescriptorBasedAPI::class)
class DataClassMembersGenerator(val components: Fir2IrComponents) {
fun generateInlineClassMembers(klass: FirClass<*>, irClass: IrClass): List<FirDeclaration> =
fun generateInlineClassMembers(klass: FirClass<*>, irClass: IrClass): List<FirDeclaration<*>> =
MyDataClassMethodsGenerator(irClass, klass.symbol.toLookupTag(), IrDeclarationOrigin.GENERATED_INLINE_CLASS_MEMBER).generate(klass)
fun generateDataClassMembers(klass: FirClass<*>, irClass: IrClass): List<FirDeclaration> =
fun generateDataClassMembers(klass: FirClass<*>, irClass: IrClass): List<FirDeclaration<*>> =
MyDataClassMethodsGenerator(irClass, klass.symbol.toLookupTag(), IrDeclarationOrigin.GENERATED_DATA_CLASS_MEMBER).generate(klass)
fun generateDataClassComponentBody(irFunction: IrFunction, lookupTag: ConeClassLikeLookupTag) =
@@ -175,14 +175,14 @@ class DataClassMembersGenerator(val components: Fir2IrComponents) {
(this.name == HASHCODE_NAME && matchesHashCodeSignature) ||
(this.name == TO_STRING && matchesToStringSignature)
fun generate(klass: FirClass<*>): List<FirDeclaration> {
fun generate(klass: FirClass<*>): List<FirDeclaration<*>> {
val propertyParametersCount = irClass.primaryConstructor?.explicitParameters?.size ?: 0
val properties = irClass.properties.filter { it.backingField != null }.take(propertyParametersCount).toList()
if (properties.isEmpty()) {
return emptyList()
}
val result = mutableListOf<FirDeclaration>()
val result = mutableListOf<FirDeclaration<*>>()
val contributedFunctionsInThisType = klass.declarations.mapNotNull {
if (it is FirSimpleFunction && it.matchesDataClassSyntheticMemberSignatures) {
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/FakeOverrideGenerator.kt
+4 -4
View File
@@ -14,8 +14,8 @@ import org.jetbrains.kotlin.fir.resolve.toSymbol
import org.jetbrains.kotlin.fir.scopes.*
import org.jetbrains.kotlin.fir.scopes.impl.FirFakeOverrideGenerator
import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
@@ -59,18 +59,18 @@ class FakeOverrideGenerator(
}
}
fun IrClass.addFakeOverrides(klass: FirClass<*>, declarations: Collection<FirDeclaration>) {
fun IrClass.addFakeOverrides(klass: FirClass<*>, declarations: Collection<FirDeclaration<*>>) {
this.declarations += getFakeOverrides(
klass,
declarations
)
}
fun IrClass.getFakeOverrides(klass: FirClass<*>, realDeclarations: Collection<FirDeclaration>): List<IrDeclaration> {
fun IrClass.getFakeOverrides(klass: FirClass<*>, realDeclarations: Collection<FirDeclaration<*>>): List<IrDeclaration> {
val result = mutableListOf<IrDeclaration>()
val useSiteMemberScope = klass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = true)
val superTypesCallableNames = useSiteMemberScope.getCallableNames()
val realDeclarationSymbols = realDeclarations.filterIsInstance<FirSymbolOwner<*>>().mapTo(mutableSetOf(), FirSymbolOwner<*>::symbol)
val realDeclarationSymbols = realDeclarations.mapTo(mutableSetOf(), FirDeclaration<*>::symbol)
for (name in superTypesCallableNames) {
generateFakeOverridesForName(this, useSiteMemberScope, name, klass, result, realDeclarationSymbols)
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyDeclaration.kt
+5 -2
View File
@@ -10,12 +10,15 @@ import org.jetbrains.kotlin.fir.backend.toIrType
import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
import org.jetbrains.kotlin.fir.symbols.Fir2IrBindableSymbol
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.declarations.IrDeclaration
import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
import org.jetbrains.kotlin.ir.declarations.IrFactory
import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
import org.jetbrains.kotlin.ir.declarations.lazy.lazyVar
import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
import kotlin.properties.ReadWriteProperty
interface AbstractFir2IrLazyDeclaration<F : FirMemberDeclaration, D : IrDeclaration> :
interface AbstractFir2IrLazyDeclaration<F : FirMemberDeclaration<*>, D : IrDeclaration> :
IrDeclaration, IrDeclarationParent, Fir2IrComponents {
val fir: F
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyFunction.kt
+1 -1
View File
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.resolve.annotations.JVM_STATIC_ANNOTATION_FQ_NAME
import kotlin.properties.ReadWriteProperty
abstract class AbstractFir2IrLazyFunction<F : FirMemberDeclaration>(
abstract class AbstractFir2IrLazyFunction<F : FirMemberDeclaration<*>>(
components: Fir2IrComponents,
override val startOffset: Int,
override val endOffset: Int,
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyPropertyAccessor.kt
+10 -4
View File
@@ -5,11 +5,17 @@
package org.jetbrains.kotlin.fir.lazy
import org.jetbrains.kotlin.fir.backend.*
import org.jetbrains.kotlin.fir.backend.ConversionTypeContext
import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
import org.jetbrains.kotlin.fir.backend.generateOverriddenAccessorSymbols
import org.jetbrains.kotlin.fir.backend.toIrType
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticPropertyAccessor
import org.jetbrains.kotlin.fir.symbols.Fir2IrSimpleFunctionSymbol
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.declarations.IrClass
import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.declarations.IrValueParameter
import org.jetbrains.kotlin.ir.declarations.lazy.lazyVar
import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
@@ -28,12 +34,12 @@ class Fir2IrLazyPropertyAccessor(
firParentClass: FirRegularClass,
symbol: Fir2IrSimpleFunctionSymbol,
isFakeOverride: Boolean
) : AbstractFir2IrLazyFunction<FirMemberDeclaration>(components, startOffset, endOffset, origin, symbol, isFakeOverride) {
) : AbstractFir2IrLazyFunction<FirMemberDeclaration<*>>(components, startOffset, endOffset, origin, symbol, isFakeOverride) {
init {
symbol.bind(this)
}
override val fir: FirMemberDeclaration
override val fir: FirMemberDeclaration<*>
get() = firAccessor ?: firParentProperty
// TODO: investigate why some deserialized properties are inline
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt
+1 -1
View File
@@ -56,7 +56,7 @@ class FirBasedSignatureComposer(private val mangler: FirMangler) : Fir2IrSignatu
}
}
override fun composeSignature(declaration: FirDeclaration, containingClass: ConeClassLikeLookupTag?): IdSignature? {
override fun composeSignature(declaration: FirDeclaration<*>, containingClass: ConeClassLikeLookupTag?): IdSignature? {
if (declaration is FirAnonymousObject || declaration is FirAnonymousFunction) return null
if (declaration is FirRegularClass && declaration.classId.isLocal) return null
if (declaration is FirCallableMemberDeclaration<*>) {
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirMangler.kt
+2 -2
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.signaturer
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.ir.util.KotlinMangler
interface FirMangler : KotlinMangler<FirDeclaration> {
interface FirMangler : KotlinMangler<FirDeclaration<*>> {
override val manglerName: String
get() = "Fir"
}
}
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaVisibilityChecker.kt
+1 -1
View File
@@ -22,7 +22,7 @@ object FirJavaVisibilityChecker : FirVisibilityChecker() {
declarationVisibility: Visibility,
symbol: FirBasedSymbol<*>,
useSiteFile: FirFile,
containingDeclarations: List<FirDeclaration>,
containingDeclarations: List<FirDeclaration<*>>,
dispatchReceiver: ReceiverValue?,
session: FirSession
): Boolean {
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt
+1 -1
View File
@@ -371,7 +371,7 @@ class JavaSymbolProvider(
classId: ClassId,
javaTypeParameterStack: JavaTypeParameterStack,
dispatchReceiver: ConeClassLikeType
): FirDeclaration {
): FirDeclaration<*> {
val fieldName = javaField.name
val fieldId = CallableId(classId.packageFqName, classId.relativeClassName, fieldName)
val returnType = javaField.type
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt
+2 -2
View File
@@ -37,7 +37,7 @@ class FirJavaClass @FirImplementationDetail internal constructor(
override val annotations: MutableList<FirAnnotationCall>,
override var status: FirDeclarationStatus,
override val classKind: ClassKind,
override val declarations: MutableList<FirDeclaration>,
override val declarations: MutableList<FirDeclaration<*>>,
override val scopeProvider: FirScopeProvider,
override val symbol: FirRegularClassSymbol,
override val superTypeRefs: MutableList<FirTypeRef>,
@@ -132,7 +132,7 @@ internal class FirJavaClassBuilder : FirRegularClassBuilder(), FirAnnotationCont
override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
override val typeParameters: MutableList<FirTypeParameterRef> = mutableListOf()
override val declarations: MutableList<FirDeclaration> = mutableListOf()
override val declarations: MutableList<FirDeclaration<*>> = mutableListOf()
override val superTypeRefs: MutableList<FirTypeRef> = mutableListOf()
compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt
+9 -9
View File
@@ -87,7 +87,7 @@ class DeclarationsConverter(
val fileAnnotationList = mutableListOf<FirAnnotationCall>()
val importList = mutableListOf<FirImport>()
val firDeclarationList = mutableListOf<FirDeclaration>()
val firDeclarationList = mutableListOf<FirDeclaration<*>>()
context.packageFqName = FqName.ROOT
file.forEachChildren {
when (it.tokenType) {
@@ -95,7 +95,7 @@ class DeclarationsConverter(
PACKAGE_DIRECTIVE -> context.packageFqName = convertPackageName(it)
IMPORT_LIST -> importList += convertImportDirectives(it)
CLASS -> firDeclarationList += convertClass(it)
FUN -> firDeclarationList += convertFunctionDeclaration(it) as FirDeclaration
FUN -> firDeclarationList += convertFunctionDeclaration(it) as FirDeclaration<*>
PROPERTY -> firDeclarationList += convertPropertyDeclaration(it)
TYPEALIAS -> firDeclarationList += convertTypeAlias(it)
OBJECT_DECLARATION -> firDeclarationList += convertClass(it)
@@ -358,7 +358,7 @@ class DeclarationsConverter(
/**
* @see org.jetbrains.kotlin.parsing.KotlinParsing.parseClassOrObject
*/
private fun convertClass(classNode: LighterASTNode): FirDeclaration {
private fun convertClass(classNode: LighterASTNode): FirDeclaration<*> {
var modifiers = Modifier()
var classKind: ClassKind = ClassKind.CLASS //TODO
var identifier: String? = null
@@ -730,12 +730,12 @@ class DeclarationsConverter(
* @see org.jetbrains.kotlin.parsing.KotlinParsing.parseClassBody
* @see org.jetbrains.kotlin.parsing.KotlinParsing.parseEnumClassBody
*/
private fun convertClassBody(classBody: LighterASTNode, classWrapper: ClassWrapper): List<FirDeclaration> {
private fun convertClassBody(classBody: LighterASTNode, classWrapper: ClassWrapper): List<FirDeclaration<*>> {
return classBody.forEachChildrenReturnList { node, container ->
when (node.tokenType) {
ENUM_ENTRY -> container += convertEnumEntry(node, classWrapper)
CLASS -> container += convertClass(node)
FUN -> container += convertFunctionDeclaration(node, classWrapper) as FirDeclaration
FUN -> container += convertFunctionDeclaration(node, classWrapper) as FirDeclaration<*>
PROPERTY -> container += convertPropertyDeclaration(node, classWrapper)
TYPEALIAS -> container += convertTypeAlias(node)
OBJECT_DECLARATION -> container += convertClass(node)
@@ -826,7 +826,7 @@ class DeclarationsConverter(
* @see org.jetbrains.kotlin.parsing.KotlinParsing.parseMemberDeclarationRest
* at INIT keyword
*/
private fun convertAnonymousInitializer(anonymousInitializer: LighterASTNode): FirDeclaration {
private fun convertAnonymousInitializer(anonymousInitializer: LighterASTNode): FirDeclaration<*> {
var firBlock: FirBlock? = null
anonymousInitializer.forEachChildren {
when (it.tokenType) {
@@ -949,7 +949,7 @@ class DeclarationsConverter(
/**
* @see org.jetbrains.kotlin.parsing.KotlinParsing.parseTypeAlias
*/
private fun convertTypeAlias(typeAlias: LighterASTNode): FirDeclaration {
private fun convertTypeAlias(typeAlias: LighterASTNode): FirDeclaration<*> {
var modifiers = Modifier()
var identifier: String? = null
lateinit var firType: FirTypeRef
@@ -985,7 +985,7 @@ class DeclarationsConverter(
/**
* @see org.jetbrains.kotlin.parsing.KotlinParsing.parseProperty
*/
fun convertPropertyDeclaration(property: LighterASTNode, classWrapper: ClassWrapper? = null): FirDeclaration {
fun convertPropertyDeclaration(property: LighterASTNode, classWrapper: ClassWrapper? = null): FirDeclaration<*> {
var modifiers = Modifier()
var identifier: String? = null
val firTypeParameters = mutableListOf<FirTypeParameter>()
@@ -1991,7 +1991,7 @@ class DeclarationsConverter(
typeParameters: List<FirTypeParameter>,
typeConstraints: List<TypeConstraint>,
to: T
) where T : FirDeclaration, T : FirTypeParameterRefsOwner {
) where T : FirDeclaration<T>, T : FirTypeParameterRefsOwner {
val typeParamNames = typeParameters.map { it.name }.toSet()
val result = typeConstraints.mapNotNull { constraint ->
val name = constraint.identifier.nameAsSafeName()
compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt
+4 -4
View File
@@ -218,7 +218,7 @@ open class RawFirBuilder(
owner: KtClassOrObject,
ownerClassBuilder: FirClassBuilder,
ownerTypeParameters: List<FirTypeParameterRef>
): FirDeclaration {
): FirDeclaration<*> {
return when (this) {
is KtSecondaryConstructor -> {
disabledLazyMode {
@@ -514,7 +514,7 @@ open class RawFirBuilder(
}
}
private fun <T> KtTypeParameterListOwner.fillDanglingConstraintsTo(to: T) where T : FirDeclaration, T : FirTypeParameterRefsOwner {
private fun <T> KtTypeParameterListOwner.fillDanglingConstraintsTo(to: T) where T : FirDeclaration<T>, T : FirTypeParameterRefsOwner {
val typeParamNames = typeParameters.mapNotNull { it.nameAsName }.toSet()
val result = typeConstraints.mapNotNull { constraint ->
constraint.subjectTypeParameterName?.getReferencedNameAsName()?.let { name ->
@@ -730,7 +730,7 @@ open class RawFirBuilder(
}
}
for (declaration in file.declarations) {
declarations += declaration.convert<FirDeclaration>()
declarations += declaration.convert<FirDeclaration<*>>()
}
}
}
@@ -738,7 +738,7 @@ open class RawFirBuilder(
private fun KtEnumEntry.toFirEnumEntry(
delegatedEnumSelfTypeRef: FirResolvedTypeRef,
ownerClassHasDefaultConstructor: Boolean
): FirDeclaration {
): FirDeclaration<*> {
val ktEnumEntry = this@toFirEnumEntry
return buildEnumEntry {
source = toFirSourceElement()
compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTotalKotlinTestCase.kt
+1 -1
View File
@@ -113,7 +113,7 @@ class RawFirBuilderTotalKotlinTestCase : AbstractRawFirBuilderTestCase() {
// errorDeclaration.psi?.let { println(it) }
// }
override fun visitDeclaration(declaration: FirDeclaration) {
override fun <T : FirDeclaration<T>> visitDeclaration(declaration: FirDeclaration<T>) {
normalDeclarations++
declaration.acceptChildren(this)
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt
+1 -1
View File
@@ -596,7 +596,7 @@ class FirCallResolver(
createResolvedReferenceWithoutCandidateForLocalVariables &&
explicitReceiver?.typeRef?.coneTypeSafe<ConeIntegerLiteralType>() == null &&
coneSymbol is FirVariableSymbol &&
(coneSymbol !is FirPropertySymbol || (coneSymbol.fir as FirMemberDeclaration).typeParameters.isEmpty())
(coneSymbol !is FirPropertySymbol || (coneSymbol.fir as FirMemberDeclaration<*>).typeParameters.isEmpty())
) {
return buildResolvedNamedReference {
this.source = source
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirVisibilityChecker.kt
+13 -13
View File
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
interface FirModuleVisibilityChecker : FirSessionComponent {
fun isInFriendModule(declaration: FirMemberDeclaration): Boolean
fun isInFriendModule(declaration: FirMemberDeclaration<*>): Boolean
}
abstract class FirVisibilityChecker : FirSessionComponent {
@@ -34,7 +34,7 @@ abstract class FirVisibilityChecker : FirSessionComponent {
declarationVisibility: Visibility,
symbol: FirBasedSymbol<*>,
useSiteFile: FirFile,
containingDeclarations: List<FirDeclaration>,
containingDeclarations: List<FirDeclaration<*>>,
dispatchReceiver: ReceiverValue?,
session: FirSession
): Boolean {
@@ -42,13 +42,13 @@ abstract class FirVisibilityChecker : FirSessionComponent {
}
}
fun <T> isVisible(
declaration: T,
fun isVisible(
declaration: FirMemberDeclaration<*>,
candidate: Candidate
): Boolean where T : FirMemberDeclaration, T : FirSymbolOwner<*> {
): Boolean {
if (declaration is FirCallableDeclaration<*> && (declaration.isIntersectionOverride || declaration.isSubstitutionOverride)) {
@Suppress("UNCHECKED_CAST")
return isVisible(declaration.originalIfFakeOverride() as T, candidate)
return isVisible(declaration.originalIfFakeOverride() as FirMemberDeclaration<*>, candidate)
}
val callInfo = candidate.callInfo
@@ -59,13 +59,13 @@ abstract class FirVisibilityChecker : FirSessionComponent {
return isVisible(declaration, session, useSiteFile, containingDeclarations, candidate.dispatchReceiverValue)
}
fun <T> isVisible(
declaration: T,
fun isVisible(
declaration: FirMemberDeclaration<*>,
session: FirSession,
useSiteFile: FirFile,
containingDeclarations: List<FirDeclaration>,
containingDeclarations: List<FirDeclaration<*>>,
dispatchReceiver: ReceiverValue?
): Boolean where T : FirMemberDeclaration, T : FirSymbolOwner<*> {
): Boolean {
val provider = session.firProvider
val symbol = declaration.symbol
return when (declaration.visibility) {
@@ -124,13 +124,13 @@ abstract class FirVisibilityChecker : FirSessionComponent {
declarationVisibility: Visibility,
symbol: FirBasedSymbol<*>,
useSiteFile: FirFile,
containingDeclarations: List<FirDeclaration>,
containingDeclarations: List<FirDeclaration<*>>,
dispatchReceiver: ReceiverValue?,
session: FirSession
): Boolean
private fun canSeePrivateMemberOf(
containingDeclarationOfUseSite: List<FirDeclaration>,
containingDeclarationOfUseSite: List<FirDeclaration<*>>,
ownerId: ClassId,
session: FirSession
): Boolean {
@@ -195,7 +195,7 @@ abstract class FirVisibilityChecker : FirSessionComponent {
}
protected fun canSeeProtectedMemberOf(
containingDeclarationOfUseSite: List<FirDeclaration>,
containingDeclarationOfUseSite: List<FirDeclaration<*>>,
dispatchReceiver: ReceiverValue?,
ownerId: ClassId, session: FirSession
): Boolean {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt
+1 -1
View File
@@ -85,6 +85,6 @@ private val USE_SITE_TARGET_NAME_MAP = mapOf(
private val DEFAULT_USE_SITE_TARGETS: Set<AnnotationUseSiteTarget> =
USE_SITE_TARGET_NAME_MAP.values.fold(setOf<AnnotationUseSiteTarget>()) { a, b -> a + b } - setOf(AnnotationUseSiteTarget.FILE)
fun FirAnnotatedDeclaration.hasAnnotation(classId: ClassId): Boolean {
fun FirAnnotatedDeclaration<*>.hasAnnotation(classId: ClassId): Boolean {
return annotations.any { it.toAnnotationClassId() == classId }
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/FirVersionRequirementsTableKey.kt
+1 -1
View File
@@ -9,4 +9,4 @@ import org.jetbrains.kotlin.metadata.deserialization.VersionRequirementTable
object FirVersionRequirementsTableKey : FirDeclarationDataKey()
var FirDeclaration.versionRequirementsTable: VersionRequirementTable? by FirDeclarationDataRegistry.data(FirVersionRequirementsTableKey)
var FirDeclaration<*>.versionRequirementsTable: VersionRequirementTable? by FirDeclarationDataRegistry.data(FirVersionRequirementsTableKey)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirDeclarationGenerationExtension.kt
+6 -6
View File
@@ -27,18 +27,18 @@ abstract class FirDeclarationGenerationExtension(session: FirSession) : FirPredi
final override val extensionType: KClass<out FirExtension> = FirDeclarationGenerationExtension::class
abstract fun generateClasses(
annotatedDeclaration: FirDeclaration,
owners: List<FirAnnotatedDeclaration>
annotatedDeclaration: FirDeclaration<*>,
owners: List<FirAnnotatedDeclaration<*>>
): List<GeneratedDeclaration<FirRegularClass>>
abstract fun generateMembersForGeneratedClass(generatedClass: GeneratedClass): List<FirDeclaration>
abstract fun generateMembersForGeneratedClass(generatedClass: GeneratedClass): List<FirDeclaration<*>>
abstract fun generateMembers(
annotatedDeclaration: FirDeclaration,
owners: List<FirAnnotatedDeclaration>
annotatedDeclaration: FirDeclaration<*>,
owners: List<FirAnnotatedDeclaration<*>>
): List<GeneratedDeclaration<*>>
data class GeneratedDeclaration<out T : FirDeclaration>(val newDeclaration: T, val owner: FirAnnotatedDeclaration)
data class GeneratedDeclaration<out T : FirDeclaration<*>>(val newDeclaration: T, val owner: FirAnnotatedDeclaration<*>)
fun interface Factory : FirExtension.Factory<FirDeclarationGenerationExtension>
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProvider.kt
+38 -38
View File
@@ -23,30 +23,30 @@ abstract class FirPredicateBasedProvider : FirSessionComponent {
}
}
abstract fun getSymbolsByPredicate(predicate: DeclarationPredicate): List<FirAnnotatedDeclaration>
abstract fun getSymbolsByPredicate(predicate: DeclarationPredicate): List<FirAnnotatedDeclaration<*>>
abstract fun getSymbolsByPredicate(
declarations: Collection<FirAnnotatedDeclaration>,
declarations: Collection<FirAnnotatedDeclaration<*>>,
predicate: DeclarationPredicate
): List<FirAnnotatedDeclaration>
): List<FirAnnotatedDeclaration<*>>
abstract fun getSymbolsWithOwnersByPredicate(
predicate: DeclarationPredicate
): List<Pair<FirAnnotatedDeclaration, List<FirAnnotatedDeclaration>>>
): List<Pair<FirAnnotatedDeclaration<*>, List<FirAnnotatedDeclaration<*>>>>
abstract fun getSymbolsWithOwnersByPredicate(
declarations: Collection<FirAnnotatedDeclaration>,
declarations: Collection<FirAnnotatedDeclaration<*>>,
predicate: DeclarationPredicate
): List<Pair<FirAnnotatedDeclaration, List<FirAnnotatedDeclaration>>>
): List<Pair<FirAnnotatedDeclaration<*>, List<FirAnnotatedDeclaration<*>>>>
abstract fun getOwnersOfDeclaration(declaration: FirAnnotatedDeclaration): List<FirAnnotatedDeclaration>?
abstract fun getOwnersOfDeclaration(declaration: FirAnnotatedDeclaration<*>): List<FirAnnotatedDeclaration<*>>?
abstract fun fileHasPluginAnnotations(file: FirFile): Boolean
abstract fun registerAnnotatedDeclaration(declaration: FirAnnotatedDeclaration, owners: PersistentList<FirAnnotatedDeclaration>)
abstract fun registerGeneratedDeclaration(declaration: FirAnnotatedDeclaration, owner: FirAnnotatedDeclaration)
abstract fun registerAnnotatedDeclaration(declaration: FirAnnotatedDeclaration<*>, owners: PersistentList<FirAnnotatedDeclaration<*>>)
abstract fun registerGeneratedDeclaration(declaration: FirAnnotatedDeclaration<*>, owner: FirAnnotatedDeclaration<*>)
abstract fun matches(predicate: DeclarationPredicate, declaration: FirAnnotatedDeclaration): Boolean
abstract fun matches(predicate: DeclarationPredicate, declaration: FirAnnotatedDeclaration<*>): Boolean
}
@NoMutableState
@@ -54,7 +54,7 @@ private class FirPredicateBasedProviderImpl(private val session: FirSession) : F
private val registeredPluginAnnotations = session.registeredPluginAnnotations
private val cache = Cache()
override fun getSymbolsByPredicate(predicate: DeclarationPredicate): List<FirAnnotatedDeclaration> {
override fun getSymbolsByPredicate(predicate: DeclarationPredicate): List<FirAnnotatedDeclaration<*>> {
val annotations = registeredPluginAnnotations.getAnnotationsForPredicate(predicate)
if (annotations.isEmpty()) return emptyList()
val declarations = annotations.flatMapTo(mutableSetOf()) { cache.declarationByAnnotation[it] + cache.declarationsUnderAnnotated[it] }
@@ -62,24 +62,24 @@ private class FirPredicateBasedProviderImpl(private val session: FirSession) : F
}
override fun getSymbolsByPredicate(
declarations: Collection<FirAnnotatedDeclaration>,
declarations: Collection<FirAnnotatedDeclaration<*>>,
predicate: DeclarationPredicate
): List<FirAnnotatedDeclaration> {
): List<FirAnnotatedDeclaration<*>> {
return declarations.filter { matches(predicate, it) }
}
override fun getSymbolsWithOwnersByPredicate(predicate: DeclarationPredicate): List<Pair<FirAnnotatedDeclaration, List<FirAnnotatedDeclaration>>> {
override fun getSymbolsWithOwnersByPredicate(predicate: DeclarationPredicate): List<Pair<FirAnnotatedDeclaration<*>, List<FirAnnotatedDeclaration<*>>>> {
return getSymbolsByPredicate(predicate).zipWithParents()
}
override fun getSymbolsWithOwnersByPredicate(
declarations: Collection<FirAnnotatedDeclaration>,
declarations: Collection<FirAnnotatedDeclaration<*>>,
predicate: DeclarationPredicate
): List<Pair<FirAnnotatedDeclaration, List<FirAnnotatedDeclaration>>> {
): List<Pair<FirAnnotatedDeclaration<*>, List<FirAnnotatedDeclaration<*>>>> {
return getSymbolsByPredicate(declarations, predicate).zipWithParents()
}
private fun List<FirAnnotatedDeclaration>.zipWithParents(): List<Pair<FirAnnotatedDeclaration, List<FirAnnotatedDeclaration>>> {
private fun List<FirAnnotatedDeclaration<*>>.zipWithParents(): List<Pair<FirAnnotatedDeclaration<*>, List<FirAnnotatedDeclaration<*>>>> {
return this.map { it to cache.ownersForDeclaration.getValue(it) }
}
@@ -87,7 +87,7 @@ private class FirPredicateBasedProviderImpl(private val session: FirSession) : F
return file in cache.filesWithPluginAnnotations
}
override fun registerAnnotatedDeclaration(declaration: FirAnnotatedDeclaration, owners: PersistentList<FirAnnotatedDeclaration>) {
override fun registerAnnotatedDeclaration(declaration: FirAnnotatedDeclaration<*>, owners: PersistentList<FirAnnotatedDeclaration<*>>) {
cache.ownersForDeclaration[declaration] = owners
registerOwnersDeclarations(declaration, owners)
@@ -101,16 +101,16 @@ private class FirPredicateBasedProviderImpl(private val session: FirSession) : F
cache.filesWithPluginAnnotations += file
}
override fun getOwnersOfDeclaration(declaration: FirAnnotatedDeclaration): List<FirAnnotatedDeclaration>? {
override fun getOwnersOfDeclaration(declaration: FirAnnotatedDeclaration<*>): List<FirAnnotatedDeclaration<*>>? {
return cache.ownersForDeclaration[declaration]
}
override fun registerGeneratedDeclaration(declaration: FirAnnotatedDeclaration, owner: FirAnnotatedDeclaration) {
override fun registerGeneratedDeclaration(declaration: FirAnnotatedDeclaration<*>, owner: FirAnnotatedDeclaration<*>) {
val owners = cache.ownersForDeclaration.getValue(owner).add(owner)
registerAnnotatedDeclaration(declaration, owners)
}
private fun registerOwnersDeclarations(declaration: FirAnnotatedDeclaration, owners: PersistentList<FirAnnotatedDeclaration>) {
private fun registerOwnersDeclarations(declaration: FirAnnotatedDeclaration<*>, owners: PersistentList<FirAnnotatedDeclaration<*>>) {
val lastOwner = owners.lastOrNull() ?: return
val annotationsFromLastOwner = cache.annotationsOfDeclaration[lastOwner]
val annotationsFromPreviousOwners = cache.parentAnnotationsOfDeclaration[lastOwner]
@@ -122,53 +122,53 @@ private class FirPredicateBasedProviderImpl(private val session: FirSession) : F
// ---------------------------------- Matching ----------------------------------
override fun matches(predicate: DeclarationPredicate, declaration: FirAnnotatedDeclaration): Boolean {
override fun matches(predicate: DeclarationPredicate, declaration: FirAnnotatedDeclaration<*>): Boolean {
return predicate.accept(matcher, declaration)
}
private val matcher = Matcher()
private inner class Matcher : DeclarationPredicateVisitor<Boolean, FirAnnotatedDeclaration>() {
override fun visitPredicate(predicate: DeclarationPredicate, data: FirAnnotatedDeclaration): Boolean {
private inner class Matcher : DeclarationPredicateVisitor<Boolean, FirAnnotatedDeclaration<*>>() {
override fun visitPredicate(predicate: DeclarationPredicate, data: FirAnnotatedDeclaration<*>): Boolean {
throw IllegalStateException("Should not be there")
}
override fun visitAny(predicate: DeclarationPredicate.Any, data: FirAnnotatedDeclaration): Boolean {
override fun visitAny(predicate: DeclarationPredicate.Any, data: FirAnnotatedDeclaration<*>): Boolean {
return true
}
override fun visitAnd(predicate: DeclarationPredicate.And, data: FirAnnotatedDeclaration): Boolean {
override fun visitAnd(predicate: DeclarationPredicate.And, data: FirAnnotatedDeclaration<*>): Boolean {
return predicate.a.accept(this, data) && predicate.b.accept(this, data)
}
override fun visitOr(predicate: DeclarationPredicate.Or, data: FirAnnotatedDeclaration): Boolean {
override fun visitOr(predicate: DeclarationPredicate.Or, data: FirAnnotatedDeclaration<*>): Boolean {
return predicate.a.accept(this, data) || predicate.b.accept(this, data)
}
override fun visitAnnotatedWith(predicate: AnnotatedWith, data: FirAnnotatedDeclaration): Boolean {
override fun visitAnnotatedWith(predicate: AnnotatedWith, data: FirAnnotatedDeclaration<*>): Boolean {
return matchWith(data, predicate.annotations)
}
override fun visitUnderAnnotatedWith(predicate: UnderAnnotatedWith, data: FirAnnotatedDeclaration): Boolean {
override fun visitUnderAnnotatedWith(predicate: UnderAnnotatedWith, data: FirAnnotatedDeclaration<*>): Boolean {
return matchUnder(data, predicate.annotations)
}
override fun visitAnnotatedWithMeta(predicate: AnnotatedWithMeta, data: FirAnnotatedDeclaration): Boolean {
override fun visitAnnotatedWithMeta(predicate: AnnotatedWithMeta, data: FirAnnotatedDeclaration<*>): Boolean {
return matchWith(data, predicate.userDefinedAnnotations)
}
override fun visitUnderMetaAnnotated(predicate: UnderMetaAnnotated, data: FirAnnotatedDeclaration): Boolean {
override fun visitUnderMetaAnnotated(predicate: UnderMetaAnnotated, data: FirAnnotatedDeclaration<*>): Boolean {
return matchUnder(data, predicate.userDefinedAnnotations)
}
private val MetaAnnotated.userDefinedAnnotations: Set<AnnotationFqn>
get() = metaAnnotations.flatMapTo(mutableSetOf()) { registeredPluginAnnotations.getAnnotationsWithMetaAnnotation(it) }
private fun matchWith(declaration: FirAnnotatedDeclaration, annotations: Set<AnnotationFqn>): Boolean {
private fun matchWith(declaration: FirAnnotatedDeclaration<*>, annotations: Set<AnnotationFqn>): Boolean {
return cache.annotationsOfDeclaration[declaration].any { it in annotations }
}
private fun matchUnder(declaration: FirAnnotatedDeclaration, annotations: Set<AnnotationFqn>): Boolean {
private fun matchUnder(declaration: FirAnnotatedDeclaration<*>, annotations: Set<AnnotationFqn>): Boolean {
return cache.parentAnnotationsOfDeclaration[declaration].any { it in annotations }
}
}
@@ -176,13 +176,13 @@ private class FirPredicateBasedProviderImpl(private val session: FirSession) : F
// ---------------------------------- Cache ----------------------------------
private class Cache {
val declarationByAnnotation: Multimap<AnnotationFqn, FirAnnotatedDeclaration> = LinkedHashMultimap.create()
val annotationsOfDeclaration: LinkedHashMultimap<FirAnnotatedDeclaration, AnnotationFqn> = LinkedHashMultimap.create()
val declarationByAnnotation: Multimap<AnnotationFqn, FirAnnotatedDeclaration<*>> = LinkedHashMultimap.create()
val annotationsOfDeclaration: LinkedHashMultimap<FirAnnotatedDeclaration<*>, AnnotationFqn> = LinkedHashMultimap.create()
val declarationsUnderAnnotated: Multimap<AnnotationFqn, FirAnnotatedDeclaration> = LinkedHashMultimap.create()
val parentAnnotationsOfDeclaration: LinkedHashMultimap<FirAnnotatedDeclaration, AnnotationFqn> = LinkedHashMultimap.create()
val declarationsUnderAnnotated: Multimap<AnnotationFqn, FirAnnotatedDeclaration<*>> = LinkedHashMultimap.create()
val parentAnnotationsOfDeclaration: LinkedHashMultimap<FirAnnotatedDeclaration<*>, AnnotationFqn> = LinkedHashMultimap.create()
val ownersForDeclaration: MutableMap<FirAnnotatedDeclaration, PersistentList<FirAnnotatedDeclaration>> = mutableMapOf()
val ownersForDeclaration: MutableMap<FirAnnotatedDeclaration<*>, PersistentList<FirAnnotatedDeclaration<*>>> = mutableMapOf()
val filesWithPluginAnnotations: MutableSet<FirFile> = mutableSetOf()
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirStatusTransformerExtension.kt
+2 -2
View File
@@ -25,8 +25,8 @@ abstract class FirStatusTransformerExtension(session: FirSession) : FirPredicate
final override val extensionType: KClass<out FirExtension> = FirStatusTransformerExtension::class
abstract fun transformStatus(
declaration: FirDeclaration,
owners: List<FirAnnotatedDeclaration>,
declaration: FirDeclaration<*>,
owners: List<FirAnnotatedDeclaration<*>>,
status: FirDeclarationStatus
): FirDeclarationStatus
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/BodyResolveComponents.kt
+3 -3
View File
@@ -45,7 +45,7 @@ data class SessionHolderImpl(override val session: FirSession, override val scop
abstract class BodyResolveComponents : SessionHolder {
abstract val returnTypeCalculator: ReturnTypeCalculator
abstract val implicitReceiverStack: ImplicitReceiverStack
abstract val containingDeclarations: List<FirDeclaration>
abstract val containingDeclarations: List<FirDeclaration<*>>
abstract val fileImportsScope: List<FirScope>
abstract val towerDataElements: List<FirTowerDataElement>
abstract val towerDataContext: FirTowerDataContext
@@ -53,7 +53,7 @@ abstract class BodyResolveComponents : SessionHolder {
abstract val noExpectedType: FirTypeRef
abstract val symbolProvider: FirSymbolProvider
abstract val file: FirFile
abstract val container: FirDeclaration
abstract val container: FirDeclaration<*>
abstract val resolutionStageRunner: ResolutionStageRunner
abstract val samResolver: FirSamResolver
abstract val callResolver: FirCallResolver
@@ -211,7 +211,7 @@ data class ImplicitReceivers(
fun SessionHolder.collectImplicitReceivers(
type: ConeKotlinType?,
owner: FirDeclaration
owner: FirDeclaration<*>
): ImplicitReceivers {
if (type == null) return ImplicitReceivers(null, emptyList())
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt
+4 -4
View File
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
import org.jetbrains.kotlin.fir.resolve.transformers.ensureResolved
import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
import org.jetbrains.kotlin.fir.scopes.impl.importedFromObjectData
import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.*
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
@@ -59,7 +59,7 @@ fun FirFunction<*>.constructFunctionalTypeRef(isSuspend: Boolean = false): FirRe
)
)
}
val rawReturnType = (this as FirTypedDeclaration).returnTypeRef.coneType
val rawReturnType = (this as FirTypedDeclaration<*>).returnTypeRef.coneType
val functionalType = createFunctionalType(parameters, receiverTypeRef?.coneType, rawReturnType, isSuspend = isSuspend)
@@ -155,7 +155,7 @@ internal fun typeForReifiedParameterReference(parameterReferenceBuilder: FirReso
return resultType.resolvedTypeFromPrototype(typeParameterSymbol.constructType(emptyArray(), false))
}
internal fun typeForQualifierByDeclaration(declaration: FirDeclaration, resultType: FirTypeRef, session: FirSession): FirTypeRef? {
internal fun typeForQualifierByDeclaration(declaration: FirDeclaration<*>, resultType: FirTypeRef, session: FirSession): FirTypeRef? {
if (declaration is FirTypeAlias) {
val expandedDeclaration = declaration.expandedConeType?.lookupTag?.toSymbol(session)?.fir ?: return null
return typeForQualifierByDeclaration(expandedDeclaration, resultType, session)
@@ -413,7 +413,7 @@ fun FirFunction<*>.getAsForbiddenNamedArgumentsTarget(session: FirSession): Forb
}
}
}
if (this is FirMemberDeclaration && status.isExpect) {
if (this is FirMemberDeclaration<*> && status.isExpect) {
return ForbiddenNamedArgumentsTarget.EXPECTED_CLASS_MEMBER
}
return when (origin) {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CallableReferenceResolution.kt
+2 -2
View File
@@ -18,11 +18,11 @@ import org.jetbrains.kotlin.fir.resolve.createFunctionalType
import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnsupportedCallableReferenceTarget
import org.jetbrains.kotlin.fir.resolve.inference.extractInputOutputTypesFromCallableReferenceExpectedType
import org.jetbrains.kotlin.fir.resolve.inference.isSuspendFunctionType
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.FirVisitor
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.resolve.calls.components.SuspendConversionStrategy
import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemOperation
import org.jetbrains.kotlin.resolve.calls.inference.model.SimpleConstraintSystemConstraintPosition
@@ -407,6 +407,6 @@ private fun FirVariable<*>.canBeMutableReference(candidate: Candidate): Boolean
if (this is FirField) return true
val original = this.unwrapFakeOverrides()
return original.source?.kind == FirFakeSourceElementKind.PropertyFromParameter ||
(original.setter is FirMemberDeclaration &&
(original.setter is FirMemberDeclaration<*> &&
candidate.callInfo.session.visibilityChecker.isVisible(original.setter!!, candidate))
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Candidate.kt
+1 -1
View File
@@ -48,7 +48,7 @@ data class CallInfo(
val typeArguments: List<FirTypeProjection>,
val session: FirSession,
val containingFile: FirFile,
val containingDeclarations: List<FirDeclaration>,
val containingDeclarations: List<FirDeclaration<*>>,
val candidateForCommonInvokeReceiver: Candidate? = null,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt
+2 -2
View File
@@ -10,8 +10,8 @@ import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
import org.jetbrains.kotlin.fir.declarations.modality
import org.jetbrains.kotlin.fir.render
import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
import org.jetbrains.kotlin.fir.resolve.inference.ConeTypeParameterBasedTypeVariable
import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
import org.jetbrains.kotlin.fir.types.coneType
@@ -102,7 +102,7 @@ class ConeOverloadConflictResolver(
}
if (discriminateAbstracts) {
val filtered = candidates.filterTo(mutableSetOf()) { (it.symbol.fir as? FirMemberDeclaration)?.modality != Modality.ABSTRACT }
val filtered = candidates.filterTo(mutableSetOf()) { (it.symbol.fir as? FirMemberDeclaration<*>)?.modality != Modality.ABSTRACT }
when (filtered.size) {
1 -> return filtered
0, candidates.size -> {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt
+4 -5
View File
@@ -6,7 +6,6 @@
package org.jetbrains.kotlin.fir.resolve.calls
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.FirVisibilityChecker
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.*
@@ -101,7 +100,7 @@ object CheckDispatchReceiver : ResolutionStage() {
override suspend fun check(candidate: Candidate, callInfo: CallInfo, sink: CheckerSink, context: ResolutionContext) {
val explicitReceiverExpression = callInfo.explicitReceiver
if (explicitReceiverExpression.isSuperCall()) {
val status = candidate.symbol.fir as? FirMemberDeclaration
val status = candidate.symbol.fir as? FirMemberDeclaration<*>
if (status?.modality == Modality.ABSTRACT) {
sink.reportDiagnostic(ResolvedWithLowPriority)
}
@@ -197,7 +196,7 @@ internal object CheckVisibility : CheckerStage() {
val visibilityChecker = callInfo.session.visibilityChecker
val symbol = candidate.symbol
val declaration = symbol.fir
if (declaration is FirMemberDeclaration) {
if (declaration is FirMemberDeclaration<*>) {
if (!checkVisibility(declaration, sink, candidate, visibilityChecker)) {
return
}
@@ -216,12 +215,12 @@ internal object CheckVisibility : CheckerStage() {
}
}
private suspend fun <T> checkVisibility(
private suspend fun <T : FirMemberDeclaration<*>> checkVisibility(
declaration: T,
sink: CheckerSink,
candidate: Candidate,
visibilityChecker: FirVisibilityChecker
): Boolean where T : FirMemberDeclaration, T : FirSymbolOwner<*> {
): Boolean {
if (!visibilityChecker.isVisible(declaration, candidate)) {
sink.yieldDiagnostic(HiddenCandidate)
return false
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/Stack.kt
+4 -4
View File
@@ -6,7 +6,7 @@
package org.jetbrains.kotlin.fir.resolve.dfa
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.resolve.dfa.cfg.CFGNode
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
@@ -76,12 +76,12 @@ class SymbolBasedNodeStorage<T, N : CFGNode<T>> : Stack<N>() where T : FirElemen
override fun top(): N = stack.top()
override fun pop(): N = stack.pop().also {
map.remove((it.fir as FirSymbolOwner<*>).symbol)
map.remove((it.fir as FirDeclaration<*>).symbol)
}
override fun push(value: N) {
stack.push(value)
map[(value.fir as FirSymbolOwner<*>).symbol] = value
map[(value.fir as FirDeclaration<*>).symbol] = value
}
operator fun get(key: FirBasedSymbol<*>): N? {
@@ -92,4 +92,4 @@ class SymbolBasedNodeStorage<T, N : CFGNode<T>> : Stack<N>() where T : FirElemen
stack.reset()
map.clear()
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraph.kt
+1 -1
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.dfa.cfg
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
class ControlFlowGraph(val declaration: FirDeclaration?, val name: String, val kind: Kind) {
class ControlFlowGraph(val declaration: FirDeclaration<*>?, val name: String, val kind: Kind) {
private var _nodes: MutableList<CFGNode<*>> = mutableListOf()
val nodes: List<CFGNode<*>>
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt
+5 -6
View File
@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.resolve.dfa.cfg
import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.builder.buildAnonymousFunctionExpression
@@ -413,13 +412,13 @@ class ControlFlowGraphBuilder {
return popGraph()
}
fun prepareForLocalClassMembers(members: Collection<FirSymbolOwner<*>>) {
fun prepareForLocalClassMembers(members: Collection<FirDeclaration<*>>) {
members.forEachMember {
enterToLocalClassesMembers[it.symbol] = lastNodes.topOrNull()
}
}
fun cleanAfterForLocalClassMembers(members: Collection<FirSymbolOwner<*>>) {
fun cleanAfterForLocalClassMembers(members: Collection<FirDeclaration<*>>) {
members.forEachMember {
enterToLocalClassesMembers.remove(it.symbol)
}
@@ -1362,7 +1361,7 @@ class ControlFlowGraphBuilder {
// ----------------------------------- Utils -----------------------------------
private inline fun Collection<FirSymbolOwner<*>>.forEachMember(block: (FirSymbolOwner<*>) -> Unit) {
private inline fun Collection<FirDeclaration<*>>.forEachMember(block: (FirDeclaration<*>) -> Unit) {
for (member in this) {
for (callableDeclaration in member.unwrap()) {
block(callableDeclaration)
@@ -1370,7 +1369,7 @@ class ControlFlowGraphBuilder {
}
}
private fun FirSymbolOwner<*>.unwrap(): List<FirSymbolOwner<*>> =
private fun FirDeclaration<*>.unwrap(): List<FirDeclaration<*>> =
when (this) {
is FirFunction<*>, is FirAnonymousInitializer -> listOf(this)
is FirProperty -> listOfNotNull(this.getter, this.setter, this)
@@ -1384,4 +1383,4 @@ class ControlFlowGraphBuilder {
}
fun FirDeclaration?.isLocalClassOrAnonymousObject() = ((this as? FirRegularClass)?.isLocal == true) || this is FirAnonymousObject
fun FirDeclaration<*>?.isLocalClassOrAnonymousObject() = ((this as? FirRegularClass)?.isLocal == true) || this is FirAnonymousObject
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/util.kt
+2 -2
View File
@@ -7,9 +7,9 @@ package org.jetbrains.kotlin.fir.resolve.dfa
import kotlinx.collections.immutable.PersistentMap
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSymbolOwner
import org.jetbrains.kotlin.fir.contracts.description.ConeBooleanConstantReference
import org.jetbrains.kotlin.fir.contracts.description.ConeConstantReference
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
import org.jetbrains.kotlin.fir.references.FirThisReference
@@ -95,7 +95,7 @@ internal val FirExpression.coneType: ConeKotlinType
internal val FirElement.symbol: FirBasedSymbol<*>?
get() = when (this) {
is FirResolvable -> symbol
is FirSymbolOwner<*> -> symbol
is FirDeclaration<*> -> symbol
is FirWhenSubjectExpression -> whenRef.value.subject?.symbol
is FirSafeCallExpression -> regularQualifiedAccess.symbol
else -> null
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt
+1 -1
View File
@@ -273,4 +273,4 @@ class FirStubTypeTransformer(
private val BUILDER_INFERENCE_ANNOTATION_CLASS_ID = ClassId.topLevel(BUILDER_INFERENCE_ANNOTATION_FQ_NAME)
fun FirElement.hasBuilderInferenceAnnotation(): Boolean =
(this as? FirAnnotatedDeclaration)?.hasAnnotation(BUILDER_INFERENCE_ANNOTATION_CLASS_ID) == true
(this as? FirAnnotatedDeclaration<*>)?.hasAnnotation(BUILDER_INFERENCE_ANNOTATION_CLASS_ID) == true
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/FirProvider.kt
+2 -2
View File
@@ -41,10 +41,10 @@ abstract class FirProvider : FirSessionComponent {
abstract fun getFirFilesByPackage(fqName: FqName): List<FirFile>
@FirProviderInternals
abstract fun recordGeneratedClass(owner: FirAnnotatedDeclaration, klass: FirRegularClass)
abstract fun recordGeneratedClass(owner: FirAnnotatedDeclaration<*>, klass: FirRegularClass)
@FirProviderInternals
abstract fun recordGeneratedMember(owner: FirAnnotatedDeclaration, klass: FirDeclaration)
abstract fun recordGeneratedMember(owner: FirAnnotatedDeclaration<*>, klass: FirDeclaration<*>)
abstract fun getClassNamesInPackage(fqName: FqName): Set<Name>
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/FirSymbolProvider.kt
+1 -1
View File
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.scopes.getDeclaredConstructors
import org.jetbrains.kotlin.fir.scopes.getFunctions
import org.jetbrains.kotlin.fir.scopes.getProperties
import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.*
import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType
import org.jetbrains.kotlin.fir.types.FirTypeRef
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirLibrarySessionProvider.kt
+3 -3
View File
@@ -27,12 +27,12 @@ class FirLibrarySessionProvider(
override fun getFirFilesByPackage(fqName: FqName): List<FirFile> = emptyList()
@FirProviderInternals
override fun recordGeneratedClass(owner: FirAnnotatedDeclaration, klass: FirRegularClass) = shouldNotBeCalled()
override fun recordGeneratedClass(owner: FirAnnotatedDeclaration<*>, klass: FirRegularClass) = shouldNotBeCalled()
@FirProviderInternals
override fun recordGeneratedMember(owner: FirAnnotatedDeclaration, klass: FirDeclaration) = shouldNotBeCalled()
override fun recordGeneratedMember(owner: FirAnnotatedDeclaration<*>, klass: FirDeclaration<*>) = shouldNotBeCalled()
override fun getClassNamesInPackage(fqName: FqName): Set<Name> = shouldNotBeCalled()
private fun shouldNotBeCalled(): Nothing = error("Should not be called for FirLibrarySessionProvider")
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirProviderImpl.kt
+4 -4
View File
@@ -14,9 +14,9 @@ import org.jetbrains.kotlin.fir.resolve.providers.FirProviderInternals
import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProviderInternals
import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
import org.jetbrains.kotlin.name.CallableId
import org.jetbrains.kotlin.fir.symbols.impl.*
import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
import org.jetbrains.kotlin.name.CallableId
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
@@ -78,16 +78,16 @@ class FirProviderImpl(val session: FirSession, val kotlinScopeProvider: FirKotli
}
@FirProviderInternals
override fun recordGeneratedClass(owner: FirAnnotatedDeclaration, klass: FirRegularClass) {
override fun recordGeneratedClass(owner: FirAnnotatedDeclaration<*>, klass: FirRegularClass) {
klass.accept(FirRecorder, FirRecorderData(state, owner.file, session.nameConflictsTracker))
}
@FirProviderInternals
override fun recordGeneratedMember(owner: FirAnnotatedDeclaration, klass: FirDeclaration) {
override fun recordGeneratedMember(owner: FirAnnotatedDeclaration<*>, klass: FirDeclaration<*>) {
klass.accept(FirRecorder, FirRecorderData(state, owner.file, session.nameConflictsTracker))
}
private val FirAnnotatedDeclaration.file: FirFile
private val FirAnnotatedDeclaration<*>.file: FirFile
get() = when (this) {
is FirFile -> this
is FirRegularClass -> getFirClassifierContainerFile(this.symbol.classId)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractPhaseTransformer.kt
+2 -3
View File
@@ -31,11 +31,10 @@ abstract class FirAbstractPhaseTransformer<D>(
file.replaceResolvePhase(transformerPhase)
}
@Suppress("UNCHECKED_CAST")
return super.transformFile(file, data) as FirFile
return super.transformFile(file, data)
}
override fun transformDeclaration(declaration: FirDeclaration, data: D): FirDeclaration {
override fun <T : FirDeclaration<T>> transformDeclaration(declaration: FirDeclaration<T>, data: D): FirDeclaration<T> {
if (declaration.resolvePhase < transformerPhase) {
declaration.replaceResolvePhase(transformerPhase)
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt
+3 -4
View File
@@ -10,7 +10,6 @@ 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.FirStatement
import org.jetbrains.kotlin.fir.resolve.ResolutionMode
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes
import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
@@ -33,7 +32,7 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(
protected val scopes = mutableListOf<FirScope>()
protected val towerScope = FirCompositeScope(scopes.asReversed())
protected open fun needReplacePhase(firDeclaration: FirDeclaration): Boolean = transformerPhase > firDeclaration.resolvePhase
protected open fun needReplacePhase(firDeclaration: FirDeclaration<*>): Boolean = transformerPhase > firDeclaration.resolvePhase
protected inline fun <T> withScopeCleanup(crossinline l: () -> T): T {
val sizeBefore = scopes.size
@@ -89,13 +88,13 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(
}
}
protected fun FirMemberDeclaration.addTypeParametersScope() {
protected fun FirMemberDeclaration<*>.addTypeParametersScope() {
if (typeParameters.isNotEmpty()) {
scopes.add(FirMemberTypeParameterScope(this))
}
}
open fun transformDeclarationContent(declaration: FirDeclaration, data: Any?): FirDeclaration {
open fun transformDeclarationContent(declaration: FirDeclaration<*>, data: Any?): FirDeclaration<*> {
return transformElement(declaration, data)
}
}

Some files were not shown because too many files have changed in this diff Show More