azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make FirClass a kind of FirClassLikeDeclaration, introduce FirRegularClass/AnonymousObject symbols

Browse Source
This commit is contained in:
Mikhail Glukhikh
2019-10-24 12:58:05 +03:00
parent 1e4f07ebc7
commit e1c889e871
63 changed files with 326 additions and 240 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt
+1 -1
View File
@@ -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)
}
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrCallableCache.kt
+3 -3
View File
@@ -17,7 +17,7 @@ class Fir2IrCallableCache {
private val variableCache = mutableMapOf<FirVariable<*>, IrVariable>()
private val localClassCache = mutableMapOf<FirClass, IrClass>()
private val localClassCache = mutableMapOf<FirClass<*>, IrClass>()
private val localFunctionCache = mutableMapOf<FirFunction<*>, 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
}
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt
+24 -21
View File
@@ -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("<anonymous>"),
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)
}
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrLocalStorage.kt
+2 -2
View File
@@ -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)
}
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt
+9 -8
View File
@@ -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<Name> = mutableListOf()): List<Name> {
private fun FirClass<*>.collectCallableNamesFromSupertypes(result: MutableList<Name> = mutableListOf()): List<Name> {
for (superTypeRef in superTypeRefs) {
superTypeRef.collectCallableNamesFromThisAndSupertypes(result)
}
return result
}
private fun FirClass.getPrimaryConstructorIfAny(): FirConstructor? =
private fun FirClass<*>.getPrimaryConstructorIfAny(): FirConstructor? =
declarations.filterIsInstance<FirConstructor>().firstOrNull()?.takeIf { it.isPrimary }
private fun IrClass.addFakeOverrides(klass: FirClass, processedCallableNames: MutableList<Name>) {
private fun IrClass.addFakeOverrides(klass: FirClass<*>, processedCallableNames: MutableList<Name>) {
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
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt
+1 -1
View File
@@ -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
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt.183
+1 -1
View File
@@ -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
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt
+16 -16
View File
@@ -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<FirRegularClassSymbol>() {
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<FirClassLikeSymbol<*>>
): 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<FirRegularClass> {
return classCache.values
.filterIsInstance<FirClassSymbol>()
.filterIsInstance<FirRegularClassSymbol>()
.filter { it.classId.relativeClassName.parent().isRoot }
.map { it.fir }
}
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt
+2 -2
View File
@@ -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) {
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt
+4 -4
View File
@@ -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<FirRegularClass> {
override var status: FirDeclarationStatusImpl = FirDeclarationStatusImpl(visibility, modality)
override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
@@ -80,7 +80,7 @@ class FirJavaClass internal constructor(
superTypeRefs.forEach { it.accept(visitor, data) }
}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableClass {
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirJavaClass {
declarations.transformInplace(transformer, data)
annotations.transformInplace(transformer, data)
typeParameters.transformInplace(transformer, data)
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt
+6 -6
View File
@@ -57,8 +57,8 @@ class KotlinDeserializedJvmSymbolsProvider(
private val javaSymbolProvider: JavaSymbolProvider,
private val kotlinClassFinder: KotlinClassFinder,
private val javaClassFinder: JavaClassFinder
) : AbstractFirSymbolProvider() {
private val classesCache = HashMap<ClassId, FirClassSymbol>()
) : AbstractFirSymbolProvider<FirClassLikeSymbol<*>>() {
private val classesCache = HashMap<ClassId, FirRegularClassSymbol>()
private val typeAliasCache = HashMap<ClassId, FirTypeAliasSymbol?>()
private val packagePartsCache = HashMap<FqName, Collection<PackagePartsCacheData>>()
@@ -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),
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt
+2 -2
View File
@@ -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) {
compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt
+4 -4
View File
@@ -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
compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt
+5 -5
View File
@@ -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
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt
+2 -1
View File
@@ -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<FirExpression>()
if (proto.argumentCount != 0 && firAnnotationClass?.classKind == ClassKind.ANNOTATION_CLASS) {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt
+4 -3
View File
@@ -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(
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt
+3 -1
View File
@@ -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<FirTypeParameterSymbol> = fir.typeParameters.map { it.symbol }
fun FirClassLikeSymbol<*>.typeParameters(): List<FirTypeParameterSymbol> =
(fir as? FirTypeParametersOwner)?.typeParameters?.map { it.symbol }.orEmpty()
fun simpleType(proto: ProtoBuf.Type): ConeLookupTagBasedType? {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/AbstractFirSymbolProvider.kt
+5 -8
View File
@@ -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<ClassId, FirClassLikeSymbol<*>?>()
abstract class AbstractFirSymbolProvider<C : FirClassLikeSymbol<*>> : FirSymbolProvider() {
protected val classCache = HashMap<ClassId, C?>()
protected val topLevelCallableCache = HashMap<CallableId, List<FirCallableSymbol<*>>>()
protected val packageCache = HashMap<FqName, FqName?>()
@@ -29,15 +26,15 @@ abstract class AbstractFirSymbolProvider : FirSymbolProvider() {
}
}
protected inline fun <K, V : Any?, T> MutableMap<K, V>.lookupCacheOrCalculateWithPostCompute(
key: K, crossinline l: (K) -> Pair<V, T>, postCompute: (V, T) -> Unit
protected inline fun <K, V : Any, T> MutableMap<K, V?>.lookupCacheOrCalculateWithPostCompute(
key: K, crossinline l: (K) -> Pair<V?, T>, 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
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt
+4 -1
View File
@@ -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<ConeKotlinTypeProjection>, isNullable: Boolean): ConeLookupTagBasedType {
fun ConeClassLikeLookupTag.constructClassType(typeArguments: Array<out ConeKotlinTypeProjection>, isNullable: Boolean): ConeLookupTagBasedType {
return ConeClassTypeImpl(this, typeArguments, isNullable)
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt
+2 -5
View File
@@ -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<N
val classes =
lookupSuperTypes(this, lookupInterfaces = true, deep = true, useSiteSession = session)
.mapNotNullTo(mutableListOf(this)) {
(session.firSymbolProvider.getSymbolByLookupTag(it.lookupTag) as? FirClassSymbol)?.fir
(session.firSymbolProvider.getSymbolByLookupTag(it.lookupTag) as? FirRegularClassSymbol)?.fir
}
val samCandidateNames = mutableSetOf<Name>()
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt
+22 -11
View File
@@ -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<FirScope>()
data class SubstitutionScopeKey(val type: ConeClassLikeType) : ScopeSessionKey<FirClassSubstitutionScope>() {}
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<FirTypeParameterSymbol, ConeKotlinType>
@@ -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
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt
+7 -5
View File
@@ -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<S : AbstractFirBasedSymbol<*>>(
}
class ImplicitDispatchReceiverValue(
boundSymbol: FirClassSymbol,
boundSymbol: FirClassSymbol<*>,
type: ConeKotlinType,
symbolProvider: FirSymbolProvider,
useSiteSession: FirSession,
scopeSession: ScopeSession
) : ImplicitReceiverValue<FirClassSymbol>(boundSymbol, type, useSiteSession, scopeSession) {
val implicitCompanionScope: FirScope? = boundSymbol.fir.companionObject?.let { companionObject ->
) : ImplicitReceiverValue<FirClassSymbol<*>>(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)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirTowerResolver.kt
+3 -2
View File
@@ -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
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerLevels.kt
+4 -5
View File
@@ -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)
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirDependenciesSymbolProviderImpl.kt
+1 -1
View File
@@ -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<FirClassLikeSymbol<*>>() {
private val dependencyProviders by lazy {
val moduleInfo = session.moduleInfo ?: return@lazy emptyList()
moduleInfo.dependenciesWithoutSelf().mapNotNull {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirLibrarySymbolProviderImpl.kt
+7 -7
View File
@@ -72,15 +72,15 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
).memberDeserializer
}
val lookup = mutableMapOf<ClassId, FirClassSymbol>()
val lookup = mutableMapOf<ClassId, FirRegularClassSymbol>()
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<Int, FirClassSymbol>()
private val fictitiousFunctionSymbols = mutableMapOf<Int, FirRegularClassSymbol>()
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,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt
+3 -5
View File
@@ -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
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt
+1 -4
View File
@@ -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
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsTransformer.kt
+2 -1
View File
@@ -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<Nothing?>() {
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
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt
+2 -2
View File
@@ -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)
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt
+2 -1
View File
@@ -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
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt
+7 -3
View File
@@ -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<Name, List<FirCallableSymbol<*>>> = run {
val result = mutableMapOf<Name, MutableList<FirCallableSymbol<*>>>()
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 -> {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLocalScope.kt
+1 -1
View File
@@ -16,7 +16,7 @@ class FirLocalScope : FirScope() {
val properties = mutableMapOf<Name, FirVariableSymbol<*>>()
val functions = mutableMapOf<Name, FirFunctionSymbol<*>>()
val classes = mutableMapOf<Name, FirClassSymbol>()
val classes = mutableMapOf<Name, FirRegularClassSymbol>()
fun storeDeclaration(declaration: FirNamedDeclaration) {
when (declaration) {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirMemberScopeProvider.kt
+7 -6
View File
@@ -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<FirRegularClass, FirClassDeclaredMemberScope>()
private val nestedClassifierCache = mutableMapOf<FirRegularClass, FirNestedClassifierScope>()
private val declaredMemberCache = mutableMapOf<FirClass<*>, FirClassDeclaredMemberScope>()
private val nestedClassifierCache = mutableMapOf<FirClass<*>, FirNestedClassifierScope>()
private val selfImportingCache = mutableMapOf<FqName, FirSelfImportingScope>()
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
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt
+5 -4
View File
@@ -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<Name, FirClassSymbol> = run {
val result = mutableMapOf<Name, FirClassSymbol>()
private val classIndex: Map<Name, FirRegularClassSymbol> = run {
val result = mutableMapOf<Name, FirRegularClassSymbol>()
for (declaration in klass.declarations) {
if (declaration is FirRegularClass) {
result[declaration.name] = declaration.symbol
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt
+8 -6
View File
@@ -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
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/FirCorrespondingSupertypesCache.kt
+6 -4
View File
@@ -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<FirClassLikeSymbol<*>, List<ConeClassLikeType>>? {
val resultingMap = HashMap<FirClassLikeSymbol<*>, List<ConeClassLikeType>>()
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
)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt
+1 -1
View File
@@ -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) {
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt
+4 -1
View File
@@ -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<FirAnonymousObject>, 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<FirTypeRef>
abstract override val declarations: List<FirDeclaration>
abstract override val annotations: List<FirAnnotationCall>
abstract override val typeRef: FirTypeRef
abstract override val symbol: FirAnonymousObjectSymbol
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnonymousObject(this, data)
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClass.kt
+4 -1
View File
@@ -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<F : FirClass<F>> : FirClassLikeDeclaration<F>, FirStatement, FirAnnotationContainer {
override val source: FirSourceElement?
override val session: FirSession
override val resolvePhase: FirResolvePhase
override val supertypesComputationStatus: SupertypesComputationStatus
override val symbol: FirClassSymbol<F>
val classKind: ClassKind
val superTypeRefs: List<FirTypeRef>
val declarations: List<FirDeclaration>
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClassLikeDeclaration.kt
+2 -6
View File
@@ -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<F : FirClassLikeDeclaration<F>> : FirStatement, FirMemberDeclaration, FirSymbolOwner<F>, FirTypeParametersOwner {
interface FirClassLikeDeclaration<F : FirClassLikeDeclaration<F>> : FirDeclaration, FirStatement, FirSymbolOwner<F> {
override val source: FirSourceElement?
override val annotations: List<FirAnnotationCall>
override val session: FirSession
override val resolvePhase: FirResolvePhase
override val name: Name
override val typeParameters: List<FirTypeParameter>
override val status: FirDeclarationStatus
override val annotations: List<FirAnnotationCall>
val supertypesComputationStatus: SupertypesComputationStatus
override val symbol: FirClassLikeSymbol<F>
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt
+10 -1
View File
@@ -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<ConeClassLikeType>() }
val FirClassSymbol<*>.superConeTypes
get() = when (this) {
is FirRegularClassSymbol -> fir.superConeTypes
is FirAnonymousObjectSymbol -> fir.superConeTypes
}
val FirClass<*>.superConeTypes get() = superTypeRefs.mapNotNull { it.coneTypeSafe<ConeClassLikeType>() }
fun FirRegularClass.collectEnumEntries(): Collection<FirEnumEntry> {
assert(classKind == ClassKind.ENUM_CLASS)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt
+2 -2
View File
@@ -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<FirDeclaration>
abstract override val symbol: FirClassSymbol
abstract override val symbol: FirRegularClassSymbol
abstract override val companionObject: FirRegularClass?
abstract override val superTypeRefs: List<FirTypeRef>
abstract val arguments: List<FirExpression>
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirRegularClass.kt
+3 -3
View File
@@ -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<FirRegularClass>, FirClass {
interface FirRegularClass : FirMemberDeclaration, FirTypeParametersOwner, FirClass<FirRegularClass> {
override val source: FirSourceElement?
override val session: FirSession
override val resolvePhase: FirResolvePhase
@@ -30,7 +30,7 @@ interface FirRegularClass : FirNamedDeclaration, FirClassLikeDeclaration<FirRegu
override val supertypesComputationStatus: SupertypesComputationStatus
override val classKind: ClassKind
override val declarations: List<FirDeclaration>
override val symbol: FirClassSymbol
override val symbol: FirRegularClassSymbol
val companionObject: FirRegularClass?
override val superTypeRefs: List<FirTypeRef>
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirSealedClass.kt
+2 -2
View File
@@ -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<FirDeclaration>
abstract override val symbol: FirClassSymbol
abstract override val symbol: FirRegularClassSymbol
abstract override val companionObject: FirRegularClass?
abstract override val superTypeRefs: List<FirTypeRef>
abstract val inheritors: List<ClassId>
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt
+2 -2
View File
@@ -19,14 +19,14 @@ import org.jetbrains.kotlin.fir.visitors.*
* DO NOT MODIFY IT MANUALLY
*/
abstract class FirTypeAlias : FirPureAbstractElement(), FirClassLikeDeclaration<FirTypeAlias> {
abstract class FirTypeAlias : FirPureAbstractElement(), FirClassLikeDeclaration<FirTypeAlias>, 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<FirTypeParameter>
abstract override val status: FirDeclarationStatus
abstract override val supertypesComputationStatus: SupertypesComputationStatus
abstract override val symbol: FirTypeAliasSymbol
abstract val expandedTypeRef: FirTypeRef
abstract override val annotations: List<FirAnnotationCall>
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt
+14 -2
View File
@@ -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<FirAnonymousObject>, 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<FirTypeRef> = mutableListOf()
override val declarations: MutableList<FirDeclaration> = mutableListOf()
override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null)
init {
symbol.bind(this)
}
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, 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<FirTypeRef>) {
superTypeRefs.clear()
superTypeRefs.addAll(newSuperTypeRefs)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt
+2 -2
View File
@@ -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<FirAnnotationCall> = mutableListOf()
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt
+3 -3
View File
@@ -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<FirRegularClass>, FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement {
override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableClass.kt
+8 -2
View File
@@ -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<F : FirClass<F>> : FirClass<F>, FirAbstractAnnotatedElement {
override val source: FirSourceElement?
override val session: FirSession
override var resolvePhase: FirResolvePhase
override var supertypesComputationStatus: SupertypesComputationStatus
override val symbol: FirClassSymbol<F>
override val classKind: ClassKind
override val superTypeRefs: MutableList<FirTypeRef>
override val declarations: MutableList<FirDeclaration>
override val annotations: MutableList<FirAnnotationCall>
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableClass
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableClass<F>
override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
override fun replaceSupertypesComputationStatus(newSupertypesComputationStatus: SupertypesComputationStatus)
override fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>)
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableRegularClass.kt
+3 -3
View File
@@ -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<FirRegularClass>, 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<FirDeclaration>
override val symbol: FirClassSymbol
override val symbol: FirRegularClassSymbol
override var companionObject: FirRegularClass?
override val superTypeRefs: MutableList<FirTypeRef>
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableRegularClass
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirSealedClassImpl.kt
+2 -2
View File
@@ -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<FirAnnotationCall> = mutableListOf()
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt
+1 -1
View File
@@ -33,8 +33,8 @@ class FirTypeAliasImpl(
override var expandedTypeRef: FirTypeRef
) : FirTypeAlias(), FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement {
override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
override var supertypesComputationStatus: SupertypesComputationStatus = SupertypesComputationStatus.NOT_COMPUTED
override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
init {
compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/ConeClassLookupTagWithFixedSymbol.kt
+15
View File
@@ -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() {
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt
+12 -5
View File
@@ -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<D>(
val classId: ClassId
@@ -24,10 +23,18 @@ sealed class FirClassLikeSymbol<D>(
override fun hashCode(): Int = fir.hashCode()
}
class FirClassSymbol(classId: ClassId) : FirClassLikeSymbol<FirRegularClass>(classId) {
override fun toLookupTag(): ConeClassLikeLookupTag = ConeClassLikeLookupTagImpl(classId)
sealed class FirClassSymbol<C : FirClass<C>>(classId: ClassId) : FirClassLikeSymbol<C>(classId) {
private val lookupTag =
if (classId.isLocal) ConeClassLookupTagWithFixedSymbol(classId, this)
else ConeClassLikeLookupTagImpl(classId)
override fun toLookupTag(): ConeClassLikeLookupTag = lookupTag
}
class FirRegularClassSymbol(classId: ClassId) : FirClassSymbol<FirRegularClass>(classId)
class FirAnonymousObjectSymbol : FirClassSymbol<FirAnonymousObject>(ClassId(FqName.ROOT, FqName("anonymous"), true))
class FirTypeAliasSymbol(classId: ClassId) : FirClassLikeSymbol<FirTypeAlias>(classId) {
override fun toLookupTag(): TypeAliasLookupTagImpl = TypeAliasLookupTagImpl(classId)
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultTransformer.kt
+1
View File
@@ -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.*
compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt
+9 -9
View File
@@ -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<in D> : FirVisitor<CompositeTransformResult<FirEle
return transformElement(field, data)
}
open fun transformClass(klass: FirClass, data: D): CompositeTransformResult<FirStatement> {
return transformElement(klass, data)
open fun <F : FirClassLikeDeclaration<F>> transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): CompositeTransformResult<FirStatement> {
return transformElement(classLikeDeclaration, data)
}
open fun <F : FirClassLikeDeclaration<F>> transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): CompositeTransformResult<FirDeclaration> {
return transformElement(classLikeDeclaration, data)
open fun <F : FirClass<F>> transformClass(klass: FirClass<F>, data: D): CompositeTransformResult<FirStatement> {
return transformElement(klass, data)
}
open fun transformRegularClass(regularClass: FirRegularClass, data: D): CompositeTransformResult<FirStatement> {
@@ -674,12 +674,12 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
return transformField(field, data)
}
final override fun visitClass(klass: FirClass, data: D): CompositeTransformResult<FirStatement> {
return transformClass(klass, data)
final override fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): CompositeTransformResult<FirStatement> {
return transformClassLikeDeclaration(classLikeDeclaration, data)
}
final override fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): CompositeTransformResult<FirDeclaration> {
return transformClassLikeDeclaration(classLikeDeclaration, data)
final override fun <F : FirClass<F>> visitClass(klass: FirClass<F>, data: D): CompositeTransformResult<FirStatement> {
return transformClass(klass, data)
}
final override fun visitRegularClass(regularClass: FirRegularClass, data: D): CompositeTransformResult<FirStatement> {
compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt
+3 -3
View File
@@ -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<out R, in D> {
open fun visitField(field: FirField, data: D): R = visitElement(field, data)
open fun visitClass(klass: FirClass, data: D): R = visitElement(klass, data)
open fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): R = visitElement(classLikeDeclaration, data)
open fun <F : FirClass<F>> visitClass(klass: FirClass<F>, 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)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt
+9 -9
View File
@@ -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<Unit, Nothing?>() {
visitElement(field)
}
open fun visitClass(klass: FirClass) {
visitElement(klass)
}
open fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>) {
visitElement(classLikeDeclaration)
}
open fun <F : FirClass<F>> visitClass(klass: FirClass<F>) {
visitElement(klass)
}
open fun visitRegularClass(regularClass: FirRegularClass) {
visitElement(regularClass)
}
@@ -672,14 +672,14 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
visitField(field)
}
final override fun visitClass(klass: FirClass, data: Nothing?) {
visitClass(klass)
}
final override fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: Nothing?) {
visitClassLikeDeclaration(classLikeDeclaration)
}
final override fun <F : FirClass<F>> visitClass(klass: FirClass<F>, data: Nothing?) {
visitClass(klass)
}
final override fun visitRegularClass(regularClass: FirRegularClass, data: Nothing?) {
visitRegularClass(regularClass)
}
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt
+4 -4
View File
@@ -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)
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt
+4 -3
View File
@@ -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") {
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt
+17 -9
View File
@@ -199,13 +199,6 @@ object NodeConfigurator : AbstractFieldConfigurator() {
needTransformOtherChildren()
}
klass.configure {
+classKind
+superTypeRefs(withReplace = true)
+declarations
+annotations
}
classLikeDeclaration.configure {
withArg("F", "FirClassLikeDeclaration<F>")
parentArg(symbolOwner, "F", "F")
@@ -213,13 +206,28 @@ object NodeConfigurator : AbstractFieldConfigurator() {
+symbol("FirClassLikeSymbol", "F")
}
klass.configure {
withArg("F", "FirClass<F>")
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)
}
compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt
+1 -1
View File
@@ -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("<anonymous>"))
if (fir.superTypeRefs.any { it.render() != "kotlin/Any" }) {
data.append(": ")
fir.superTypeRefs.joinTo(data, separator = ", ") { typeRef -> typeRef.render() }