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 4159e52ff25..5483a60c5d4 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 @@ -246,7 +246,7 @@ class Fir2IrClassifierStorage( // If non-local classes are already created (this means we are in body translation) we do everything immediately // The last variant is possible for local variables like 'val a = object : Any() { ... }' if (processMembersOfClassesOnTheFlyImmediately) { - processMembersOfClassCreatedOnTheFly(classOrLocalParent, result) + converter.processClassMembers(classOrLocalParent, result) converter.bindFakeOverridesInClass(result) } else { localClassesCreatedOnTheFly[classOrLocalParent] = result @@ -262,7 +262,7 @@ class Fir2IrClassifierStorage( // Before the call it's not possible, because f/o binding for regular classes isn't done yet processMembersOfClassesOnTheFlyImmediately = true for ((klass, irClass) in localClassesCreatedOnTheFly) { - processMembersOfClassCreatedOnTheFly(klass, irClass) + converter.processClassMembers(klass, irClass) // See the problem from KT-57441 // class Wrapper { // private val dummy = object: Bar {} @@ -279,13 +279,6 @@ class Fir2IrClassifierStorage( localClassesCreatedOnTheFly.clear() } - private fun processMembersOfClassCreatedOnTheFly(klass: FirClass, irClass: IrClass) { - when (klass) { - is FirRegularClass -> converter.processRegularClassMembers(klass, irClass) - is FirAnonymousObject -> converter.processAnonymousObjectMembers(klass, irClass, processHeaders = false) - } - } - fun processClassHeader(klass: FirClass, irClass: IrClass = getCachedIrClass(klass)!!): IrClass { irClass.declareTypeParameters(klass) irClass.setThisReceiver(klass.typeParameters) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt index b050a9d0957..1f9eab39dac 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt @@ -113,10 +113,7 @@ class Fir2IrConverter( fun processLocalClassAndNestedClasses(klass: FirClass, parent: IrDeclarationParent): IrClass { val irClass = registerClassAndNestedClasses(klass, parent) processClassAndNestedClassHeaders(klass) - when (klass) { - is FirRegularClass -> processRegularClassMembers(klass, irClass) - is FirAnonymousObject -> processAnonymousObjectMembers(klass, irClass, processHeaders = false) - } + processClassMembers(klass, irClass) bindFakeOverridesInClass(irClass) return irClass } @@ -171,56 +168,33 @@ class Fir2IrConverter( } } - // TODO: unite with/extract common part from processRegularClassMembers - fun processAnonymousObjectMembers( + fun processAnonymousObjectHeaders( anonymousObject: FirAnonymousObject, irClass: IrClass, - processHeaders: Boolean - ): IrClass { - if (processHeaders) { - registerNestedClasses(anonymousObject, irClass) - processNestedClassHeaders(anonymousObject) - } - anonymousObject.primaryConstructorIfAny(session)?.let { - irClass.declarations += declarationStorage.createIrConstructor( - it.fir, irClass, isLocal = true - ) - } - for (declaration in syntheticPropertiesLast(anonymousObject.declarations)) { - val irDeclaration = processMemberDeclaration(declaration, anonymousObject, irClass) ?: continue - irClass.declarations += irDeclaration - } - // Add delegated members *before* fake override generations. - // Otherwise, fake overrides for delegated members, which are redundant, will be added. - val realDeclarations = delegatedMembers(irClass) + anonymousObject.declarations - with(fakeOverrideGenerator) { - irClass.addFakeOverrides(anonymousObject, realDeclarations) - } - - return irClass + ) { + registerNestedClasses(anonymousObject, irClass) + processNestedClassHeaders(anonymousObject) } - internal fun processRegularClassMembers( - regularClass: FirRegularClass, - irClass: IrClass = - classifierStorage.getCachedIrClass(regularClass) ?: error("Expecting existing IrClass for class ${regularClass.name}") - ): IrClass { + internal fun processClassMembers(klass: FirClass, irClass: IrClass): IrClass { val allDeclarations = mutableListOf().apply { - addAll(regularClass.declarations) - if (generatorExtensions.isNotEmpty()) { - addAll(regularClass.generatedMembers(session)) - addAll(regularClass.generatedNestedClassifiers(session)) + addAll(klass.declarations) + if (klass is FirRegularClass && generatorExtensions.isNotEmpty()) { + addAll(klass.generatedMembers(session)) + addAll(klass.generatedNestedClassifiers(session)) } } - val irConstructor = (allDeclarations.firstOrNull { it is FirConstructor && it.isPrimary })?.let { - declarationStorage.getOrCreateIrConstructor(it as FirConstructor, irClass, isLocal = regularClass.isLocal) + val irConstructor = klass.primaryConstructorIfAny(session)?.let { + declarationStorage.getOrCreateIrConstructor( + it.fir, irClass, isLocal = klass.isLocal + ) } if (irConstructor != null) { irClass.declarations += irConstructor } // At least on enum entry creation we may need a default constructor, so ctors should be converted first for (declaration in syntheticPropertiesLast(allDeclarations)) { - val irDeclaration = processMemberDeclaration(declaration, regularClass, irClass) ?: continue + val irDeclaration = processMemberDeclaration(declaration, klass, irClass) ?: continue irClass.declarations += irDeclaration } // Add delegated members *before* fake override generations. @@ -228,22 +202,22 @@ class Fir2IrConverter( allDeclarations += delegatedMembers(irClass) // Add synthetic members *before* fake override generations. // Otherwise, redundant members, e.g., synthetic toString _and_ fake override toString, will be added. - if (irConstructor != null && (irClass.isValue || irClass.isData)) { + if (klass is FirRegularClass && irConstructor != null && (irClass.isValue || irClass.isData)) { declarationStorage.enterScope(irConstructor) val dataClassMembersGenerator = DataClassMembersGenerator(components) if (irClass.isSingleFieldValueClass) { - allDeclarations += dataClassMembersGenerator.generateSingleFieldValueClassMembers(regularClass, irClass) + allDeclarations += dataClassMembersGenerator.generateSingleFieldValueClassMembers(klass, irClass) } if (irClass.isMultiFieldValueClass) { - allDeclarations += dataClassMembersGenerator.generateMultiFieldValueClassMembers(regularClass, irClass) + allDeclarations += dataClassMembersGenerator.generateMultiFieldValueClassMembers(klass, irClass) } if (irClass.isData) { - allDeclarations += dataClassMembersGenerator.generateDataClassMembers(regularClass, irClass) + allDeclarations += dataClassMembersGenerator.generateDataClassMembers(klass, irClass) } declarationStorage.leaveScope(irConstructor) } with(fakeOverrideGenerator) { - irClass.addFakeOverrides(regularClass, allDeclarations) + irClass.addFakeOverrides(klass, allDeclarations) } return irClass @@ -303,7 +277,7 @@ class Fir2IrConverter( registerClassAndNestedClasses(it, irClass) } } - if (generatorExtensions.isNotEmpty()) { + if (klass is FirRegularClass && generatorExtensions.isNotEmpty()) { klass.generatedNestedClassifiers(session).forEach { if (it is FirRegularClass) { registerClassAndNestedClasses(it, irClass) @@ -323,7 +297,7 @@ class Fir2IrConverter( processClassAndNestedClassHeaders(it) } } - if (generatorExtensions.isNotEmpty()) { + if (klass is FirRegularClass && generatorExtensions.isNotEmpty()) { klass.generatedNestedClassifiers(session).forEach { if (it is FirRegularClass) { processClassAndNestedClassHeaders(it) @@ -341,7 +315,7 @@ class Fir2IrConverter( (containingClass !is FirRegularClass || containingClass.isLocal) return when (declaration) { is FirRegularClass -> { - processRegularClassMembers(declaration) + processClassMembers(declaration, classifierStorage.getCachedIrClass(declaration)!!) } is FirScript -> { parent as IrFile 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 f0a53db2392..48ac733c23c 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 @@ -138,7 +138,8 @@ class Fir2IrVisitor( declarationStorage.enterScope(irEnumEntry) classifierStorage.putEnumEntryClassInScope(enumEntry, correspondingClass) val anonymousObject = (enumEntry.initializer as FirAnonymousObjectExpression).anonymousObject - converter.processAnonymousObjectMembers(anonymousObject, correspondingClass, processHeaders = true) + converter.processAnonymousObjectHeaders(anonymousObject, correspondingClass) + converter.processClassMembers(anonymousObject, correspondingClass) converter.bindFakeOverridesInClass(correspondingClass) conversionScope.withParent(correspondingClass) { memberGenerator.convertClassContent(correspondingClass, anonymousObject) 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 c1575976cee..6bd56d7468d 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 @@ -59,7 +59,7 @@ internal class ClassMemberGenerator( conversionScope.withClass(irClass) { val allDeclarations = buildList { addAll(klass.declarations) - if (session.extensionService.declarationGenerators.isNotEmpty()) { + if (klass is FirRegularClass && session.extensionService.declarationGenerators.isNotEmpty()) { addAll(klass.generatedMembers(session).sortedWith(FirCallableDeclarationComparator)) addAll(klass.generatedNestedClassifiers(session).sortedWith(FirMemberDeclarationComparator)) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/generatedDeclarationsUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/generatedDeclarationsUtils.kt index 99b5bdbeaa1..2abe90d719a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/generatedDeclarationsUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/generatedDeclarationsUtils.kt @@ -7,13 +7,13 @@ package org.jetbrains.kotlin.fir.extensions import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration -import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration +import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope import org.jetbrains.kotlin.fir.scopes.processClassifiersByName import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol -fun FirClass.generatedNestedClassifiers(session: FirSession): List { +fun FirRegularClass.generatedNestedClassifiers(session: FirSession): List { val scope = session.declaredMemberScope(this, memberRequiredPhase = null) val result = mutableListOf() for (name in scope.getClassifierNames()) { @@ -28,7 +28,7 @@ fun FirClass.generatedNestedClassifiers(session: FirSession): List { +fun FirRegularClass.generatedMembers(session: FirSession): List { val scope = session.declaredMemberScope(this, memberRequiredPhase = null) val result = mutableListOf() for (name in scope.getCallableNames()) {