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

2019-10-24 12:58:05 +03:00
parent 1e4f07ebc7
commit e1c889e871
63 changed files with 326 additions and 240 deletions
@@ -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
 }

 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -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
 }

 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -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 }
    }
@@ -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) {
@@ -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)
@@ -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),
@@ -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) {