diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirSessionCommonComponents.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirSessionCommonComponents.kt index 21eb7f67c84..a4d94cd9cf7 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirSessionCommonComponents.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirSessionCommonComponents.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir import org.jetbrains.kotlin.fir.extensions.FirExtensionService import org.jetbrains.kotlin.fir.extensions.FirPredicateBasedProvider import org.jetbrains.kotlin.fir.extensions.FirRegisteredPluginAnnotations -import org.jetbrains.kotlin.fir.resolve.transformers.plugin.GeneratedNestedClassIndex +import org.jetbrains.kotlin.fir.resolve.transformers.plugin.GeneratedClassIndex import org.jetbrains.kotlin.fir.scopes.impl.FirDeclaredMemberScopeProvider import org.jetbrains.kotlin.fir.types.FirCorrespondingSupertypesCache @@ -19,5 +19,5 @@ fun FirSession.registerCommonComponents() { register(FirExtensionService::class, FirExtensionService(this)) register(FirRegisteredPluginAnnotations::class, FirRegisteredPluginAnnotations.create(this)) register(FirPredicateBasedProvider::class, FirPredicateBasedProvider.create(this)) - register(GeneratedNestedClassIndex::class, GeneratedNestedClassIndex.create()) + register(GeneratedClassIndex::class, GeneratedClassIndex.create()) } \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirExistingClassModificationExtension.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirDeclarationGenerationExtension.kt similarity index 67% rename from compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirExistingClassModificationExtension.kt rename to compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirDeclarationGenerationExtension.kt index 0d76ade5462..b7e93f3d89c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirExistingClassModificationExtension.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirDeclarationGenerationExtension.kt @@ -9,14 +9,14 @@ import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirRegularClass -import org.jetbrains.kotlin.fir.resolve.transformers.plugin.GeneratedNestedClass +import org.jetbrains.kotlin.fir.resolve.transformers.plugin.GeneratedClass import kotlin.reflect.KClass /* * TODO: * - check that annotations or meta-annotations is not empty */ -abstract class FirExistingClassModificationExtension(session: FirSession) : FirPredicateBasedExtension(session) { +abstract class FirDeclarationGenerationExtension(session: FirSession) : FirPredicateBasedExtension(session) { companion object { val NAME = FirExtensionPointName("ExistingClassModification") } @@ -24,23 +24,23 @@ abstract class FirExistingClassModificationExtension(session: FirSession) : FirP final override val name: FirExtensionPointName get() = NAME - final override val extensionType: KClass = FirExistingClassModificationExtension::class + final override val extensionType: KClass = FirDeclarationGenerationExtension::class - abstract fun generateNestedClasses( + abstract fun generateClasses( annotatedDeclaration: FirDeclaration, owners: List ): List> - abstract fun generateMembersForNestedClasses(generatedNestedClass: GeneratedNestedClass): List + abstract fun generateMembersForGeneratedClass(generatedClass: GeneratedClass): List abstract fun generateMembers( annotatedDeclaration: FirDeclaration, owners: List ): List> - data class GeneratedDeclaration(val newDeclaration: T, val owner: FirRegularClass) + data class GeneratedDeclaration(val newDeclaration: T, val owner: FirAnnotatedDeclaration) - fun interface Factory : FirExtension.Factory + fun interface Factory : FirExtension.Factory } -val FirExtensionService.existingClassModifiers: List by FirExtensionService.registeredExtensions() +val FirExtensionService.declarationGenerators: List by FirExtensionService.registeredExtensions() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirExtensionRegistrar.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirExtensionRegistrar.kt index ae30a832ddb..b3c93591513 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirExtensionRegistrar.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirExtensionRegistrar.kt @@ -16,7 +16,7 @@ abstract class FirExtensionRegistrar { ) { val AVAILABLE_EXTENSIONS = listOf( FirStatusTransformerExtension::class, - FirExistingClassModificationExtension::class, + FirDeclarationGenerationExtension::class, AbstractFirAdditionalCheckersExtension::class ) } @@ -30,8 +30,8 @@ abstract class FirExtensionRegistrar { } @JvmName("plusClassGenerationExtension") - operator fun ((FirSession) -> FirExistingClassModificationExtension).unaryPlus() { - registerExtension(FirExistingClassModificationExtension::class, FirExistingClassModificationExtension.Factory { this.invoke(it) }) + operator fun ((FirSession) -> FirDeclarationGenerationExtension).unaryPlus() { + registerExtension(FirDeclarationGenerationExtension::class, FirDeclarationGenerationExtension.Factory { this.invoke(it) }) } @JvmName("plusAdditionalCheckersExtension") diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProvider.kt index b2f6610c9fc..41d450c5efe 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProvider.kt @@ -25,11 +25,23 @@ abstract class FirPredicateBasedProvider : FirSessionComponent { } abstract fun getSymbolsByPredicate(predicate: DeclarationPredicate): List + + abstract fun getSymbolsByPredicate( + declarations: Collection, + predicate: DeclarationPredicate + ): List + abstract fun getSymbolsWithOwnersByPredicate( predicate: DeclarationPredicate ): List>> + abstract fun getSymbolsWithOwnersByPredicate( + declarations: Collection, + predicate: DeclarationPredicate + ): List>> + abstract fun registerAnnotatedDeclaration(declaration: FirAnnotatedDeclaration, owners: PersistentList) + abstract fun registerGeneratedDeclaration(declaration: FirAnnotatedDeclaration, owner: FirAnnotatedDeclaration) abstract fun matches(predicate: DeclarationPredicate, declaration: FirAnnotatedDeclaration): Boolean } @@ -41,13 +53,30 @@ private class FirPredicateBasedProviderImpl(private val session: FirSession) : F override fun getSymbolsByPredicate(predicate: DeclarationPredicate): List { val annotations = registeredPluginAnnotations.getAnnotationsForPredicate(predicate) if (annotations.isEmpty()) return emptyList() - return annotations.flatMapTo(mutableSetOf()) { cache.declarationByAnnotation[it] + cache.declarationsUnderAnnotated[it] }.filter { - matches(predicate, it) - } + val declarations = annotations.flatMapTo(mutableSetOf()) { cache.declarationByAnnotation[it] + cache.declarationsUnderAnnotated[it] } + return getSymbolsByPredicate(declarations, predicate) + } + + override fun getSymbolsByPredicate( + declarations: Collection, + predicate: DeclarationPredicate + ): List { + return declarations.filter { matches(predicate, it) } } override fun getSymbolsWithOwnersByPredicate(predicate: DeclarationPredicate): List>> { - return getSymbolsByPredicate(predicate).map { it to cache.ownersForDeclaration.getValue(it) } + return getSymbolsByPredicate(predicate).zipWithParents() + } + + override fun getSymbolsWithOwnersByPredicate( + declarations: Collection, + predicate: DeclarationPredicate + ): List>> { + return getSymbolsByPredicate(declarations, predicate).zipWithParents() + } + + private fun List.zipWithParents(): List>> { + return this.map { it to cache.ownersForDeclaration.getValue(it) } } override fun registerAnnotatedDeclaration(declaration: FirAnnotatedDeclaration, owners: PersistentList) { @@ -62,6 +91,11 @@ private class FirPredicateBasedProviderImpl(private val session: FirSession) : F cache.annotationsOfDeclaration.putAll(declaration, matchingAnnotations) } + override fun registerGeneratedDeclaration(declaration: FirAnnotatedDeclaration, owner: FirAnnotatedDeclaration) { + val owners = cache.ownersForDeclaration.getValue(owner).add(owner) + registerAnnotatedDeclaration(declaration, owners) + } + private fun registerOwnersDeclarations(declaration: FirAnnotatedDeclaration, owners: PersistentList) { val lastOwner = owners.lastOrNull() ?: return val annotationsFromLastOwner = cache.annotationsOfDeclaration[lastOwner] diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/FirProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/FirProvider.kt index bf85e082d83..e1923286ed1 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/FirProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/FirProvider.kt @@ -5,9 +5,7 @@ package org.jetbrains.kotlin.fir.resolve.providers -import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration -import org.jetbrains.kotlin.fir.declarations.FirFile -import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.name.ClassId @@ -47,5 +45,8 @@ abstract class FirProvider : FirSymbolProvider() { abstract fun getFirFilesByPackage(fqName: FqName): List @FirProviderInternals - abstract fun recordNestedClass(owner: FirRegularClass, klass: FirRegularClass) + abstract fun recordGeneratedClass(owner: FirAnnotatedDeclaration, klass: FirRegularClass) + + @FirProviderInternals + abstract fun recordGeneratedMember(owner: FirAnnotatedDeclaration, klass: FirDeclaration) } \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirProviderImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirProviderImpl.kt index 3704a351d2e..4293ab9178e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirProviderImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirProviderImpl.kt @@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.scopes.impl.nestedClassifierScope import org.jetbrains.kotlin.fir.symbols.CallableId import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor -import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitorVoid import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -68,11 +67,22 @@ class FirProviderImpl(val session: FirSession, val kotlinScopeProvider: KotlinSc } @FirProviderInternals - override fun recordNestedClass(owner: FirRegularClass, klass: FirRegularClass) { - val file = getFirClassifierContainerFile(owner.symbol.classId) - klass.accept(FirRecorder, state to file) + override fun recordGeneratedClass(owner: FirAnnotatedDeclaration, klass: FirRegularClass) { + klass.accept(FirRecorder, state to owner.file) } + @FirProviderInternals + override fun recordGeneratedMember(owner: FirAnnotatedDeclaration, klass: FirDeclaration) { + klass.accept(FirRecorder, state to owner.file) + } + + private val FirAnnotatedDeclaration.file: FirFile + get() = when (this) { + is FirFile -> this + is FirRegularClass -> getFirClassifierContainerFile(this.symbol.classId) + else -> error("Should not be here") + } + private fun recordFile(file: FirFile, state: State) { val packageName = file.packageFqName state.fileMap.merge(packageName, listOf(file)) { a, b -> a + b } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt index 5002065aaf3..d59daf7a8a6 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt @@ -25,7 +25,7 @@ fun FirResolvePhase.createCompilerProcessorByPhase( return when (this) { RAW_FIR -> throw IllegalStateException("Raw FIR building phase does not have a transformer") ANNOTATIONS_FOR_PLUGINS -> FirPluginAnnotationsResolveProcessor(session, scopeSession) - NESTED_CLASS_GENERATION -> FirGlobalNestedClassGenerationProcessor(session, scopeSession) + CLASS_GENERATION -> FirGlobalClassGenerationProcessor(session, scopeSession) IMPORTS -> FirImportResolveProcessor(session, scopeSession) SUPER_TYPES -> FirSupertypeResolverProcessor(session, scopeSession) SEALED_CLASS_INHERITORS -> FirSealedClassInheritorsProcessor(session, scopeSession) @@ -46,7 +46,7 @@ fun FirResolvePhase.createTransformerBasedProcessorByPhase( return when (this) { RAW_FIR -> throw IllegalStateException("Raw FIR building phase does not have a transformer") ANNOTATIONS_FOR_PLUGINS -> FirPluginAnnotationsResolveProcessor(session, scopeSession) - NESTED_CLASS_GENERATION -> FirDummyTransformerBasedProcessor(session, scopeSession) // TODO: remove + CLASS_GENERATION -> FirDummyTransformerBasedProcessor(session, scopeSession) // TODO: remove IMPORTS -> FirImportResolveProcessor(session, scopeSession) SUPER_TYPES -> FirSupertypeResolverProcessor(session, scopeSession) SEALED_CLASS_INHERITORS -> FirSealedClassInheritorsProcessor(session, scopeSession) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalClassGenerationProcessor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalClassGenerationProcessor.kt new file mode 100644 index 00000000000..d9437f007b1 --- /dev/null +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalClassGenerationProcessor.kt @@ -0,0 +1,67 @@ +/* + * Copyright 2010-2020 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.resolve.transformers.plugin + +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.addDeclaration +import org.jetbrains.kotlin.fir.extensions.* +import org.jetbrains.kotlin.fir.resolve.ScopeSession +import org.jetbrains.kotlin.fir.resolve.firProvider +import org.jetbrains.kotlin.fir.resolve.providers.FirProviderInternals +import org.jetbrains.kotlin.fir.resolve.transformers.FirGlobalResolveProcessor + +class FirGlobalClassGenerationProcessor( + session: FirSession, + scopeSession: ScopeSession +) : FirGlobalResolveProcessor(session, scopeSession) { + override fun process() { + val extensions = session.extensionService.declarationGenerators + if (extensions.isEmpty()) return + val provider = session.predicateBasedProvider + for (extension in extensions) { + var annotatedDeclarations = provider.getSymbolsWithOwnersByPredicate(extension.predicate) + while (annotatedDeclarations.isNotEmpty()) { + val newClasses = generateClasses(annotatedDeclarations, extension) + annotatedDeclarations = provider.getSymbolsWithOwnersByPredicate(newClasses, extension.predicate) + } + } + } + + private fun generateClasses( + declarations: List>>, + extension: FirDeclarationGenerationExtension, + ): List { + val newClasses = mutableListOf() + for ((declaration, owners) in declarations) { + generateClass(extension, declaration, owners, newClasses) + } + return newClasses + } + + @OptIn(FirProviderInternals::class) + private fun generateClass( + extension: FirDeclarationGenerationExtension, + declaration: FirAnnotatedDeclaration, + owners: List, + newClasses: MutableList + ) { + val generatedClasses = extension.generateClasses(declaration, owners) + for ((klass, owner) in generatedClasses) { + when (owner) { + is FirRegularClass -> owner.addDeclaration(klass) + is FirFile -> owner.addDeclaration(klass) + } + session.generatedClassIndex.registerClass(klass, owner) + session.predicateBasedProvider.registerGeneratedDeclaration(klass, owner) + session.firProvider.recordGeneratedClass(owner, klass) + newClasses += klass + } + } +} + diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalNestedClassGenerationProcessor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalNestedClassGenerationProcessor.kt deleted file mode 100644 index 6b07890f97c..00000000000 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalNestedClassGenerationProcessor.kt +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright 2010-2020 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.resolve.transformers.plugin - -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.addDeclaration -import org.jetbrains.kotlin.fir.extensions.existingClassModifiers -import org.jetbrains.kotlin.fir.extensions.extensionService -import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider -import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.resolve.firProvider -import org.jetbrains.kotlin.fir.resolve.providers.FirProviderInternals -import org.jetbrains.kotlin.fir.resolve.transformers.FirGlobalResolveProcessor - -class FirGlobalNestedClassGenerationProcessor( - session: FirSession, - scopeSession: ScopeSession -) : FirGlobalResolveProcessor(session, scopeSession) { - @OptIn(FirProviderInternals::class) - override fun process() { - val extensions = session.extensionService.existingClassModifiers - if (extensions.isEmpty()) return - val provider = session.predicateBasedProvider - val index = session.generatedNestedClassIndex - for (extension in extensions) { - val declarations = provider.getSymbolsWithOwnersByPredicate(extension.predicate) - for ((declaration, owners) in declarations) { - val nestedClasses = extension.generateNestedClasses(declaration, owners) - for ((nestedClass, owner) in nestedClasses) { - owner.addDeclaration(nestedClass) - index.registerNestedClass(nestedClass, owner) - session.firProvider.recordNestedClass(owner, nestedClass) - } - } - } - } -} - diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalNewMemberGenerationProcessor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalNewMemberGenerationProcessor.kt index 51c3bedbb51..964d51b927e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalNewMemberGenerationProcessor.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalNewMemberGenerationProcessor.kt @@ -6,49 +6,61 @@ package org.jetbrains.kotlin.fir.resolve.transformers.plugin import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.addDeclaration import org.jetbrains.kotlin.fir.declarations.validate -import org.jetbrains.kotlin.fir.extensions.FirExistingClassModificationExtension -import org.jetbrains.kotlin.fir.extensions.existingClassModifiers +import org.jetbrains.kotlin.fir.extensions.FirDeclarationGenerationExtension +import org.jetbrains.kotlin.fir.extensions.declarationGenerators import org.jetbrains.kotlin.fir.extensions.extensionService import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider import org.jetbrains.kotlin.fir.resolve.ScopeSession +import org.jetbrains.kotlin.fir.resolve.firProvider +import org.jetbrains.kotlin.fir.resolve.providers.FirProviderInternals import org.jetbrains.kotlin.fir.resolve.transformers.FirGlobalResolveProcessor class FirGlobalNewMemberGenerationProcessor( session: FirSession, scopeSession: ScopeSession ) : FirGlobalResolveProcessor(session, scopeSession) { - private val index = session.generatedNestedClassIndex + private val index = session.generatedClassIndex private val provider = session.predicateBasedProvider override fun process() { - val extensions = session.extensionService.existingClassModifiers + val extensions = session.extensionService.declarationGenerators if (extensions.isEmpty()) return for (extension in extensions) { generateNewMembers(extension) - fillGeneratedNestedClasses(extension) + fillGeneratedClasses(extension) } } - private fun generateNewMembers(extension: FirExistingClassModificationExtension) { + @OptIn(FirProviderInternals::class) + private fun generateNewMembers(extension: FirDeclarationGenerationExtension) { val declarations = provider.getSymbolsWithOwnersByPredicate(extension.predicate) for ((declaration, owners) in declarations) { val newMembers = extension.generateMembers(declaration, owners) for ((newMember, owner) in newMembers) { newMember.validate() - owner.addDeclaration(newMember) + when (owner) { + is FirRegularClass -> owner.addDeclaration(newMember) + is FirFile -> owner.addDeclaration(newMember) + else -> error("Should not be here") + } + session.firProvider.recordGeneratedMember(owner, newMember) } } } - private fun fillGeneratedNestedClasses(extension: FirExistingClassModificationExtension) { - for (generatedNestedClass in index[extension.key]) { - val nestedClass = generatedNestedClass.nestedClass - val newMembers = extension.generateMembersForNestedClasses(generatedNestedClass) + @OptIn(FirProviderInternals::class) + private fun fillGeneratedClasses(extension: FirDeclarationGenerationExtension) { + for (generatedClass in index[extension.key]) { + val klass = generatedClass.klass + val newMembers = extension.generateMembersForGeneratedClass(generatedClass) for (newMember in newMembers) { newMember.validate() - nestedClass.addDeclaration(newMember) + klass.addDeclaration(newMember) + session.firProvider.recordGeneratedMember(klass, newMember) } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/GeneratedNestedClassIndex.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/GeneratedClassIndex.kt similarity index 52% rename from compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/GeneratedNestedClassIndex.kt rename to compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/GeneratedClassIndex.kt index 17eac2e879a..327a20ab5e8 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/GeneratedNestedClassIndex.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/GeneratedClassIndex.kt @@ -8,34 +8,35 @@ package org.jetbrains.kotlin.fir.resolve.transformers.plugin import com.google.common.collect.ArrayListMultimap import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSessionComponent +import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin import org.jetbrains.kotlin.fir.declarations.FirPluginKey import org.jetbrains.kotlin.fir.declarations.FirRegularClass -data class GeneratedNestedClass(val nestedClass: FirRegularClass, val owner: FirRegularClass) +data class GeneratedClass(val klass: FirRegularClass, val owner: FirAnnotatedDeclaration) -abstract class GeneratedNestedClassIndex : FirSessionComponent { +abstract class GeneratedClassIndex : FirSessionComponent { companion object { - fun create(): GeneratedNestedClassIndex { - return GeneratedNestedClassIndexImpl() + fun create(): GeneratedClassIndex { + return GeneratedClassIndexImpl() } } - abstract fun registerNestedClass(klass: FirRegularClass, owner: FirRegularClass) - abstract operator fun get(key: FirPluginKey): List + abstract fun registerClass(klass: FirRegularClass, owner: FirAnnotatedDeclaration) + abstract operator fun get(key: FirPluginKey): List } -val FirSession.generatedNestedClassIndex: GeneratedNestedClassIndex by FirSession.sessionComponentAccessor() +val FirSession.generatedClassIndex: GeneratedClassIndex by FirSession.sessionComponentAccessor() -private class GeneratedNestedClassIndexImpl : GeneratedNestedClassIndex() { - private val index: ArrayListMultimap = ArrayListMultimap.create() +private class GeneratedClassIndexImpl : GeneratedClassIndex() { + private val index: ArrayListMultimap = ArrayListMultimap.create() - override fun registerNestedClass(klass: FirRegularClass, owner: FirRegularClass) { + override fun registerClass(klass: FirRegularClass, owner: FirAnnotatedDeclaration) { val key = (klass.origin as FirDeclarationOrigin.Plugin).key - index.put(key, GeneratedNestedClass(klass, owner)) + index.put(key, GeneratedClass(klass, owner)) } - override fun get(key: FirPluginKey): List { + override fun get(key: FirPluginKey): List { return index.get(key) } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt index 92afb669193..fd069f76d42 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.declarations enum class FirResolvePhase { RAW_FIR, ANNOTATIONS_FOR_PLUGINS, // run only if some extensions are registered - NESTED_CLASS_GENERATION, // plugin phase + CLASS_GENERATION, // plugin phase IMPORTS, SUPER_TYPES, SEALED_CLASS_INHERITORS, diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirIdeProvider.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirIdeProvider.kt index 94bb99e96b9..6e1d562124c 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirIdeProvider.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirIdeProvider.kt @@ -10,9 +10,7 @@ import com.intellij.openapi.project.Project import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.builder.RawFirBuilder -import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration -import org.jetbrains.kotlin.fir.declarations.FirFile -import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.psi import org.jetbrains.kotlin.fir.resolve.providers.FirProvider import org.jetbrains.kotlin.fir.resolve.providers.FirProviderInternals @@ -153,9 +151,15 @@ class FirIdeProvider( } @FirProviderInternals - override fun recordNestedClass(owner: FirRegularClass, klass: FirRegularClass) { + override fun recordGeneratedClass(owner: FirAnnotatedDeclaration, klass: FirRegularClass) { // TODO: check that this implementation is correct - cacheProvider.recordNestedClass(owner, klass) + cacheProvider.recordGeneratedClass(owner, klass) + } + + @FirProviderInternals + override fun recordGeneratedMember(owner: FirAnnotatedDeclaration, klass: FirDeclaration) { + // TODO: check that this implementation is correct + cacheProvider.recordGeneratedMember(owner, klass) } }