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 a3fde4ff096..33339985669 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 @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.caches.getValue import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.builder.buildFile import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty +import org.jetbrains.kotlin.fir.declarations.utils.isExpect import org.jetbrains.kotlin.fir.declarations.utils.isInline import org.jetbrains.kotlin.fir.declarations.utils.isJava import org.jetbrains.kotlin.fir.declarations.utils.visibility @@ -57,12 +58,10 @@ import org.jetbrains.kotlin.ir.util.functions import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.SpecialNames import org.jetbrains.kotlin.name.StandardClassIds -import org.jetbrains.kotlin.psi.KtQualifiedExpression import org.jetbrains.kotlin.psi.psiUtil.startOffsetSkippingComments import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.util.OperatorNameConventions -import org.jetbrains.kotlin.utils.addToStdlib.safeAs internal fun FirElement.convertWithOffsets( f: (startOffset: Int, endOffset: Int) -> T @@ -128,9 +127,8 @@ class ConversionTypeContext internal constructor( } } +context(Fir2IrComponents) fun FirClassifierSymbol<*>.toSymbol( - session: FirSession, - classifierStorage: Fir2IrClassifierStorage, typeContext: ConversionTypeContext = ConversionTypeContext.DEFAULT, handleAnnotations: ((List) -> Unit)? = null ): IrClassifierSymbol { @@ -142,7 +140,7 @@ fun FirClassifierSymbol<*>.toSymbol( handleAnnotations?.invoke(fir.expandedTypeRef.annotations) val coneClassLikeType = fir.expandedTypeRef.coneType as ConeClassLikeType coneClassLikeType.lookupTag.toSymbol(session) - ?.toSymbol(session, classifierStorage, typeContext, handleAnnotations) + ?.toSymbol(typeContext, handleAnnotations) ?: classifierStorage.getIrClassSymbolForNotFoundClass(coneClassLikeType.lookupTag) } is FirClassSymbol -> { @@ -152,31 +150,26 @@ fun FirClassifierSymbol<*>.toSymbol( } } +context(Fir2IrComponents) private fun FirBasedSymbol<*>.toSymbolForCall( dispatchReceiver: FirExpression, - session: FirSession, - classifierStorage: Fir2IrClassifierStorage, - declarationStorage: Fir2IrDeclarationStorage, preferGetter: Boolean, explicitReceiver: FirExpression? = null, isDelegate: Boolean = false -) = when (this) { +): IrSymbol? = when (this) { is FirCallableSymbol<*> -> unwrapCallRepresentative().toSymbolForCall( dispatchReceiver, - declarationStorage, preferGetter, explicitReceiver, isDelegate ) - is FirClassifierSymbol<*> -> toSymbol(session, classifierStorage) + is FirClassifierSymbol<*> -> toSymbol() else -> error("Unknown symbol: $this") } +context(Fir2IrComponents) fun FirReference.toSymbolForCall( dispatchReceiver: FirExpression, - session: FirSession, - classifierStorage: Fir2IrClassifierStorage, - declarationStorage: Fir2IrDeclarationStorage, conversionScope: Fir2IrConversionScope, preferGetter: Boolean = true, explicitReceiver: FirExpression? = null, // Actual only for callable references @@ -186,9 +179,6 @@ fun FirReference.toSymbolForCall( is FirResolvedNamedReference -> resolvedSymbol.toSymbolForCall( dispatchReceiver, - session, - classifierStorage, - declarationStorage, preferGetter, explicitReceiver, isDelegate @@ -196,9 +186,6 @@ fun FirReference.toSymbolForCall( is FirErrorNamedReference -> candidateSymbol?.toSymbolForCall( dispatchReceiver, - session, - classifierStorage, - declarationStorage, preferGetter, explicitReceiver, isDelegate @@ -218,9 +205,9 @@ fun FirReference.toSymbolForCall( } } +context(Fir2IrComponents) private fun FirCallableSymbol<*>.toSymbolForCall( dispatchReceiver: FirExpression, - declarationStorage: Fir2IrDeclarationStorage, preferGetter: Boolean, explicitReceiver: FirExpression? = null, isDelegate: Boolean = false @@ -254,7 +241,7 @@ private fun FirCallableSymbol<*>.toSymbolForCall( ?: throw AssertionError("Written synthetic property must have a setter") } delegateSymbol.unwrapCallRepresentative() - .toSymbolForCall(dispatchReceiver, declarationStorage, preferGetter, isDelegate = false) + .toSymbolForCall(dispatchReceiver, preferGetter, isDelegate = false) } ?: declarationStorage.getIrPropertySymbol(this) } } @@ -336,6 +323,7 @@ internal tailrec fun FirCallableSymbol<*>.unwrapSubstitutionAndIntersectionOverr return this } +context(Fir2IrComponents) internal tailrec fun FirCallableSymbol<*>.unwrapCallRepresentative(root: FirCallableSymbol<*> = this): FirCallableSymbol<*> { val fir = fir if (fir is FirConstructor) { @@ -363,10 +351,9 @@ internal tailrec fun FirCallableSymbol<*>.unwrapCallRepresentative(root: FirCall return overriddenSymbol.unwrapCallRepresentative(this) } +context(Fir2IrComponents) internal fun FirSimpleFunction.processOverriddenFunctionSymbols( containingClass: FirClass, - session: FirSession, - scopeSession: ScopeSession, processor: (FirNamedFunctionSymbol) -> Unit ) { val scope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = true) @@ -381,17 +368,12 @@ internal fun FirSimpleFunction.processOverriddenFunctionSymbols( } } -internal fun FirSimpleFunction.generateOverriddenFunctionSymbols( - containingClass: FirClass, - session: FirSession, - scopeSession: ScopeSession, - declarationStorage: Fir2IrDeclarationStorage, - fakeOverrideGenerator: FakeOverrideGenerator, -): List { - val superClasses = containingClass.getSuperTypesAsIrClasses(declarationStorage) ?: return emptyList() +context(Fir2IrComponents) +internal fun FirSimpleFunction.generateOverriddenFunctionSymbols(containingClass: FirClass): List { + val superClasses = containingClass.getSuperTypesAsIrClasses() ?: return emptyList() val overriddenSet = mutableSetOf() - processOverriddenFunctionSymbols(containingClass, session, scopeSession) { + processOverriddenFunctionSymbols(containingClass) { for (overridden in fakeOverrideGenerator.getOverriddenSymbolsInSupertypes(it, superClasses)) { overriddenSet += overridden } @@ -432,19 +414,17 @@ fun FirTypeScope.processOverriddenPropertiesFromSuperClasses( processor(unwrapped) } -private fun FirClass.getSuperTypesAsIrClasses( - declarationStorage: Fir2IrDeclarationStorage -): Set? { +context(Fir2IrComponents) +private fun FirClass.getSuperTypesAsIrClasses(): Set? { val irClass = declarationStorage.classifierStorage.getIrClassSymbol(symbol).owner as? IrClass ?: return null return irClass.superTypes.mapNotNull { it.classifierOrNull?.owner as? IrClass }.toSet() } +context(Fir2IrComponents) internal fun FirProperty.processOverriddenPropertySymbols( containingClass: FirClass, - session: FirSession, - scopeSession: ScopeSession, processor: (FirPropertySymbol) -> Unit ): List { val scope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = true) @@ -462,17 +442,12 @@ internal fun FirProperty.processOverriddenPropertySymbols( return overriddenSet.toList() } -internal fun FirProperty.generateOverriddenPropertySymbols( - containingClass: FirClass, - session: FirSession, - scopeSession: ScopeSession, - declarationStorage: Fir2IrDeclarationStorage, - fakeOverrideGenerator: FakeOverrideGenerator, -): List { - val superClasses = containingClass.getSuperTypesAsIrClasses(declarationStorage) ?: return emptyList() +context(Fir2IrComponents) +internal fun FirProperty.generateOverriddenPropertySymbols(containingClass: FirClass): List { + val superClasses = containingClass.getSuperTypesAsIrClasses() ?: return emptyList() val overriddenSet = mutableSetOf() - processOverriddenPropertySymbols(containingClass, session, scopeSession) { + processOverriddenPropertySymbols(containingClass) { for (overridden in fakeOverrideGenerator.getOverriddenSymbolsInSupertypes(it, superClasses)) { overriddenSet += overridden } @@ -481,18 +456,12 @@ internal fun FirProperty.generateOverriddenPropertySymbols( return overriddenSet.toList() } -internal fun FirProperty.generateOverriddenAccessorSymbols( - containingClass: FirClass, - isGetter: Boolean, - session: FirSession, - scopeSession: ScopeSession, - declarationStorage: Fir2IrDeclarationStorage, - fakeOverrideGenerator: FakeOverrideGenerator, -): List { +context(Fir2IrComponents) +internal fun FirProperty.generateOverriddenAccessorSymbols(containingClass: FirClass, isGetter: Boolean): List { val scope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = true) scope.processPropertiesByName(name) {} val overriddenSet = mutableSetOf() - val superClasses = containingClass.getSuperTypesAsIrClasses(declarationStorage) ?: return emptyList() + val superClasses = containingClass.getSuperTypesAsIrClasses() ?: return emptyList() scope.processOverriddenPropertiesFromSuperClasses(symbol, containingClass) { if (it.fir.visibility == Visibilities.Private) { @@ -548,8 +517,8 @@ internal fun FirReference.statementOrigin(): IrStatementOrigin? { } } +context(Fir2IrComponents) internal fun IrDeclarationParent.declareThisReceiverParameter( - symbolTable: SymbolTable, thisType: IrType, thisOrigin: IrDeclarationOrigin, startOffset: Int = this.startOffset, @@ -644,11 +613,11 @@ fun Fir2IrComponents.computeValueClassRepresentation(klass: FirRegularClass): Va } } -fun FirRegularClass.getIrSymbolsForSealedSubclasses(components: Fir2IrComponents): List { - val session = components.session +context(Fir2IrComponents) +fun FirRegularClass.getIrSymbolsForSealedSubclasses(): List { val symbolProvider = session.symbolProvider return getSealedClassInheritors(session).mapNotNull { - symbolProvider.getClassLikeSymbolByClassId(it)?.toSymbol(session, components.classifierStorage) + symbolProvider.getClassLikeSymbolByClassId(it)?.toSymbol() }.filterIsInstance() } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrBuiltIns.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrBuiltIns.kt index 889cfebedf6..d5abf92ec9f 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrBuiltIns.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrBuiltIns.kt @@ -53,7 +53,7 @@ class Fir2IrBuiltIns( private fun annotationSymbolById(id: ClassId): IrClassSymbol? = provider?.getClassSymbolById(id) ?: session.symbolProvider.getClassLikeSymbolByClassId(id)?.toSymbol( - session, classifierStorage, ConversionTypeContext.DEFAULT + ConversionTypeContext.DEFAULT ) as? IrClassSymbol private fun IrClassSymbol.toConstructorCall(): IrConstructorCallImpl = diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt index 60753567795..24d9af3c269 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt @@ -86,7 +86,6 @@ class Fir2IrClassifierStorage( IrSimpleTypeImpl(getIrTypeParameterSymbol(it.symbol, ConversionTypeContext.DEFAULT), false, emptyList(), emptyList()) } thisReceiver = declareThisReceiverParameter( - symbolTable, thisType = IrSimpleTypeImpl(symbol, false, typeArguments, emptyList()), thisOrigin = IrDeclarationOrigin.INSTANCE_RECEIVER ) 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 6a19add2b64..2754e0f3f0c 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 @@ -365,7 +365,6 @@ class Fir2IrDeclarationStorage( Name.identifier("\$this\$$suffix") } ?: SpecialNames.THIS declareThisReceiverParameter( - symbolTable, thisType = receiverTypeRef.toIrType(typeContext), thisOrigin = thisOrigin, startOffset = startOffset, @@ -378,7 +377,6 @@ class Fir2IrDeclarationStorage( val isLocal = function is FirSimpleFunction && function.isLocal if (function !is FirAnonymousFunction && containingClass != null && !isStatic && !isLocal) { dispatchReceiverParameter = declareThisReceiverParameter( - symbolTable, thisType = containingClass.thisReceiver?.type ?: error("No this receiver"), thisOrigin = thisOrigin ) @@ -388,7 +386,6 @@ class Fir2IrDeclarationStorage( val outerClass = containingClass?.parentClassOrNull if (containingClass?.isInner == true && outerClass != null) { dispatchReceiverParameter = declareThisReceiverParameter( - symbolTable, thisType = outerClass.thisReceiver!!.type, thisOrigin = thisOrigin ) @@ -728,7 +725,7 @@ class Fir2IrDeclarationStorage( } if (correspondingProperty is Fir2IrLazyProperty && correspondingProperty.containingClass != null && !isFakeOverride && thisReceiverOwner != null) { this.overriddenSymbols = correspondingProperty.fir.generateOverriddenAccessorSymbols( - correspondingProperty.containingClass, !isSetter, session, scopeSession, declarationStorage, fakeOverrideGenerator + correspondingProperty.containingClass, !isSetter ) } } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt index fb3acf96fb1..3758b1fce6b 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt @@ -114,7 +114,7 @@ class Fir2IrTypeConverter( val irSymbol = getBuiltInClassSymbol(classId) - ?: lookupTag.toSymbol(session)?.toSymbol(session, classifierStorage, typeContext) { + ?: lookupTag.toSymbol(session)?.toSymbol(typeContext) { typeAnnotations += with(annotationGenerator) { it.toIrAnnotations() } } ?: (lookupTag as? ConeClassLikeLookupTag)?.let(classifierStorage::getIrClassSymbolForNotFoundClass) 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 fe925cced48..e8eb715bed4 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 @@ -164,7 +164,7 @@ class Fir2IrVisitor( } val irClass = classifierStorage.getCachedIrClass(regularClass)!! if (regularClass.isSealed) { - irClass.sealedSubclasses = regularClass.getIrSymbolsForSealedSubclasses(components) + irClass.sealedSubclasses = regularClass.getIrSymbolsForSealedSubclasses() } return conversionScope.withParent(irClass) { conversionScope.withContainingFirClass(regularClass) { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt index 75e31f1366d..311d98aae30 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt @@ -82,8 +82,10 @@ class CallAndReferenceGenerator( } val symbol = callableReferenceAccess.calleeReference.toSymbolForCall( - callableReferenceAccess.dispatchReceiver, session, classifierStorage, declarationStorage, conversionScope, - explicitReceiver = callableReferenceAccess.explicitReceiver, isDelegate = isDelegate + callableReferenceAccess.dispatchReceiver, + conversionScope, + explicitReceiver = callableReferenceAccess.explicitReceiver, + isDelegate = isDelegate ) // val x by y -> // val `x$delegate` = y @@ -283,9 +285,6 @@ class CallAndReferenceGenerator( val calleeReference = qualifiedAccess.calleeReference val symbol = calleeReference.toSymbolForCall( dispatchReceiver, - session, - classifierStorage, - declarationStorage, conversionScope ) return qualifiedAccess.convertWithOffsets { startOffset, endOffset -> @@ -363,7 +362,7 @@ class CallAndReferenceGenerator( val type = irBuiltIns.unitType val calleeReference = variableAssignment.calleeReference val symbol = calleeReference.toSymbolForCall( - variableAssignment.dispatchReceiver, session, classifierStorage, declarationStorage, conversionScope, preferGetter = false + variableAssignment.dispatchReceiver, conversionScope, preferGetter = false ) val origin = variableAssignment.getIrAssignmentOrigin() return variableAssignment.convertWithOffsets { startOffset, endOffset -> @@ -530,7 +529,7 @@ class CallAndReferenceGenerator( if (classSymbol != null) { IrGetObjectValueImpl( startOffset, endOffset, irType, - classSymbol.toSymbol(this.session, this.classifierStorage) as IrClassSymbol + classSymbol.toSymbol() as IrClassSymbol ) } else { IrErrorCallExpressionImpl( diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt index 3cb2dd7d3bb..4e3b41e3d0f 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt @@ -195,9 +195,7 @@ internal class ClassMemberGenerator( declarationStorage.leaveScope(irFunction) } if (irFunction is IrSimpleFunction && firFunction is FirSimpleFunction && containingClass != null) { - irFunction.overriddenSymbols = firFunction.generateOverriddenFunctionSymbols( - containingClass, session, scopeSession, declarationStorage, fakeOverrideGenerator - ) + irFunction.overriddenSymbols = firFunction.generateOverriddenFunctionSymbols(containingClass) } } return irFunction @@ -209,9 +207,7 @@ internal class ClassMemberGenerator( val propertyType = property.returnTypeRef.toIrType() irProperty.initializeBackingField(property, initializerExpression = initializer ?: delegate) if (containingClass != null) { - irProperty.overriddenSymbols = property.generateOverriddenPropertySymbols( - containingClass, session, scopeSession, declarationStorage, fakeOverrideGenerator - ) + irProperty.overriddenSymbols = property.generateOverriddenPropertySymbols(containingClass) } irProperty.getter?.setPropertyAccessorContent( property, property.getter, irProperty, propertyType, @@ -310,9 +306,7 @@ internal class ClassMemberGenerator( } } if (containingClass != null) { - this.overriddenSymbols = property.generateOverriddenAccessorSymbols( - containingClass, isGetter, session, scopeSession, declarationStorage, fakeOverrideGenerator - ) + this.overriddenSymbols = property.generateOverriddenAccessorSymbols(containingClass, isGetter) } } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DataClassMembersGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DataClassMembersGenerator.kt index 16e4f1b2371..2c368212650 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DataClassMembersGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DataClassMembersGenerator.kt @@ -57,7 +57,7 @@ import org.jetbrains.kotlin.util.OperatorNameConventions.TO_STRING * fir own logic that traverses class hierarchies in fir elements. Also, this one creates and passes IR elements, instead of providing how * to declare them, to [DataClassMembersGenerator]. */ -class DataClassMembersGenerator(val components: Fir2IrComponents) { +class DataClassMembersGenerator(val components: Fir2IrComponents) : Fir2IrComponents by components { fun generateSingleFieldValueClassMembers(klass: FirClass, irClass: IrClass): List = MyDataClassMethodsGenerator(irClass, klass.symbol.toLookupTag(), IrDeclarationOrigin.GENERATED_SINGLE_FIELD_VALUE_CLASS_MEMBER) @@ -155,7 +155,6 @@ class DataClassMembersGenerator(val components: Fir2IrComponents) { fun generateDispatchReceiverParameter(irFunction: IrFunction) = irFunction.declareThisReceiverParameter( - components.symbolTable, irClass.defaultType, origin, UNDEFINED_OFFSET, diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt index 38d5572b1ae..dcfac819a33 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt @@ -213,7 +213,7 @@ class DelegatedMemberGenerator( val baseSymbols = mutableListOf() // the overridden symbols should be collected only after all fake overrides for all superclases are created and bound to their // overridden symbols, otherwise in some cases they will be left in inconsistent state leading to the errors in IR - delegateOverride.processOverriddenFunctionSymbols(firSubClass, session, scopeSession) { + delegateOverride.processOverriddenFunctionSymbols(firSubClass) { baseSymbols.add(it) } baseFunctionSymbols[delegateFunction] = baseSymbols @@ -294,7 +294,7 @@ class DelegatedMemberGenerator( // the overridden symbols should be collected only after all fake overrides for all superclases are created and bound to their // overridden symbols, otherwise in some cases they will be left in inconsistent state leading to the errors in IR val baseSymbols = mutableListOf() - firDelegateProperty.processOverriddenPropertySymbols(firSubClass, session, scopeSession) { + firDelegateProperty.processOverriddenPropertySymbols(firSubClass) { baseSymbols.add(it) } basePropertySymbols[delegateProperty] = baseSymbols @@ -304,18 +304,14 @@ class DelegatedMemberGenerator( getter.overriddenSymbols = firDelegateProperty.generateOverriddenAccessorSymbols( firSubClass, - isGetter = true, - session, - scopeSession, - declarationStorage, - fakeOverrideGenerator + isGetter = true ) annotationGenerator.generate(getter, firDelegateProperty) if (delegateProperty.isVar) { val setter = delegateProperty.setter!! setter.overriddenSymbols = firDelegateProperty.generateOverriddenAccessorSymbols( - firSubClass, isGetter = false, session, scopeSession, declarationStorage, fakeOverrideGenerator + firSubClass, isGetter = false ) annotationGenerator.generate(setter, firDelegateProperty) } @@ -325,6 +321,8 @@ class DelegatedMemberGenerator( companion object { private val PLATFORM_DEPENDENT_CLASS_ID = ClassId.topLevel(FqName("kotlin.internal.PlatformDependent")) + + context(Fir2IrComponents) private fun , D : FirCallableDeclaration> S.unwrapDelegateTarget( subClassLookupTag: ConeClassLikeLookupTag, firField: FirField, diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyFunction.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyFunction.kt index d1ae4d34793..3d55ea8f879 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyFunction.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyFunction.kt @@ -96,7 +96,7 @@ abstract class AbstractFir2IrLazyFunction( protected fun createThisReceiverParameter(thisType: IrType): IrValueParameter { declarationStorage.enterScope(this) - return declareThisReceiverParameter(symbolTable, thisType, origin).apply { + return declareThisReceiverParameter(thisType, origin).apply { declarationStorage.leaveScope(this@AbstractFir2IrLazyFunction) } } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt index 99934f96e91..f00bb85d803 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt @@ -110,7 +110,7 @@ class Fir2IrLazyClass( override var sealedSubclasses: List by lazyVar(lock) { if (fir.isSealed) { - fir.getIrSymbolsForSealedSubclasses(components) + fir.getIrSymbolsForSealedSubclasses() } else { emptyList() } @@ -125,7 +125,6 @@ class Fir2IrLazyClass( ) } val receiver = declareThisReceiverParameter( - symbolTable, thisType = IrSimpleTypeImpl(symbol, hasQuestionMark = false, arguments = typeArguments, annotations = emptyList()), thisOrigin = IrDeclarationOrigin.INSTANCE_RECEIVER ) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyConstructor.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyConstructor.kt index 0d1e76c25a2..d2ca2c46924 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyConstructor.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyConstructor.kt @@ -86,7 +86,6 @@ class Fir2IrLazyConstructor( if (containingClass?.isInner == true && outerClass != null) { declarationStorage.enterScope(this) declareThisReceiverParameter( - symbolTable, thisType = outerClass.thisReceiver!!.type, thisOrigin = origin ).apply { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt index d7aa1cdf7ad..d1d10de4f0b 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt @@ -229,13 +229,7 @@ class Fir2IrLazyProperty( override var overriddenSymbols: List by lazyVar(lock) { if (containingClass == null) return@lazyVar emptyList() - fir.generateOverriddenPropertySymbols( - containingClass, - session, - scopeSession, - declarationStorage, - fakeOverrideGenerator - ) + fir.generateOverriddenPropertySymbols(containingClass) } override var metadata: MetadataSource? diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyPropertyAccessor.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyPropertyAccessor.kt index 1dbbc2c96fe..0b3930cc39f 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyPropertyAccessor.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyPropertyAccessor.kt @@ -106,14 +106,7 @@ class Fir2IrLazyPropertyAccessor( override var overriddenSymbols: List by lazyVar(lock) { if (firParentClass == null) return@lazyVar emptyList() - firParentProperty.generateOverriddenAccessorSymbols( - firParentClass, - !isSetter, - session, - scopeSession, - declarationStorage, - fakeOverrideGenerator - ) + firParentProperty.generateOverriddenAccessorSymbols(firParentClass, !isSetter) } override val initialSignatureFunction: IrFunction? by lazy { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazySimpleFunction.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazySimpleFunction.kt index d1ace6d8357..423d61c67b9 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazySimpleFunction.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazySimpleFunction.kt @@ -94,7 +94,7 @@ class Fir2IrLazySimpleFunction( ) fakeOverrideGenerator.getOverriddenSymbolsForFakeOverride(this)?.let { return@lazyVar it } } - fir.generateOverriddenFunctionSymbols(firParent, session, scopeSession, declarationStorage, fakeOverrideGenerator) + fir.generateOverriddenFunctionSymbols(firParent) } override val initialSignatureFunction: IrFunction? by lazy {