diff --git a/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt b/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt index 9d1c29cbbfd..2dbbf508df9 100644 --- a/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt +++ b/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt @@ -328,7 +328,7 @@ class MultiModuleHtmlFirDump(private val outputRoot: File) { symbolIds[symbolOwner.symbol] = symbolCounter++ } - override fun visitVariable(variable: FirVariable) { + override fun > visitVariable(variable: FirVariable) { indexDeclaration(variable) super.visitVariable(variable) } @@ -696,7 +696,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver generate(type.directExpansionType(session) ?: ConeKotlinErrorType("No expansion for type-alias")) } is ConeTypeParameterType -> resolved { - symbolRef(type.lookupTag.toSymbol(session)) { + symbolRef(type.lookupTag.toSymbol()) { simpleName(type.lookupTag.name) } } @@ -794,7 +794,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver +"> " } - private fun FlowContent.generateReceiver(declaration: FirCallableDeclaration) { + private fun FlowContent.generateReceiver(declaration: FirCallableDeclaration<*>) { generateReceiver(declaration.receiverTypeRef) } @@ -873,13 +873,13 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver is FirWhenExpression -> generate(statement, isStatement = true) is FirTryExpression -> generate(statement, isStatement = true) is FirExpression -> iline { generate(statement) } - is FirVariable -> iline { generate(statement) } + is FirVariable<*> -> iline { generate(statement) } is FirVariableAssignment -> iline { generate(statement) } else -> unsupported(statement) } } - private fun FlowContent.generate(variable: FirVariable) { + private fun FlowContent.generate(variable: FirVariable<*>) { if (variable.isVal) { keyword("val ") } else { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt index 6dd3956f24c..aa97b6ec837 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt @@ -104,10 +104,11 @@ fun FirReference.toSymbol(declarationStorage: Fir2IrDeclarationStorage): IrSymbo fun FirNamedReference.toSymbol(declarationStorage: Fir2IrDeclarationStorage): IrSymbol? { if (this is FirResolvedCallableReference) { when (val callableSymbol = this.coneSymbol) { - is FirFunctionSymbol -> return callableSymbol.toFunctionSymbol(declarationStorage) + is FirFunctionSymbol<*> -> return callableSymbol.toFunctionSymbol(declarationStorage) is FirPropertySymbol -> return callableSymbol.toPropertyOrFieldSymbol(declarationStorage) + is FirFieldSymbol -> return callableSymbol.toPropertyOrFieldSymbol(declarationStorage) is FirBackingFieldSymbol -> return callableSymbol.toPropertyOrFieldSymbol(declarationStorage) - is FirVariableSymbol -> return callableSymbol.toValueSymbol(declarationStorage) + is FirVariableSymbol<*> -> return callableSymbol.toValueSymbol(declarationStorage) } } return null @@ -121,14 +122,14 @@ fun FirTypeParameterSymbol.toTypeParameterSymbol(declarationStorage: Fir2IrDecla return declarationStorage.getIrTypeParameterSymbol(this) } -fun FirFunctionSymbol.toFunctionSymbol(declarationStorage: Fir2IrDeclarationStorage): IrFunctionSymbol { +fun FirFunctionSymbol<*>.toFunctionSymbol(declarationStorage: Fir2IrDeclarationStorage): IrFunctionSymbol { return declarationStorage.getIrFunctionSymbol(this) } -fun FirVariableSymbol.toPropertyOrFieldSymbol(declarationStorage: Fir2IrDeclarationStorage): IrSymbol { +fun FirVariableSymbol<*>.toPropertyOrFieldSymbol(declarationStorage: Fir2IrDeclarationStorage): IrSymbol { return declarationStorage.getIrPropertyOrFieldSymbol(this) } -fun FirVariableSymbol.toValueSymbol(declarationStorage: Fir2IrDeclarationStorage): IrValueSymbol { +fun FirVariableSymbol<*>.toValueSymbol(declarationStorage: Fir2IrDeclarationStorage): IrValueSymbol { return declarationStorage.getIrValueSymbol(this) } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrCallableCache.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrCallableCache.kt index a1e71b63129..b6cea311547 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrCallableCache.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrCallableCache.kt @@ -13,7 +13,7 @@ import org.jetbrains.kotlin.ir.declarations.* class Fir2IrCallableCache { private val parameterCache = mutableMapOf() - private val variableCache = mutableMapOf() + private val variableCache = mutableMapOf, IrVariable>() private val localClassCache = mutableMapOf() @@ -25,9 +25,9 @@ class Fir2IrCallableCache { parameterCache[firParameter] = irParameter } - fun getVariable(variable: FirVariable): IrVariable? = variableCache[variable] + fun getVariable(variable: FirVariable<*>): IrVariable? = variableCache[variable] - fun putVariable(firVariable: FirVariable, irVariable: IrVariable) { + fun putVariable(firVariable: FirVariable<*>, irVariable: IrVariable) { variableCache[firVariable] = irVariable } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt index a7ac6f69b82..84c17976653 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt @@ -197,7 +197,7 @@ class Fir2IrDeclarationStorage( } } - internal fun findIrParent(callableMemberDeclaration: FirCallableMemberDeclaration): IrDeclarationParent? { + internal fun findIrParent(callableMemberDeclaration: FirCallableMemberDeclaration<*>): IrDeclarationParent? { val firBasedSymbol = callableMemberDeclaration.symbol val callableId = firBasedSymbol.callableId val parentClassId = callableId.classId @@ -449,7 +449,7 @@ class Fir2IrDeclarationStorage( } } - fun createAndSaveIrVariable(variable: FirVariable): IrVariable { + fun createAndSaveIrVariable(variable: FirVariable<*>): IrVariable { val type = variable.returnTypeRef.toIrType(session, this) val irVariable = variable.convertWithOffsets { startOffset, endOffset -> declareIrVariable( @@ -479,9 +479,9 @@ class Fir2IrDeclarationStorage( return irSymbolTable.referenceTypeParameter(irTypeParameter.descriptor) } - fun getIrFunctionSymbol(firFunctionSymbol: FirFunctionSymbol): IrFunctionSymbol { + fun getIrFunctionSymbol(firFunctionSymbol: FirFunctionSymbol<*>): IrFunctionSymbol { val firDeclaration = firFunctionSymbol.fir - val irParent = (firDeclaration as? FirCallableMemberDeclaration)?.let { findIrParent(it) } + val irParent = (firDeclaration as? FirCallableMemberDeclaration<*>)?.let { findIrParent(it) } return when (firDeclaration) { is FirNamedFunction -> { val irDeclaration = getIrFunction(firDeclaration, irParent, shouldLeaveScope = true).apply { @@ -499,7 +499,7 @@ class Fir2IrDeclarationStorage( } } - fun getIrPropertyOrFieldSymbol(firVariableSymbol: FirVariableSymbol): IrSymbol { + fun getIrPropertyOrFieldSymbol(firVariableSymbol: FirVariableSymbol<*>): IrSymbol { return when (val fir = firVariableSymbol.fir) { is FirProperty -> { val irProperty = getIrProperty(fir).apply { @@ -517,13 +517,13 @@ class Fir2IrDeclarationStorage( } } - private fun getIrVariableSymbol(firVariable: FirVariable): IrVariableSymbol { + private fun getIrVariableSymbol(firVariable: FirVariable<*>): IrVariableSymbol { val irDeclaration = localStorage.getVariable(firVariable) ?: throw IllegalArgumentException("Cannot find variable ${firVariable.render()} in local storage") return irSymbolTable.referenceVariable(irDeclaration.descriptor) } - fun getIrValueSymbol(firVariableSymbol: FirVariableSymbol): IrValueSymbol { + fun getIrValueSymbol(firVariableSymbol: FirVariableSymbol<*>): IrValueSymbol { return when (val firDeclaration = firVariableSymbol.fir) { is FirValueParameter -> { val irDeclaration = localStorage.getParameter(firDeclaration) @@ -531,10 +531,9 @@ class Fir2IrDeclarationStorage( ?: return getIrVariableSymbol(firDeclaration) irSymbolTable.referenceValueParameter(irDeclaration.descriptor) } - is FirVariable -> { + else -> { getIrVariableSymbol(firDeclaration) } - else -> throw AssertionError("Should not be here") } } } \ No newline at end of file diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrLocalStorage.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrLocalStorage.kt index 03026288426..75ef3ba10e9 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrLocalStorage.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrLocalStorage.kt @@ -32,7 +32,7 @@ class Fir2IrLocalStorage { return null } - fun getVariable(variable: FirVariable): IrVariable? { + fun getVariable(variable: FirVariable<*>): IrVariable? { for (cache in cacheStack.asReversed()) { val local = cache.getVariable(variable) if (local != null) return local @@ -60,7 +60,7 @@ class Fir2IrLocalStorage { cacheStack.last().putParameter(firParameter, irParameter) } - fun putVariable(firVariable: FirVariable, irVariable: IrVariable) { + fun putVariable(firVariable: FirVariable<*>, irVariable: IrVariable) { cacheStack.last().putVariable(firVariable, irVariable) } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt index 55be56a405f..19a0b7c596a 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt @@ -21,13 +21,8 @@ import org.jetbrains.kotlin.fir.resolve.buildUseSiteScope import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope -import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTagImpl -import org.jetbrains.kotlin.fir.symbols.ConeClassifierLookupTag -import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol +import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef @@ -207,8 +202,8 @@ internal class Fir2IrVisitor( processedFunctionNames += name useSiteScope.processFunctionsByName(name) { functionSymbol -> // TODO: think about overloaded functions. May be we should process all names. - if (functionSymbol is FirFunctionSymbol) { - val originalFunction = functionSymbol.fir as FirNamedFunction + if (functionSymbol is FirNamedFunctionSymbol) { + val originalFunction = functionSymbol.fir val origin = IrDeclarationOrigin.FAKE_OVERRIDE if (functionSymbol.isFakeOverride) { // Substitution case @@ -222,7 +217,7 @@ internal class Fir2IrVisitor( } else if (fakeOverrideMode != FakeOverrideMode.SUBSTITUTION) { // Trivial fake override case val fakeOverrideSymbol = FirClassSubstitutionScope.createFakeOverride(session, originalFunction, functionSymbol) - val fakeOverrideFunction = fakeOverrideSymbol.fir as FirNamedFunction + val fakeOverrideFunction = fakeOverrideSymbol.fir val irFunction = declarationStorage.getIrFunction( fakeOverrideFunction, declarationStorage.findIrParent(originalFunction), origin = origin @@ -278,7 +273,7 @@ internal class Fir2IrVisitor( private fun T.setFunctionContent( descriptor: FunctionDescriptor, firFunction: FirFunction, - firOverriddenSymbol: FirFunctionSymbol? = null + firOverriddenSymbol: FirNamedFunctionSymbol? = null ): T { setParentByParentStack() withParent { @@ -395,23 +390,25 @@ internal class Fir2IrVisitor( // TODO: find delegated constructor correctly val classId = constructedClassSymbol.classId val provider = this@Fir2IrVisitor.session.service() - var constructorSymbol: FirCallableSymbol? = null + var constructorSymbol: FirConstructorSymbol? = null provider.getClassUseSiteMemberScope(classId, this@Fir2IrVisitor.session, ScopeSession())!!.processFunctionsByName( classId.shortClassName ) { - if (arguments.size <= ((it as FirFunctionSymbol).fir as FirFunction).valueParameters.size) { - constructorSymbol = it - ProcessorAction.STOP - } else { - ProcessorAction.NEXT + when { + it !is FirConstructorSymbol -> ProcessorAction.NEXT + arguments.size <= it.fir.valueParameters.size -> { + constructorSymbol = it + ProcessorAction.STOP + } + else -> ProcessorAction.NEXT } } - if (constructorSymbol == null) return null + val foundConstructorSymbol = constructorSymbol ?: return null return convertWithOffsets { startOffset, endOffset -> IrDelegatingConstructorCallImpl( startOffset, endOffset, constructedIrType, - declarationStorage.getIrFunctionSymbol(constructorSymbol as FirFunctionSymbol) as IrConstructorSymbol + declarationStorage.getIrFunctionSymbol(foundConstructorSymbol) as IrConstructorSymbol ).apply { for ((index, argument) in arguments.withIndex()) { val argumentExpression = argument.toIrExpression() @@ -459,7 +456,7 @@ internal class Fir2IrVisitor( } } - override fun visitVariable(variable: FirVariable, data: Any?): IrElement { + override fun > visitVariable(variable: FirVariable, data: Any?): IrElement { val irVariable = declarationStorage.createAndSaveIrVariable(variable) return irVariable.setParentByParentStack().apply { val initializer = variable.initializer diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt index 354dfeaa7aa..cba1511e292 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt @@ -21,17 +21,11 @@ import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod import org.jetbrains.kotlin.fir.java.scopes.JavaClassEnhancementScope import org.jetbrains.kotlin.fir.java.scopes.JavaClassUseSiteScope import org.jetbrains.kotlin.fir.resolve.* -import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.impl.FirSuperTypeScope import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope import org.jetbrains.kotlin.fir.symbols.CallableId -import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol -import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol +import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.ConeClassErrorType import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl @@ -59,7 +53,7 @@ class JavaSymbolProvider( content: KotlinClassFinder.Result.ClassFileContent? ): JavaClass? = facade.findClass(JavaClassFinder.Request(classId, previouslyFoundClassFileContent = content?.content), searchScope) - override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List = + override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List> = emptyList() override fun getClassDeclaredMemberScope(classId: ClassId): FirScope? { @@ -72,9 +66,8 @@ class JavaSymbolProvider( useSiteSession: FirSession, scopeSession: ScopeSession ): FirScope? { - val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null - val javaClass = symbol.firUnsafe() - return buildJavaEnhancementScope(useSiteSession, javaClass.symbol, scopeSession) + val symbol = this.getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null + return buildJavaEnhancementScope(useSiteSession, symbol, scopeSession) } private fun buildJavaEnhancementScope( @@ -140,9 +133,9 @@ class JavaSymbolProvider( } } - override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? = getFirJavaClass(classId) + override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? = getFirJavaClass(classId) - fun getFirJavaClass(classId: ClassId, content: KotlinClassFinder.Result.ClassFileContent? = null): ConeClassLikeSymbol? { + fun getFirJavaClass(classId: ClassId, content: KotlinClassFinder.Result.ClassFileContent? = null): FirClassLikeSymbol<*>? { if (!hasTopLevelClassOf(classId)) return null return classCache.lookupCacheOrCalculateWithPostCompute(classId, { val foundClass = findClass(classId, content) @@ -197,7 +190,7 @@ class JavaSymbolProvider( for (javaMethod in javaClass.methods) { val methodName = javaMethod.name val methodId = CallableId(classId.packageFqName, classId.relativeClassName, methodName) - val methodSymbol = FirFunctionSymbol(methodId) + val methodSymbol = FirNamedFunctionSymbol(methodId) val returnType = javaMethod.returnType val firJavaMethod = FirJavaMethod( this@JavaSymbolProvider.session, methodSymbol, methodName, @@ -219,7 +212,7 @@ class JavaSymbolProvider( val constructorId = CallableId(classId.packageFqName, classId.relativeClassName, classId.shortClassName) fun addJavaConstructor(visibility: Visibility = Visibilities.PUBLIC): FirJavaConstructor { - val constructorSymbol = FirFunctionSymbol(constructorId) + val constructorSymbol = FirConstructorSymbol(constructorId) val classTypeParameters = javaClass.typeParameters.convertTypeParameters(javaTypeParameterStack) val firJavaConstructor = FirJavaConstructor( this@JavaSymbolProvider.session, constructorSymbol, visibility, diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaConstructor.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaConstructor.kt index 7e9ebafc809..6e5adb08a04 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaConstructor.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaConstructor.kt @@ -14,15 +14,15 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirAbstractCallableMember import org.jetbrains.kotlin.fir.declarations.impl.FirConstructorImpl.Companion.NAME import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef class FirJavaConstructor( session: FirSession, - override val symbol: FirFunctionSymbol, + override val symbol: FirConstructorSymbol, visibility: Visibility, delegatedSelfTypeRef: FirTypeRef -) : FirAbstractCallableMember( +) : FirAbstractCallableMember( session, psi = null, name = NAME, diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaField.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaField.kt index d204204f402..b0555504da3 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaField.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaField.kt @@ -11,21 +11,20 @@ import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirField import org.jetbrains.kotlin.fir.declarations.impl.FirAbstractCallableMember import org.jetbrains.kotlin.fir.expressions.FirExpression -import org.jetbrains.kotlin.fir.java.types.FirJavaTypeRef -import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.name.Name class FirJavaField( session: FirSession, - override val symbol: FirPropertySymbol, + override val symbol: FirFieldSymbol, name: Name, visibility: Visibility, modality: Modality?, returnTypeRef: FirTypeRef, override val isVar: Boolean, isStatic: Boolean -) : FirAbstractCallableMember( +) : FirAbstractCallableMember( session, psi = null, name = name, visibility = visibility, modality = modality, isExpect = false, isActual = false, isOverride = false, diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaMethod.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaMethod.kt index 3dd9c586c4a..8d86241dbe1 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaMethod.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaMethod.kt @@ -10,13 +10,12 @@ import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.impl.FirMemberFunctionImpl import org.jetbrains.kotlin.fir.java.types.FirJavaTypeRef -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol -import org.jetbrains.kotlin.fir.types.FirTypeRef +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.name.Name class FirJavaMethod( session: FirSession, - symbol: FirFunctionSymbol, + symbol: FirNamedFunctionSymbol, name: Name, visibility: Visibility, modality: Modality?, diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt index 69b3ebefc3d..62e1d0721f5 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt @@ -24,16 +24,15 @@ import org.jetbrains.kotlin.fir.java.topLevelName import org.jetbrains.kotlin.fir.references.FirErrorNamedReference import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl import org.jetbrains.kotlin.fir.resolve.* -import org.jetbrains.kotlin.fir.resolve.transformers.firSafeNullable import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope import org.jetbrains.kotlin.fir.service import org.jetbrains.kotlin.fir.symbols.* import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef -import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl import org.jetbrains.kotlin.load.java.JavaClassFinder @@ -145,12 +144,12 @@ class KotlinDeserializedJvmSymbolsProvider( useSiteSession: FirSession, scopeSession: ScopeSession ): FirScope? { - val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null + val symbol = this.getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null - return symbol.firSafeNullable()?.buildDefaultUseSiteScope(session, scopeSession) + return symbol.fir.buildDefaultUseSiteScope(session, scopeSession) } - override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? { + override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? { return findAndDeserializeClass(classId) ?: findAndDeserializeTypeAlias(classId) } @@ -316,8 +315,7 @@ class KotlinDeserializedJvmSymbolsProvider( if (classId in handledByJava) return null - val result = kotlinClassFinder.findKotlinClassOrContent(classId) - val kotlinJvmBinaryClass = when (result) { + val kotlinJvmBinaryClass = when (val result = kotlinClassFinder.findKotlinClassOrContent(classId)) { is KotlinClassFinder.Result.KotlinClass -> result.kotlinJvmBinaryClass is KotlinClassFinder.Result.ClassFileContent -> { handledByJava.add(classId) @@ -360,7 +358,7 @@ class KotlinDeserializedJvmSymbolsProvider( // } } - private fun loadFunctionsByName(part: PackagePartsCacheData, name: Name): List { + private fun loadFunctionsByName(part: PackagePartsCacheData, name: Name): List> { val functionIds = part.topLevelFunctionNameIndex[name] ?: return emptyList() return functionIds.map { part.proto.getFunction(it) } .map { @@ -370,7 +368,7 @@ class KotlinDeserializedJvmSymbolsProvider( } } - private fun loadPropertiesByName(part: PackagePartsCacheData, name: Name): List { + private fun loadPropertiesByName(part: PackagePartsCacheData, name: Name): List> { val propertyIds = part.topLevelPropertyNameIndex[name] ?: return emptyList() return propertyIds.map { part.proto.getProperty(it) } .map { @@ -380,7 +378,7 @@ class KotlinDeserializedJvmSymbolsProvider( } } - override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List { + override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List> { return getPackageParts(packageFqName).flatMap { part -> loadFunctionsByName(part, name) + loadPropertiesByName(part, name) } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt index 51d9f8a9302..b030f590a50 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt @@ -163,7 +163,7 @@ private fun JavaClassifierType.enhanceInflexibleType( arg.toConeProjection( session, javaTypeParameterStack, - ((originalTag as? FirBasedSymbol<*>)?.fir as? FirCallableMemberDeclaration)?.typeParameters?.getOrNull(localArgIndex) + ((originalTag as? FirBasedSymbol<*>)?.fir as? FirCallableMemberDeclaration<*>)?.typeParameters?.getOrNull(localArgIndex) ) } else { val argEnhancedTypeRef = arg.enhancePossiblyFlexible(session, javaTypeParameterStack, annotations, qualifiers, globalArgIndex) diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt index 97958523bde..555de1c409a 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt @@ -18,13 +18,10 @@ import org.jetbrains.kotlin.fir.java.enhancement.EnhancementSignatureParts import org.jetbrains.kotlin.fir.java.toNotNullConeKotlinType import org.jetbrains.kotlin.fir.java.types.FirJavaTypeRef import org.jetbrains.kotlin.fir.render -import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.symbols.* -import org.jetbrains.kotlin.fir.symbols.impl.FirAccessorSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol +import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.ir.expressions.IrConstKind import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver @@ -53,42 +50,42 @@ class JavaClassEnhancementScope( private val context: FirJavaEnhancementContext = FirJavaEnhancementContext(session) { null }.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, owner.annotations) - private val enhancements = mutableMapOf() + private val enhancements = mutableMapOf, FirCallableSymbol<*>>() - override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction { + override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction { useSiteScope.processPropertiesByName(name) process@{ original -> val field = enhancements.getOrPut(original) { enhance(original, name) } - processor(field as ConeVariableSymbol) + processor(field) } return super.processPropertiesByName(name, processor) } - override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction { + override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction { useSiteScope.processFunctionsByName(name) process@{ original -> val function = enhancements.getOrPut(original) { enhance(original, name) } - processor(function as ConeFunctionSymbol) + processor(function as FirFunctionSymbol<*>) } return super.processFunctionsByName(name, processor) } private fun enhance( - original: ConeVariableSymbol, + original: FirCallableSymbol<*>, name: Name - ): ConeVariableSymbol { - when (val firElement = (original as FirBasedSymbol<*>).fir) { + ): FirCallableSymbol<*> { + when (val firElement = original.fir) { is FirJavaField -> { if (firElement.returnTypeRef !is FirJavaTypeRef) return original val memberContext = context.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, firElement.annotations) val newReturnTypeRef = enhanceReturnType(firElement, emptyList(), memberContext, null) - val symbol = FirPropertySymbol(original.callableId) + val symbol = FirFieldSymbol(original.callableId) with(firElement) { FirJavaField( - session, + this@JavaClassEnhancementScope.session, symbol, name, visibility, @@ -116,23 +113,24 @@ class JavaClassEnhancementScope( } private fun enhance( - original: ConeFunctionSymbol, + original: FirFunctionSymbol<*>, name: Name - ): FirFunctionSymbol { - val firMethod = (original as FirFunctionSymbol).fir as? FirFunction + ): FirFunctionSymbol<*> { + val firMethod = original.fir - if (firMethod !is FirJavaMethod && firMethod !is FirJavaConstructor || firMethod !is FirCallableMemberDeclaration) return original - return enhanceMethod(firMethod, original.callableId, name) as FirFunctionSymbol + if (firMethod !is FirJavaMethod && firMethod !is FirJavaConstructor) { + return original + } + return enhanceMethod(firMethod, original.callableId, name) } private fun enhanceMethod( - firMethod: FirFunction, + firMethod: FirMemberFunction<*>, methodId: CallableId, name: Name, isAccessor: Boolean = false, propertyId: CallableId? = null - ): ConeCallableSymbol { - require(firMethod is FirCallableMemberDeclaration) + ): FirFunctionSymbol<*> { val memberContext = context.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, firMethod.annotations) val predefinedEnhancementInfo = @@ -169,7 +167,6 @@ class JavaClassEnhancementScope( ) } - val symbol = if (!isAccessor) FirFunctionSymbol(methodId) else FirAccessorSymbol(callableId = propertyId!!, accessorId = methodId) val newValueParameters = firMethod.valueParameters.zip(newValueParameterInfo) { valueParameter, newInfo -> val (newTypeRef, newDefaultValue) = newInfo with(valueParameter) { @@ -182,27 +179,29 @@ class JavaClassEnhancementScope( } } } - val function = when (firMethod) { + val function: FirMemberFunction<*> = when (firMethod) { is FirJavaConstructor -> FirConstructorImpl( - this@JavaClassEnhancementScope.session, null, symbol as FirFunctionSymbol, + this@JavaClassEnhancementScope.session, null, FirConstructorSymbol(methodId), newReceiverTypeRef, newReturnTypeRef ).apply { this.valueParameters += newValueParameters this.typeParameters += firMethod.typeParameters } else -> FirMemberFunctionImpl( - this@JavaClassEnhancementScope.session, null, symbol, name, - newReceiverTypeRef, newReturnTypeRef + this@JavaClassEnhancementScope.session, null, + if (!isAccessor) FirNamedFunctionSymbol(methodId) + else FirAccessorSymbol(callableId = propertyId!!, accessorId = methodId), + name, newReceiverTypeRef, newReturnTypeRef ).apply { this.valueParameters += newValueParameters this.typeParameters += firMethod.typeParameters } } - function.apply { + (function as FirAbstractCallableMember<*>).apply { status = firMethod.status as FirDeclarationStatusImpl annotations += firMethod.annotations } - return symbol + return function.symbol } private fun FirFunction.computeJvmDescriptor(): String = buildString { @@ -255,7 +254,7 @@ class JavaClassEnhancementScope( private fun enhanceReceiverType( ownerFunction: FirJavaMethod, - overriddenMembers: List, + overriddenMembers: List>, memberContext: FirJavaEnhancementContext ): FirResolvedTypeRef { val signatureParts = ownerFunction.partsForValueParameter( @@ -272,8 +271,8 @@ class JavaClassEnhancementScope( private data class EnhanceValueParameterResult(val typeRef: FirResolvedTypeRef, val defaultValue: FirExpression?) private fun enhanceValueParameter( - ownerFunction: FirCallableMemberDeclaration, - overriddenMembers: List, + ownerFunction: FirCallableMemberDeclaration<*>, + overriddenMembers: List>, hasReceiver: Boolean, memberContext: FirJavaEnhancementContext, predefinedEnhancementInfo: PredefinedFunctionEnhancementInfo?, @@ -297,8 +296,8 @@ class JavaClassEnhancementScope( } private fun enhanceReturnType( - owner: FirCallableMemberDeclaration, - overriddenMembers: List, + owner: FirCallableMemberDeclaration<*>, + overriddenMembers: List>, memberContext: FirJavaEnhancementContext, predefinedEnhancementInfo: PredefinedFunctionEnhancementInfo? ): FirResolvedTypeRef { @@ -315,9 +314,9 @@ class JavaClassEnhancementScope( return signatureParts.type } - private val overrideBindCache = mutableMapOf>>() + private val overrideBindCache = mutableMapOf?, List>>>() - private fun FirCallableMemberDeclaration.overriddenMembers(): List { + private fun FirCallableMemberDeclaration<*>.overriddenMembers(): List> { val backMap = overrideBindCache.getOrPut(this.name) { useSiteScope.bindOverrides(this.name) useSiteScope @@ -325,36 +324,36 @@ class JavaClassEnhancementScope( .toList() .groupBy({ (_, key) -> key }, { (value) -> value }) } - return backMap[this.symbol]?.map { it.firUnsafe() } ?: emptyList() + return backMap[this.symbol]?.map { it.fir as FirCallableMemberDeclaration<*> } ?: emptyList() } private sealed class TypeInSignature { - abstract fun getTypeRef(member: FirCallableMemberDeclaration): FirTypeRef + abstract fun getTypeRef(member: FirCallableMemberDeclaration<*>): FirTypeRef object Return : TypeInSignature() { - override fun getTypeRef(member: FirCallableMemberDeclaration): FirTypeRef = member.returnTypeRef + override fun getTypeRef(member: FirCallableMemberDeclaration<*>): FirTypeRef = member.returnTypeRef } object Receiver : TypeInSignature() { - override fun getTypeRef(member: FirCallableMemberDeclaration): FirTypeRef { + override fun getTypeRef(member: FirCallableMemberDeclaration<*>): FirTypeRef { if (member is FirJavaMethod) return member.valueParameters[0].returnTypeRef return member.receiverTypeRef!! } } class ValueParameter(val hasReceiver: Boolean, val index: Int) : TypeInSignature() { - override fun getTypeRef(member: FirCallableMemberDeclaration): FirTypeRef { + override fun getTypeRef(member: FirCallableMemberDeclaration<*>): FirTypeRef { if (hasReceiver && member is FirJavaMethod) { - return (member as FirFunction).valueParameters[index + 1].returnTypeRef + return member.valueParameters[index + 1].returnTypeRef } return (member as FirFunction).valueParameters[index].returnTypeRef } } } - private fun FirCallableMemberDeclaration.partsForValueParameter( + private fun FirCallableMemberDeclaration<*>.partsForValueParameter( typeQualifierResolver: FirAnnotationTypeQualifierResolver, - overriddenMembers: List, + overriddenMembers: List>, // TODO: investigate if it's really can be a null (check properties' with extension overrides in Java) parameterContainer: FirAnnotationContainer?, methodContext: FirJavaEnhancementContext, @@ -370,9 +369,9 @@ class JavaClassEnhancementScope( typeInSignature ) - private fun FirCallableMemberDeclaration.parts( + private fun FirCallableMemberDeclaration<*>.parts( typeQualifierResolver: FirAnnotationTypeQualifierResolver, - overriddenMembers: List, + overriddenMembers: List>, typeContainer: FirAnnotationContainer?, isCovariant: Boolean, containerContext: FirJavaEnhancementContext, diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteScope.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteScope.kt index a47cda63a8d..d65fe2b1a1d 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteScope.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteScope.kt @@ -13,18 +13,12 @@ import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass import org.jetbrains.kotlin.fir.java.toNotNullConeKotlinType import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap -import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.scopes.ProcessorAction.* import org.jetbrains.kotlin.fir.scopes.impl.FirAbstractProviderBasedScope -import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol -import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol -import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol import org.jetbrains.kotlin.fir.symbols.* -import org.jetbrains.kotlin.fir.symbols.impl.FirAccessorSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol +import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl @@ -42,7 +36,7 @@ class JavaClassUseSiteScope( if (klass is FirJavaClass) klass.javaTypeParameterStack else JavaTypeParameterStack.EMPTY //base symbol as key, overridden as value - internal val overriddenByBase = mutableMapOf() + internal val overriddenByBase = mutableMapOf, FirCallableSymbol<*>?>() private val context: ConeTypeContext = session.typeContext @@ -64,9 +58,8 @@ class JavaClassUseSiteScope( substitutor ) - private fun isOverriddenFunCheck(overriddenInJava: FirFunction, base: FirFunction): Boolean { - overriddenInJava as FirCallableMemberDeclaration - val receiverTypeRef = (base as FirCallableMemberDeclaration).receiverTypeRef + private fun isOverriddenFunCheck(overriddenInJava: FirNamedFunction, base: FirNamedFunction): Boolean { + val receiverTypeRef = base.receiverTypeRef val baseParameterTypes = listOfNotNull(receiverTypeRef) + base.valueParameters.map { it.returnTypeRef } if (overriddenInJava.valueParameters.size != baseParameterTypes.size) return false @@ -111,7 +104,7 @@ class JavaClassUseSiteScope( } internal fun bindOverrides(name: Name) { - val overrideCandidates = mutableSetOf() + val overrideCandidates = mutableSetOf>() declaredMemberScope.processFunctionsByName(name) { overrideCandidates += it NEXT @@ -124,29 +117,31 @@ class JavaClassUseSiteScope( } } - private fun ConeCallableSymbol.getOverridden(candidates: Set): ConeCallableSymbol? { + private fun FirCallableSymbol<*>.getOverridden(candidates: Set>): FirCallableSymbol<*>? { if (overriddenByBase.containsKey(this)) return overriddenByBase[this] val overriding = when (this) { - is FirFunctionSymbol -> { - val self = firUnsafe() - self as FirCallableMemberDeclaration + is FirNamedFunctionSymbol -> { + val self = this.fir candidates.firstOrNull { - val overridden = (it as? FirFunctionSymbol)?.fir as? FirFunction + val overridden = (it as? FirNamedFunctionSymbol)?.fir overridden != null && self.modality != Modality.FINAL && isOverriddenFunCheck(overridden, self) } } + is FirConstructorSymbol, is FirFieldSymbol -> { + null + } is FirPropertySymbol -> { - val self = fir as? FirProperty ?: return null + val self = fir candidates.firstOrNull { when (it) { - is FirFunctionSymbol -> { - val overridden = it.fir as FirNamedFunction + is FirNamedFunctionSymbol -> { + val overridden = it.fir self.modality != Modality.FINAL && isOverriddenPropertyCheck(overridden, self) } is FirPropertySymbol -> { val overridden = it.fir - overridden is FirProperty && self.modality != Modality.FINAL && isOverriddenPropertyCheck(overridden, self) + self.modality != Modality.FINAL && isOverriddenPropertyCheck(overridden, self) } else -> false } @@ -154,9 +149,9 @@ class JavaClassUseSiteScope( } } is FirAccessorSymbol -> { - val self = fir as FirNamedFunction + val self = fir candidates.firstOrNull { - val overridden = (it as? FirFunctionSymbol)?.fir as? FirNamedFunction + val overridden = (it as? FirNamedFunctionSymbol)?.fir overridden != null && self.modality != Modality.FINAL && isOverriddenFunCheck(overridden, self) } } @@ -167,8 +162,8 @@ class JavaClassUseSiteScope( return overriding } - override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction { - val overrideCandidates = mutableSetOf() + override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction { + val overrideCandidates = mutableSetOf>() if (!declaredMemberScope.processFunctionsByName(name) { overrideCandidates += it processor(it) @@ -190,9 +185,9 @@ class JavaClassUseSiteScope( propertyName: Name, accessorName: Name, isGetter: Boolean, - processor: (ConeVariableSymbol) -> ProcessorAction + processor: (FirCallableSymbol<*>) -> ProcessorAction ): ProcessorAction { - val overrideCandidates = mutableSetOf() + val overrideCandidates = mutableSetOf>() val klass = symbol.fir if (!declaredMemberScope.processPropertiesByName(propertyName) { variableSymbol -> overrideCandidates += variableSymbol @@ -201,19 +196,17 @@ class JavaClassUseSiteScope( ) return STOP if (klass is FirJavaClass) { if (!declaredMemberScope.processFunctionsByName(accessorName) { functionSymbol -> - if (functionSymbol is FirFunctionSymbol) { + if (functionSymbol is FirNamedFunctionSymbol) { val fir = functionSymbol.fir - if (fir is FirNamedFunction) { - if (fir.isStatic) { + if (fir.isStatic) { + return@processFunctionsByName NEXT + } + when (isGetter) { + true -> if (fir.valueParameters.isNotEmpty()) { return@processFunctionsByName NEXT } - when (isGetter) { - true -> if (fir.valueParameters.isNotEmpty()) { - return@processFunctionsByName NEXT - } - false -> if (fir.valueParameters.size != 1) { - return@processFunctionsByName NEXT - } + false -> if (fir.valueParameters.size != 1) { + return@processFunctionsByName NEXT } } } @@ -222,8 +215,8 @@ class JavaClassUseSiteScope( accessorId = functionSymbol.callableId, callableId = CallableId(functionSymbol.callableId.packageName, functionSymbol.callableId.className, propertyName) ) - if (functionSymbol is FirBasedSymbol<*>) { - (functionSymbol.fir as? FirCallableMemberDeclaration)?.let { callableMember -> accessorSymbol.bind(callableMember) } + if (functionSymbol is FirNamedFunctionSymbol) { + functionSymbol.fir.let { callableMember -> accessorSymbol.bind(callableMember) } } processor(accessorSymbol) } @@ -231,12 +224,12 @@ class JavaClassUseSiteScope( } return superTypesScope.processPropertiesByName(propertyName) { - val firCallableMember = (it as FirBasedSymbol<*>).fir as? FirCallableMemberDeclaration + val firCallableMember = it.fir as? FirCallableMemberDeclaration<*> if (firCallableMember?.isStatic == true) { NEXT } else { val overriddenBy = it.getOverridden(overrideCandidates) - if (overriddenBy == null && it is ConePropertySymbol) { + if (overriddenBy == null && it is FirVariableSymbol<*>) { processor(it) } else { NEXT @@ -245,7 +238,7 @@ class JavaClassUseSiteScope( } } - override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction { + override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction { val getterName = Name.identifier(getterPrefix + name.asString().capitalize()) return processAccessorFunctionsAndPropertiesByName(name, getterName, isGetter = true, processor = processor) } diff --git a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt index 5a3df688a7c..a71389cf957 100644 --- a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt +++ b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt @@ -431,7 +431,7 @@ internal fun generateAccessExpression(session: FirSession, psi: PsiElement?, nam calleeReference = FirSimpleNamedReference(session, psi, name) } -internal fun generateResolvedAccessExpression(session: FirSession, psi: PsiElement?, variable: FirVariable): FirQualifiedAccessExpression = +internal fun generateResolvedAccessExpression(session: FirSession, psi: PsiElement?, variable: FirVariable<*>): FirQualifiedAccessExpression = FirQualifiedAccessExpressionImpl(session, psi).apply { calleeReference = FirResolvedCallableReferenceImpl(session, psi, variable.name, variable.symbol) } @@ -439,7 +439,7 @@ internal fun generateResolvedAccessExpression(session: FirSession, psi: PsiEleme internal fun generateDestructuringBlock( session: FirSession, multiDeclaration: KtDestructuringDeclaration, - container: FirVariable, + container: FirVariable<*>, tmpVariable: Boolean, extractAnnotationsTo: KtAnnotated.(FirAbstractAnnotatedElement) -> Unit, toFirOrImplicitTypeRef: KtTypeReference?.() -> FirTypeRef @@ -465,14 +465,14 @@ internal fun generateDestructuringBlock( internal fun generateTemporaryVariable( session: FirSession, psi: PsiElement?, name: Name, initializer: FirExpression -): FirVariable = +): FirVariable<*> = FirVariableImpl(session, psi, name, FirImplicitTypeRefImpl(session, psi), false, initializer, FirVariableSymbol(name)).apply { symbol.bind(this) } internal fun generateTemporaryVariable( session: FirSession, psi: PsiElement?, specialName: String, initializer: FirExpression -): FirVariable = generateTemporaryVariable(session, psi, Name.special("<$specialName>"), initializer) +): FirVariable<*> = generateTemporaryVariable(session, psi, Name.special("<$specialName>"), initializer) private fun FirModifiableQualifiedAccess<*>.initializeLValue( session: FirSession, diff --git a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/DataClassUtils.kt b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/DataClassUtils.kt index 5115ca0972a..4b977473e0b 100644 --- a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/DataClassUtils.kt +++ b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/DataClassUtils.kt @@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl import org.jetbrains.kotlin.fir.expressions.impl.* import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl import org.jetbrains.kotlin.fir.symbols.CallableId -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl import org.jetbrains.kotlin.name.FqName @@ -35,7 +35,7 @@ internal fun KtClassOrObject.generateComponentFunctions( if (!ktParameter.hasValOrVar()) continue val name = Name.identifier("component$componentIndex") componentIndex++ - val symbol = FirFunctionSymbol(CallableId(packageFqName, classFqName, name)) + val symbol = FirNamedFunctionSymbol(CallableId(packageFqName, classFqName, name)) firClass.addDeclaration( FirMemberFunctionImpl( session, ktParameter, symbol, name, @@ -76,7 +76,7 @@ internal fun KtClassOrObject.generateCopyFunction( firPrimaryConstructor: FirConstructor, toFirOrErrorTypeRef: KtTypeReference?.() -> FirTypeRef ) { - val symbol = FirFunctionSymbol(CallableId(packageFqName, classFqName, copyName)) + val symbol = FirNamedFunctionSymbol(CallableId(packageFqName, classFqName, copyName)) firClass.addDeclaration( FirMemberFunctionImpl( session, this, symbol, copyName, diff --git a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt index f7e46fa5317..bf6087a890a 100644 --- a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt +++ b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt @@ -403,7 +403,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { val firConstructor = FirPrimaryConstructorImpl( session, this ?: owner, - FirFunctionSymbol(callableIdForClassConstructor()), + FirConstructorSymbol(callableIdForClassConstructor()), this?.visibility ?: defaultVisibility(), this?.hasExpectModifier() ?: false, this?.hasActualModifier() ?: false, @@ -625,7 +625,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { FirMemberFunctionImpl( session, function, - FirFunctionSymbol(callableIdForName(function.nameAsSafeName, function.isLocal)), + FirNamedFunctionSymbol(callableIdForName(function.nameAsSafeName, function.isLocal)), function.nameAsSafeName, if (function.isLocal) Visibilities.LOCAL else function.visibility, function.modality, @@ -713,7 +713,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) { val firConstructor = FirConstructorImpl( session, this, - FirFunctionSymbol(callableIdForClassConstructor()), + FirConstructorSymbol(callableIdForClassConstructor()), visibility, hasExpectModifier(), hasActualModifier(), diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt index 4208fdbc961..48532587924 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.deserialization import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.impl.FirClassImpl import org.jetbrains.kotlin.fir.declarations.impl.FirEnumEntryImpl -import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTagImpl import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl @@ -57,7 +56,7 @@ fun deserializeClassToSymbol( classId, classProto, nameResolver, session, defaultAnnotationDeserializer ?: FirBuiltinAnnotationDeserializer(session) ) - typeParameters += context.typeDeserializer.ownTypeParameters.map { it.firUnsafe() } + typeParameters += context.typeDeserializer.ownTypeParameters.map { it.fir } annotations += context.annotationDeserializer.loadClassAnnotations(classProto, context.nameResolver) val typeDeserializer = context.typeDeserializer diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt index e78ac3463be..cc53faa4cba 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt @@ -11,12 +11,8 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.impl.* import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionStub -import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe import org.jetbrains.kotlin.fir.symbols.CallableId -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol +import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl @@ -146,7 +142,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) { emptyList() /* TODO */ ) ).apply { - typeParameters += local.typeDeserializer.ownTypeParameters.map { it.firUnsafe() } + typeParameters += local.typeDeserializer.ownTypeParameters.map { it.fir } } } @@ -183,7 +179,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) { } else null, delegate = null ).apply { - typeParameters += local.typeDeserializer.ownTypeParameters.map { it.firUnsafe() } + typeParameters += local.typeDeserializer.ownTypeParameters.map { it.fir } annotations += c.annotationDeserializer.loadPropertyAnnotations(proto, local.nameResolver) } } @@ -200,7 +196,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) { c.versionRequirementTable val callableName = c.nameResolver.getName(proto.name) - val symbol = FirFunctionSymbol(CallableId(c.packageFqName, c.relativeClassName, callableName)) + val symbol = FirNamedFunctionSymbol(CallableId(c.packageFqName, c.relativeClassName, callableName)) val local = c.childContext(proto.typeParameterList) // TODO: support contracts @@ -223,7 +219,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) { receiverTypeRef = proto.receiverType(local.typeTable)?.toTypeRef(local), returnTypeRef = proto.returnType(local.typeTable).toTypeRef(local) ).apply { - typeParameters += local.typeDeserializer.ownTypeParameters.map { it.firUnsafe() } + typeParameters += local.typeDeserializer.ownTypeParameters.map { it.fir } valueParameters += local.memberDeserializer.valueParameters(proto.valueParameterList) annotations += local.annotationDeserializer.loadFunctionAnnotations(proto, local.nameResolver) } @@ -232,7 +228,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) { fun loadConstructor(proto: ProtoBuf.Constructor, klass: FirRegularClass): FirConstructor { val flags = proto.flags val relativeClassName = c.relativeClassName!! - val symbol = FirFunctionSymbol(CallableId(c.packageFqName, relativeClassName, relativeClassName.shortName())) + val symbol = FirConstructorSymbol(CallableId(c.packageFqName, relativeClassName, relativeClassName.shortName())) val local = c.childContext(emptyList()) val isPrimary = !Flags.IS_SECONDARY.get(flags) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt index d899aa41e06..5beedd483ad 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt @@ -8,10 +8,8 @@ package org.jetbrains.kotlin.fir.deserialization import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl import org.jetbrains.kotlin.fir.resolve.toTypeProjection -import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe import org.jetbrains.kotlin.fir.symbols.* -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeAbbreviatedTypeImpl @@ -68,11 +66,11 @@ class FirTypeDeserializer( } } - private val typeParameterDescriptors = + private val typeParameterDescriptors: Map = if (typeParameterProtos.isEmpty()) { - mapOf() + mapOf() } else { - val result = LinkedHashMap() + val result = LinkedHashMap() for ((index, proto) in typeParameterProtos.withIndex()) { if (!proto.hasId()) continue val name = nameResolver.getName(proto.name) @@ -94,8 +92,8 @@ class FirTypeDeserializer( init { for ((index, proto) in typeParameterProtos.withIndex()) { if (!proto.hasId()) continue - val symbol = typeParameterDescriptors[proto.id] as FirTypeParameterSymbol - val declaration = symbol.firUnsafe() + val symbol = typeParameterDescriptors[proto.id]!! + val declaration = symbol.fir as FirTypeParameterImpl declaration.apply { proto.upperBoundList.mapTo(bounds) { FirResolvedTypeRefImpl(session, null, type(it), emptyList()) @@ -104,17 +102,11 @@ class FirTypeDeserializer( } } - val ownTypeParameters: List + val ownTypeParameters: List get() = typeParameterDescriptors.values.toList() - fun ConeClassLikeSymbol.typeParameters(): List = when (this) { - is FirTypeAliasSymbol -> fir.typeParameters - is FirClassSymbol -> fir.typeParameters - else -> error("?!id:2") - }.map { - it.symbol - } + fun FirClassLikeSymbol<*>.typeParameters(): List = fir.typeParameters.map { it.symbol } fun simpleType(proto: ProtoBuf.Type): ConeLookupTagBasedType? { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/AbstractFirSymbolProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/AbstractFirSymbolProvider.kt index c43cc8e0b27..9224668cebe 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/AbstractFirSymbolProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/AbstractFirSymbolProvider.kt @@ -7,16 +7,16 @@ package org.jetbrains.kotlin.fir.resolve import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.symbols.CallableId -import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol -import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName abstract class AbstractFirSymbolProvider : FirSymbolProvider() { - protected val classCache = HashMap() - protected val topLevelCallableCache = HashMap>() + protected val classCache = HashMap?>() + protected val topLevelCallableCache = HashMap>>() protected val packageCache = HashMap() protected inline fun MutableMap.lookupCacheOrCalculate(key: K, crossinline l: (K) -> V): V? { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirProvider.kt index 85e1e62b9cb..44b09ecd3e9 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirProvider.kt @@ -10,7 +10,8 @@ import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration import org.jetbrains.kotlin.fir.service import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol -import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -18,9 +19,9 @@ import org.jetbrains.kotlin.name.Name abstract class FirProvider : FirSymbolProvider() { abstract fun getFirClassifierByFqName(fqName: ClassId): FirMemberDeclaration? - abstract override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? + abstract override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? - abstract override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List + abstract override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List> override fun getPackage(fqName: FqName): FqName? { if (getFirFilesByPackage(fqName).isNotEmpty()) return fqName diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirSymbolProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirSymbolProvider.kt index bd873531121..bb9fb0e18cd 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirSymbolProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirSymbolProvider.kt @@ -11,13 +11,15 @@ import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.service import org.jetbrains.kotlin.fir.symbols.* +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name abstract class FirSymbolProvider { - abstract fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? + abstract fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? fun getSymbolByLookupTag(lookupTag: ConeClassifierLookupTag): ConeClassifierSymbol? { return when (lookupTag) { @@ -35,7 +37,7 @@ abstract class FirSymbolProvider { } } - abstract fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List + abstract fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List> abstract fun getClassDeclaredMemberScope(classId: ClassId): FirScope? abstract fun getClassUseSiteMemberScope( diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt index f61905b3c33..5dd1f9ececb 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.service import org.jetbrains.kotlin.fir.symbols.* import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeAbbreviatedTypeImpl import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl @@ -52,6 +53,8 @@ fun ConeClassifierLookupTag.toSymbol(useSiteSession: FirSession): ConeClassifier else -> error("sealed ${this::class}") } +fun ConeTypeParameterLookupTag.toSymbol(): FirTypeParameterSymbol = this.symbol as FirTypeParameterSymbol + fun ConeClassLikeLookupTag.constructClassType(typeArguments: Array, isNullable: Boolean): ConeLookupTagBasedType { return ConeClassTypeImpl(this, typeArguments, isNullable) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt index 1eb449e516c..531dd264791 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt @@ -7,14 +7,11 @@ package org.jetbrains.kotlin.fir.resolve import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirRegularClass -import org.jetbrains.kotlin.fir.declarations.FirTypeParameter import org.jetbrains.kotlin.fir.resolve.transformers.firSafeNullable -import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol -import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl @@ -33,8 +30,7 @@ fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: ScopeSession) } is ConeTypeParameterType -> { // TODO: support LibraryTypeParameterSymbol or get rid of it - val toSymbol = this.lookupTag.toSymbol(useSiteSession)?.takeIf { it is FirBasedSymbol<*> } ?: return null - val fir = toSymbol.firUnsafe() + val fir = lookupTag.toSymbol().fir FirCompositeScope( fir.bounds.mapNotNullTo(mutableListOf()) { it.coneTypeUnsafe().scope(useSiteSession, scopeSession) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt index 85c05d7af00..84d40ddfb69 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt @@ -85,7 +85,7 @@ fun FirRegularClass.buildDefaultUseSiteScope(useSiteSession: FirSession, builder private fun ConeClassLikeType.wrapSubstitutionScopeIfNeed( session: FirSession, useSiteScope: FirScope, - declaration: FirClassLikeDeclaration, + declaration: FirClassLikeDeclaration<*>, builder: ScopeSession ): FirScope { if (this.typeArguments.isEmpty()) return useSiteScope diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CallResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CallResolver.kt index e7acfc91ed2..f7bffdcdfce 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CallResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CallResolver.kt @@ -13,7 +13,6 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier import org.jetbrains.kotlin.fir.expressions.impl.FirQualifiedAccessExpressionImpl -import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.constructClassType @@ -29,9 +28,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirExplicitSimpleImportingScope import org.jetbrains.kotlin.fir.scopes.processClassifiersByNameWithAction import org.jetbrains.kotlin.fir.service import org.jetbrains.kotlin.fir.symbols.* -import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -93,7 +90,7 @@ class CheckerSinkImpl(override val components: InferenceComponents, var continua class Candidate( - val symbol: ConeSymbol, + val symbol: FirBasedSymbol<*>, val dispatchReceiverValue: ClassDispatchReceiverValue?, val implicitExtensionReceiverValue: ImplicitReceiverValue?, val explicitReceiverKind: ExplicitReceiverKind, @@ -136,14 +133,14 @@ enum class TowerDataKind { interface TowerScopeLevel { - sealed class Token { - object Properties : Token() + sealed class Token> { + object Properties : Token() - object Functions : Token() - object Objects : Token() + object Functions : Token>() + object Objects : Token>() } - fun processElementsByName( + fun > processElementsByName( token: Token, name: Name, explicitReceiver: ExpressionReceiverValue?, @@ -159,7 +156,7 @@ interface TowerScopeLevel { } object Empty : TowerScopeLevel { - override fun processElementsByName( + override fun > processElementsByName( token: Token, name: Name, explicitReceiver: ExpressionReceiverValue?, @@ -169,15 +166,15 @@ interface TowerScopeLevel { } abstract class SessionBasedTowerLevel(val session: FirSession) : TowerScopeLevel { - protected fun ConeSymbol.dispatchReceiverValue(): ClassDispatchReceiverValue? { + protected fun FirBasedSymbol<*>.dispatchReceiverValue(): ClassDispatchReceiverValue? { return when (this) { - is FirFunctionSymbol -> fir.dispatchReceiverValue(session) + is FirNamedFunctionSymbol -> fir.dispatchReceiverValue(session) is FirClassSymbol -> ClassDispatchReceiverValue(fir.symbol) else -> null } } - protected fun ConeCallableSymbol.hasConsistentExtensionReceiver(extensionReceiver: ReceiverValue?): Boolean { + protected fun FirCallableSymbol<*>.hasConsistentExtensionReceiver(extensionReceiver: ReceiverValue?): Boolean { val hasExtensionReceiver = hasExtensionReceiver() return hasExtensionReceiver == (extensionReceiver != null) } @@ -196,7 +193,7 @@ class MemberScopeTowerLevel( val scopeSession: ScopeSession ) : SessionBasedTowerLevel(session) { - private fun processMembers( + private fun > processMembers( output: TowerScopeLevel.TowerScopeLevelProcessor, explicitExtensionReceiver: ExpressionReceiverValue?, processScopeMembers: FirScope.(processor: (T) -> ProcessorAction) -> ProcessorAction @@ -205,11 +202,11 @@ class MemberScopeTowerLevel( val extensionReceiver = implicitExtensionReceiver ?: explicitExtensionReceiver val scope = dispatchReceiver.type.scope(session, scopeSession) ?: return ProcessorAction.NEXT if (scope.processScopeMembers { candidate -> - if (candidate is ConeCallableSymbol && candidate.hasConsistentExtensionReceiver(extensionReceiver)) { + if (candidate is FirCallableSymbol<*> && candidate.hasConsistentExtensionReceiver(extensionReceiver)) { // NB: we do not check dispatchReceiverValue != null here, // because of objects & constructors (see comments in dispatchReceiverValue() implementation) output.consumeCandidate(candidate, candidate.dispatchReceiverValue(), implicitExtensionReceiver) - } else if (candidate is ConeClassLikeSymbol) { + } else if (candidate is FirClassLikeSymbol<*>) { output.consumeCandidate(candidate, null, implicitExtensionReceiver) } else { ProcessorAction.NEXT @@ -222,7 +219,7 @@ class MemberScopeTowerLevel( } } - override fun processElementsByName( + override fun > processElementsByName( token: TowerScopeLevel.Token, name: Name, explicitReceiver: ExpressionReceiverValue?, @@ -244,7 +241,7 @@ class MemberScopeTowerLevel( } -private fun ConeCallableSymbol.hasExtensionReceiver(): Boolean = (this as? FirCallableSymbol)?.fir?.receiverTypeRef != null +private fun FirCallableSymbol<*>.hasExtensionReceiver(): Boolean = this.fir.receiverTypeRef != null // This is more like "scope-based tower level" // We can access here members of currently accessible scope which is not influenced by explicit receiver @@ -258,7 +255,7 @@ class ScopeTowerLevel( val scope: FirScope, val implicitExtensionReceiver: ImplicitReceiverValue? = null ) : SessionBasedTowerLevel(session) { - override fun processElementsByName( + override fun > processElementsByName( token: TowerScopeLevel.Token, name: Name, explicitReceiver: ExpressionReceiverValue?, @@ -305,7 +302,7 @@ class ScopeTowerLevel( * Handles only statics and top-levels, DOES NOT handle objects/companions members */ class QualifiedReceiverTowerLevel(session: FirSession) : SessionBasedTowerLevel(session) { - override fun processElementsByName( + override fun > processElementsByName( token: TowerScopeLevel.Token, name: Name, explicitReceiver: ExpressionReceiverValue?, @@ -329,8 +326,8 @@ class QualifiedReceiverTowerLevel(session: FirSession) : SessionBasedTowerLevel( } } else { scope.processCallables(name, token.cast()) { - val fir = it.firUnsafe() - if (fir.isStatic || it.callableId.classId == null) { + val fir = it.fir + if (fir is FirCallableMemberDeclaration<*> && fir.isStatic || it.callableId.classId == null) { processor.consumeCandidate(it as T, null, null) } else { ProcessorAction.NEXT @@ -341,7 +338,7 @@ class QualifiedReceiverTowerLevel(session: FirSession) : SessionBasedTowerLevel( } -class QualifiedReceiverTowerDataConsumer( +class QualifiedReceiverTowerDataConsumer>( val session: FirSession, val name: Name, val token: TowerScopeLevel.Token, @@ -599,7 +596,7 @@ class MultiplexerTowerDataConsumer( } -class ExplicitReceiverTowerDataConsumer( +class ExplicitReceiverTowerDataConsumer>( val session: FirSession, val name: Name, val token: TowerScopeLevel.Token, @@ -657,11 +654,11 @@ class ExplicitReceiverTowerDataConsumer( dispatchReceiverValue: ClassDispatchReceiverValue?, implicitExtensionReceiverValue: ImplicitReceiverValue? ): ProcessorAction { - if (symbol is FirFunctionSymbol && symbol.callableId.packageName.startsWith(defaultPackage)) { + if (symbol is FirNamedFunctionSymbol && symbol.callableId.packageName.startsWith(defaultPackage)) { val explicitReceiverType = explicitReceiver.type if (dispatchReceiverValue == null && explicitReceiverType is ConeClassType) { val declarationReceiverTypeRef = - (symbol as? FirCallableSymbol)?.fir?.receiverTypeRef as? FirResolvedTypeRef + (symbol as? FirCallableSymbol<*>)?.fir?.receiverTypeRef as? FirResolvedTypeRef val declarationReceiverType = declarationReceiverTypeRef?.type if (declarationReceiverType is ConeClassType) { if (!AbstractTypeChecker.isSubtypeOf( @@ -699,7 +696,7 @@ class ExplicitReceiverTowerDataConsumer( } -class NoExplicitReceiverTowerDataConsumer( +class NoExplicitReceiverTowerDataConsumer>( val session: FirSession, val name: Name, val token: TowerScopeLevel.Token, @@ -962,7 +959,7 @@ class InvokeCandidateCollector( } } -fun FirCallableDeclaration.dispatchReceiverValue(session: FirSession): ClassDispatchReceiverValue? { +fun FirCallableDeclaration<*>.dispatchReceiverValue(session: FirSession): ClassDispatchReceiverValue? { // TODO: this is not true at least for inner class constructors if (this is FirConstructor) return null val id = (this.symbol as ConeCallableSymbol).callableId.classId ?: return null diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt index fcca40ea917..76e393d0067 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.fir.resolve.calls import org.jetbrains.kotlin.fir.expressions.* -import org.jetbrains.kotlin.fir.symbols.ConeSymbol +import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.resolve.calls.components.PostponedArgumentsAnalyzer import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintStorage import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind @@ -28,7 +28,7 @@ class CandidateFactory( } fun createCandidate( - symbol: ConeSymbol, + symbol: FirBasedSymbol<*>, dispatchReceiverValue: ClassDispatchReceiverValue?, implicitExtensionReceiverValue: ImplicitReceiverValue?, explicitReceiverKind: ExplicitReceiverKind diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt index 25e117f72a1..dbb9f299ee9 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt @@ -6,12 +6,10 @@ package org.jetbrains.kotlin.fir.resolve.calls import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration -import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.renderWithType import org.jetbrains.kotlin.fir.resolve.constructType import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap -import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe import org.jetbrains.kotlin.fir.service import org.jetbrains.kotlin.fir.symbols.StandardClassIds import org.jetbrains.kotlin.fir.symbols.invoke @@ -23,8 +21,8 @@ import org.jetbrains.kotlin.resolve.calls.inference.model.SimpleConstraintSystem internal object CreateFreshTypeVariableSubstitutorStage : ResolutionStage() { override suspend fun check(candidate: Candidate, sink: CheckerSink, callInfo: CallInfo) { - val declaration = candidate.symbol.firUnsafe() - if (declaration !is FirCallableMemberDeclaration || declaration.typeParameters.isEmpty()) { + val declaration = candidate.symbol.fir + if (declaration !is FirCallableMemberDeclaration<*> || declaration.typeParameters.isEmpty()) { candidate.substitutor = ConeSubstitutor.Empty return } @@ -85,7 +83,7 @@ internal object CreateFreshTypeVariableSubstitutorStage : ResolutionStage() { } fun createToFreshVariableSubstitutorAndAddInitialConstraints( - declaration: FirCallableMemberDeclaration, + declaration: FirCallableMemberDeclaration<*>, candidate: Candidate, csBuilder: ConstraintSystemOperation ): Pair> { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/OverloadConflictResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/OverloadConflictResolver.kt index 5d84ab332d5..7a55c922897 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/OverloadConflictResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/OverloadConflictResolver.kt @@ -5,11 +5,9 @@ package org.jetbrains.kotlin.fir.resolve.calls -import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.declarations.FirConstructor import org.jetbrains.kotlin.fir.declarations.FirNamedFunction import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap -import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.coneTypeUnsafe @@ -51,8 +49,7 @@ class ConeOverloadConflictResolver( } private fun createFlatSignature(call: Candidate): FlatSignature { - val declaration = call.symbol.firUnsafe() - return when (declaration) { + return when (val declaration = call.symbol.fir) { is FirNamedFunction -> createFlatSignature(call, declaration) is FirConstructor -> createFlatSignature(call, declaration) else -> error("Not supported: $declaration") diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolverParts.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolverParts.kt index 4241790523a..bbedb18aa4d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolverParts.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolverParts.kt @@ -6,12 +6,9 @@ package org.jetbrains.kotlin.fir.resolve.calls import org.jetbrains.kotlin.descriptors.Visibilities -import org.jetbrains.kotlin.fir.declarations.FirFunction import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier import org.jetbrains.kotlin.fir.resolve.FirProvider -import org.jetbrains.kotlin.fir.resolve.transformers.firSafeNullable -import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe import org.jetbrains.kotlin.fir.service import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol @@ -24,7 +21,6 @@ import org.jetbrains.kotlin.load.java.JavaVisibilities import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind.* -import java.lang.IllegalStateException abstract class ResolutionStage { @@ -80,7 +76,7 @@ internal sealed class CheckReceivers : ResolutionStage() { } override fun Candidate.getReceiverValue(): ReceiverValue? { - val callableSymbol = symbol as? FirCallableSymbol ?: return null + val callableSymbol = symbol as? FirCallableSymbol<*> ?: return null val callable = callableSymbol.fir val type = (callable.receiverTypeRef as FirResolvedTypeRef?)?.type ?: return null return object : ReceiverValue { @@ -136,8 +132,8 @@ internal sealed class CheckReceivers : ResolutionStage() { internal object MapArguments : ResolutionStage() { override suspend fun check(candidate: Candidate, sink: CheckerSink, callInfo: CallInfo) { - val symbol = candidate.symbol as? FirFunctionSymbol ?: return sink.reportApplicability(CandidateApplicability.HIDDEN) - val function = symbol.firUnsafe() + val symbol = candidate.symbol as? FirFunctionSymbol<*> ?: return sink.reportApplicability(CandidateApplicability.HIDDEN) + val function = symbol.fir val processor = FirCallArgumentsProcessor(function, callInfo.arguments) val mappingResult = processor.process() candidate.argumentMapping = mappingResult.argumentMapping @@ -190,8 +186,8 @@ internal object CheckVisibility : CheckerStage() { override suspend fun check(candidate: Candidate, sink: CheckerSink, callInfo: CallInfo) { val symbol = candidate.symbol - val declaration = symbol.firSafeNullable() - if (declaration != null && !declaration.visibility.isPublicAPI) { + val declaration = symbol.fir + if (declaration is FirMemberDeclaration && !declaration.visibility.isPublicAPI) { val visible = when (declaration.visibility) { JavaVisibilities.PACKAGE_VISIBILITY -> symbol.packageFqName() == callInfo.containingFile.packageFqName diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Synthetics.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Synthetics.kt index 748e2a9aad2..0c542ee968d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Synthetics.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Synthetics.kt @@ -11,10 +11,11 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter import org.jetbrains.kotlin.fir.declarations.impl.FirMemberPropertyImpl import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator -import org.jetbrains.kotlin.fir.resolve.transformers.firSafeNullable import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.symbols.* +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.name.Name @@ -33,10 +34,10 @@ class FirSyntheticPropertiesScope( private fun checkGetAndCreateSynthetic( name: Name, - symbol: ConeFunctionSymbol, - processor: (ConeVariableSymbol) -> ProcessorAction + symbol: FirFunctionSymbol<*>, + processor: (FirCallableSymbol<*>) -> ProcessorAction ): ProcessorAction { - val fir = symbol.firSafeNullable() ?: return ProcessorAction.NEXT + val fir = symbol.fir as? FirNamedFunction ?: return ProcessorAction.NEXT if (fir.typeParameters.isNotEmpty()) return ProcessorAction.NEXT if (fir.valueParameters.isNotEmpty()) return ProcessorAction.NEXT @@ -67,7 +68,7 @@ class FirSyntheticPropertiesScope( return processor(synthetic) } - override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction { + override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction { if (name.isSpecial) return ProcessorAction.NEXT if (baseScope.processFunctionsByName(Name.guessByFirstCharacter("get${name.identifier.capitalize()}")) { checkGetAndCreateSynthetic(name, it, processor) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirCompositeSymbolProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirCompositeSymbolProvider.kt index f06d96a8dca..535ee5b48d3 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirCompositeSymbolProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirCompositeSymbolProvider.kt @@ -9,8 +9,8 @@ import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.scopes.FirScope -import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol -import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -25,7 +25,7 @@ class FirCompositeSymbolProvider(val providers: List) : FirSy return providers.firstNotNullResult { it.getClassUseSiteMemberScope(classId, useSiteSession, scopeSession) } } - override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List { + override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List> { return providers.flatMap { it.getTopLevelCallableSymbols(packageFqName, name) } } @@ -35,7 +35,7 @@ class FirCompositeSymbolProvider(val providers: List) : FirSy return providers.firstNotNullResult { it.getPackage(fqName) } } - override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? { + override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? { return providers.firstNotNullResult { it.getClassLikeSymbolByFqName(classId) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirDependenciesSymbolProviderImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirDependenciesSymbolProviderImpl.kt index 0d14217be2f..c1d186fa5b5 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirDependenciesSymbolProviderImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirDependenciesSymbolProviderImpl.kt @@ -13,8 +13,8 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.service import org.jetbrains.kotlin.fir.symbols.CallableId -import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol -import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -28,7 +28,7 @@ class FirDependenciesSymbolProviderImpl(val session: FirSession) : AbstractFirSy }.toList() } - override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List { + override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List> { return topLevelCallableCache.lookupCacheOrCalculate(CallableId(packageFqName, null, name)) { dependencyProviders.flatMap { provider -> provider.getTopLevelCallableSymbols(packageFqName, name) } } ?: emptyList() @@ -37,7 +37,7 @@ class FirDependenciesSymbolProviderImpl(val session: FirSession) : AbstractFirSy override fun getClassDeclaredMemberScope(classId: ClassId) = dependencyProviders.firstNotNullResult { it.getClassDeclaredMemberScope(classId) } - override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? { + override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? { return classCache.lookupCacheOrCalculate(classId) { for (provider in dependencyProviders) { provider.getClassLikeSymbolByFqName(classId)?.let { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirLibrarySymbolProviderImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirLibrarySymbolProviderImpl.kt index db5ef27c482..e0c9e9f236e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirLibrarySymbolProviderImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirLibrarySymbolProviderImpl.kt @@ -20,12 +20,12 @@ import org.jetbrains.kotlin.fir.deserialization.FirBuiltinAnnotationDeserializer import org.jetbrains.kotlin.fir.deserialization.FirDeserializationContext import org.jetbrains.kotlin.fir.deserialization.deserializeClassToSymbol import org.jetbrains.kotlin.fir.resolve.* -import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.impl.FirClassDeclaredMemberScope import org.jetbrains.kotlin.fir.symbols.* +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl @@ -76,7 +76,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( val lookup = mutableMapOf() - fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? = + fun getClassLikeSymbolByFqName(classId: ClassId): FirClassSymbol? = findAndDeserializeClass(classId) private fun findAndDeserializeClass( @@ -109,7 +109,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( } } - fun getTopLevelCallableSymbols(name: Name): List { + fun getTopLevelCallableSymbols(name: Name): List> { return packageProto.`package`.functionList.filter { nameResolver.getName(it.name) == name }.map { memberDeserializer.loadFunction(it).symbol } @@ -130,7 +130,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( scopeSession: ScopeSession ): FirScope? { val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null - return symbol.firUnsafe().buildDefaultUseSiteScope(useSiteSession, scopeSession) + return symbol.fir.buildDefaultUseSiteScope(useSiteSession, scopeSession) } override fun getPackage(fqName: FqName): FqName? { @@ -152,9 +152,9 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( private val allPackageFragments = loadBuiltIns().groupBy { it.fqName } - private val fictitiousFunctionSymbols = mutableMapOf() + private val fictitiousFunctionSymbols = mutableMapOf() - override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? { + override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassSymbol? { return allPackageFragments[classId.packageFqName]?.firstNotNullResult { it.getClassLikeSymbolByFqName(classId) } ?: with(classId) { @@ -204,7 +204,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( FirMemberFunctionImpl( session, null, - FirFunctionSymbol(CallableId(packageFqName, relativeClassName, name)), + FirNamedFunctionSymbol(CallableId(packageFqName, relativeClassName, name)), name, Visibilities.PUBLIC, Modality.ABSTRACT, @@ -251,7 +251,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( } } - override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List { + override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List> { return allPackageFragments[packageFqName]?.flatMap { it.getTopLevelCallableSymbols(name) } ?: emptyList() @@ -273,7 +273,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( } override fun getAllCallableNamesInClass(classId: ClassId): Set { - return getClassDeclarations(classId).filterIsInstance().mapTo(mutableSetOf()) { it.name } + return getClassDeclarations(classId).filterIsInstance>().mapTo(mutableSetOf()) { it.name } } private fun getClassDeclarations(classId: ClassId): List { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt index 9f72ca4a54f..e6cd796b888 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt @@ -15,6 +15,8 @@ import org.jetbrains.kotlin.fir.resolve.buildDefaultUseSiteScope import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.impl.FirClassDeclaredMemberScope import org.jetbrains.kotlin.fir.symbols.* +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType @@ -29,11 +31,11 @@ class FirProviderImpl(val session: FirSession) : FirProvider() { return state.callableContainerMap[symbol] } - override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? { - return (getFirClassifierByFqName(classId) as? FirSymbolOwner<*>)?.symbol as? ConeClassLikeSymbol + override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? { + return getFirClassifierByFqName(classId)?.symbol } - override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List { + override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List> { return (state.callableMap[CallableId(packageFqName, null, name)] ?: emptyList()) } @@ -71,8 +73,10 @@ class FirProviderImpl(val session: FirSession) : FirProvider() { state.classifierContainerFileMap[classId] = file } - override fun visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration) { - val symbol = callableMemberDeclaration.symbol as ConeCallableSymbol + override fun > visitCallableMemberDeclaration( + callableMemberDeclaration: FirCallableMemberDeclaration + ) { + val symbol = callableMemberDeclaration.symbol val callableId = symbol.callableId state.callableMap.merge(callableId, listOf(symbol)) { a, b -> a + b } state.callableContainerMap[symbol] = file @@ -96,9 +100,9 @@ class FirProviderImpl(val session: FirSession) : FirProvider() { private class State { val fileMap = mutableMapOf>() - val classifierMap = mutableMapOf() + val classifierMap = mutableMapOf>() val classifierContainerFileMap = mutableMapOf() - val callableMap = mutableMapOf>() + val callableMap = mutableMapOf>>() val callableContainerMap = mutableMapOf() fun setFrom(other: State) { @@ -120,7 +124,7 @@ class FirProviderImpl(val session: FirSession) : FirProvider() { return state.fileMap[fqName].orEmpty() } - override fun getFirClassifierByFqName(fqName: ClassId): FirClassLikeDeclaration? { + override fun getFirClassifierByFqName(fqName: ClassId): FirClassLikeDeclaration<*>? { return state.classifierMap[fqName] } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirTypeResolverImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirTypeResolverImpl.kt index 0f7c4528bc5..5906056e97d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirTypeResolverImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirTypeResolverImpl.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.* import org.jetbrains.kotlin.name.ClassId @@ -29,13 +30,13 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver { private data class ClassIdInSession(val session: FirSession, val id: ClassId) - private val implicitBuiltinTypeSymbols = mutableMapOf() + private val implicitBuiltinTypeSymbols = mutableMapOf>() // TODO: get rid of session used here, and may be also of the cache above (see KT-30275) - private fun resolveBuiltInQualified(id: ClassId, session: FirSession): ConeClassLikeSymbol { + private fun resolveBuiltInQualified(id: ClassId, session: FirSession): FirClassLikeSymbol<*> { val nameInSession = ClassIdInSession(session, id) return implicitBuiltinTypeSymbols.getOrPut(nameInSession) { - symbolProvider.getClassLikeSymbolByFqName(id) as ConeClassLikeSymbol + symbolProvider.getClassLikeSymbolByFqName(id)!! } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt index 29572f74fd4..b833d5a4ab9 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirTopLevelDeclaredMemberScope import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType import org.jetbrains.kotlin.fir.symbols.* import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.* import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult @@ -205,8 +206,8 @@ open class FirBodyResolveTransformer( FirErrorTypeRefImpl(session, access.psi, newCallee.errorReason) is FirResolvedCallableReference -> { val symbol = newCallee.coneSymbol - if (symbol is ConeCallableSymbol) { - val returnType = jump.tryCalculateReturnType(symbol.firUnsafe()) + if (symbol is FirCallableSymbol<*>) { + val returnType = jump.tryCalculateReturnType(symbol.fir) if (access.safe && access.explicitReceiver!!.resultType.coneTypeUnsafe().isNullable) { returnType.withReplacedConeType( session, @@ -215,11 +216,11 @@ open class FirBodyResolveTransformer( } else { returnType } - } else if (symbol is ConeClassifierSymbol) { - val firUnsafe = symbol.firUnsafe() + } else if (symbol is ConeClassifierSymbol && symbol is FirBasedSymbol<*>) { + val fir = symbol.fir // TODO: unhack - if (firUnsafe is FirEnumEntry) { - (firUnsafe.superTypeRefs.firstOrNull() as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl( + if (fir is FirEnumEntry) { + (fir.superTypeRefs.firstOrNull() as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl( session, null, "no enum item supertype" @@ -275,7 +276,7 @@ open class FirBodyResolveTransformer( val resultType = resolvedQualifier.resultType if (classId != null) { val classSymbol = symbolProvider.getClassLikeSymbolByFqName(classId)!! - val declaration = classSymbol.firUnsafe() + val declaration = classSymbol.fir if (declaration is FirClass) { if (declaration.classKind == ClassKind.OBJECT) { return resultType.resolvedTypeFromPrototype( @@ -851,7 +852,7 @@ open class FirBodyResolveTransformer( val expectedType = data as FirTypeRef? val kind = constExpression.kind - if (expectedType == null || expectedType is FirImplicitTypeRef || expectedType == null || + if (expectedType == null || expectedType is FirImplicitTypeRef || kind == IrConstKind.Null || kind == IrConstKind.Boolean || kind == IrConstKind.Char ) { val symbol = when (kind) { @@ -968,7 +969,7 @@ open class FirBodyResolveTransformer( } } - private fun storeVariableReturnType(variable: FirVariable) { + private fun storeVariableReturnType(variable: FirVariable<*>) { val initializer = variable.initializer if (variable.returnTypeRef is FirImplicitTypeRef) { when { @@ -1021,8 +1022,8 @@ open class FirBodyResolveTransformer( } } - override fun transformVariable(variable: FirVariable, data: Any?): CompositeTransformResult { - val variable = super.transformVariable(variable, variable.returnTypeRef).single as FirVariable + override fun > transformVariable(variable: FirVariable, data: Any?): CompositeTransformResult { + val variable = super.transformVariable(variable, variable.returnTypeRef).single as FirVariable<*> storeVariableReturnType(variable) if (variable !is FirProperty) { localScopes.lastOrNull()?.storeDeclaration(variable) @@ -1085,7 +1086,7 @@ open class FirBodyResolveTransformer( val symbol = symbolProvider.getClassLikeSymbolByFqName(classId)!! // TODO: Unify logic? symbol.constructType( - Array(symbol.firUnsafe().typeParameters.size) { + Array(symbol.fir.typeParameters.size) { ConeStarProjection }, isNullable = false @@ -1161,7 +1162,7 @@ class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: Sc val returnTypeRef = declaration.returnTypeRef if (returnTypeRef is FirResolvedTypeRef) return returnTypeRef cycleErrorType(declaration)?.let { return it } - require(declaration is FirCallableMemberDeclaration) { "${declaration::class}: ${declaration.render()}" } + require(declaration is FirCallableMemberDeclaration<*>) { "${declaration::class}: ${declaration.render()}" } val symbol = declaration.symbol as ConeCallableSymbol diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompleterTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompleterTransformer.kt index 8bb76f67b4c..26a9b59820e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompleterTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompleterTransformer.kt @@ -68,7 +68,7 @@ class FirCallCompleterTransformer( val functionCall = functionCall.transformArguments(this, data) as FirFunctionCall val subCandidate = calleeReference.candidate - val declaration = subCandidate.symbol.firUnsafe() + val declaration = subCandidate.symbol.firUnsafe>() val newTypeParameters = declaration.typeParameters.map { ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false) } .map { subCandidate.substitutor.substituteOrSelf(it) } .map { finalSubstitutor.substituteOrSelf(it) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt index 28319bede38..db86f0027a6 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt @@ -33,7 +33,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer() { return when (this) { is FirEnumEntry -> Modality.FINAL is FirRegularClass -> if (classKind == ClassKind.INTERFACE) Modality.ABSTRACT else Modality.FINAL - is FirCallableMemberDeclaration -> { + is FirCallableMemberDeclaration<*> -> { val containingClass = classes.lastOrNull() when { containingClass == null -> Modality.FINAL diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypeResolverTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypeResolverTransformer.kt index d2e250347c2..86fae893fa4 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypeResolverTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypeResolverTransformer.kt @@ -59,7 +59,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer() { return property.compose() } - private fun resolveSupertypesOrExpansions(classLikeDeclaration: FirClassLikeDeclaration): FirDeclaration { + private fun resolveSupertypesOrExpansions(classLikeDeclaration: FirClassLikeDeclaration<*>): FirDeclaration { val classId = classLikeDeclaration.symbol.classId if (classId in fullyComputed) return classLikeDeclaration @@ -76,7 +76,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer() { file: FirFile, private val currentlyComputing: MutableSet, private val fullyComputed: MutableSet, - private val knownFirClassLikeDeclaration: FirClassLikeDeclaration? = null + private val knownFirClassLikeDeclaration: FirClassLikeDeclaration<*>? = null ) : FirAbstractTreeTransformerWithSuperTypes(reversedScopePriority = true) { lateinit var resultingClass: FirDeclaration @@ -108,7 +108,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer() { return resolveNestedClassesSupertypes(transformedClass, data) } - private fun FirClassLikeDeclaration.matchesRequestedDeclaration(): Boolean { + private fun FirClassLikeDeclaration<*>.matchesRequestedDeclaration(): Boolean { if (knownFirClassLikeDeclaration != null) return knownFirClassLikeDeclaration == this return symbol.classId == requestedClassId } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/Scopes.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/Scopes.kt index a216105afd1..2f3f5f75f08 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/Scopes.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/Scopes.kt @@ -11,9 +11,9 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.buildUseSiteScope import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.scopes.impl.* -import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol -import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol import org.jetbrains.kotlin.fir.types.ConeAbbreviatedType import org.jetbrains.kotlin.fir.types.ConeClassLikeType @@ -38,8 +38,7 @@ fun FirCompositeScope.addImportingScopes(file: FirFile, session: FirSession) { } private fun finalExpansionName(symbol: FirTypeAliasSymbol, session: FirSession): Name? { - val expandedType = symbol.fir.expandedTypeRef.coneTypeUnsafe() - return when (expandedType) { + return when (val expandedType = symbol.fir.expandedTypeRef.coneTypeUnsafe()) { is ConeAbbreviatedType -> expandedType.abbreviationLookupTag.toSymbol(session)?.safeAs()?.let { finalExpansionName(it, session) @@ -50,8 +49,8 @@ private fun finalExpansionName(symbol: FirTypeAliasSymbol, session: FirSession): } fun processConstructors( - matchedSymbol: ConeClassLikeSymbol?, - processor: (ConeFunctionSymbol) -> ProcessorAction, + matchedSymbol: FirClassLikeSymbol<*>?, + processor: (FirFunctionSymbol<*>) -> ProcessorAction, session: FirSession, scopeSession: ScopeSession, name: Name @@ -61,13 +60,12 @@ fun processConstructors( val scope = when (matchedSymbol) { is FirTypeAliasSymbol -> matchedSymbol.fir.buildUseSiteScope(session, scopeSession) is FirClassSymbol -> matchedSymbol.fir.buildUseSiteScope(session, scopeSession) - else -> null } val constructorName = when (matchedSymbol) { is FirTypeAliasSymbol -> finalExpansionName(matchedSymbol, session) ?: return ProcessorAction.NEXT - else -> name + is FirClassSymbol -> name } //TODO: why don't we use declared member scope at this point? diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/AbstractFirOverrideScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/AbstractFirOverrideScope.kt index a867811c859..31e4e20c160 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/AbstractFirOverrideScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/AbstractFirOverrideScope.kt @@ -61,7 +61,7 @@ abstract class AbstractFirOverrideScope(val session: FirSession) : FirScope() { protected fun ConeCallableSymbol.isOverridden(seen: Set): ConeCallableSymbol? { if (overrides.containsKey(this)) return overrides[this] - fun similarFunctionsOrBothProperties(declaration: FirCallableDeclaration, self: FirCallableDeclaration): Boolean { + fun similarFunctionsOrBothProperties(declaration: FirCallableDeclaration<*>, self: FirCallableDeclaration<*>): Boolean { return when (declaration) { is FirNamedFunction -> self is FirNamedFunction && isOverriddenFunCheck(declaration, self) is FirConstructor -> false @@ -75,9 +75,9 @@ abstract class AbstractFirOverrideScope(val session: FirSession) : FirScope() { } } - val self = (this as AbstractFirBasedSymbol<*>).fir as FirCallableMemberDeclaration + val self = (this as AbstractFirBasedSymbol<*>).fir as FirCallableMemberDeclaration<*> val overriding = seen.firstOrNull { - val member = (it as AbstractFirBasedSymbol<*>).fir as FirCallableMemberDeclaration + val member = (it as AbstractFirBasedSymbol<*>).fir as FirCallableMemberDeclaration<*> self.modality != Modality.FINAL && similarFunctionsOrBothProperties(member, self) } // TODO: two or more overrides for one fun? diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractImportingScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractImportingScope.kt index fd3d17e2d39..9fea74b9daa 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractImportingScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractImportingScope.kt @@ -7,16 +7,17 @@ package org.jetbrains.kotlin.fir.scopes.impl import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirResolvedImport -import org.jetbrains.kotlin.fir.declarations.FirTypeAlias import org.jetbrains.kotlin.fir.declarations.expandedConeType import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.calls.TowerScopeLevel import org.jetbrains.kotlin.fir.resolve.toSymbol -import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.scopes.processConstructors import org.jetbrains.kotlin.fir.symbols.* +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.utils.addToStdlib.cast @@ -32,9 +33,9 @@ abstract class FirAbstractImportingScope(session: FirSession, lookupInFir: Boole val symbol = provider.getClassLikeSymbolByFqName(classId) ?: error("No scope/symbol for $classId") - if (symbol is ConeTypeAliasSymbol) { - val expansionSymbol = symbol.firUnsafe().expandedConeType?.lookupTag?.toSymbol(session) - if (expansionSymbol as? ConeClassLikeSymbol != null) { + if (symbol is FirTypeAliasSymbol) { + val expansionSymbol = symbol.fir.expandedConeType?.lookupTag?.toSymbol(session) + if (expansionSymbol is ConeClassLikeSymbol) { return getStaticsScope(expansionSymbol.classId) } } @@ -42,11 +43,11 @@ abstract class FirAbstractImportingScope(session: FirSession, lookupInFir: Boole return null } - protected fun processCallables( + protected fun > processCallables( import: FirResolvedImport, name: Name, token: TowerScopeLevel.Token, - processor: (ConeCallableSymbol) -> ProcessorAction + processor: (FirCallableSymbol<*>) -> ProcessorAction ): ProcessorAction { val callableId = CallableId(import.packageFqName, import.relativeClassName, name) @@ -95,20 +96,20 @@ abstract class FirAbstractImportingScope(session: FirSession, lookupInFir: Boole return ProcessorAction.NEXT } - abstract fun processCallables( + abstract fun > processCallables( name: Name, token: TowerScopeLevel.Token, - processor: (ConeCallableSymbol) -> ProcessorAction + processor: (FirCallableSymbol<*>) -> ProcessorAction ): ProcessorAction - final override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction { + final override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction { return processCallables( name, TowerScopeLevel.Token.Functions - ) { if (it is ConeFunctionSymbol) processor(it) else ProcessorAction.NEXT } + ) { if (it is FirFunctionSymbol<*>) processor(it) else ProcessorAction.NEXT } } - final override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction { + final override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction { return processCallables( name, TowerScopeLevel.Token.Properties diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractSimpleImportingScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractSimpleImportingScope.kt index cf1bf67e56c..5e3905fabea 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractSimpleImportingScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractSimpleImportingScope.kt @@ -10,9 +10,9 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider import org.jetbrains.kotlin.fir.resolve.calls.TowerScopeLevel import org.jetbrains.kotlin.fir.scopes.FirPosition -import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.symbols.* +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name @@ -41,10 +41,10 @@ abstract class FirAbstractSimpleImportingScope(session: FirSession) : FirAbstrac return true } - override fun processCallables( + override fun > processCallables( name: Name, token: TowerScopeLevel.Token, - processor: (ConeCallableSymbol) -> ProcessorAction + processor: (FirCallableSymbol<*>) -> ProcessorAction ): ProcessorAction { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractStarImportingScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractStarImportingScope.kt index 42e7548f253..4cf87657cc6 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractStarImportingScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractStarImportingScope.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.resolve.calls.TowerScopeLevel import org.jetbrains.kotlin.fir.scopes.FirPosition import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.symbols.* +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name @@ -41,10 +42,10 @@ abstract class FirAbstractStarImportingScope( } - override fun processCallables( + override fun > processCallables( name: Name, token: TowerScopeLevel.Token, - processor: (ConeCallableSymbol) -> ProcessorAction + processor: (FirCallableSymbol<*>) -> ProcessorAction ): ProcessorAction { for (import in starImports) { if (processCallables(import, name, token, processor).stop()) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt index 5d944339b07..903af32c21c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.service import org.jetbrains.kotlin.fir.symbols.* import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.name.Name class FirClassDeclaredMemberScopeProvider { @@ -37,11 +38,11 @@ fun declaredMemberScope(klass: FirRegularClass): FirClassDeclaredMemberScope { } class FirClassDeclaredMemberScope(klass: FirRegularClass) : FirScope() { - private val callablesIndex: Map> = run { - val result = mutableMapOf>() + private val callablesIndex: Map>> = run { + val result = mutableMapOf>>() for (declaration in klass.declarations) { when (declaration) { - is FirCallableMemberDeclaration -> { + is FirCallableMemberDeclaration<*> -> { val name = if (declaration is FirConstructor) klass.name else declaration.name result.getOrPut(name) { mutableListOf() } += declaration.symbol } @@ -66,20 +67,20 @@ class FirClassDeclaredMemberScope(klass: FirRegularClass) : FirScope() { result } - override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction { + override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction { val symbols = callablesIndex[name] ?: emptyList() for (symbol in symbols) { - if (symbol is ConeFunctionSymbol && !processor(symbol)) { + if (symbol is FirFunctionSymbol<*> && !processor(symbol)) { return STOP } } return NEXT } - override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction { + override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction { val symbols = callablesIndex[name] ?: emptyList() for (symbol in symbols) { - if (symbol is ConePropertySymbol && !processor(symbol)) { + if (symbol is ConeVariableSymbol && !processor(symbol)) { return STOP } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt index 11e7547a916..ec21ae4fa41 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt @@ -6,8 +6,6 @@ package org.jetbrains.kotlin.fir.scopes.impl import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirConstructor -import org.jetbrains.kotlin.fir.declarations.FirFunction import org.jetbrains.kotlin.fir.declarations.FirNamedFunction import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl import org.jetbrains.kotlin.fir.declarations.impl.FirMemberFunctionImpl @@ -15,13 +13,14 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculatorWithJump -import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction -import org.jetbrains.kotlin.fir.symbols.* -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol -import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol +import org.jetbrains.kotlin.fir.symbols.impl.* +import org.jetbrains.kotlin.fir.types.ConeKotlinType +import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef +import org.jetbrains.kotlin.fir.types.FirTypeRef +import org.jetbrains.kotlin.fir.types.coneTypeUnsafe import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl import org.jetbrains.kotlin.name.Name @@ -32,22 +31,22 @@ class FirClassSubstitutionScope( substitution: Map ) : FirScope() { - private val fakeOverrides = mutableMapOf() + private val fakeOverrides = mutableMapOf, FirFunctionSymbol<*>>() private val substitutor = ConeSubstitutorByMap(substitution) - override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction { + override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction { useSiteScope.processFunctionsByName(name) process@{ original -> val function = fakeOverrides.getOrPut(original) { createFakeOverride(original) } - processor(function as ConeFunctionSymbol) + processor(function) } return super.processFunctionsByName(name, processor) } - override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction { + override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction { return useSiteScope.processPropertiesByName(name, processor) } @@ -57,11 +56,12 @@ class FirClassSubstitutionScope( return substitutor.substituteOrNull(this) } - private fun createFakeOverride(original: ConeFunctionSymbol): FirFunctionSymbol { - - val member = original.firUnsafe() - if (member is FirConstructor) return original as FirFunctionSymbol // TODO: substitution for constructors - member as FirNamedFunction + private fun createFakeOverride(original: FirFunctionSymbol<*>): FirFunctionSymbol<*> { + val member = when (original) { + is FirNamedFunctionSymbol -> original.fir + is FirConstructorSymbol -> return original + is FirAccessorSymbol -> throw AssertionError("Should not be here") + } val receiverType = member.receiverTypeRef?.coneTypeUnsafe() val newReceiverType = receiverType?.substitute() @@ -73,19 +73,19 @@ class FirClassSubstitutionScope( it.returnTypeRef.coneTypeUnsafe().substitute() } - return createFakeOverride(session, member, original as FirFunctionSymbol, newReceiverType, newReturnType, newParameterTypes) + return createFakeOverride(session, member, original, newReceiverType, newReturnType, newParameterTypes) } companion object { fun createFakeOverride( session: FirSession, baseFunction: FirNamedFunction, - baseSymbol: FirFunctionSymbol, + baseSymbol: FirNamedFunctionSymbol, newReceiverType: ConeKotlinType? = null, newReturnType: ConeKotlinType? = null, newParameterTypes: List? = null - ): FirFunctionSymbol { - val symbol = FirFunctionSymbol(baseSymbol.callableId, true, baseSymbol) + ): FirNamedFunctionSymbol { + val symbol = FirNamedFunctionSymbol(baseSymbol.callableId, true, baseSymbol) with(baseFunction) { // TODO: consider using here some light-weight functions instead of pseudo-real FirMemberFunctionImpl // As second alternative, we can invent some light-weight kind of FirRegularClass diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassUseSiteScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassUseSiteScope.kt index 03b769f2c03..3d867b9a5f6 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassUseSiteScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassUseSiteScope.kt @@ -12,6 +12,8 @@ import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NEXT import org.jetbrains.kotlin.fir.scopes.ProcessorAction.STOP import org.jetbrains.kotlin.fir.symbols.* +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.name.Name class FirClassUseSiteScope( @@ -20,7 +22,7 @@ class FirClassUseSiteScope( private val declaredMemberScope: FirScope ) : AbstractFirOverrideScope(session) { - override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction { + override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction { val seen = mutableSetOf() if (!declaredMemberScope.processFunctionsByName(name) { seen += it @@ -39,7 +41,7 @@ class FirClassUseSiteScope( } } - override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction { + override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction { val seen = mutableSetOf() if (!declaredMemberScope.processPropertiesByName(name) { seen += it diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt index 7c747e01ec7..3d263514aa7 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt @@ -11,9 +11,9 @@ import org.jetbrains.kotlin.fir.scopes.FirTypeParameterScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NEXT import org.jetbrains.kotlin.fir.scopes.ProcessorAction.STOP -import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol -import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.name.Name class FirCompositeScope( @@ -57,11 +57,11 @@ class FirCompositeScope( return NEXT } - override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction { + override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction { return processComposite(FirScope::processFunctionsByName, name, processor) } - override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction { + override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction { return processComposite(FirScope::processPropertiesByName, name, processor) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLocalScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLocalScope.kt index 9a5ecea5c89..747989165f9 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLocalScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLocalScope.kt @@ -12,20 +12,21 @@ import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.expressions.FirVariable import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction -import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol -import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol import org.jetbrains.kotlin.name.Name class FirLocalScope : FirScope() { - val properties = mutableMapOf() - val functions = mutableMapOf() + val properties = mutableMapOf>() + val functions = mutableMapOf>() fun storeDeclaration(declaration: FirNamedDeclaration) { when (declaration) { - is FirVariable -> properties[declaration.name] = declaration.symbol - is FirNamedFunction -> functions[declaration.name] = declaration.symbol as FirFunctionSymbol + is FirVariable<*> -> properties[declaration.name] = declaration.symbol + is FirNamedFunction -> functions[declaration.name] = declaration.symbol as FirNamedFunctionSymbol } } @@ -33,7 +34,7 @@ class FirLocalScope : FirScope() { properties[FirBackingFieldReference.NAME] = property.backingFieldSymbol } - override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction { + override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction { val prop = functions[name] if (prop != null) { return processor(prop) @@ -41,7 +42,7 @@ class FirLocalScope : FirScope() { return ProcessorAction.NEXT } - override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction { + override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction { val prop = properties[name] if (prop != null) { return processor(prop) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirSuperTypeScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirSuperTypeScope.kt index b8b2000f621..7ddf3befd9a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirSuperTypeScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirSuperTypeScope.kt @@ -8,9 +8,9 @@ package org.jetbrains.kotlin.fir.scopes.impl import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction -import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol -import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.name.Name class FirSuperTypeScope( @@ -18,7 +18,7 @@ class FirSuperTypeScope( val scopes: List ) : AbstractFirOverrideScope(session) { - override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction { + override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction { val accepted = HashSet() val pending = mutableListOf() for (scope in scopes) { @@ -40,9 +40,9 @@ class FirSuperTypeScope( return super.processFunctionsByName(name, processor) } - override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction { - val accepted = HashSet() - val pending = mutableListOf() + override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction { + val accepted = HashSet>() + val pending = mutableListOf>() for (scope in scopes) { if (scope.processPropertiesByName(name) { if (it !in accepted && it.isOverridden(accepted) == null) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTopLevelDeclaredMemberScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTopLevelDeclaredMemberScope.kt index 03a8a99dda6..180925b22bc 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTopLevelDeclaredMemberScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTopLevelDeclaredMemberScope.kt @@ -12,9 +12,9 @@ import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NEXT import org.jetbrains.kotlin.fir.scopes.ProcessorAction.STOP import org.jetbrains.kotlin.fir.scopes.processConstructors -import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol import org.jetbrains.kotlin.fir.symbols.ConePropertySymbol -import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name @@ -25,7 +25,7 @@ class FirTopLevelDeclaredMemberScope( ) : FirAbstractProviderBasedScope(session, lookupInFir) { private val packageFqName = file.packageFqName - override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction { + override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction { val matchedClass = provider.getClassLikeSymbolByFqName(ClassId(packageFqName, name)) if (processConstructors( @@ -40,14 +40,14 @@ class FirTopLevelDeclaredMemberScope( } val symbols = provider.getTopLevelCallableSymbols(packageFqName, name) for (symbol in symbols) { - if (symbol is ConeFunctionSymbol && !processor(symbol)) { + if (symbol is FirFunctionSymbol<*> && !processor(symbol)) { return STOP } } return NEXT } - override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction { + override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction { val symbols = provider.getTopLevelCallableSymbols(packageFqName, name) for (symbol in symbols) { if (symbol is ConePropertySymbol && !processor(symbol)) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/symbols/StandardTypes.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/symbols/StandardTypes.kt index 2efaa3741d1..6b6b2d90164 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/symbols/StandardTypes.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/symbols/StandardTypes.kt @@ -6,13 +6,14 @@ package org.jetbrains.kotlin.fir.symbols import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.name.ClassId -val FirSymbolProvider.Any: ConeClassLikeSymbol get() = this.getClassLikeSymbolByFqName(StandardClassIds.Any)!! -val FirSymbolProvider.Nothing: ConeClassLikeSymbol get() = this.getClassLikeSymbolByFqName(StandardClassIds.Nothing)!! +val FirSymbolProvider.Any: FirClassLikeSymbol<*> get() = this.getClassLikeSymbolByFqName(StandardClassIds.Any)!! +val FirSymbolProvider.Nothing: FirClassLikeSymbol<*> get() = this.getClassLikeSymbolByFqName(StandardClassIds.Nothing)!! -operator fun ClassId.invoke(symbolProvider: FirSymbolProvider): ConeClassLikeSymbol { +operator fun ClassId.invoke(symbolProvider: FirSymbolProvider): FirClassLikeSymbol<*> { return symbolProvider.getClassLikeSymbolByFqName(this)!! } \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt index d59cd625eab..2343b50ea3e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt @@ -277,8 +277,8 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext { } override fun TypeConstructorMarker.isCommonFinalClassConstructor(): Boolean { - val classSymbol = this as? ConeClassSymbol ?: return false - val fir = (classSymbol as FirClassSymbol).fir + val classSymbol = this as? FirClassSymbol ?: return false + val fir = classSymbol.fir return fir.modality == Modality.FINAL && fir.classKind != ClassKind.ENUM_ENTRY && fir.classKind != ClassKind.ANNOTATION_CLASS diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirLoadCompiledKotlin.kt b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirLoadCompiledKotlin.kt index 0a1759fb0e3..6b8d0a19b04 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirLoadCompiledKotlin.kt +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirLoadCompiledKotlin.kt @@ -9,7 +9,6 @@ import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider -import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.compileKotlinToDirAndGetModule import org.jetbrains.kotlin.name.ClassId @@ -66,7 +65,7 @@ abstract class AbstractFirLoadCompiledKotlin : AbstractFirResolveWithSessionTest for (name in provider.getAllCallableNamesInPackage(packageFqName)) { for (symbol in provider.getTopLevelCallableSymbols(packageFqName, name)) { - (symbol as FirCallableSymbol).fir.accept(firRenderer) + symbol.fir.accept(firRenderer) builder.appendln() } } diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/BuiltInsDeserializationForFirTestCase.kt b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/BuiltInsDeserializationForFirTestCase.kt index db2e6ae39cc..be473722c58 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/BuiltInsDeserializationForFirTestCase.kt +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/BuiltInsDeserializationForFirTestCase.kt @@ -9,7 +9,6 @@ import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider -import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName @@ -42,7 +41,7 @@ class BuiltInsDeserializationForFirTestCase : AbstractFirResolveWithSessionTestC for (name in provider.getAllCallableNamesInPackage(packageFqName)) { for (symbol in provider.getTopLevelCallableSymbols(packageFqName, name)) { - (symbol as FirCallableSymbol).fir.accept(firRenderer) + symbol.fir.accept(firRenderer) builder.appendln() } } diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt index e5a9fcc8255..647cff7535b 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt @@ -34,7 +34,8 @@ import org.jetbrains.kotlin.fir.resolve.impl.FirCompositeSymbolProvider import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope import org.jetbrains.kotlin.fir.service -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName @@ -190,8 +191,8 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() { if (declaration in renderedDeclarations) continue when (declaration) { is FirJavaConstructor -> enhancementScope.processFunctionsByName(javaClass.name) { symbol -> - val enhanced = (symbol as? FirFunctionSymbol)?.fir - if (enhanced != null && enhanced !in renderedDeclarations) { + val enhanced = symbol.fir + if (enhanced !in renderedDeclarations) { enhanced.accept(renderer, null) renderer.newLine() renderedDeclarations += enhanced @@ -199,8 +200,8 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() { ProcessorAction.NEXT } is FirJavaMethod -> enhancementScope.processFunctionsByName(declaration.name) { symbol -> - val enhanced = (symbol as? FirFunctionSymbol)?.fir - if (enhanced != null && enhanced !in renderedDeclarations) { + val enhanced = symbol.fir + if (enhanced !in renderedDeclarations) { enhanced.accept(renderer, null) renderer.newLine() renderedDeclarations += enhanced @@ -208,8 +209,8 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() { ProcessorAction.NEXT } is FirJavaField -> enhancementScope.processPropertiesByName(declaration.name) { symbol -> - val enhanced = (symbol as? FirPropertySymbol)?.fir - if (enhanced != null && enhanced !in renderedDeclarations) { + val enhanced = symbol.fir + if (enhanced !in renderedDeclarations) { enhanced.accept(renderer, null) renderer.newLine() renderedDeclarations += enhanced diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt index e313700daf8..eafd05ebe6b 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt @@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirUnitExpression import org.jetbrains.kotlin.fir.references.FirErrorNamedReference import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef @@ -146,7 +146,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { } } - override fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration) { + override fun > visitCallableDeclaration(callableDeclaration: FirCallableDeclaration) { if (callableDeclaration is FirMemberDeclaration) { visitMemberDeclaration(callableDeclaration) } else { @@ -178,7 +178,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { private fun FirMemberDeclaration.modalityAsString(): String { return modality?.name?.toLowerCase() ?: run { - if (this is FirCallableMemberDeclaration && this.isOverride) { + if (this is FirCallableMemberDeclaration<*> && this.isOverride) { "open?" } else { "final?" @@ -203,7 +203,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { if (memberDeclaration.isActual) { print("actual ") } - if (memberDeclaration is FirCallableMemberDeclaration) { + if (memberDeclaration is FirCallableMemberDeclaration<*>) { if (memberDeclaration.isOverride) { print("override ") } @@ -257,9 +257,9 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { override fun visitNamedDeclaration(namedDeclaration: FirNamedDeclaration) { visitDeclaration(namedDeclaration) - if (namedDeclaration !is FirCallableDeclaration) { // Handled by visitCallableDeclaration + if (namedDeclaration !is FirCallableDeclaration<*>) { // Handled by visitCallableDeclaration print(" " + namedDeclaration.name) - if (namedDeclaration is FirClassLikeDeclaration) { + if (namedDeclaration is FirClassLikeDeclaration<*>) { namedDeclaration.typeParameters.renderTypeParameters() } } else if (namedDeclaration is FirMemberDeclaration) { @@ -278,7 +278,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { is FirNamedFunction -> "fun" is FirProperty -> if (declaration.isVal) "val" else "var" is FirField -> "field" - is FirVariable -> if (declaration.isVal) "lval" else "lvar" + is FirVariable<*> -> if (declaration.isVal) "lval" else "lvar" else -> "unknown" } ) @@ -325,7 +325,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { anonymousObject.renderDeclarations() } - override fun visitVariable(variable: FirVariable) { + override fun > visitVariable(variable: FirVariable) { visitCallableDeclaration(variable) variable.initializer?.let { print(" = ") @@ -798,7 +798,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { override fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference) { print("R|") - val isFakeOverride = (resolvedCallableReference.coneSymbol as? FirFunctionSymbol)?.isFakeOverride == true + val isFakeOverride = (resolvedCallableReference.coneSymbol as? FirNamedFunctionSymbol)?.isFakeOverride == true if (isFakeOverride) { print("FakeOverride<") @@ -810,7 +810,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { print(symbol.classId) if (isFakeOverride) { when (symbol) { - is FirFunctionSymbol -> { + is FirNamedFunctionSymbol -> { print(": ") symbol.fir.returnTypeRef.accept(this) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirCallableDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirCallableDeclaration.kt index 46c58c4706c..23ff3e9173d 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirCallableDeclaration.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirCallableDeclaration.kt @@ -12,11 +12,11 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirVisitor // Good name needed (something with receiver, type parameters, return type, and name) -interface FirCallableDeclaration : +interface FirCallableDeclaration> : @VisitedSupertype FirDeclaration, - FirTypedDeclaration, FirSymbolOwner { + FirTypedDeclaration, FirSymbolOwner { - override val symbol: FirCallableSymbol + override val symbol: FirCallableSymbol val receiverTypeRef: FirTypeRef? diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirCallableMemberDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirCallableMemberDeclaration.kt index c5cff1639af..4d57cda77e5 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirCallableMemberDeclaration.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirCallableMemberDeclaration.kt @@ -9,7 +9,8 @@ import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource -interface FirCallableMemberDeclaration : @VisitedSupertype FirDeclaration, FirMemberDeclaration, FirCallableDeclaration { +interface FirCallableMemberDeclaration> : + @VisitedSupertype FirDeclaration, FirMemberDeclaration, FirCallableDeclaration { val isOverride: Boolean get() = status.isOverride diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClassLikeDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClassLikeDeclaration.kt index 4f8e5a97e35..598d76ff990 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClassLikeDeclaration.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClassLikeDeclaration.kt @@ -7,14 +7,16 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.expressions.FirStatement -import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol +import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol import org.jetbrains.kotlin.fir.visitors.FirVisitor -interface FirClassLikeDeclaration : @VisitedSupertype FirMemberDeclaration, FirStatement { - val symbol: ConeClassLikeSymbol +interface FirClassLikeDeclaration> : + @VisitedSupertype FirMemberDeclaration, FirStatement, FirSymbolOwner { + override val symbol: FirClassLikeSymbol override fun accept(visitor: FirVisitor, data: D): R { return super.accept(visitor, data) @@ -25,7 +27,7 @@ interface FirClassLikeDeclaration : @VisitedSupertype FirMemberDeclaration, FirS } } -fun ConeClassifierSymbol.toFirClassLike(): FirClassLikeDeclaration? = +fun ConeClassifierSymbol.toFirClassLike(): FirClassLikeDeclaration<*>? = when (this) { is FirClassSymbol -> this.fir is FirTypeAliasSymbol -> this.fir diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirConstructor.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirConstructor.kt index 087bdaae495..480f9411c45 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirConstructor.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirConstructor.kt @@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall import org.jetbrains.kotlin.fir.visitors.FirVisitor @BaseTransformedType -interface FirConstructor : @VisitedSupertype FirFunction, FirCallableMemberDeclaration { +interface FirConstructor : @VisitedSupertype FirMemberFunction { val isPrimary: Boolean get() = false diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirField.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirField.kt index a9307bfadb0..98acd6dc9ad 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirField.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirField.kt @@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.FirVariable import org.jetbrains.kotlin.fir.visitors.FirVisitor @BaseTransformedType -interface FirField : @VisitedSupertype FirDeclaration, FirCallableMemberDeclaration, FirVariable { +interface FirField : @VisitedSupertype FirDeclaration, FirCallableMemberDeclaration, FirVariable { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitField(this, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirMemberFunction.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirMemberFunction.kt new file mode 100644 index 00000000000..1dc38595ccd --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirMemberFunction.kt @@ -0,0 +1,29 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.declarations + +import org.jetbrains.kotlin.fir.VisitedSupertype +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.visitors.FirVisitor + +interface FirMemberFunction> : + @VisitedSupertype FirFunction, FirCallableMemberDeclaration { + + override val symbol: FirFunctionSymbol + + override fun accept(visitor: FirVisitor, data: D): R { + return visitor.visitMemberFunction(this, data) + } + + override fun acceptChildren(visitor: FirVisitor, data: D) { + super.acceptChildren(visitor, data) + for (parameter in valueParameters) { + parameter.accept(visitor, data) + } + body?.accept(visitor, data) + } +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirNamedFunction.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirNamedFunction.kt index 0b0cea5f0f6..74cc7686220 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirNamedFunction.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirNamedFunction.kt @@ -7,12 +7,10 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.VisitedSupertype -import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.fir.visitors.FirVisitor @BaseTransformedType -interface FirNamedFunction : @VisitedSupertype FirFunction, FirCallableMemberDeclaration, FirMemberDeclaration { +interface FirNamedFunction : @VisitedSupertype FirMemberFunction, FirMemberDeclaration { val isOperator: Boolean get() = status.isOperator val isInfix: Boolean get() = status.isInfix @@ -29,12 +27,4 @@ interface FirNamedFunction : @VisitedSupertype FirFunction, FirCallableMemberDec override fun accept(visitor: FirVisitor, data: D): R = visitor.visitNamedFunction(this, data) - - override fun acceptChildren(visitor: FirVisitor, data: D) { - super.acceptChildren(visitor, data) - for (parameter in valueParameters) { - parameter.accept(visitor, data) - } - body?.accept(visitor, data) - } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirProperty.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirProperty.kt index d21aae15132..e9ffb67c626 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirProperty.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirProperty.kt @@ -14,7 +14,8 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor // May be should not inherit FirVariable @BaseTransformedType -interface FirProperty : @VisitedSupertype FirDeclaration, FirCallableMemberDeclaration, FirVariable, FirMemberDeclaration { +interface FirProperty : + @VisitedSupertype FirDeclaration, FirCallableMemberDeclaration, FirVariable, FirMemberDeclaration { val isConst: Boolean get() = status.isConst val isLateInit: Boolean get() = status.isLateInit diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirRegularClass.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirRegularClass.kt index 9328153f704..c6b490ab458 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirRegularClass.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirRegularClass.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.VisitedSupertype -import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirVisitor @@ -15,7 +14,7 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor // May be all containers should be properties and not base classes // About descriptors: introduce something like FirDescriptor which is FirUnresolved at the beginning and FirSymbol(descriptor) at the end @BaseTransformedType -interface FirRegularClass : FirClass, @VisitedSupertype FirClassLikeDeclaration, FirSymbolOwner { +interface FirRegularClass : FirClass, @VisitedSupertype FirClassLikeDeclaration { val isInner: Boolean get() = status.isInner val isCompanion: Boolean get() = status.isCompanion diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt index ecbadbba2ac..4765b9eec94 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt @@ -5,14 +5,13 @@ package org.jetbrains.kotlin.fir.declarations -import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.coneTypeSafe import org.jetbrains.kotlin.fir.visitors.FirVisitor -interface FirTypeAlias : FirClassLikeDeclaration, FirSymbolOwner { +interface FirTypeAlias : FirClassLikeDeclaration { fun replaceExpandTypeRef(typeRef: FirTypeRef): FirTypeAlias val expandedTypeRef: FirTypeRef diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirValueParameter.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirValueParameter.kt index a4274c3e763..b2cd5c07616 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirValueParameter.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirValueParameter.kt @@ -9,12 +9,11 @@ import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirVariable -import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol import org.jetbrains.kotlin.fir.visitors.FirVisitor @BaseTransformedType -interface FirValueParameter : @VisitedSupertype FirDeclaration, FirTypedDeclaration, FirNamedDeclaration, FirVariable { +interface FirValueParameter : @VisitedSupertype FirDeclaration, FirTypedDeclaration, FirNamedDeclaration, FirVariable { val isCrossinline: Boolean val isNoinline: Boolean @@ -23,7 +22,7 @@ interface FirValueParameter : @VisitedSupertype FirDeclaration, FirTypedDeclarat val defaultValue: FirExpression? - override val symbol: FirVariableSymbol + override val symbol: FirVariableSymbol override fun accept(visitor: FirVisitor, data: D): R = visitor.visitValueParameter(this, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractCallableMember.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractCallableMember.kt index 1a17d41d69d..6b75f92a959 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractCallableMember.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractCallableMember.kt @@ -17,9 +17,9 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource -abstract class FirAbstractCallableMember : FirAbstractMemberDeclaration, FirCallableMemberDeclaration { +abstract class FirAbstractCallableMember> : + FirAbstractMemberDeclaration, FirCallableMemberDeclaration { -// final override val symbol: FirBasedSymbol final override var receiverTypeRef: FirTypeRef? final override var returnTypeRef: FirTypeRef diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirConstructorImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirConstructorImpl.kt index 1d2cb9d93ea..1abb2ec170c 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirConstructorImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirConstructorImpl.kt @@ -14,23 +14,23 @@ import org.jetbrains.kotlin.fir.declarations.FirConstructor import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.name.Name -open class FirConstructorImpl : FirAbstractCallableMember, FirConstructor { +open class FirConstructorImpl : FirAbstractCallableMember, FirConstructor { - override val symbol: FirFunctionSymbol + override val symbol: FirConstructorSymbol final override var delegatedConstructor: FirDelegatedConstructorCall? = null constructor( session: FirSession, psi: PsiElement?, - symbol: FirFunctionSymbol, + symbol: FirConstructorSymbol, visibility: Visibility, isExpect: Boolean, isActual: Boolean, @@ -48,7 +48,7 @@ open class FirConstructorImpl : FirAbstractCallableMember, FirConstructor { constructor( session: FirSession, psi: PsiElement?, - symbol: FirFunctionSymbol, + symbol: FirConstructorSymbol, receiverTypeRef: FirTypeRef?, returnTypeRef: FirTypeRef ) : super(session, psi, NAME, receiverTypeRef, returnTypeRef) { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultSetterValueParameter.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultSetterValueParameter.kt index e085044b939..b3f467f0927 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultSetterValueParameter.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultSetterValueParameter.kt @@ -20,7 +20,7 @@ class FirDefaultSetterValueParameter( session: FirSession, psi: PsiElement?, override var returnTypeRef: FirTypeRef, - override val symbol: FirVariableSymbol = FirVariableSymbol(name) + override val symbol: FirVariableSymbol = FirVariableSymbol(name) ) : FirAbstractNamedAnnotatedDeclaration(session, psi, name), FirValueParameter { init { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberFunctionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberFunctionImpl.kt index e712284a745..ea209bbf3fd 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberFunctionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberFunctionImpl.kt @@ -12,22 +12,23 @@ import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.FirBlock -import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.name.Name -open class FirMemberFunctionImpl : FirAbstractCallableMember, FirNamedFunction, FirModifiableFunction { +open class FirMemberFunctionImpl : FirAbstractCallableMember, FirNamedFunction, FirModifiableFunction { - override val symbol: FirCallableSymbol + // NB: FirAccessorSymbol can be here + override val symbol: FirFunctionSymbol constructor( session: FirSession, psi: PsiElement?, - symbol: FirCallableSymbol, + symbol: FirFunctionSymbol, name: Name, receiverTypeRef: FirTypeRef?, returnTypeRef: FirTypeRef @@ -39,7 +40,7 @@ open class FirMemberFunctionImpl : FirAbstractCallableMember, FirNamedFunction, constructor( session: FirSession, psi: PsiElement?, - symbol: FirFunctionSymbol, + symbol: FirNamedFunctionSymbol, name: Name, visibility: Visibility, modality: Modality?, diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt index 3ef2bb43b2a..32588a0e96e 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt @@ -40,7 +40,7 @@ class FirMemberPropertyImpl( override var getter: FirPropertyAccessor, override var setter: FirPropertyAccessor?, override var delegate: FirExpression? -) : FirAbstractCallableMember( +) : FirAbstractCallableMember( session, psi, name, visibility, modality, isExpect, isActual, isOverride, receiverTypeRef, returnTypeRef ), FirProperty { override val backingFieldSymbol = FirBackingFieldSymbol(symbol.callableId) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPrimaryConstructorImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPrimaryConstructorImpl.kt index aa1ccfecee9..47408515c55 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPrimaryConstructorImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPrimaryConstructorImpl.kt @@ -9,13 +9,13 @@ import com.intellij.psi.PsiElement import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef class FirPrimaryConstructorImpl( session: FirSession, psi: PsiElement?, - symbol: FirFunctionSymbol, + symbol: FirConstructorSymbol, visibility: Visibility, isExpect: Boolean, isActual: Boolean, diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirValueParameterImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirValueParameterImpl.kt index 62432abe601..3aa3ffe5e5f 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirValueParameterImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirValueParameterImpl.kt @@ -25,7 +25,7 @@ open class FirValueParameterImpl( override val isCrossinline: Boolean, override val isNoinline: Boolean, override val isVararg: Boolean, - override val symbol: FirVariableSymbol = FirVariableSymbol(name) + override val symbol: FirVariableSymbol = FirVariableSymbol(name) ) : FirAbstractNamedAnnotatedDeclaration(session, psi, name), FirValueParameter { init { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirVariableImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirVariableImpl.kt index 9cde72fa65a..3763ace3b19 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirVariableImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirVariableImpl.kt @@ -8,10 +8,8 @@ package org.jetbrains.kotlin.fir.declarations.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirVariable -import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol import org.jetbrains.kotlin.fir.transformSingle import org.jetbrains.kotlin.fir.types.FirTypeRef @@ -25,9 +23,9 @@ class FirVariableImpl( override var returnTypeRef: FirTypeRef, override val isVar: Boolean, override var initializer: FirExpression?, - override val symbol: FirVariableSymbol = FirVariableSymbol(name), + override val symbol: FirVariableSymbol = FirVariableSymbol(name), override var delegate: FirExpression? = null -) : FirAbstractNamedAnnotatedDeclaration(session, psiElement, name), FirVariable { +) : FirAbstractNamedAnnotatedDeclaration(session, psiElement, name), FirVariable { init { symbol.bind(this) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirVariable.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirVariable.kt index 2d9543dd600..482db834078 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirVariable.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirVariable.kt @@ -10,7 +10,8 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol import org.jetbrains.kotlin.fir.visitors.FirVisitor -interface FirVariable : @VisitedSupertype FirDeclaration, FirTypedDeclaration, FirCallableDeclaration, FirNamedDeclaration, FirStatement { +interface FirVariable> : + @VisitedSupertype FirDeclaration, FirTypedDeclaration, FirCallableDeclaration, FirNamedDeclaration, FirStatement { val isVar: Boolean val isVal: Boolean @@ -20,7 +21,7 @@ interface FirVariable : @VisitedSupertype FirDeclaration, FirTypedDeclaration, F val delegate: FirExpression? - override val symbol: FirVariableSymbol + override val symbol: FirVariableSymbol override fun accept(visitor: FirVisitor, data: D): R = visitor.visitVariable(this, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenExpression.kt index 3601c60914b..6c58ac90115 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenExpression.kt @@ -17,7 +17,7 @@ abstract class FirWhenExpression( abstract val subject: FirExpression? // when (val subjectVariable = subject()) { ... } - abstract val subjectVariable: FirVariable? + abstract val subjectVariable: FirVariable<*>? abstract val branches: List diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenExpressionImpl.kt index ce0479a6952..d0922e0942a 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenExpressionImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenExpressionImpl.kt @@ -17,7 +17,7 @@ class FirWhenExpressionImpl( session: FirSession, psiElement: PsiElement?, override var subject: FirExpression? = null, - override var subjectVariable: FirVariable? = null + override var subjectVariable: FirVariable<*>? = null ) : FirWhenExpression(session, psiElement) { override val branches = mutableListOf() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirPropertyFromParameterCallableReference.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirPropertyFromParameterCallableReference.kt index 45865e84738..a88f0ca8f9d 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirPropertyFromParameterCallableReference.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirPropertyFromParameterCallableReference.kt @@ -16,5 +16,5 @@ class FirPropertyFromParameterCallableReference( session: FirSession, psi: PsiElement?, override val name: Name, - override val coneSymbol: FirVariableSymbol + override val coneSymbol: FirVariableSymbol<*> ) : FirAbstractElement(session, psi), FirResolvedCallableReference \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/scopes/FirScope.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/scopes/FirScope.kt index 330e7444863..1111b94d0e3 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/scopes/FirScope.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/scopes/FirScope.kt @@ -8,8 +8,8 @@ package org.jetbrains.kotlin.fir.scopes import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NEXT import org.jetbrains.kotlin.fir.scopes.ProcessorAction.STOP import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol -import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol -import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.name.Name abstract class FirScope { @@ -25,12 +25,13 @@ abstract class FirScope { open fun processFunctionsByName( name: Name, - processor: (ConeFunctionSymbol) -> ProcessorAction + processor: (FirFunctionSymbol<*>) -> ProcessorAction ): ProcessorAction = NEXT open fun processPropertiesByName( name: Name, - processor: (ConeVariableSymbol) -> ProcessorAction + // NB: it'd be great to write FirVariableSymbol<*> here, but there is FirAccessorSymbol :( + processor: (FirCallableSymbol<*>) -> ProcessorAction ): ProcessorAction = NEXT } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/AbstractFirBasedSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/AbstractFirBasedSymbol.kt index 9c95de61a99..b1111ad8d2c 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/AbstractFirBasedSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/AbstractFirBasedSymbol.kt @@ -5,9 +5,9 @@ package org.jetbrains.kotlin.fir.symbols -import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.declarations.FirDeclaration -abstract class AbstractFirBasedSymbol : FirBasedSymbol where E : FirElement, E : FirSymbolOwner { +abstract class AbstractFirBasedSymbol : FirBasedSymbol where E : FirDeclaration, E : FirSymbolOwner { override lateinit var fir: E diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirAccessorSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirAccessorSymbol.kt deleted file mode 100644 index 72a88348498..00000000000 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirAccessorSymbol.kt +++ /dev/null @@ -1,14 +0,0 @@ -/* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.fir.symbols.impl - -import org.jetbrains.kotlin.fir.symbols.CallableId -import org.jetbrains.kotlin.fir.symbols.ConePropertySymbol - -class FirAccessorSymbol( - override val callableId: CallableId, - val accessorId: CallableId -) : ConePropertySymbol, FirCallableSymbol() \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt index 987bab1f71d..c6a20e35f65 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt @@ -9,4 +9,4 @@ import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol -abstract class FirCallableSymbol : ConeCallableSymbol, AbstractFirBasedSymbol() +abstract class FirCallableSymbol> : ConeCallableSymbol, AbstractFirBasedSymbol() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt new file mode 100644 index 00000000000..522a78366b2 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt @@ -0,0 +1,33 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.symbols.impl + +import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration +import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.FirTypeAlias +import org.jetbrains.kotlin.fir.symbols.* +import org.jetbrains.kotlin.name.ClassId + +sealed class FirClassLikeSymbol>( + override val classId: ClassId +) : ConeClassLikeSymbol, AbstractFirBasedSymbol() { + override fun equals(other: Any?): Boolean = + other is FirClassLikeSymbol<*> && fir == other.fir + + override fun hashCode(): Int = fir.hashCode() +} + +class FirClassSymbol(classId: ClassId) : FirClassLikeSymbol(classId), ConeClassSymbol { + override fun toLookupTag(): ConeClassLikeLookupTag = ConeClassLikeLookupTagImpl(classId) +} + +class FirTypeAliasSymbol(override val classId: ClassId) : FirClassLikeSymbol(classId), ConeTypeAliasSymbol { + override fun toLookupTag(): TypeAliasLookupTagImpl = TypeAliasLookupTagImpl(classId) +} + +class TypeAliasLookupTagImpl( + override val classId: ClassId +) : ConeTypeAliasLookupTag() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassSymbol.kt deleted file mode 100644 index f2f69d31983..00000000000 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassSymbol.kt +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.fir.symbols.impl - -import org.jetbrains.kotlin.fir.declarations.FirRegularClass -import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol -import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag -import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTagImpl -import org.jetbrains.kotlin.fir.symbols.ConeClassSymbol -import org.jetbrains.kotlin.name.ClassId - -class FirClassSymbol(override val classId: ClassId) : ConeClassSymbol, AbstractFirBasedSymbol() { - override fun toLookupTag(): ConeClassLikeLookupTag = ConeClassLikeLookupTagImpl(classId) - - override fun equals(other: Any?): Boolean = - other is FirClassSymbol && fir == other.fir - - override fun hashCode(): Int = fir.hashCode() -} diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFieldSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFieldSymbol.kt deleted file mode 100644 index 9bb2f82444e..00000000000 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFieldSymbol.kt +++ /dev/null @@ -1,8 +0,0 @@ -/* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.fir.symbols.impl - -typealias FirFieldSymbol = FirPropertySymbol \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFunctionSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFunctionSymbol.kt index 5b4067ec0f5..e69e6c036eb 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFunctionSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFunctionSymbol.kt @@ -5,16 +5,31 @@ package org.jetbrains.kotlin.fir.symbols.impl +import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.symbols.CallableId import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.ConePropertySymbol import org.jetbrains.kotlin.fir.types.ConeKotlinType -class FirFunctionSymbol( - override val callableId: CallableId, - val isFakeOverride: Boolean = false, - // Actual for fake override only - val overriddenSymbol: FirFunctionSymbol? = null -) : ConeFunctionSymbol, FirCallableSymbol() { +sealed class FirFunctionSymbol>( + override val callableId: CallableId +) : ConeFunctionSymbol, FirCallableSymbol() { override val parameters: List get() = emptyList() } + +class FirNamedFunctionSymbol( + callableId: CallableId, + val isFakeOverride: Boolean = false, + // Actual for fake override only + val overriddenSymbol: FirNamedFunctionSymbol? = null +) : FirFunctionSymbol(callableId) + +class FirConstructorSymbol( + callableId: CallableId +) : FirFunctionSymbol(callableId) + +class FirAccessorSymbol( + callableId: CallableId, + val accessorId: CallableId +) : ConePropertySymbol, FirFunctionSymbol(callableId) \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeAliasSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeAliasSymbol.kt index 8eedfbfa4b5..5147b31cf7c 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeAliasSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeAliasSymbol.kt @@ -12,22 +12,3 @@ import org.jetbrains.kotlin.fir.symbols.ConeTypeAliasLookupTag import org.jetbrains.kotlin.fir.symbols.ConeTypeAliasSymbol import org.jetbrains.kotlin.name.ClassId -class FirTypeAliasSymbol( - override val classId: ClassId -) : ConeTypeAliasSymbol, AbstractFirBasedSymbol() { - override fun toLookupTag(): ConeClassLikeLookupTag = TypeAliasLookupTagImpl(classId) - - override fun equals(other: Any?): Boolean = - other is FirTypeAliasSymbol && classId == other.classId && fir == other.fir - - override fun hashCode(): Int { - var result = 31 - result = result * 19 + classId.hashCode() - result = result * 19 + fir.hashCode() - return result - } -} - -class TypeAliasLookupTagImpl( - override val classId: ClassId -) : ConeTypeAliasLookupTag() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirPropertySymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirVariableSymbol.kt similarity index 54% rename from compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirPropertySymbol.kt rename to compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirVariableSymbol.kt index 69dd5c0910d..96a11177535 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirPropertySymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirVariableSymbol.kt @@ -5,17 +5,22 @@ package org.jetbrains.kotlin.fir.symbols.impl +import org.jetbrains.kotlin.fir.declarations.FirField +import org.jetbrains.kotlin.fir.declarations.FirProperty +import org.jetbrains.kotlin.fir.expressions.FirVariable import org.jetbrains.kotlin.fir.symbols.CallableId import org.jetbrains.kotlin.fir.symbols.ConePropertySymbol import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol import org.jetbrains.kotlin.name.Name -open class FirPropertySymbol(callableId: CallableId) : FirVariableSymbol(callableId), ConePropertySymbol - -class FirBackingFieldSymbol(callableId: CallableId) : FirVariableSymbol(callableId) - -open class FirVariableSymbol(override val callableId: CallableId) : ConeVariableSymbol, FirCallableSymbol() { +open class FirVariableSymbol>(override val callableId: CallableId) : ConeVariableSymbol, FirCallableSymbol() { @Deprecated("TODO: Better solution for local vars?") constructor(name: Name) : this(CallableId(name)) // TODO? } + +open class FirPropertySymbol(callableId: CallableId) : ConePropertySymbol, FirVariableSymbol(callableId) + +class FirBackingFieldSymbol(callableId: CallableId) : FirVariableSymbol(callableId) + +class FirFieldSymbol(callableId: CallableId) : FirVariableSymbol(callableId) diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt index 58f709fa641..947d5212f46 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt @@ -24,11 +24,11 @@ abstract class FirTransformer : FirVisitor { + open fun > transformCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): CompositeTransformResult { return transformDeclaration(callableDeclaration, data) } - open fun transformCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): CompositeTransformResult { + open fun > transformCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): CompositeTransformResult { return transformDeclaration(callableMemberDeclaration, data) } @@ -48,18 +48,22 @@ abstract class FirTransformer : FirVisitor> transformMemberFunction(memberFunction: FirMemberFunction, data: D): CompositeTransformResult { + return transformFunction(memberFunction, data) + } + open fun transformConstructor(constructor: FirConstructor, data: D): CompositeTransformResult { - return transformFunction(constructor, data) + return transformMemberFunction(constructor, data) + } + + open fun transformNamedFunction(namedFunction: FirNamedFunction, data: D): CompositeTransformResult { + return transformMemberFunction(namedFunction, data) } open fun transformModifiableFunction(modifiableFunction: FirModifiableFunction, data: D): CompositeTransformResult { return transformFunction(modifiableFunction, data) } - open fun transformNamedFunction(namedFunction: FirNamedFunction, data: D): CompositeTransformResult { - return transformFunction(namedFunction, data) - } - open fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): CompositeTransformResult { return transformFunction(propertyAccessor, data) } @@ -84,7 +88,7 @@ abstract class FirTransformer : FirVisitor { + open fun > transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): CompositeTransformResult { return transformMemberDeclaration(classLikeDeclaration, data) } @@ -116,7 +120,7 @@ abstract class FirTransformer : FirVisitor { + open fun > transformVariable(variable: FirVariable, data: D): CompositeTransformResult { return transformDeclaration(variable, data) } @@ -488,11 +492,11 @@ abstract class FirTransformer : FirVisitor { + final override fun > visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): CompositeTransformResult { return transformCallableDeclaration(callableDeclaration, data) } - final override fun visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): CompositeTransformResult { + final override fun > visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): CompositeTransformResult { return transformCallableMemberDeclaration(callableMemberDeclaration, data) } @@ -508,7 +512,7 @@ abstract class FirTransformer : FirVisitor { + final override fun > visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): CompositeTransformResult { return transformClassLikeDeclaration(classLikeDeclaration, data) } @@ -648,6 +652,10 @@ abstract class FirTransformer : FirVisitor> visitMemberFunction(memberFunction: FirMemberFunction, data: D): CompositeTransformResult { + return transformMemberFunction(memberFunction, data) + } + final override fun visitModifiableClass(modifiableClass: FirModifiableClass, data: D): CompositeTransformResult { return transformModifiableClass(modifiableClass, data) } @@ -828,7 +836,7 @@ abstract class FirTransformer : FirVisitor { + final override fun > visitVariable(variable: FirVariable, data: D): CompositeTransformResult { return transformVariable(variable, data) } diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt index 4a15f71b362..c4bab0eda35 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt @@ -24,11 +24,11 @@ abstract class FirVisitor { return visitElement(declaration, data) } - open fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): R { + open fun > visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): R { return visitDeclaration(callableDeclaration, data) } - open fun visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): R { + open fun > visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): R { return visitDeclaration(callableMemberDeclaration, data) } @@ -48,18 +48,22 @@ abstract class FirVisitor { return visitFunction(anonymousFunction, data) } + open fun > visitMemberFunction(memberFunction: FirMemberFunction, data: D): R { + return visitFunction(memberFunction, data) + } + open fun visitConstructor(constructor: FirConstructor, data: D): R { - return visitFunction(constructor, data) + return visitMemberFunction(constructor, data) + } + + open fun visitNamedFunction(namedFunction: FirNamedFunction, data: D): R { + return visitMemberFunction(namedFunction, data) } open fun visitModifiableFunction(modifiableFunction: FirModifiableFunction, data: D): R { return visitFunction(modifiableFunction, data) } - open fun visitNamedFunction(namedFunction: FirNamedFunction, data: D): R { - return visitFunction(namedFunction, data) - } - open fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): R { return visitFunction(propertyAccessor, data) } @@ -84,7 +88,7 @@ abstract class FirVisitor { return visitNamedDeclaration(memberDeclaration, data) } - open fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): R { + open fun > visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): R { return visitMemberDeclaration(classLikeDeclaration, data) } @@ -116,7 +120,7 @@ abstract class FirVisitor { return visitDeclaration(valueParameter, data) } - open fun visitVariable(variable: FirVariable, data: D): R { + open fun > visitVariable(variable: FirVariable, data: D): R { return visitDeclaration(variable, data) } diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt index bea282b39a7..ceefa8a2d39 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt @@ -24,11 +24,11 @@ abstract class FirVisitorVoid : FirVisitor() { visitElement(declaration, null) } - open fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration) { + open fun > visitCallableDeclaration(callableDeclaration: FirCallableDeclaration) { visitDeclaration(callableDeclaration, null) } - open fun visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration) { + open fun > visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration) { visitDeclaration(callableMemberDeclaration, null) } @@ -48,18 +48,22 @@ abstract class FirVisitorVoid : FirVisitor() { visitFunction(anonymousFunction, null) } + open fun > visitMemberFunction(memberFunction: FirMemberFunction) { + visitFunction(memberFunction, null) + } + open fun visitConstructor(constructor: FirConstructor) { - visitFunction(constructor, null) + visitMemberFunction(constructor, null) + } + + open fun visitNamedFunction(namedFunction: FirNamedFunction) { + visitMemberFunction(namedFunction, null) } open fun visitModifiableFunction(modifiableFunction: FirModifiableFunction) { visitFunction(modifiableFunction, null) } - open fun visitNamedFunction(namedFunction: FirNamedFunction) { - visitFunction(namedFunction, null) - } - open fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor) { visitFunction(propertyAccessor, null) } @@ -84,7 +88,7 @@ abstract class FirVisitorVoid : FirVisitor() { visitNamedDeclaration(memberDeclaration, null) } - open fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration) { + open fun > visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration) { visitMemberDeclaration(classLikeDeclaration, null) } @@ -116,7 +120,7 @@ abstract class FirVisitorVoid : FirVisitor() { visitDeclaration(valueParameter, null) } - open fun visitVariable(variable: FirVariable) { + open fun > visitVariable(variable: FirVariable) { visitDeclaration(variable, null) } @@ -488,11 +492,11 @@ abstract class FirVisitorVoid : FirVisitor() { visitCallWithArgumentList(callWithArgumentList) } - final override fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: Nothing?) { + final override fun > visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: Nothing?) { visitCallableDeclaration(callableDeclaration) } - final override fun visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: Nothing?) { + final override fun > visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: Nothing?) { visitCallableMemberDeclaration(callableMemberDeclaration) } @@ -508,7 +512,7 @@ abstract class FirVisitorVoid : FirVisitor() { visitClass(klass) } - final override fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: Nothing?) { + final override fun > visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: Nothing?) { visitClassLikeDeclaration(classLikeDeclaration) } @@ -648,6 +652,10 @@ abstract class FirVisitorVoid : FirVisitor() { visitMemberDeclaration(memberDeclaration) } + final override fun > visitMemberFunction(memberFunction: FirMemberFunction, data: Nothing?) { + visitMemberFunction(memberFunction) + } + final override fun visitModifiableClass(modifiableClass: FirModifiableClass, data: Nothing?) { visitModifiableClass(modifiableClass) } @@ -828,7 +836,7 @@ abstract class FirVisitorVoid : FirVisitor() { visitValueParameter(valueParameter) } - final override fun visitVariable(variable: FirVariable, data: Nothing?) { + final override fun > visitVariable(variable: FirVariable, data: Nothing?) { visitVariable(variable) } diff --git a/compiler/testData/ir/irText/expressions/javaSyntheticPropertyAccess.fir.txt b/compiler/testData/ir/irText/expressions/javaSyntheticPropertyAccess.fir.txt index 17e49477003..b482fbd1ebc 100644 --- a/compiler/testData/ir/irText/expressions/javaSyntheticPropertyAccess.fir.txt +++ b/compiler/testData/ir/irText/expressions/javaSyntheticPropertyAccess.fir.txt @@ -2,10 +2,12 @@ FILE fqName: fileName:/javaSyntheticPropertyAccess.kt FUN name:test visibility:public modality:FINAL <> (j:.J) returnType:kotlin.Unit VALUE_PARAMETER name:j index:0 type:.J BLOCK_BODY - ERROR_CALL 'Unresolved reference: R|/J.foo|' type=kotlin.Int + CALL 'public open fun getFoo (): kotlin.Int declared in .J' type=kotlin.Int origin=null + $this: GET_VAR 'j: .J declared in .test' type=.J origin=null ERROR_CALL 'Unresolved reference: R|/J.foo|' type=IrErrorType VAR name: type:kotlin.Int [val] - ERROR_CALL 'Unresolved reference: R|/J.foo|' type=kotlin.Int + CALL 'public open fun getFoo (): kotlin.Int declared in .J' type=kotlin.Int origin=null + $this: GET_VAR 'j: .J declared in .test' type=.J origin=null ERROR_CALL 'Unresolved reference: R|/J.foo|' type=IrErrorType GET_VAR 'val : kotlin.Int [val] declared in .test' type=kotlin.Int origin=null ERROR_CALL 'Unresolved reference: R|/J.foo|' type=IrErrorType diff --git a/compiler/testData/ir/irText/stubs/javaSyntheticProperty.fir.txt b/compiler/testData/ir/irText/stubs/javaSyntheticProperty.fir.txt index 3988df6c6b6..c398e7c6b48 100644 --- a/compiler/testData/ir/irText/stubs/javaSyntheticProperty.fir.txt +++ b/compiler/testData/ir/irText/stubs/javaSyntheticProperty.fir.txt @@ -2,7 +2,8 @@ FILE fqName: fileName:/javaSyntheticProperty.kt PROPERTY name:test visibility:public modality:FINAL [val] FIELD PROPERTY_BACKING_FIELD name:test type:kotlin.String? visibility:public [final,static] EXPRESSION_BODY - ERROR_CALL 'Unresolved reference: R|/J.foo|' type=kotlin.String? + CALL 'public open fun getFoo (): kotlin.String? declared in .J' type=kotlin.String? origin=null + $this: CONSTRUCTOR_CALL 'public constructor () declared in .J' type=.J origin=null FUN DEFAULT_PROPERTY_ACCESSOR name: visibility:public modality:FINAL <> () returnType:kotlin.String? correspondingProperty: PROPERTY name:test visibility:public modality:FINAL [val] BLOCK_BODY diff --git a/idea/src/org/jetbrains/kotlin/idea/fir/IdeFirDependenciesSymbolProvider.kt b/idea/src/org/jetbrains/kotlin/idea/fir/IdeFirDependenciesSymbolProvider.kt index 63a9cc10b34..5a6bd57105f 100644 --- a/idea/src/org/jetbrains/kotlin/idea/fir/IdeFirDependenciesSymbolProvider.kt +++ b/idea/src/org/jetbrains/kotlin/idea/fir/IdeFirDependenciesSymbolProvider.kt @@ -17,8 +17,8 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.service -import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol -import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.idea.caches.project.ModuleSourceInfo import org.jetbrains.kotlin.idea.caches.project.getModuleInfo import org.jetbrains.kotlin.idea.stubindex.KotlinFullClassNameIndex @@ -43,7 +43,7 @@ class IdeFirDependenciesSymbolProvider( private val javaSymbolProvider by lazy { JavaSymbolProvider(sessionProvider.getSession(moduleInfo)!!, project, depScope) } - private fun buildKotlinClassOnRequest(file: KtFile, classId: ClassId, session: FirSession): ConeClassLikeSymbol? { + private fun buildKotlinClassOnRequest(file: KtFile, classId: ClassId, session: FirSession): FirClassLikeSymbol<*>? { val impl = FirProvider.getInstance(session) as FirProviderImpl val classifier = impl.getClassLikeSymbolByFqName(classId) if (classifier != null) { @@ -69,7 +69,7 @@ class IdeFirDependenciesSymbolProvider( TODO("not implemented") } - private fun tryKotlin(classId: ClassId): ConeClassLikeSymbol? { + private fun tryKotlin(classId: ClassId): FirClassLikeSymbol<*>? { return classCache.lookupCacheOrCalculate(classId) { val index = KotlinFullClassNameIndex.getInstance() @@ -91,15 +91,15 @@ class IdeFirDependenciesSymbolProvider( } } - private fun tryJava(classId: ClassId): ConeClassLikeSymbol? { + private fun tryJava(classId: ClassId): FirClassLikeSymbol<*>? { return javaSymbolProvider.getClassLikeSymbolByFqName(classId) } - override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? { + override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? { return tryKotlin(classId) ?: tryJava(classId) } - override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List { + override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List> { // TODO return emptyList() } diff --git a/idea/tests/org/jetbrains/kotlin/idea/fir/AbstractFirMultiModuleResolveTest.kt b/idea/tests/org/jetbrains/kotlin/idea/fir/AbstractFirMultiModuleResolveTest.kt index 3f12b6dfe5e..ed301c89623 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/fir/AbstractFirMultiModuleResolveTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/fir/AbstractFirMultiModuleResolveTest.kt @@ -32,7 +32,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope import org.jetbrains.kotlin.fir.service -import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.idea.KotlinFileType import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo import org.jetbrains.kotlin.idea.caches.project.isLibraryClasses @@ -159,7 +158,7 @@ abstract class AbstractFirMultiModuleResolveTest : AbstractMultiModuleTest() { renderedDeclarations += declaration } else { enhancementScope.processFunctionsByName(declaration.name) { symbol -> - val enhanced = (symbol as? FirFunctionSymbol)?.fir + val enhanced = symbol.fir if (enhanced != null && enhanced !in renderedDeclarations) { enhanced.accept(renderer, null) renderer.newLine()