From e1c889e8717f47c5edbbf478098b99edf8bed258 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Thu, 24 Oct 2019 12:58:05 +0300 Subject: [PATCH] Make FirClass a kind of FirClassLikeDeclaration, introduce FirRegularClass/AnonymousObject symbols --- .../kotlin/fir/backend/ConversionUtils.kt | 2 +- .../kotlin/fir/backend/Fir2IrCallableCache.kt | 6 +-- .../fir/backend/Fir2IrDeclarationStorage.kt | 45 ++++++++++--------- .../kotlin/fir/backend/Fir2IrLocalStorage.kt | 4 +- .../kotlin/fir/backend/Fir2IrVisitor.kt | 17 +++---- .../kotlin/fir/java/FirJavaElementFinder.kt | 2 +- .../fir/java/FirJavaElementFinder.kt.183 | 2 +- .../kotlin/fir/java/JavaSymbolProvider.kt | 32 ++++++------- .../jetbrains/kotlin/fir/java/JavaUtils.kt | 4 +- .../fir/java/declarations/FirJavaClass.kt | 8 ++-- .../KotlinDeserializedJvmSymbolsProvider.kt | 12 ++--- .../FirAnnotationTypeQualifierResolver.kt | 4 +- .../converter/DeclarationsConverter.kt | 8 ++-- .../kotlin/fir/builder/RawFirBuilder.kt | 10 ++--- .../AbstractAnnotationDeserializer.kt | 3 +- .../deserialization/ClassDeserialization.kt | 7 +-- .../deserialization/FirTypeDeserializer.kt | 4 +- .../fir/resolve/AbstractFirSymbolProvider.kt | 13 +++--- .../kotlin/fir/resolve/ResolveUtils.kt | 5 ++- .../kotlin/fir/resolve/SamResolution.kt | 7 +-- .../kotlin/fir/resolve/SupertypeUtils.kt | 33 +++++++++----- .../kotlin/fir/resolve/calls/FirReceivers.kt | 12 ++--- .../fir/resolve/calls/FirTowerResolver.kt | 5 ++- .../kotlin/fir/resolve/calls/TowerLevels.kt | 9 ++-- .../impl/FirDependenciesSymbolProviderImpl.kt | 2 +- .../impl/FirLibrarySymbolProviderImpl.kt | 14 +++--- .../fir/resolve/impl/FirProviderImpl.kt | 8 ++-- ...irAbstractTreeTransformerWithSuperTypes.kt | 5 +-- .../FirSealedClassInheritorsTransformer.kt | 3 +- .../FirWhenExhaustivenessTransformer.kt | 4 +- .../FirExpressionsResolveTransformer.kt | 3 +- .../impl/FirClassDeclaredMemberScope.kt | 10 +++-- .../kotlin/fir/scopes/impl/FirLocalScope.kt | 2 +- .../fir/scopes/impl/FirMemberScopeProvider.kt | 13 +++--- .../scopes/impl/FirNestedClassifierScope.kt | 9 ++-- .../kotlin/fir/types/ConeTypeContext.kt | 14 +++--- .../types/FirCorrespondingSupertypesCache.kt | 10 +++-- .../org/jetbrains/kotlin/fir/FirRenderer.kt | 2 +- .../fir/declarations/FirAnonymousObject.kt | 5 ++- .../kotlin/fir/declarations/FirClass.kt | 5 ++- .../declarations/FirClassLikeDeclaration.kt | 8 +--- .../fir/declarations/FirDeclarationUtil.kt | 11 ++++- .../kotlin/fir/declarations/FirEnumEntry.kt | 4 +- .../fir/declarations/FirRegularClass.kt | 6 +-- .../kotlin/fir/declarations/FirSealedClass.kt | 4 +- .../kotlin/fir/declarations/FirTypeAlias.kt | 4 +- .../impl/FirAnonymousObjectImpl.kt | 16 ++++++- .../fir/declarations/impl/FirClassImpl.kt | 4 +- .../fir/declarations/impl/FirEnumEntryImpl.kt | 6 +-- .../declarations/impl/FirModifiableClass.kt | 10 ++++- .../impl/FirModifiableRegularClass.kt | 6 +-- .../declarations/impl/FirSealedClassImpl.kt | 4 +- .../fir/declarations/impl/FirTypeAliasImpl.kt | 2 +- .../impl/ConeClassLookupTagWithFixedSymbol.kt | 15 +++++++ .../fir/symbols/impl/FirClassLikeSymbol.kt | 17 ++++--- .../fir/visitors/FirDefaultTransformer.kt | 1 + .../kotlin/fir/visitors/FirTransformer.kt | 18 ++++---- .../kotlin/fir/visitors/FirVisitor.kt | 6 +-- .../kotlin/fir/visitors/FirVisitorVoid.kt | 18 ++++---- .../fir/tree/generator/FirTreeBuilder.kt | 8 ++-- .../generator/ImplementationConfigurator.kt | 7 +-- .../fir/tree/generator/NodeConfigurator.kt | 26 +++++++---- .../compiler/visualizer/FirVisualizer.kt | 2 +- 63 files changed, 326 insertions(+), 240 deletions(-) create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/ConeClassLookupTagWithFixedSymbol.kt 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 0e49a107ef3..ef3057ec36e 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 @@ -133,7 +133,7 @@ private fun AbstractFirBasedSymbol<*>.toSymbol(declarationStorage: Fir2IrDeclara else -> null } -fun FirClassSymbol.toClassSymbol(declarationStorage: Fir2IrDeclarationStorage): IrClassSymbol { +fun FirClassSymbol<*>.toClassSymbol(declarationStorage: Fir2IrDeclarationStorage): IrClassSymbol { return declarationStorage.getIrClassSymbol(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 d1d17dd62cb..5b096878305 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 @@ -17,7 +17,7 @@ class Fir2IrCallableCache { private val variableCache = mutableMapOf, IrVariable>() - private val localClassCache = mutableMapOf() + private val localClassCache = mutableMapOf, IrClass>() private val localFunctionCache = mutableMapOf, IrSimpleFunction>() @@ -33,9 +33,9 @@ class Fir2IrCallableCache { variableCache[firVariable] = irVariable } - fun getLocalClass(localClass: FirClass): IrClass? = localClassCache[localClass] + fun getLocalClass(localClass: FirClass<*>): IrClass? = localClassCache[localClass] - fun putLocalClass(localClass: FirClass, irClass: IrClass) { + fun putLocalClass(localClass: FirClass<*>, irClass: IrClass) { require(localClass !is FirRegularClass || localClass.visibility == Visibilities.LOCAL) localClassCache[localClass] = irClass } 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 078c786758b..97ba1db06b9 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 @@ -114,7 +114,7 @@ class Fir2IrDeclarationStorage( leaveScope(descriptor) } - private fun IrClass.declareSupertypesAndTypeParameters(klass: FirClass): IrClass { + private fun IrClass.declareSupertypesAndTypeParameters(klass: FirClass<*>): IrClass { for (superTypeRef in klass.superTypeRefs) { superTypes += superTypeRef.toIrType(session, this@Fir2IrDeclarationStorage) } @@ -128,31 +128,33 @@ class Fir2IrDeclarationStorage( return this } - fun getIrClass(regularClass: FirRegularClass, setParent: Boolean = true): IrClass { + fun getIrClass(klass: FirClass<*>, setParent: Boolean = true): IrClass { + val regularClass = klass as? FirRegularClass + fun create(): IrClass { val descriptor = WrappedClassDescriptor() val origin = IrDeclarationOrigin.DEFINED - val modality = regularClass.modality!! - return regularClass.convertWithOffsets { startOffset, endOffset -> + val modality = regularClass?.modality ?: Modality.FINAL + return klass.convertWithOffsets { startOffset, endOffset -> irSymbolTable.declareClass(startOffset, endOffset, origin, descriptor, modality) { symbol -> IrClassImpl( startOffset, endOffset, origin, symbol, - regularClass.name, - regularClass.classKind, - regularClass.visibility, + regularClass?.name ?: Name.special(""), + klass.classKind, + regularClass?.visibility ?: Visibilities.LOCAL, modality, - isCompanion = regularClass.isCompanion, - isInner = regularClass.isInner, - isData = regularClass.isData, - isExternal = regularClass.isExternal, - isInline = regularClass.isInline, - isExpect = regularClass.isExpect + isCompanion = regularClass?.isCompanion == true, + isInner = regularClass?.isInner == true, + isData = regularClass?.isData == true, + isExternal = regularClass?.isExternal == true, + isInline = regularClass?.isInline == true, + isExpect = regularClass?.isExpect == true ).apply { descriptor.bind(this) - if (setParent) { + if (setParent && regularClass != null) { val classId = regularClass.classId val parentId = classId.outerClassId if (parentId != null) { @@ -172,16 +174,17 @@ class Fir2IrDeclarationStorage( } } - if (regularClass.visibility == Visibilities.LOCAL) { - val cached = localStorage.getLocalClass(regularClass) + if (regularClass?.visibility == Visibilities.LOCAL || klass is FirAnonymousObject) { + val cached = localStorage.getLocalClass(klass) if (cached != null) return cached val created = create() - localStorage.putLocalClass(regularClass, created) - created.declareSupertypesAndTypeParameters(regularClass) + localStorage.putLocalClass(klass, created) + created.declareSupertypesAndTypeParameters(klass) return created } - return classCache.getOrPut(regularClass, { create() }) { - it.declareSupertypesAndTypeParameters(regularClass) + // NB: klass can be either FirRegularClass or FirAnonymousObject + return classCache.getOrPut(klass as FirRegularClass, { create() }) { + it.declareSupertypesAndTypeParameters(klass) } } @@ -617,7 +620,7 @@ class Fir2IrDeclarationStorage( } } - fun getIrClassSymbol(firClassSymbol: FirClassSymbol): IrClassSymbol { + fun getIrClassSymbol(firClassSymbol: FirClassSymbol<*>): IrClassSymbol { val irClass = getIrClass(firClassSymbol.fir) return irSymbolTable.referenceClass(irClass.descriptor) } 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 7917047203e..843a60a8634 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 @@ -43,7 +43,7 @@ class Fir2IrLocalStorage { return null } - fun getLocalClass(localClass: FirClass): IrClass? { + fun getLocalClass(localClass: FirClass<*>): IrClass? { for (cache in cacheStack.asReversed()) { val local = cache.getLocalClass(localClass) if (local != null) return local @@ -67,7 +67,7 @@ class Fir2IrLocalStorage { cacheStack.last().putVariable(firVariable, irVariable) } - fun putLocalClass(firClass: FirClass, irClass: IrClass) { + fun putLocalClass(firClass: FirClass<*>, irClass: IrClass) { cacheStack.last().putLocalClass(firClass, irClass) } 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 ed5e01a39e7..3af504c1cdf 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 @@ -167,7 +167,7 @@ class Fir2IrVisitor( if (superType is ConeClassLikeType) { when (val superSymbol = superType.lookupTag.toSymbol(this@Fir2IrVisitor.session)) { is FirClassSymbol -> { - val superClass = superSymbol.fir + val superClass = superSymbol.fir as FirClass<*> for (declaration in superClass.declarations) { if (declaration is FirMemberDeclaration && (declaration is FirSimpleFunction || declaration is FirProperty)) { result += declaration.name @@ -185,17 +185,17 @@ class Fir2IrVisitor( return result } - private fun FirClass.collectCallableNamesFromSupertypes(result: MutableList = mutableListOf()): List { + private fun FirClass<*>.collectCallableNamesFromSupertypes(result: MutableList = mutableListOf()): List { for (superTypeRef in superTypeRefs) { superTypeRef.collectCallableNamesFromThisAndSupertypes(result) } return result } - private fun FirClass.getPrimaryConstructorIfAny(): FirConstructor? = + private fun FirClass<*>.getPrimaryConstructorIfAny(): FirConstructor? = declarations.filterIsInstance().firstOrNull()?.takeIf { it.isPrimary } - private fun IrClass.addFakeOverrides(klass: FirClass, processedCallableNames: MutableList) { + private fun IrClass.addFakeOverrides(klass: FirClass<*>, processedCallableNames: MutableList) { if (fakeOverrideMode == FakeOverrideMode.NONE) return val superTypesCallableNames = klass.collectCallableNamesFromSupertypes() val useSiteMemberScope = (klass as? FirRegularClass)?.buildUseSiteMemberScope(session, ScopeSession()) ?: return @@ -262,7 +262,7 @@ class Fir2IrVisitor( } } - private fun IrClass.setClassContent(klass: FirClass) { + private fun IrClass.setClassContent(klass: FirClass<*>) { declarationStorage.enterScope(descriptor) val primaryConstructor = klass.getPrimaryConstructorIfAny() val irPrimaryConstructor = primaryConstructor?.accept(this@Fir2IrVisitor, null) as IrConstructor? @@ -341,7 +341,7 @@ class Fir2IrVisitor( if (classLikeSymbol !is FirClassSymbol) { lastClass } else { - val firClass = classLikeSymbol.fir + val firClass = classLikeSymbol.fir as FirClass<*> declarationStorage.getIrClass(firClass, setParent = false) } } @@ -421,7 +421,7 @@ class Fir2IrVisitor( private fun FirDelegatedConstructorCall.toIrDelegatingConstructorCall(): IrDelegatingConstructorCall? { val constructedClassSymbol = with(typeContext) { (constructedTypeRef as FirResolvedTypeRef).type.typeConstructor() - } as? FirClassSymbol ?: return null + } as? FirClassSymbol<*> ?: return null val constructedIrType = constructedTypeRef.toIrType(this@Fir2IrVisitor.session, declarationStorage) // TODO: find delegated constructor correctly val classId = constructedClassSymbol.classId @@ -709,7 +709,8 @@ class Fir2IrVisitor( when (symbol) { is IrClassSymbol -> { val irClass = symbol.owner - val irConstructor = firSymbol?.fir?.getPrimaryConstructorIfAny()?.let { firConstructor -> + val fir = firSymbol?.fir as? FirClass<*> + val irConstructor = fir?.getPrimaryConstructorIfAny()?.let { firConstructor -> declarationStorage.getIrConstructor(firConstructor, irParent = irClass, shouldLeaveScope = true) }?.apply { this.parent = irClass diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt index f6c9298b330..998c69e33ef 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt @@ -210,7 +210,7 @@ private fun ConeClassLikeType.toFirClass(session: FirSession): FirRegularClass? return when (this) { is ConeAbbreviatedType -> this.directExpansionType(session)?.toFirClass(session) else -> (this.lookupTag.toSymbol(session) as? FirClassSymbol)?.fir - } + } as? FirRegularClass } /////////////////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt.183 b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt.183 index 99fe3c67684..a6c6a58f665 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt.183 +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt.183 @@ -211,7 +211,7 @@ private fun ConeClassLikeType.toFirClass(session: FirSession): FirRegularClass? return when (this) { is ConeAbbreviatedType -> this.directExpansionType(session)?.toFirClass(session) else -> (this.lookupTag.toSymbol(session) as? FirClassSymbol)?.fir - } + } as? FirRegularClass } /////////////////////////////////////////////////////////////////////////////////////////////////////////////// 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 45a7bea06f6..02a434ca55c 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 @@ -11,11 +11,8 @@ import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Visibility 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.declarations.addDefaultBoundIfNecessary +import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl -import org.jetbrains.kotlin.fir.declarations.visibility import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass import org.jetbrains.kotlin.fir.java.declarations.FirJavaConstructor import org.jetbrains.kotlin.fir.java.declarations.FirJavaField @@ -48,7 +45,7 @@ class JavaSymbolProvider( val session: FirSession, val project: Project, private val searchScope: GlobalSearchScope -) : AbstractFirSymbolProvider() { +) : AbstractFirSymbolProvider() { private val facade: KotlinJavaPsiFacade get() = KotlinJavaPsiFacade.getInstance(project) @@ -61,7 +58,7 @@ class JavaSymbolProvider( emptyList() override fun getClassDeclaredMemberScope(classId: ClassId): FirScope? { - val classSymbol = getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null + val classSymbol = getClassLikeSymbolByFqName(classId) ?: return null return declaredMemberScope(classSymbol.fir) } @@ -70,18 +67,21 @@ class JavaSymbolProvider( useSiteSession: FirSession, scopeSession: ScopeSession ): FirScope? { - val symbol = this.getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null + val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null return buildJavaEnhancementScope(useSiteSession, symbol, scopeSession, mutableSetOf()) } private fun buildJavaEnhancementScope( useSiteSession: FirSession, - symbol: FirClassSymbol, + symbol: FirRegularClassSymbol, scopeSession: ScopeSession, visitedSymbols: MutableSet> ): JavaClassEnhancementScope { return scopeSession.getOrBuild(symbol, JAVA_ENHANCEMENT) { - JavaClassEnhancementScope(useSiteSession, buildJavaUseSiteMemberScope(symbol.fir, useSiteSession, scopeSession, visitedSymbols)) + JavaClassEnhancementScope( + useSiteSession, + buildJavaUseSiteMemberScope(symbol.fir, useSiteSession, scopeSession, visitedSymbols) + ) } } @@ -98,7 +98,7 @@ class JavaSymbolProvider( .mapNotNull { useSiteSuperType -> if (useSiteSuperType is ConeClassErrorType) return@mapNotNull null val symbol = useSiteSuperType.lookupTag.toSymbol(useSiteSession) - if (symbol is FirClassSymbol && visitedSymbols.add(symbol)) { + if (symbol is FirRegularClassSymbol && visitedSymbols.add(symbol)) { // We need JavaClassEnhancementScope here to have already enhanced signatures from supertypes val scope = buildJavaEnhancementScope(useSiteSession, symbol, scopeSession, visitedSymbols) visitedSymbols.remove(symbol) @@ -151,16 +151,16 @@ class JavaSymbolProvider( } } - override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? = getFirJavaClass(classId) + override fun getClassLikeSymbolByFqName(classId: ClassId): FirRegularClassSymbol? = getFirJavaClass(classId) - fun getFirJavaClass(classId: ClassId, content: KotlinClassFinder.Result.ClassFileContent? = null): FirClassLikeSymbol<*>? { + fun getFirJavaClass(classId: ClassId, content: KotlinClassFinder.Result.ClassFileContent? = null): FirRegularClassSymbol? { if (!hasTopLevelClassOf(classId)) return null return classCache.lookupCacheOrCalculateWithPostCompute(classId, { val foundClass = findClass(classId, content) if (foundClass == null || foundClass.annotations.any { it.classId?.asSingleFqName() == JvmAnnotationNames.METADATA_FQ_NAME }) { null to null } else { - FirClassSymbol(classId) to foundClass + FirRegularClassSymbol(classId) to foundClass } }) { firSymbol, foundClass -> foundClass?.let { javaClass -> @@ -169,7 +169,7 @@ class JavaSymbolProvider( val isTopLevel = parentFqName.isRoot if (!isTopLevel) { val parentId = ClassId(classId.packageFqName, parentFqName, false) - val parentClassSymbol = getClassLikeSymbolByFqName(parentId) as? FirClassSymbol + val parentClassSymbol = getClassLikeSymbolByFqName(parentId) val parentClass = parentClassSymbol?.fir if (parentClass is FirJavaClass) { javaTypeParameterStack.addStack(parentClass.javaTypeParameterStack) @@ -177,7 +177,7 @@ class JavaSymbolProvider( } FirJavaClass( (javaClass as? JavaElementImpl<*>)?.psi?.toFirSourceElement(), session, - firSymbol as FirClassSymbol, javaClass.name, + firSymbol, javaClass.name, javaClass.visibility, javaClass.modality, javaClass.classKind, isTopLevel = isTopLevel, isStatic = javaClass.isStatic, @@ -291,7 +291,7 @@ class JavaSymbolProvider( fun getJavaTopLevelClasses(): List { return classCache.values - .filterIsInstance() + .filterIsInstance() .filter { it.classId.relativeClassName.parent().isRoot } .map { it.fir } } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt index d6963dd09af..2b843f794e9 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt @@ -28,7 +28,7 @@ import org.jetbrains.kotlin.fir.resolve.firSymbolProvider import org.jetbrains.kotlin.fir.resolve.getClassDeclaredCallableSymbols import org.jetbrains.kotlin.fir.symbols.StandardClassIds import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.toFirSourceElement import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl @@ -178,7 +178,7 @@ internal fun JavaAnnotation.toFirAnnotationCall( source = null, useSiteTarget = null, annotationTypeRef = FirResolvedTypeRefImpl( source = null, - type = ConeClassTypeImpl(FirClassSymbol(classId!!).toLookupTag(), emptyArray(), isNullable = false) + type = ConeClassTypeImpl(FirRegularClassSymbol(classId!!).toLookupTag(), emptyArray(), isNullable = false) ) ).apply { for (argument in this@toFirAnnotationCall.arguments) { diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt index bf2bbf7ba8d..6becb5f25e3 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt @@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableClass import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirVisitor @@ -27,7 +27,7 @@ import org.jetbrains.kotlin.name.Name class FirJavaClass internal constructor( override val source: FirSourceElement?, override val session: FirSession, - override val symbol: FirClassSymbol, + override val symbol: FirRegularClassSymbol, override val name: Name, visibility: Visibility, modality: Modality?, @@ -35,7 +35,7 @@ class FirJavaClass internal constructor( isTopLevel: Boolean, isStatic: Boolean, internal val javaTypeParameterStack: JavaTypeParameterStack -) : FirPureAbstractElement(), FirRegularClass, FirModifiableClass { +) : FirPureAbstractElement(), FirRegularClass, FirModifiableClass { override var status: FirDeclarationStatusImpl = FirDeclarationStatusImpl(visibility, modality) override val annotations: MutableList = mutableListOf() override val typeParameters: MutableList = mutableListOf() @@ -80,7 +80,7 @@ class FirJavaClass internal constructor( superTypeRefs.forEach { it.accept(visitor, data) } } - override fun transformChildren(transformer: FirTransformer, data: D): FirModifiableClass { + override fun transformChildren(transformer: FirTransformer, data: D): FirJavaClass { declarations.transformInplace(transformer, data) annotations.transformInplace(transformer, data) typeParameters.transformInplace(transformer, data) 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 ffee8b79382..424127f3386 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 @@ -57,8 +57,8 @@ class KotlinDeserializedJvmSymbolsProvider( private val javaSymbolProvider: JavaSymbolProvider, private val kotlinClassFinder: KotlinClassFinder, private val javaClassFinder: JavaClassFinder -) : AbstractFirSymbolProvider() { - private val classesCache = HashMap() +) : AbstractFirSymbolProvider>() { + private val classesCache = HashMap() private val typeAliasCache = HashMap() private val packagePartsCache = HashMap>() @@ -142,7 +142,7 @@ class KotlinDeserializedJvmSymbolsProvider( ): FirScope? { val symbol = this.getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null - return symbol.fir.buildDefaultUseSiteMemberScope(session, scopeSession) + return (symbol.fir as FirClass<*>).buildDefaultUseSiteMemberScope(session, scopeSession) } override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? { @@ -304,7 +304,7 @@ class KotlinDeserializedJvmSymbolsProvider( private fun findAndDeserializeClass( classId: ClassId, parentContext: FirDeserializationContext? = null - ): FirClassSymbol? { + ): FirRegularClassSymbol? { if (!hasTopLevelClassOf(classId)) return null if (classesCache.containsKey(classId)) return classesCache[classId] @@ -314,7 +314,7 @@ class KotlinDeserializedJvmSymbolsProvider( is KotlinClassFinder.Result.KotlinClass -> result.kotlinJvmBinaryClass is KotlinClassFinder.Result.ClassFileContent -> { handledByJava.add(classId) - return javaSymbolProvider.getFirJavaClass(classId, result) as FirClassSymbol? + return javaSymbolProvider.getFirJavaClass(classId, result) } null -> null } @@ -325,7 +325,7 @@ class KotlinDeserializedJvmSymbolsProvider( if (kotlinJvmBinaryClass.classHeader.kind != KotlinClassHeader.Kind.CLASS) return null val (nameResolver, classProto) = kotlinJvmBinaryClass.readClassDataFrom() ?: return null - val symbol = FirClassSymbol(classId) + val symbol = FirRegularClassSymbol(classId) deserializeClassToSymbol( classId, classProto, symbol, nameResolver, session, JvmBinaryAnnotationDeserializer(session), diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt index 9cd8816cba2..de25f9314cb 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt @@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.resolve.toSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.load.java.* import org.jetbrains.kotlin.load.java.JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME import org.jetbrains.kotlin.load.java.lazy.NullabilityQualifierWithApplicability @@ -51,7 +51,7 @@ class FirAnnotationTypeQualifierResolver(private val session: FirSession, privat } private val FirAnnotationCall.resolvedClass: FirRegularClass? - get() = (coneClassLikeType?.lookupTag?.toSymbol(this@FirAnnotationTypeQualifierResolver.session) as? FirClassSymbol)?.fir + get() = (coneClassLikeType?.lookupTag?.toSymbol(this@FirAnnotationTypeQualifierResolver.session) as? FirRegularClassSymbol)?.fir fun resolveTypeQualifierAnnotation(annotationCall: FirAnnotationCall): FirAnnotationCall? { if (jsr305State.disabled) { diff --git a/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt b/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt index 231376e6581..32186d07968 100644 --- a/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt +++ b/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt @@ -379,7 +379,7 @@ class DeclarationsConverter( className, status, classKind, - FirClassSymbol(context.currentClassId) + FirRegularClassSymbol(context.currentClassId) ) } else { FirClassImpl( @@ -388,7 +388,7 @@ class DeclarationsConverter( className, status, classKind, - FirClassSymbol(context.currentClassId) + FirRegularClassSymbol(context.currentClassId) ) } firClass.annotations += modifiers.annotations @@ -464,7 +464,7 @@ class DeclarationsConverter( superTypeRefs.ifEmpty { superTypeRefs += implicitAnyType } val delegatedType = delegatedSuperTypeRef ?: implicitAnyType - return FirAnonymousObjectImpl(null, session).apply { + return FirAnonymousObjectImpl(null, session, FirAnonymousObjectSymbol()).apply { annotations += modifiers.annotations this.superTypeRefs += superTypeRefs this.typeRef = superTypeRefs.first() @@ -514,7 +514,7 @@ class DeclarationsConverter( null, session, enumEntryName, - FirClassSymbol(context.currentClassId) + FirRegularClassSymbol(context.currentClassId) ) firEnumEntry.annotations += modifiers.annotations 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 354ddb95a0d..103a5854414 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 @@ -317,7 +317,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder } private fun KtClassOrObject.extractSuperTypeListEntriesTo( - container: FirModifiableClass, delegatedSelfTypeRef: FirTypeRef? + container: FirModifiableClass<*>, delegatedSelfTypeRef: FirTypeRef? ): FirTypeRef? { var superTypeCallEntry: KtSuperTypeCallEntry? = null var delegatedSuperTypeRef: FirTypeRef? = null @@ -439,7 +439,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder enumEntry.toFirSourceElement(), session, enumEntry.nameAsSafeName, - FirClassSymbol(context.currentClassId) + FirRegularClassSymbol(context.currentClassId) ) enumEntry.extractAnnotationsTo(firEnumEntry) val delegatedSelfType = enumEntry.toDelegatedSelfType(firEnumEntry) @@ -486,7 +486,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder classOrObject.nameAsSafeName, status, classKind, - FirClassSymbol(context.currentClassId) + FirRegularClassSymbol(context.currentClassId) ) } else { FirClassImpl( @@ -495,7 +495,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder classOrObject.nameAsSafeName, status, classKind, - FirClassSymbol(context.currentClassId) + FirRegularClassSymbol(context.currentClassId) ) } classOrObject.extractAnnotationsTo(firClass) @@ -538,7 +538,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder override fun visitObjectLiteralExpression(expression: KtObjectLiteralExpression, data: Unit): FirElement { val objectDeclaration = expression.objectDeclaration - return FirAnonymousObjectImpl(expression.toFirSourceElement(), session).apply { + return FirAnonymousObjectImpl(expression.toFirSourceElement(), session, FirAnonymousObjectSymbol()).apply { objectDeclaration.extractAnnotationsTo(this) objectDeclaration.extractSuperTypeListEntriesTo(this, null) this.typeRef = superTypeRefs.first() // TODO diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt index ead3e4ded0d..54041ee0998 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.resolve.constructType import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl @@ -70,7 +71,7 @@ abstract class AbstractAnnotationDeserializer( val classId = nameResolver.getClassId(proto.id) val lookupTag = ConeClassLikeLookupTagImpl(classId) val symbol = lookupTag.toSymbol(session) - val firAnnotationClass = (symbol as? FirClassSymbol)?.fir + val firAnnotationClass = (symbol as? FirRegularClassSymbol)?.fir var arguments = emptyList() if (proto.argumentCount != 0 && firAnnotationClass?.classKind == ClassKind.ANNOTATION_CLASS) { 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 6f1c87905d0..92646a8f803 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 @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirEnumEntryImpl import org.jetbrains.kotlin.fir.declarations.impl.FirSealedClassImpl import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl import org.jetbrains.kotlin.metadata.ProtoBuf @@ -30,12 +31,12 @@ import org.jetbrains.kotlin.serialization.deserialization.getName fun deserializeClassToSymbol( classId: ClassId, classProto: ProtoBuf.Class, - symbol: FirClassSymbol, + symbol: FirRegularClassSymbol, nameResolver: NameResolver, session: FirSession, defaultAnnotationDeserializer: AbstractAnnotationDeserializer?, parentContext: FirDeserializationContext? = null, - deserializeNestedClass: (ClassId, FirDeserializationContext) -> FirClassSymbol? + deserializeNestedClass: (ClassId, FirDeserializationContext) -> FirRegularClassSymbol? ) { val flags = classProto.flags val kind = Flags.CLASS_KIND.get(flags) @@ -119,7 +120,7 @@ fun deserializeClassToSymbol( val enumEntryName = nameResolver.getName(enumEntryProto.name) val enumEntryId = classId.createNestedClassId(enumEntryName) - val symbol = FirClassSymbol(enumEntryId) + val symbol = FirRegularClassSymbol(enumEntryId) FirEnumEntryImpl(null, session, enumEntryId.shortClassName, symbol).apply { resolvePhase = FirResolvePhase.DECLARATIONS superTypeRefs += FirResolvedTypeRefImpl( 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 833496b5067..37c7281deb8 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 @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.fir.deserialization import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner import org.jetbrains.kotlin.fir.declarations.addDefaultBoundIfNecessary import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl import org.jetbrains.kotlin.fir.resolve.toTypeProjection @@ -109,7 +110,8 @@ class FirTypeDeserializer( get() = typeParameterDescriptors.values.toList() - fun FirClassLikeSymbol<*>.typeParameters(): List = fir.typeParameters.map { it.symbol } + fun FirClassLikeSymbol<*>.typeParameters(): List = + (fir as? FirTypeParametersOwner)?.typeParameters?.map { it.symbol }.orEmpty() 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 1802bd4954f..6d14b1443f4 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 @@ -5,17 +5,14 @@ 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.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?>() +abstract class AbstractFirSymbolProvider> : FirSymbolProvider() { + protected val classCache = HashMap() protected val topLevelCallableCache = HashMap>>() protected val packageCache = HashMap() @@ -29,15 +26,15 @@ abstract class AbstractFirSymbolProvider : FirSymbolProvider() { } } - protected inline fun MutableMap.lookupCacheOrCalculateWithPostCompute( - key: K, crossinline l: (K) -> Pair, postCompute: (V, T) -> Unit + protected inline fun MutableMap.lookupCacheOrCalculateWithPostCompute( + key: K, crossinline l: (K) -> Pair, postCompute: (V, T) -> Unit ): V? { return if (containsKey(key)) { this[key] } else { val calculated = l(key) this[key] = calculated.first - postCompute(calculated.first, calculated.second) + calculated.first?.let { first -> postCompute(first, calculated.second) } calculated.first } } 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 e71b2952d32..23a0de40a8b 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 @@ -47,6 +47,9 @@ val FirSession.correspondingSupertypesCache: FirCorrespondingSupertypesCache by val FirSession.memberScopeProvider: FirMemberScopeProvider by componentArrayAccessor() fun ConeClassLikeLookupTag.toSymbol(useSiteSession: FirSession): FirClassLikeSymbol<*>? { + if (this is ConeClassLookupTagWithFixedSymbol) { + return this.symbol + } val firSymbolProvider = useSiteSession.firSymbolProvider return firSymbolProvider.getSymbolByLookupTag(this) } @@ -96,7 +99,7 @@ fun ConeClassifierLookupTag.toSymbol(useSiteSession: FirSession): FirClassifierS fun ConeTypeParameterLookupTag.toSymbol(): FirTypeParameterSymbol = this.symbol as FirTypeParameterSymbol -fun ConeClassLikeLookupTag.constructClassType(typeArguments: Array, isNullable: Boolean): ConeLookupTagBasedType { +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/SamResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt index e556354c92d..c0e86f66e66 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt @@ -20,10 +20,7 @@ import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.symbols.CallableId import org.jetbrains.kotlin.fir.symbols.StandardClassIds -import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl @@ -217,7 +214,7 @@ private fun FirRegularClass.computeSamCandidateNames(session: FirSession): Set() 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 802baa2ee8d..b5168d24935 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 @@ -13,14 +13,11 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope import org.jetbrains.kotlin.fir.scopes.impl.FirClassUseSiteMemberScope import org.jetbrains.kotlin.fir.scopes.impl.FirSuperTypeScope import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol -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.* fun lookupSuperTypes( - klass: FirRegularClass, + klass: FirClass<*>, lookupInterfaces: Boolean, deep: Boolean, useSiteSession: FirSession @@ -51,6 +48,13 @@ val USE_SITE = scopeSessionKey() data class SubstitutionScopeKey(val type: ConeClassLikeType) : ScopeSessionKey() {} +fun FirClassSymbol<*>.buildUseSiteMemberScope(useSiteSession: FirSession, builder: ScopeSession): FirScope? { + when (this) { + is FirAnonymousObjectSymbol -> return fir.buildDefaultUseSiteMemberScope(useSiteSession, builder) + is FirRegularClassSymbol -> return fir.buildUseSiteMemberScope(useSiteSession, builder) + } +} + fun FirRegularClass.buildUseSiteMemberScope(useSiteSession: FirSession, builder: ScopeSession): FirScope? { if (classId.isLocal) { // It's not possible to find local class by symbol @@ -67,7 +71,7 @@ fun FirTypeAlias.buildUseSiteMemberScope(useSiteSession: FirSession, builder: Sc } } -fun FirRegularClass.buildDefaultUseSiteMemberScope(useSiteSession: FirSession, builder: ScopeSession): FirScope { +fun FirClass<*>.buildDefaultUseSiteMemberScope(useSiteSession: FirSession, builder: ScopeSession): FirScope { return builder.getOrBuild(symbol, USE_SITE) { val declaredScope = declaredMemberScope(this) @@ -75,7 +79,7 @@ fun FirRegularClass.buildDefaultUseSiteMemberScope(useSiteSession: FirSession, b .mapNotNull { useSiteSuperType -> if (useSiteSuperType is ConeClassErrorType) return@mapNotNull null val symbol = useSiteSuperType.lookupTag.toSymbol(useSiteSession) - if (symbol is FirClassSymbol) { + if (symbol is FirRegularClassSymbol) { val useSiteMemberScope = symbol.fir.buildUseSiteMemberScope(useSiteSession, builder)!! useSiteSuperType.wrapSubstitutionScopeIfNeed(useSiteSession, useSiteMemberScope, symbol.fir, builder) } else { @@ -94,8 +98,9 @@ fun ConeClassLikeType.wrapSubstitutionScopeIfNeed( ): FirScope { if (this.typeArguments.isEmpty()) return useSiteMemberScope return builder.getOrBuild(declaration.symbol, SubstitutionScopeKey(this)) { + val typeParameters = (declaration as? FirTypeParametersOwner)?.typeParameters.orEmpty() @Suppress("UNCHECKED_CAST") - val substitution = declaration.typeParameters.zip(this.typeArguments) { typeParameter, typeArgument -> + val substitution = typeParameters.zip(this.typeArguments) { typeParameter, typeArgument -> typeParameter.symbol to (typeArgument as? ConeTypedProjection)?.type }.filter { (_, type) -> type != null }.toMap() as Map @@ -121,7 +126,7 @@ private fun FirClassifierSymbol<*>.collectSuperTypes( when (this) { is FirClassSymbol -> { val superClassTypes = - fir.superConeTypes.mapNotNull { + superConeTypes.mapNotNull { it.computePartialExpansion(useSiteSession) .takeIf { type -> lookupInterfaces || type.isClassBasedType(useSiteSession) } } @@ -149,5 +154,11 @@ private fun FirClassifierSymbol<*>.collectSuperTypes( private fun ConeClassLikeType?.isClassBasedType( useSiteSession: FirSession -) = this !is ConeClassErrorType && - (this?.lookupTag?.toSymbol(useSiteSession) as? FirClassSymbol)?.fir?.classKind == ClassKind.CLASS +): Boolean { + if (this is ConeClassErrorType) return false + val symbol = this?.lookupTag?.toSymbol(useSiteSession) as? FirClassSymbol ?: return false + return when (symbol) { + is FirAnonymousObjectSymbol -> true + is FirRegularClassSymbol -> symbol.fir.classKind == ClassKind.CLASS + } +} diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt index f65783edd41..59c3163686e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt @@ -6,6 +6,8 @@ package org.jetbrains.kotlin.fir.resolve.calls import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner import org.jetbrains.kotlin.fir.declarations.classId import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.impl.FirThisReceiverExpressionImpl @@ -37,10 +39,10 @@ private fun receiverExpression(symbol: AbstractFirBasedSymbol<*>, type: ConeKotl typeRef = FirResolvedTypeRefImpl(null, type) } -class ClassDispatchReceiverValue(val klassSymbol: FirClassSymbol) : ReceiverValue { +class ClassDispatchReceiverValue(val klassSymbol: FirClassSymbol<*>) : ReceiverValue { override val type: ConeKotlinType = ConeClassTypeImpl( klassSymbol.toLookupTag(), - klassSymbol.fir.typeParameters.map { ConeStarProjection }.toTypedArray(), + (klassSymbol.fir as? FirTypeParametersOwner)?.typeParameters?.map { ConeStarProjection }?.toTypedArray().orEmpty(), isNullable = false ) @@ -86,13 +88,13 @@ abstract class ImplicitReceiverValue>( } class ImplicitDispatchReceiverValue( - boundSymbol: FirClassSymbol, + boundSymbol: FirClassSymbol<*>, type: ConeKotlinType, symbolProvider: FirSymbolProvider, useSiteSession: FirSession, scopeSession: ScopeSession -) : ImplicitReceiverValue(boundSymbol, type, useSiteSession, scopeSession) { - val implicitCompanionScope: FirScope? = boundSymbol.fir.companionObject?.let { companionObject -> +) : ImplicitReceiverValue>(boundSymbol, type, useSiteSession, scopeSession) { + val implicitCompanionScope: FirScope? = (boundSymbol.fir as? FirRegularClass)?.companionObject?.let { companionObject -> val companionId = companionObject.classId if (companionId.isLocal) { companionObject.buildDefaultUseSiteMemberScope(useSiteSession, scopeSession) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirTowerResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirTowerResolver.kt index 45456dc163f..0485175adf0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirTowerResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirTowerResolver.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.fir.resolve.calls import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.isInner import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents import org.jetbrains.kotlin.fir.resolve.calls.TowerDataKind.EMPTY @@ -110,7 +111,7 @@ class FirTowerResolver( if (blockDispatchReceivers) { continue } - if (!implicitDispatchReceiverValue.boundSymbol.fir.isInner) { + if ((implicitDispatchReceiverValue.boundSymbol.fir as? FirRegularClass)?.isInner == false) { blockDispatchReceivers = true } } @@ -192,7 +193,7 @@ class FirTowerResolver( // } towerDataConsumer.consume(TOWER_LEVEL, ScopeTowerLevel(session, components, implicitCompanionScope), group++) } - if (!implicitReceiverValue.boundSymbol.fir.isInner) { + if ((implicitReceiverValue.boundSymbol.fir as? FirRegularClass)?.isInner == false) { blockDispatchReceivers = true } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerLevels.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerLevels.kt index ad06326172a..fa8391d2a6b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerLevels.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerLevels.kt @@ -67,7 +67,7 @@ abstract class SessionBasedTowerLevel(val session: FirSession) : TowerScopeLevel is FirNamedFunctionSymbol -> fir.dispatchReceiverValue(session) is FirPropertySymbol -> fir.dispatchReceiverValue(session) is FirFieldSymbol -> fir.dispatchReceiverValue(session) - is FirClassSymbol -> ClassDispatchReceiverValue(fir.symbol) + is FirClassSymbol -> ClassDispatchReceiverValue(this) else -> null } } @@ -263,9 +263,8 @@ fun FirCallableDeclaration<*>.dispatchReceiverValue(session: FirSession): ClassD if (this is FirConstructor) return null val id = this.symbol.callableId.classId ?: return null val symbol = session.firSymbolProvider.getClassLikeSymbolByFqName(id) as? FirClassSymbol ?: return null - val regularClass = symbol.fir - return ClassDispatchReceiverValue(regularClass.symbol) + return ClassDispatchReceiverValue(symbol) } private fun FirCallableSymbol<*>.hasExtensionReceiver(): Boolean = this.fir.receiverTypeRef != null @@ -333,7 +332,7 @@ private fun processSyntheticConstructors( bodyResolveComponents: BodyResolveComponents ): ProcessorAction { if (matchedSymbol == null) return ProcessorAction.NEXT - if (matchedSymbol !is FirClassSymbol) return ProcessorAction.NEXT + if (matchedSymbol !is FirRegularClassSymbol) return ProcessorAction.NEXT val function = bodyResolveComponents.samResolver.getSamConstructor(matchedSymbol.fir) ?: return ProcessorAction.NEXT @@ -351,7 +350,7 @@ private fun processConstructors( if (matchedSymbol != null) { val scope = when (matchedSymbol) { is FirTypeAliasSymbol -> matchedSymbol.fir.buildUseSiteMemberScope(session, scopeSession) - is FirClassSymbol -> matchedSymbol.fir.buildUseSiteMemberScope(session, scopeSession) + is FirClassSymbol -> matchedSymbol.buildUseSiteMemberScope(session, scopeSession) } 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 68ff3bf77a7..42908da63bf 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 @@ -19,7 +19,7 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult -class FirDependenciesSymbolProviderImpl(val session: FirSession) : AbstractFirSymbolProvider() { +class FirDependenciesSymbolProviderImpl(val session: FirSession) : AbstractFirSymbolProvider>() { private val dependencyProviders by lazy { val moduleInfo = session.moduleInfo ?: return@lazy emptyList() moduleInfo.dependenciesWithoutSelf().mapNotNull { 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 481b50dd516..bb37032264a 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 @@ -72,15 +72,15 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( ).memberDeserializer } - val lookup = mutableMapOf() + val lookup = mutableMapOf() - fun getClassLikeSymbolByFqName(classId: ClassId): FirClassSymbol? = + fun getClassLikeSymbolByFqName(classId: ClassId): FirRegularClassSymbol? = findAndDeserializeClass(classId) private fun findAndDeserializeClass( classId: ClassId, parentContext: FirDeserializationContext? = null - ): FirClassSymbol? { + ): FirRegularClassSymbol? { val classIdExists = classId in classDataFinder.allClassIds val shouldBeEnumEntry = !classIdExists && classId.outerClassId in classDataFinder.allClassIds if (!classIdExists && !shouldBeEnumEntry) return null @@ -91,7 +91,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( return null } } - return lookup.getOrPut(classId, { FirClassSymbol(classId) }) { symbol -> + return lookup.getOrPut(classId, { FirRegularClassSymbol(classId) }) { symbol -> if (shouldBeEnumEntry) { FirEnumEntryImpl(null, session, classId.shortClassName, symbol).apply { resolvePhase = FirResolvePhase.DECLARATIONS @@ -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): FirClassSymbol? { + override fun getClassLikeSymbolByFqName(classId: ClassId): FirRegularClassSymbol? { return allPackageFragments[classId.packageFqName]?.firstNotNullResult { it.getClassLikeSymbolByFqName(classId) } ?: with(classId) { @@ -171,7 +171,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider( isData = false isInline = false } - FirClassSymbol(this).apply { + FirRegularClassSymbol(this).apply { FirClassImpl( null, session, 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 b4c05afd31f..f8677f67dbd 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 @@ -16,10 +16,7 @@ import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.impl.FirClassDeclaredMemberScope import org.jetbrains.kotlin.fir.symbols.CallableId import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag -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.symbols.impl.* import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitorVoid @@ -219,7 +216,8 @@ class FirProviderImpl(val session: FirSession) : FirProvider() { scopeSession: ScopeSession ): FirScope? { return when (val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null) { - is FirClassSymbol -> symbol.fir.buildDefaultUseSiteMemberScope(useSiteSession, scopeSession) + is FirRegularClassSymbol -> symbol.fir.buildDefaultUseSiteMemberScope(useSiteSession, scopeSession) + is FirAnonymousObjectSymbol -> symbol.fir.buildDefaultUseSiteMemberScope(useSiteSession, scopeSession) is FirTypeAliasSymbol -> { val expandedTypeRef = symbol.fir.expandedTypeRef as FirResolvedTypeRef val expandedType = expandedTypeRef.type as? ConeLookupTagBasedType ?: return null diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt index ba88ad9c3e0..57b8771aac2 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt @@ -5,10 +5,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers -import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration -import org.jetbrains.kotlin.fir.declarations.FirRegularClass -import org.jetbrains.kotlin.fir.declarations.FirResolvePhase -import org.jetbrains.kotlin.fir.declarations.isCompanion +import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsTransformer.kt index f56c0499fdf..89e2c4250ce 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsTransformer.kt @@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider import org.jetbrains.kotlin.fir.resolve.firSymbolProvider import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef @@ -81,7 +82,7 @@ class FirSealedClassInheritorsTransformer : FirTransformer() { val lookupTag = ((typeRef as FirResolvedTypeRef).type as? ConeLookupTagBasedType)?.lookupTag ?: return null val classLikeSymbol: FirClassifierSymbol<*> = symbolProvider.getSymbolByLookupTag(lookupTag) ?: return null return when (classLikeSymbol) { - is FirClassSymbol -> classLikeSymbol.fir + is FirRegularClassSymbol -> classLikeSymbol.fir is FirTypeAliasSymbol -> extractClassFromTypeRef(symbolProvider, classLikeSymbol.fir.expandedTypeRef) else -> null } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt index 1ef35a1f2d0..6ea60f68967 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt @@ -144,8 +144,8 @@ class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyRe override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: SealedExhaustivenessData) { val lookupTag = (resolvedTypeRef.type as? ConeLookupTagBasedType)?.lookupTag ?: return - val klass = (data.symbolProvider.getSymbolByLookupTag(lookupTag) as? FirClassSymbol)?.fir ?: return - data.visitedInheritors.replace(klass.symbol.classId, true) + val symbol = data.symbolProvider.getSymbolByLookupTag(lookupTag) as? FirClassSymbol ?: return + data.visitedInheritors.replace(symbol.classId, true) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index 381956654cc..55f3f01fd06 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve import org.jetbrains.kotlin.fir.BuiltinTypes import org.jetbrains.kotlin.fir.FirCallResolver +import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.impl.FirErrorExpressionImpl import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionWithSmartcastImpl @@ -346,7 +347,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) : val symbol = symbolProvider.getClassLikeSymbolByFqName(classId) // TODO: Unify logic? symbol?.constructType( - Array(symbol.phasedFir.typeParameters.size) { + Array((symbol.phasedFir as? FirTypeParametersOwner)?.typeParameters?.size ?: 0) { ConeStarProjection }, isNullable = false 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 59b323e4135..760acbd0711 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 @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.fir.scopes.impl import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration +import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirConstructor import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.scopes.FirScope @@ -18,15 +19,18 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol import org.jetbrains.kotlin.name.Name -class FirClassDeclaredMemberScope(klass: FirRegularClass) : FirScope() { +class FirClassDeclaredMemberScope(klass: FirClass<*>) : FirScope() { private val nestedClassifierScope = nestedClassifierScope(klass) private val callablesIndex: Map>> = run { val result = mutableMapOf>>() - for (declaration in klass.declarations) { + loop@ for (declaration in klass.declarations) { when (declaration) { is FirCallableMemberDeclaration<*> -> { - val name = if (declaration is FirConstructor) klass.name else declaration.name + val name = when (declaration) { + is FirConstructor -> if (klass is FirRegularClass) klass.name else continue@loop + else -> declaration.name + } result.getOrPut(name) { mutableListOf() } += declaration.symbol } is FirRegularClass -> { 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 227d34d8a77..409b8464e72 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 @@ -16,7 +16,7 @@ class FirLocalScope : FirScope() { val properties = mutableMapOf>() val functions = mutableMapOf>() - val classes = mutableMapOf() + val classes = mutableMapOf() fun storeDeclaration(declaration: FirNamedDeclaration) { when (declaration) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirMemberScopeProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirMemberScopeProvider.kt index 368652dcf16..4423ea9afcd 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirMemberScopeProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirMemberScopeProvider.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.scopes.impl import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSessionComponent +import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.resolve.memberScopeProvider import org.jetbrains.kotlin.name.ClassId @@ -14,17 +15,17 @@ import org.jetbrains.kotlin.name.FqName class FirMemberScopeProvider : FirSessionComponent { - private val declaredMemberCache = mutableMapOf() - private val nestedClassifierCache = mutableMapOf() + private val declaredMemberCache = mutableMapOf, FirClassDeclaredMemberScope>() + private val nestedClassifierCache = mutableMapOf, FirNestedClassifierScope>() private val selfImportingCache = mutableMapOf() - fun declaredMemberScope(klass: FirRegularClass): FirClassDeclaredMemberScope { + fun declaredMemberScope(klass: FirClass<*>): FirClassDeclaredMemberScope { return declaredMemberCache.getOrPut(klass) { FirClassDeclaredMemberScope(klass) } } - fun nestedClassifierScope(klass: FirRegularClass): FirNestedClassifierScope { + fun nestedClassifierScope(klass: FirClass<*>): FirNestedClassifierScope { return nestedClassifierCache.getOrPut(klass) { FirNestedClassifierScope(klass) } @@ -38,14 +39,14 @@ class FirMemberScopeProvider : FirSessionComponent { } } -fun declaredMemberScope(klass: FirRegularClass): FirClassDeclaredMemberScope { +fun declaredMemberScope(klass: FirClass<*>): FirClassDeclaredMemberScope { return klass .session .memberScopeProvider .declaredMemberScope(klass) } -fun nestedClassifierScope(klass: FirRegularClass): FirNestedClassifierScope { +fun nestedClassifierScope(klass: FirClass<*>): FirNestedClassifierScope { return klass .session .memberScopeProvider diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt index 0136ecc186c..537c7d4967c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt @@ -5,17 +5,18 @@ package org.jetbrains.kotlin.fir.scopes.impl +import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.name.Name -class FirNestedClassifierScope(val klass: FirRegularClass) : FirScope() { +class FirNestedClassifierScope(val klass: FirClass<*>) : FirScope() { - private val classIndex: Map = run { - val result = mutableMapOf() + private val classIndex: Map = run { + val result = mutableMapOf() for (declaration in klass.declarations) { if (declaration is FirRegularClass) { result[declaration.name] = declaration.symbol 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 bc8b19db696..31d655b26e2 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 @@ -192,11 +192,12 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty //require(this is ConeSymbol) return when (this) { is FirTypeParameterSymbol, + is FirAnonymousObjectSymbol, is ConeCapturedTypeConstructor, is ErrorTypeConstructor, is ConeTypeVariableTypeConstructor, is ConeIntersectionType -> 0 - is FirClassSymbol -> fir.typeParameters.size + is FirRegularClassSymbol -> fir.typeParameters.size is FirTypeAliasSymbol -> fir.typeParameters.size else -> error("?!:10") } @@ -206,7 +207,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty //require(this is ConeSymbol) return when (this) { is FirTypeParameterSymbol -> error("?!:11") - is FirClassSymbol -> fir.typeParameters[index].symbol + is FirRegularClassSymbol -> fir.typeParameters[index].symbol is FirTypeAliasSymbol -> fir.typeParameters[index].symbol else -> error("?!:12") } @@ -218,7 +219,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty return when (this) { is ConeTypeVariableTypeConstructor -> emptyList() is FirTypeParameterSymbol -> fir.bounds.map { it.coneTypeUnsafe() } - is FirClassSymbol -> fir.superConeTypes + is FirClassSymbol<*> -> fir.superConeTypes is FirTypeAliasSymbol -> listOfNotNull(fir.expandedConeType) is ConeCapturedTypeConstructor -> supertypes!! is ConeIntersectionType -> intersectedTypes @@ -232,7 +233,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty override fun TypeConstructorMarker.isClassTypeConstructor(): Boolean { //assert(this is ConeSymbol) - return this is FirClassSymbol + return this is FirClassSymbol<*> } override fun TypeParameterMarker.getVariance(): TypeVariance { @@ -275,7 +276,8 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty } override fun TypeConstructorMarker.isCommonFinalClassConstructor(): Boolean { - val classSymbol = this as? FirClassSymbol ?: return false + if (this is FirAnonymousObjectSymbol) return true + val classSymbol = this as? FirRegularClassSymbol ?: return false val fir = classSymbol.fir return fir.modality == Modality.FINAL && fir.classKind != ClassKind.ENUM_ENTRY && @@ -352,7 +354,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty if (this is ConeIntersectionType) return false require(this is ConeLookupTagBasedType) val typeConstructor = this.typeConstructor() - return typeConstructor is FirClassSymbol || + return typeConstructor is FirClassSymbol<*> || typeConstructor is FirTypeParameterSymbol } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/FirCorrespondingSupertypesCache.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/FirCorrespondingSupertypesCache.kt index ee753cdae98..6e2dd84d5a2 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/FirCorrespondingSupertypesCache.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/FirCorrespondingSupertypesCache.kt @@ -7,6 +7,8 @@ package org.jetbrains.kotlin.fir.types import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSessionComponent +import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration +import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner import org.jetbrains.kotlin.fir.resolve.constructClassType import org.jetbrains.kotlin.fir.resolve.constructType import org.jetbrains.kotlin.fir.resolve.toSymbol @@ -52,15 +54,15 @@ class FirCorrespondingSupertypesCache(private val session: FirSession) : FirSess ): Map, List>? { val resultingMap = HashMap, List>() - val subtypeClassSymbol = with(context) { + val subtypeClassSymbol: FirClassLikeSymbol<*> = with(context) { subtype.typeConstructor() as? FirClassLikeSymbol<*> ?: return null } - val subtypeFirClass = subtypeClassSymbol.fir + val subtypeFirClass: FirClassLikeDeclaration<*> = subtypeClassSymbol.fir val defaultType = subtypeClassSymbol.toLookupTag().constructClassType( - subtypeFirClass.typeParameters.map { + (subtypeFirClass as? FirTypeParametersOwner)?.typeParameters?.map { it.symbol.toLookupTag().constructType(emptyArray(), isNullable = false) - }.toTypedArray(), + }?.toTypedArray().orEmpty(), isNullable = false ) 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 dae94eb1c7f..f47c1943da4 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt @@ -236,7 +236,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { visitDeclaration(namedDeclaration) if (namedDeclaration !is FirCallableDeclaration<*>) { // Handled by visitCallableDeclaration print(" " + namedDeclaration.name) - if (namedDeclaration is FirClassLikeDeclaration<*>) { + if (namedDeclaration is FirTypeParametersOwner) { namedDeclaration.typeParameters.renderTypeParameters() } } else if (namedDeclaration is FirMemberDeclaration) { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt index 18235973f89..af2b0da25a7 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.* @@ -19,15 +20,17 @@ import org.jetbrains.kotlin.fir.visitors.* * DO NOT MODIFY IT MANUALLY */ -abstract class FirAnonymousObject : FirPureAbstractElement(), FirClass, FirExpression { +abstract class FirAnonymousObject : FirPureAbstractElement(), FirClass, FirExpression { abstract override val source: FirSourceElement? abstract override val session: FirSession abstract override val resolvePhase: FirResolvePhase + abstract override val supertypesComputationStatus: SupertypesComputationStatus abstract override val classKind: ClassKind abstract override val superTypeRefs: List abstract override val declarations: List abstract override val annotations: List abstract override val typeRef: FirTypeRef + abstract override val symbol: FirAnonymousObjectSymbol override fun accept(visitor: FirVisitor, data: D): R = visitor.visitAnonymousObject(this, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClass.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClass.kt index 5526cb92b14..a516c9621da 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClass.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClass.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirStatement +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.* @@ -19,10 +20,12 @@ import org.jetbrains.kotlin.fir.visitors.* * DO NOT MODIFY IT MANUALLY */ -interface FirClass : FirDeclaration, FirStatement, FirAnnotationContainer { +interface FirClass> : FirClassLikeDeclaration, FirStatement, FirAnnotationContainer { override val source: FirSourceElement? override val session: FirSession override val resolvePhase: FirResolvePhase + override val supertypesComputationStatus: SupertypesComputationStatus + override val symbol: FirClassSymbol val classKind: ClassKind val superTypeRefs: List val declarations: List 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 85319139e1b..0ab80944471 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 @@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.FirSymbolOwner import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol -import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.fir.visitors.* /* @@ -19,14 +18,11 @@ import org.jetbrains.kotlin.fir.visitors.* * DO NOT MODIFY IT MANUALLY */ -interface FirClassLikeDeclaration> : FirStatement, FirMemberDeclaration, FirSymbolOwner, FirTypeParametersOwner { +interface FirClassLikeDeclaration> : FirDeclaration, FirStatement, FirSymbolOwner { override val source: FirSourceElement? - override val annotations: List override val session: FirSession override val resolvePhase: FirResolvePhase - override val name: Name - override val typeParameters: List - override val status: FirDeclarationStatus + override val annotations: List val supertypesComputationStatus: SupertypesComputationStatus override val symbol: FirClassLikeSymbol diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt index cc8ece1d1d2..f013cdac6a5 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt @@ -9,6 +9,9 @@ import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.fir.declarations.impl.FirEnumEntryImpl import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableRegularClass import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl +import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.coneTypeSafe @@ -60,7 +63,13 @@ val FirTypeAlias.expandedConeType: ConeClassLikeType? get() = expandedTypeRef.co val FirRegularClass.classId get() = symbol.classId -val FirClass.superConeTypes get() = superTypeRefs.mapNotNull { it.coneTypeSafe() } +val FirClassSymbol<*>.superConeTypes + get() = when (this) { + is FirRegularClassSymbol -> fir.superConeTypes + is FirAnonymousObjectSymbol -> fir.superConeTypes + } + +val FirClass<*>.superConeTypes get() = superTypeRefs.mapNotNull { it.coneTypeSafe() } fun FirRegularClass.collectEnumEntries(): Collection { assert(classKind == ClassKind.ENUM_CLASS) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt index f67aaa4d44d..4e2fdd96d87 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt @@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirExpression -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.fir.visitors.* @@ -32,7 +32,7 @@ abstract class FirEnumEntry : FirPureAbstractElement(), FirRegularClass { abstract override val supertypesComputationStatus: SupertypesComputationStatus abstract override val classKind: ClassKind abstract override val declarations: List - abstract override val symbol: FirClassSymbol + abstract override val symbol: FirRegularClassSymbol abstract override val companionObject: FirRegularClass? abstract override val superTypeRefs: List abstract val arguments: List 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 cb1481976c4..d9733a211f2 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 @@ -9,7 +9,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.fir.visitors.* @@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.* * DO NOT MODIFY IT MANUALLY */ -interface FirRegularClass : FirNamedDeclaration, FirClassLikeDeclaration, FirClass { +interface FirRegularClass : FirMemberDeclaration, FirTypeParametersOwner, FirClass { override val source: FirSourceElement? override val session: FirSession override val resolvePhase: FirResolvePhase @@ -30,7 +30,7 @@ interface FirRegularClass : FirNamedDeclaration, FirClassLikeDeclaration - override val symbol: FirClassSymbol + override val symbol: FirRegularClassSymbol val companionObject: FirRegularClass? override val superTypeRefs: List diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirSealedClass.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirSealedClass.kt index 9769ae6c56d..c93e56b241f 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirSealedClass.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirSealedClass.kt @@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirPureAbstractElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name @@ -32,7 +32,7 @@ abstract class FirSealedClass : FirPureAbstractElement(), FirRegularClass { abstract override val supertypesComputationStatus: SupertypesComputationStatus abstract override val classKind: ClassKind abstract override val declarations: List - abstract override val symbol: FirClassSymbol + abstract override val symbol: FirRegularClassSymbol abstract override val companionObject: FirRegularClass? abstract override val superTypeRefs: List abstract val inheritors: List 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 6415ae409e6..15bb07eb8ce 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 @@ -19,14 +19,14 @@ import org.jetbrains.kotlin.fir.visitors.* * DO NOT MODIFY IT MANUALLY */ -abstract class FirTypeAlias : FirPureAbstractElement(), FirClassLikeDeclaration { +abstract class FirTypeAlias : FirPureAbstractElement(), FirClassLikeDeclaration, FirMemberDeclaration, FirTypeParametersOwner { abstract override val source: FirSourceElement? abstract override val session: FirSession abstract override val resolvePhase: FirResolvePhase + abstract override val supertypesComputationStatus: SupertypesComputationStatus abstract override val name: Name abstract override val typeParameters: List abstract override val status: FirDeclarationStatus - abstract override val supertypesComputationStatus: SupertypesComputationStatus abstract override val symbol: FirTypeAliasSymbol abstract val expandedTypeRef: FirTypeRef abstract override val annotations: List diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt index e306db4c077..555e154f238 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt @@ -11,8 +11,10 @@ import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.fir.declarations.SupertypesComputationStatus import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement +import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl import org.jetbrains.kotlin.fir.visitors.* @@ -24,15 +26,21 @@ import org.jetbrains.kotlin.fir.visitors.* class FirAnonymousObjectImpl( override val source: FirSourceElement?, - override val session: FirSession -) : FirAnonymousObject(), FirModifiableClass, FirAbstractAnnotatedElement { + override val session: FirSession, + override val symbol: FirAnonymousObjectSymbol +) : FirAnonymousObject(), FirModifiableClass, FirAbstractAnnotatedElement { override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR + override var supertypesComputationStatus: SupertypesComputationStatus = SupertypesComputationStatus.NOT_COMPUTED override val classKind: ClassKind get() = ClassKind.OBJECT override val superTypeRefs: MutableList = mutableListOf() override val declarations: MutableList = mutableListOf() override val annotations: MutableList = mutableListOf() override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null) + init { + symbol.bind(this) + } + override fun acceptChildren(visitor: FirVisitor, data: D) { superTypeRefs.forEach { it.accept(visitor, data) } declarations.forEach { it.accept(visitor, data) } @@ -52,6 +60,10 @@ class FirAnonymousObjectImpl( resolvePhase = newResolvePhase } + override fun replaceSupertypesComputationStatus(newSupertypesComputationStatus: SupertypesComputationStatus) { + supertypesComputationStatus = newSupertypesComputationStatus + } + override fun replaceSuperTypeRefs(newSuperTypeRefs: List) { superTypeRefs.clear() superTypeRefs.addAll(newSuperTypeRefs) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt index 200a1353354..9904e3d245b 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt @@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.FirTypeParameter import org.jetbrains.kotlin.fir.declarations.SupertypesComputationStatus import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.fir.visitors.* @@ -33,7 +33,7 @@ class FirClassImpl( override val name: Name, override var status: FirDeclarationStatus, override val classKind: ClassKind, - override val symbol: FirClassSymbol + override val symbol: FirRegularClassSymbol ) : FirPureAbstractElement(), FirRegularClass, FirModifiableRegularClass, FirAbstractAnnotatedElement { override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR override val annotations: MutableList = mutableListOf() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt index dd48e281b1e..535bd9dc2aa 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt @@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.declarations.SupertypesComputationStatus import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.fir.visitors.* @@ -34,8 +34,8 @@ class FirEnumEntryImpl( override val source: FirSourceElement?, override val session: FirSession, override val name: Name, - override val symbol: FirClassSymbol -) : FirEnumEntry(), FirModifiableClass, FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement { + override val symbol: FirRegularClassSymbol +) : FirEnumEntry(), FirModifiableClass, FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement { override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR override val annotations: MutableList = mutableListOf() override val typeParameters: MutableList = mutableListOf() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableClass.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableClass.kt index 5eb27d423d9..418483ebfc8 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableClass.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableClass.kt @@ -11,8 +11,10 @@ import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.fir.declarations.SupertypesComputationStatus import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.* @@ -21,17 +23,21 @@ import org.jetbrains.kotlin.fir.visitors.* * DO NOT MODIFY IT MANUALLY */ -interface FirModifiableClass : FirClass, FirAbstractAnnotatedElement { +interface FirModifiableClass> : FirClass, FirAbstractAnnotatedElement { override val source: FirSourceElement? override val session: FirSession override var resolvePhase: FirResolvePhase + override var supertypesComputationStatus: SupertypesComputationStatus + override val symbol: FirClassSymbol override val classKind: ClassKind override val superTypeRefs: MutableList override val declarations: MutableList override val annotations: MutableList - override fun transformChildren(transformer: FirTransformer, data: D): FirModifiableClass + override fun transformChildren(transformer: FirTransformer, data: D): FirModifiableClass override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) + override fun replaceSupertypesComputationStatus(newSupertypesComputationStatus: SupertypesComputationStatus) + override fun replaceSuperTypeRefs(newSuperTypeRefs: List) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableRegularClass.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableRegularClass.kt index fc71c546b3b..e1108da8143 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableRegularClass.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableRegularClass.kt @@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.FirTypeParameter import org.jetbrains.kotlin.fir.declarations.SupertypesComputationStatus import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.fir.visitors.* @@ -26,7 +26,7 @@ import org.jetbrains.kotlin.fir.visitors.* * DO NOT MODIFY IT MANUALLY */ -interface FirModifiableRegularClass : FirRegularClass, FirModifiableClass, FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement { +interface FirModifiableRegularClass : FirRegularClass, FirModifiableClass, FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement { override val source: FirSourceElement? override val session: FirSession override var resolvePhase: FirResolvePhase @@ -37,7 +37,7 @@ interface FirModifiableRegularClass : FirRegularClass, FirModifiableClass, FirMo override var supertypesComputationStatus: SupertypesComputationStatus override val classKind: ClassKind override val declarations: MutableList - override val symbol: FirClassSymbol + override val symbol: FirRegularClassSymbol override var companionObject: FirRegularClass? override val superTypeRefs: MutableList override fun transformChildren(transformer: FirTransformer, data: D): FirModifiableRegularClass diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirSealedClassImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirSealedClassImpl.kt index b3c8a1c38de..ecd5557e3ed 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirSealedClassImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirSealedClassImpl.kt @@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.FirTypeParameter import org.jetbrains.kotlin.fir.declarations.SupertypesComputationStatus import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name @@ -34,7 +34,7 @@ class FirSealedClassImpl( override val name: Name, override var status: FirDeclarationStatus, override val classKind: ClassKind, - override val symbol: FirClassSymbol + override val symbol: FirRegularClassSymbol ) : FirSealedClass(), FirModifiableRegularClass, FirAbstractAnnotatedElement { override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR override val annotations: MutableList = mutableListOf() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt index d1b7d0220e6..66a4c5cccb0 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt @@ -33,8 +33,8 @@ class FirTypeAliasImpl( override var expandedTypeRef: FirTypeRef ) : FirTypeAlias(), FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement { override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR - override val typeParameters: MutableList = mutableListOf() override var supertypesComputationStatus: SupertypesComputationStatus = SupertypesComputationStatus.NOT_COMPUTED + override val typeParameters: MutableList = mutableListOf() override val annotations: MutableList = mutableListOf() init { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/ConeClassLookupTagWithFixedSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/ConeClassLookupTagWithFixedSymbol.kt new file mode 100644 index 00000000000..3d03417cd71 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/ConeClassLookupTagWithFixedSymbol.kt @@ -0,0 +1,15 @@ +/* + * 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.ConeClassLikeLookupTag +import org.jetbrains.kotlin.name.ClassId + +data class ConeClassLookupTagWithFixedSymbol( + override val classId: ClassId, + val symbol: FirClassSymbol<*> +) : ConeClassLikeLookupTag() { +} \ No newline at end of file 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 index 84e49156928..4c3fed07add 100644 --- 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 @@ -6,12 +6,11 @@ package org.jetbrains.kotlin.fir.symbols.impl import org.jetbrains.kotlin.fir.FirSymbolOwner -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.declarations.* import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag import org.jetbrains.kotlin.fir.symbols.ConeTypeAliasLookupTag import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName sealed class FirClassLikeSymbol( val classId: ClassId @@ -24,10 +23,18 @@ sealed class FirClassLikeSymbol( override fun hashCode(): Int = fir.hashCode() } -class FirClassSymbol(classId: ClassId) : FirClassLikeSymbol(classId) { - override fun toLookupTag(): ConeClassLikeLookupTag = ConeClassLikeLookupTagImpl(classId) +sealed class FirClassSymbol>(classId: ClassId) : FirClassLikeSymbol(classId) { + private val lookupTag = + if (classId.isLocal) ConeClassLookupTagWithFixedSymbol(classId, this) + else ConeClassLikeLookupTagImpl(classId) + + override fun toLookupTag(): ConeClassLikeLookupTag = lookupTag } +class FirRegularClassSymbol(classId: ClassId) : FirClassSymbol(classId) + +class FirAnonymousObjectSymbol : FirClassSymbol(ClassId(FqName.ROOT, FqName("anonymous"), true)) + class FirTypeAliasSymbol(classId: ClassId) : FirClassLikeSymbol(classId) { override fun toLookupTag(): TypeAliasLookupTagImpl = TypeAliasLookupTagImpl(classId) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultTransformer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultTransformer.kt index 33187374ba7..240999d73e4 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultTransformer.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultTransformer.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.fir.visitors +import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirEnumEntry import org.jetbrains.kotlin.fir.declarations.FirSealedClass import org.jetbrains.kotlin.fir.expressions.* diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt index 80b35266210..0b3b77e5e7e 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt @@ -33,8 +33,8 @@ import org.jetbrains.kotlin.fir.declarations.FirVariable import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.declarations.FirField -import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration +import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirSealedClass import org.jetbrains.kotlin.fir.declarations.FirTypeAlias @@ -234,12 +234,12 @@ abstract class FirTransformer : FirVisitor { - return transformElement(klass, data) + open fun > transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): CompositeTransformResult { + return transformElement(classLikeDeclaration, data) } - open fun > transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): CompositeTransformResult { - return transformElement(classLikeDeclaration, data) + open fun > transformClass(klass: FirClass, data: D): CompositeTransformResult { + return transformElement(klass, data) } open fun transformRegularClass(regularClass: FirRegularClass, data: D): CompositeTransformResult { @@ -674,12 +674,12 @@ abstract class FirTransformer : FirVisitor { - return transformClass(klass, data) + final override fun > visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): CompositeTransformResult { + return transformClassLikeDeclaration(classLikeDeclaration, data) } - final override fun > visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): CompositeTransformResult { - return transformClassLikeDeclaration(classLikeDeclaration, data) + final override fun > visitClass(klass: FirClass, data: D): CompositeTransformResult { + return transformClass(klass, data) } final override fun visitRegularClass(regularClass: FirRegularClass, data: D): CompositeTransformResult { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt index fd8e9bc3144..e0f4ee9bdd2 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt @@ -33,8 +33,8 @@ import org.jetbrains.kotlin.fir.declarations.FirVariable import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.declarations.FirField -import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration +import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirSealedClass import org.jetbrains.kotlin.fir.declarations.FirTypeAlias @@ -178,10 +178,10 @@ abstract class FirVisitor { open fun visitField(field: FirField, data: D): R = visitElement(field, data) - open fun visitClass(klass: FirClass, data: D): R = visitElement(klass, data) - open fun > visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): R = visitElement(classLikeDeclaration, data) + open fun > visitClass(klass: FirClass, data: D): R = visitElement(klass, data) + open fun visitRegularClass(regularClass: FirRegularClass, data: D): R = visitElement(regularClass, data) open fun visitSealedClass(sealedClass: FirSealedClass, data: D): R = visitElement(sealedClass, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt index 500926a89b0..9181f3151e6 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt @@ -33,8 +33,8 @@ import org.jetbrains.kotlin.fir.declarations.FirVariable import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.declarations.FirField -import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration +import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirSealedClass import org.jetbrains.kotlin.fir.declarations.FirTypeAlias @@ -232,14 +232,14 @@ abstract class FirVisitorVoid : FirVisitor() { visitElement(field) } - open fun visitClass(klass: FirClass) { - visitElement(klass) - } - open fun > visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration) { visitElement(classLikeDeclaration) } + open fun > visitClass(klass: FirClass) { + visitElement(klass) + } + open fun visitRegularClass(regularClass: FirRegularClass) { visitElement(regularClass) } @@ -672,14 +672,14 @@ abstract class FirVisitorVoid : FirVisitor() { visitField(field) } - final override fun visitClass(klass: FirClass, data: Nothing?) { - visitClass(klass) - } - final override fun > visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: Nothing?) { visitClassLikeDeclaration(classLikeDeclaration) } + final override fun > visitClass(klass: FirClass, data: Nothing?) { + visitClass(klass) + } + final override fun visitRegularClass(regularClass: FirRegularClass, data: Nothing?) { visitRegularClass(regularClass) } diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt index 32445142bbc..77bf3ef3522 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt @@ -40,11 +40,11 @@ object FirTreeBuilder : AbstractFirTreeBuilder() { val valueParameter = element("ValueParameter", Declaration, variable) val property = element("Property", Declaration, variable, controlFlowGraphOwner, typeParametersOwner, callableMemberDeclaration) val field = element("Field", Declaration, variable, callableMemberDeclaration) // TODO: add noImpl - val klass = element("Class", Declaration, declaration, statement, annotationContainer) - val classLikeDeclaration = element("ClassLikeDeclaration", Declaration, statement, memberDeclaration, symbolOwner, typeParametersOwner) - val regularClass = element("RegularClass", Declaration, namedDeclaration, classLikeDeclaration, klass) + val classLikeDeclaration = element("ClassLikeDeclaration", Declaration, declaration, statement, symbolOwner) + val klass = element("Class", Declaration, classLikeDeclaration, statement, annotationContainer) + val regularClass = element("RegularClass", Declaration, memberDeclaration, typeParametersOwner, klass) val sealedClass = element("SealedClass", Declaration, regularClass) - val typeAlias = element("TypeAlias", Declaration, classLikeDeclaration) + val typeAlias = element("TypeAlias", Declaration, classLikeDeclaration, memberDeclaration, typeParametersOwner) val enumEntry = element("EnumEntry", Declaration, regularClass) val function = element("Function", Declaration, callableDeclaration, controlFlowGraphOwner, targetElement, annotationContainer, typeParametersOwner, statement) diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt index 1b498dd6602..56fac0ae727 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt @@ -54,7 +54,7 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator() val modifiableClass = impl(klass, "FirModifiableClass") val modifiableRegularClass = impl(regularClass, "FirModifiableRegularClass") { - parents += modifiableClass + parents += modifiableClass.withArg(regularClass) parents += modifiableTypeParametersOwner } @@ -68,15 +68,16 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator() impl(sealedClass, config = regularClassConfig) impl(anonymousObject) { - parents += modifiableClass + parents += modifiableClass.withArg(anonymousObject) default("classKind") { value = "ClassKind.OBJECT" withGetter = true } + defaultSupertypesComputationStatus() } impl(enumEntry) { - parents += modifiableClass + parents += modifiableClass.withArg(regularClass) parents += modifiableTypeParametersOwner default("status", "FirDeclarationStatusImpl(Visibilities.UNKNOWN, Modality.FINAL)") default("classKind") { diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt index b6f14c971f5..bc002276629 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt @@ -199,13 +199,6 @@ object NodeConfigurator : AbstractFieldConfigurator() { needTransformOtherChildren() } - klass.configure { - +classKind - +superTypeRefs(withReplace = true) - +declarations - +annotations - } - classLikeDeclaration.configure { withArg("F", "FirClassLikeDeclaration") parentArg(symbolOwner, "F", "F") @@ -213,13 +206,28 @@ object NodeConfigurator : AbstractFieldConfigurator() { +symbol("FirClassLikeSymbol", "F") } + klass.configure { + withArg("F", "FirClass") + parentArg(classLikeDeclaration, "F", "F") + +symbol("FirClassSymbol", "F") + +classKind + +superTypeRefs(withReplace = true) + +declarations + +annotations + } + regularClass.configure { - parentArg(classLikeDeclaration, "F", regularClass) - +symbol("FirClassSymbol") + parentArg(klass, "F", regularClass) + +symbol("FirRegularClassSymbol") +field("companionObject", regularClass, nullable = true) +superTypeRefs(withReplace = true) } + anonymousObject.configure { + parentArg(klass, "F", anonymousObject) + +symbol("FirAnonymousObjectSymbol") + } + sealedClass.configure { +fieldList("inheritors", classIdType, withReplace = true) } diff --git a/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt b/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt index f70e6bfb56d..bf71f3d0d57 100644 --- a/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt +++ b/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt @@ -431,7 +431,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() { val fir = symbolProvider.getClassLikeSymbolByFqName(it)?.fir if (fir is FirClass) { data.append(fir.classKind.name.toLowerCase()).append(" ") - data.append(fir.name) + data.append((fir as? FirRegularClass)?.name ?: Name.special("")) if (fir.superTypeRefs.any { it.render() != "kotlin/Any" }) { data.append(": ") fir.superTypeRefs.joinTo(data, separator = ", ") { typeRef -> typeRef.render() }