diff --git a/analysis/symbol-light-classes/build.gradle.kts b/analysis/symbol-light-classes/build.gradle.kts index d849f8e8f17..f655dc27d42 100644 --- a/analysis/symbol-light-classes/build.gradle.kts +++ b/analysis/symbol-light-classes/build.gradle.kts @@ -33,4 +33,9 @@ projectTest(jUnitMode = JUnitMode.JUnit5) { useJUnitPlatform() } +tasks.withType().configureEach { + kotlinOptions.freeCompilerArgs += "-Xcontext-receivers" +} + + testsJar() diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/FirLightTypeParameterListForSymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/FirLightTypeParameterListForSymbol.kt index 8fe5eb08f25..c99655ba874 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/FirLightTypeParameterListForSymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/FirLightTypeParameterListForSymbol.kt @@ -13,6 +13,9 @@ import org.jetbrains.kotlin.idea.KotlinLanguage import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithTypeParameters import org.jetbrains.kotlin.light.classes.symbol.elements.FirLightTypeParameter +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession + +context(KtAnalysisSession) internal class FirLightTypeParameterListForSymbol( internal val owner: PsiTypeParameterListOwner, private val symbolWithTypeParameterList: KtSymbolWithTypeParameters, diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/KotlinAsJavaFirSupport.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/KotlinAsJavaFirSupport.kt index 2a97d2270a7..0df122ee21e 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/KotlinAsJavaFirSupport.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/KotlinAsJavaFirSupport.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.light.classes.symbol import com.intellij.openapi.project.Project import com.intellij.psi.PsiClass import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.decompiled.light.classes.DecompiledLightClassesFactory import org.jetbrains.kotlin.analysis.project.structure.KtLibraryModule import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule @@ -19,6 +20,7 @@ import org.jetbrains.kotlin.asJava.classes.KtFakeLightClass import org.jetbrains.kotlin.asJava.classes.KtLightClass import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName import org.jetbrains.kotlin.light.classes.symbol.caches.SymbolLightClassFacadeCache +import org.jetbrains.kotlin.light.classes.symbol.classes.analyseForLightClasses import org.jetbrains.kotlin.light.classes.symbol.classes.getOrCreateFirLightClass import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName @@ -129,12 +131,15 @@ class KotlinAsJavaFirSupport(private val project: Project) : KotlinAsJavaSupport TODO("Not implemented") private fun getFacadeClassesForFiles(facadeFqName: FqName, allFiles: Collection): Collection { + if (allFiles.isEmpty()) return emptyList() val filesByModule = allFiles.groupBy { it.getKtModule(project) } val lightClassFacadeCache = project.getService(SymbolLightClassFacadeCache::class.java) - return filesByModule.values.mapNotNull { files -> - lightClassFacadeCache.getOrCreateSymbolLightFacade(files, facadeFqName) + return filesByModule.mapNotNull { (module, files) -> + analyseForLightClasses(module) { + lightClassFacadeCache.getOrCreateSymbolLightFacade(files, facadeFqName) + } } } } diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/annotations/annotationsUtils.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/annotations/annotationsUtils.kt index 9d833f404d9..10a54b44b5a 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/annotations/annotationsUtils.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/annotations/annotationsUtils.kt @@ -5,13 +5,13 @@ package org.jetbrains.kotlin.light.classes.symbol -import com.intellij.openapi.project.Project import com.intellij.psi.CommonClassNames.JAVA_LANG_ANNOTATION_RETENTION import com.intellij.psi.PsiAnnotation import com.intellij.psi.PsiClass import com.intellij.psi.PsiElement import org.jetbrains.annotations.NotNull import org.jetbrains.annotations.Nullable +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.annotations.annotations import org.jetbrains.kotlin.resolve.deprecation.DeprecationLevelValue import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget @@ -49,18 +49,17 @@ internal fun KtAnnotatedSymbol.getJvmNameFromAnnotation(annotationUseSiteTarget: } } +context(KtAnalysisSession) internal fun isHiddenByDeprecation( - project: Project, symbol: KtAnnotatedSymbol, annotationUseSiteTarget: AnnotationUseSiteTarget? = null ): Boolean { - return project.analyzeWithSymbolAsContext(symbol) { - symbol.getDeprecationStatus(annotationUseSiteTarget)?.deprecationLevel == DeprecationLevelValue.HIDDEN - } + return symbol.getDeprecationStatus(annotationUseSiteTarget)?.deprecationLevel == DeprecationLevelValue.HIDDEN } -internal fun KtAnnotatedSymbol.isHiddenOrSynthetic(project: Project, annotationUseSiteTarget: AnnotationUseSiteTarget? = null) = - isHiddenByDeprecation(project, this, annotationUseSiteTarget) || hasJvmSyntheticAnnotation(annotationUseSiteTarget) +context(KtAnalysisSession) +internal fun KtAnnotatedSymbol.isHiddenOrSynthetic(annotationUseSiteTarget: AnnotationUseSiteTarget? = null) = + isHiddenByDeprecation(this, annotationUseSiteTarget) || hasJvmSyntheticAnnotation(annotationUseSiteTarget) internal fun KtAnnotatedSymbol.hasJvmFieldAnnotation(): Boolean = hasAnnotation(JVM_FIELD_ANNOTATION_CLASS_ID, null) diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/caches/SymbolLightClassFacadeCache.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/caches/SymbolLightClassFacadeCache.kt index 4b20cd9b87e..e566313787a 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/caches/SymbolLightClassFacadeCache.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/caches/SymbolLightClassFacadeCache.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.light.classes.symbol.caches import com.intellij.openapi.project.Project +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.decompiled.light.classes.DecompiledLightClassesFactory import org.jetbrains.kotlin.analysis.decompiler.psi.file.KtClsFile import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModificationTracker @@ -14,6 +15,7 @@ import org.jetbrains.kotlin.analysis.utils.collections.ConcurrentMapBasedCache import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName import org.jetbrains.kotlin.light.classes.symbol.FirLightClassForFacade +import org.jetbrains.kotlin.light.classes.symbol.classes.analyseForLightClasses import org.jetbrains.kotlin.light.classes.symbol.decompiled.KtLightClassForDecompiledFacade import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.KtClassOrObject @@ -47,7 +49,9 @@ class SymbolLightClassFacadeCache(private val project: Project) { val firstFile = ktFiles.first() return when { ktFiles.none { it.isCompiled } -> - return FirLightClassForFacade(firstFile.manager, facadeClassFqName, ktFiles) + analyseForLightClasses(firstFile) { + FirLightClassForFacade(firstFile.manager, facadeClassFqName, ktFiles) + } ktFiles.all { it.isCompiled } -> { val file = ktFiles.firstOrNull { it.javaFileFacadeFqName == facadeClassFqName } as? KtClsFile ?: error("Can't find the representative decompiled file for $facadeClassFqName") diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightAnnotationClassSymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightAnnotationClassSymbol.kt index 93ef5ccf732..d56668630c9 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightAnnotationClassSymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightAnnotationClassSymbol.kt @@ -15,7 +15,9 @@ import org.jetbrains.kotlin.asJava.elements.KtLightMethod import org.jetbrains.kotlin.analysis.api.symbols.* import org.jetbrains.kotlin.analysis.api.symbols.markers.isPrivateOrPrivateToThis import org.jetbrains.kotlin.light.classes.symbol.classes.createMethods +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession +context(KtAnalysisSession) internal class FirLightAnnotationClassSymbol( private val classOrObjectSymbol: KtNamedClassOrObjectSymbol, manager: PsiManager @@ -36,17 +38,12 @@ internal class FirLightAnnotationClassSymbol( override fun getOwnFields(): List = _ownFields private val _ownMethods: List by lazyPub { - val result = mutableListOf() + val visibleDeclarations = classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols() + .filterNot { it is KtFunctionSymbol && it.visibility.isPrivateOrPrivateToThis() } + .filterNot { it is KtConstructorSymbol } - analyzeWithSymbolAsContext(classOrObjectSymbol) { - val visibleDeclarations = classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols() - .filterNot { it is KtFunctionSymbol && it.visibility.isPrivateOrPrivateToThis() } - .filterNot { it is KtConstructorSymbol } - - createMethods(visibleDeclarations, result) - } - + createMethods(visibleDeclarations, result) result } diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightAnonymousClassForSymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightAnonymousClassForSymbol.kt index ec43586e6ad..84d96cc90a6 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightAnonymousClassForSymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightAnonymousClassForSymbol.kt @@ -11,6 +11,7 @@ import com.intellij.psi.impl.PsiClassImplUtil import com.intellij.psi.search.SearchScope import com.intellij.psi.stubs.IStubElementType import com.intellij.psi.stubs.StubElement +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.lifetime.isValid import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.asJava.elements.KtLightField @@ -24,6 +25,7 @@ import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.debugText.getDebugText import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub +context(KtAnalysisSession) internal class FirLightAnonymousClassForSymbol( private val anonymousObjectSymbol: KtAnonymousObjectSymbol, manager: PsiManager @@ -51,16 +53,12 @@ internal class FirLightAnonymousClassForSymbol( override fun getOwnMethods(): List = _ownMethods private val _ownMethods: List by lazyPub { - val result = mutableListOf() - analyzeWithSymbolAsContext(anonymousObjectSymbol) { - val declaredMemberScope = anonymousObjectSymbol.getDeclaredMemberScope() + val declaredMemberScope = anonymousObjectSymbol.getDeclaredMemberScope() - createMethods(declaredMemberScope.getCallableSymbols(), result) - - createConstructors(declaredMemberScope.getConstructors(), result) - } + createMethods(declaredMemberScope.getCallableSymbols(), result) + createConstructors(declaredMemberScope.getConstructors(), result) result } @@ -69,20 +67,18 @@ internal class FirLightAnonymousClassForSymbol( val result = mutableListOf() val nameGenerator = FirLightField.FieldNameGenerator() - analyzeWithSymbolAsContext(anonymousObjectSymbol) { - anonymousObjectSymbol.getDeclaredMemberScope().getCallableSymbols() - .filterIsInstance() - .forEach { propertySymbol -> - createField( - propertySymbol, - nameGenerator, - isTopLevel = false, - forceStatic = false, - takePropertyVisibility = propertySymbol.hasJvmFieldAnnotation(), - result - ) - } - } + anonymousObjectSymbol.getDeclaredMemberScope().getCallableSymbols() + .filterIsInstance() + .forEach { propertySymbol -> + createField( + propertySymbol, + nameGenerator, + isTopLevel = false, + forceStatic = false, + takePropertyVisibility = propertySymbol.hasJvmFieldAnnotation(), + result + ) + } result } diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassBase.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassBase.kt index 6f7cf663a8f..5eed3830c48 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassBase.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassBase.kt @@ -19,6 +19,7 @@ import com.intellij.psi.util.CachedValueProvider import com.intellij.psi.util.PsiUtil import org.jetbrains.annotations.NonNls import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModificationTracker import org.jetbrains.kotlin.asJava.classes.* @@ -26,6 +27,7 @@ import org.jetbrains.kotlin.idea.KotlinLanguage import org.jetbrains.kotlin.light.classes.symbol.classes.checkIsInheritor import javax.swing.Icon +context(KtAnalysisSession) abstract class FirLightClassBase protected constructor( manager: PsiManager ) : LightElement(manager, KotlinLanguage.INSTANCE), PsiClass, KtExtensibleLightClass { diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForClassOrObjectSymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForClassOrObjectSymbol.kt index c5ef4a25dda..5c632173421 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForClassOrObjectSymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForClassOrObjectSymbol.kt @@ -12,11 +12,12 @@ import com.intellij.psi.search.SearchScope import com.intellij.psi.stubs.IStubElementType import com.intellij.psi.stubs.StubElement import org.jetbrains.annotations.NonNls +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.symbols.* +import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind import org.jetbrains.kotlin.asJava.classes.getOutermostClassOrObject import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.asJava.elements.KtLightField -import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind import org.jetbrains.kotlin.asJava.elements.KtLightMethod import org.jetbrains.kotlin.light.classes.symbol.classes.createInnerClasses import org.jetbrains.kotlin.light.classes.symbol.classes.createMethods @@ -31,6 +32,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.applyIf import org.jetbrains.kotlin.utils.addToStdlib.ifFalse import org.jetbrains.kotlin.utils.addToStdlib.ifTrue +context(KtAnalysisSession) internal abstract class FirLightClassForClassOrObjectSymbol( private val classOrObjectSymbol: KtNamedClassOrObjectSymbol, manager: PsiManager @@ -90,22 +92,20 @@ internal abstract class FirLightClassForClassOrObjectSymbol( protected fun addMethodsFromCompanionIfNeeded(result: MutableList) { classOrObjectSymbol.companionObject?.run { - analyzeWithSymbolAsContext(this) { - val methods = getDeclaredMemberScope().getCallableSymbols() - .filterIsInstance() - .filter { it.hasJvmStaticAnnotation() } - createMethods(methods, result) + val methods = getDeclaredMemberScope().getCallableSymbols() + .filterIsInstance() + .filter { it.hasJvmStaticAnnotation() } + createMethods(methods, result) - val properties = getDeclaredMemberScope().getCallableSymbols() - .filterIsInstance() - properties.forEach { property -> - createPropertyAccessors( - result, - property, - isTopLevel = false, - onlyJvmStatic = true - ) - } + val properties = getDeclaredMemberScope().getCallableSymbols() + .filterIsInstance() + properties.forEach { property -> + createPropertyAccessors( + result, + property, + isTopLevel = false, + onlyJvmStatic = true + ) } } } @@ -125,24 +125,22 @@ internal abstract class FirLightClassForClassOrObjectSymbol( protected fun addFieldsFromCompanionIfNeeded(result: MutableList) { classOrObjectSymbol.companionObject?.run { - analyzeWithSymbolAsContext(this) { - getDeclaredMemberScope().getCallableSymbols() - .filterIsInstance() - .applyIf(isInterface) { - filter { it.hasJvmFieldAnnotation() || it.isConst } - } - .mapTo(result) { - FirLightFieldForPropertySymbol( - propertySymbol = it, - fieldName = it.name.asString(), - containingClass = this@FirLightClassForClassOrObjectSymbol, - lightMemberOrigin = null, - isTopLevel = false, - forceStatic = true, - takePropertyVisibility = true - ) - } - } + getDeclaredMemberScope().getCallableSymbols() + .filterIsInstance() + .applyIf(isInterface) { + filter { it.hasJvmFieldAnnotation() || it.isConst } + } + .mapTo(result) { + FirLightFieldForPropertySymbol( + propertySymbol = it, + fieldName = it.name.asString(), + containingClass = this@FirLightClassForClassOrObjectSymbol, + lightMemberOrigin = null, + isTopLevel = false, + forceStatic = true, + takePropertyVisibility = true + ) + } } } diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForEnumEntry.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForEnumEntry.kt index 2403e92f5b7..0297081e2f8 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForEnumEntry.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForEnumEntry.kt @@ -7,17 +7,18 @@ package org.jetbrains.kotlin.light.classes.symbol import com.intellij.psi.* import com.intellij.psi.impl.PsiClassImplUtil -import org.jetbrains.kotlin.asJava.elements.KtLightMethod import org.jetbrains.kotlin.analysis.api.lifetime.isValid import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode import org.jetbrains.kotlin.asJava.classes.KotlinSuperTypeListBuilder import org.jetbrains.kotlin.asJava.classes.lazyPub +import org.jetbrains.kotlin.asJava.elements.KtLightMethod import org.jetbrains.kotlin.light.classes.symbol.classes.createConstructors import org.jetbrains.kotlin.light.classes.symbol.classes.createMethods import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind import org.jetbrains.kotlin.psi.KtClassOrObject - +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession +context(KtAnalysisSession) internal class FirLightClassForEnumEntry( private val enumEntrySymbol: KtEnumEntrySymbol, private val enumConstant: FirLightFieldForEnumEntry, @@ -82,10 +83,10 @@ internal class FirLightClassForEnumEntry( override fun isEnum(): Boolean = false private val _extendsList: PsiReferenceList? by lazyPub { - val mappedType = analyzeWithSymbolAsContext(enumEntrySymbol) { + val mappedType = enumEntrySymbol.returnType.asPsiType(this@FirLightClassForEnumEntry, KtTypeMappingMode.SUPER_TYPE) as? PsiClassType ?: return@lazyPub null - } + KotlinSuperTypeListBuilder( kotlinOrigin = enumClass.kotlinOrigin?.getSuperTypeList(), @@ -126,13 +127,10 @@ internal class FirLightClassForEnumEntry( override fun getOwnMethods(): MutableList { val result = mutableListOf() - analyzeWithSymbolAsContext(enumEntrySymbol) { - val declaredMemberScope = enumEntrySymbol.getDeclaredMemberScope() + val declaredMemberScope = enumEntrySymbol.getDeclaredMemberScope() - createMethods(declaredMemberScope.getCallableSymbols(), result) - - createConstructors(declaredMemberScope.getConstructors(), result) - } + createMethods(declaredMemberScope.getCallableSymbols(), result) + createConstructors(declaredMemberScope.getConstructors(), result) return result } diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForFacade.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForFacade.kt index ccbc011f7d7..413c530d00e 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForFacade.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForFacade.kt @@ -10,6 +10,7 @@ import com.intellij.psi.* import com.intellij.psi.impl.light.LightEmptyImplementsList import com.intellij.psi.impl.light.LightModifierList import org.jetbrains.annotations.NonNls +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.scopes.KtScope import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol @@ -32,6 +33,7 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.KtFile +context(KtAnalysisSession) class FirLightClassForFacade( manager: PsiManager, override val facadeClassFqName: FqName, @@ -85,15 +87,13 @@ class FirLightClassForFacade( val methodsAndProperties = sequence { for (fileSymbol in fileSymbols) { - analyzeWithSymbolAsContext(fileSymbol) { - for (callableSymbol in fileSymbol.getFileScope().getCallableSymbols()) { - if (callableSymbol !is KtFunctionSymbol && callableSymbol !is KtKotlinPropertySymbol) continue - if (callableSymbol !is KtSymbolWithVisibility) continue - if ((callableSymbol as? KtAnnotatedSymbol)?.hasInlineOnlyAnnotation() == true) continue - val isPrivate = callableSymbol.toPsiVisibilityForMember(isTopLevel = true) == PsiModifier.PRIVATE - if (isPrivate && multiFileClass) continue - yield(callableSymbol) - } + for (callableSymbol in fileSymbol.getFileScope().getCallableSymbols()) { + if (callableSymbol !is KtFunctionSymbol && callableSymbol !is KtKotlinPropertySymbol) continue + if (callableSymbol !is KtSymbolWithVisibility) continue + if ((callableSymbol as? KtAnnotatedSymbol)?.hasInlineOnlyAnnotation() == true) continue + val isPrivate = callableSymbol.toPsiVisibilityForMember(isTopLevel = true) == PsiModifier.PRIVATE + if (isPrivate && multiFileClass) continue + yield(callableSymbol) } } } @@ -146,9 +146,7 @@ class FirLightClassForFacade( val result = mutableListOf() val nameGenerator = FirLightField.FieldNameGenerator() for (fileSymbol in fileSymbols) { - analyzeWithSymbolAsContext(fileSymbol) { - loadFieldsFromFile(fileSymbol.getFileScope(), nameGenerator, result) - } + loadFieldsFromFile(fileSymbol.getFileScope(), nameGenerator, result) } result } diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForInterfaceDefaultImpls.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForInterfaceDefaultImpls.kt index c06328961c5..c7c0e0ca785 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForInterfaceDefaultImpls.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForInterfaceDefaultImpls.kt @@ -11,6 +11,9 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.load.java.JvmAbi +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession + +context(KtAnalysisSession) internal class FirLightClassForInterfaceDefaultImpls( private val classOrObjectSymbol: KtNamedClassOrObjectSymbol, private val containingClass: FirLightClassBase, diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForSymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForSymbol.kt index 717224f02c4..75ec468ee78 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForSymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForSymbol.kt @@ -31,6 +31,7 @@ import org.jetbrains.kotlin.util.OperatorNameConventions.EQUALS import org.jetbrains.kotlin.util.OperatorNameConventions.TO_STRING import org.jetbrains.kotlin.utils.addToStdlib.applyIf +context(KtAnalysisSession) internal open class FirLightClassForSymbol( private val classOrObjectSymbol: KtNamedClassOrObjectSymbol, manager: PsiManager @@ -72,32 +73,31 @@ internal open class FirLightClassForSymbol( val result = mutableListOf() - analyzeWithSymbolAsContext(classOrObjectSymbol) { - val declaredMemberScope = classOrObjectSymbol.getDeclaredMemberScope() + val declaredMemberScope = classOrObjectSymbol.getDeclaredMemberScope() - val visibleDeclarations = declaredMemberScope.getCallableSymbols().applyIf(isEnum) { - filterNot { function -> - function is KtFunctionSymbol && - (function.name == ENUM_VALUES || function.name == ENUM_VALUE_OF) - } - }.applyIf(classOrObjectSymbol.isObject) { - filterNot { - it is KtKotlinPropertySymbol && it.isConst - } - }.applyIf(classOrObjectSymbol.isData) { - // Technically, synthetic members of `data` class, such as `componentN` or `copy`, are visible. - // They're just needed to be added later (to be in a backward-compatible order of members). - filterNot { function -> - function is KtFunctionSymbol && function.origin == KtSymbolOrigin.SOURCE_MEMBER_GENERATED - } + val visibleDeclarations = declaredMemberScope.getCallableSymbols().applyIf(isEnum) { + filterNot { function -> + function is KtFunctionSymbol && + (function.name == ENUM_VALUES || function.name == ENUM_VALUE_OF) + } + }.applyIf(classOrObjectSymbol.isObject) { + filterNot { + it is KtKotlinPropertySymbol && it.isConst + } + }.applyIf(classOrObjectSymbol.isData) { + // Technically, synthetic members of `data` class, such as `componentN` or `copy`, are visible. + // They're just needed to be added later (to be in a backward-compatible order of members). + filterNot { function -> + function is KtFunctionSymbol && function.origin == KtSymbolOrigin.SOURCE_MEMBER_GENERATED } - - val suppressStatic = isCompanionObject - createMethods(visibleDeclarations, result, suppressStatic = suppressStatic) - - createConstructors(declaredMemberScope.getConstructors(), result) } + val suppressStatic = isCompanionObject + createMethods(visibleDeclarations, result, suppressStatic = suppressStatic) + + createConstructors(declaredMemberScope.getConstructors(), result) + + addMethodsFromCompanionIfNeeded(result) addMethodsFromDataClass(result) @@ -114,17 +114,13 @@ internal open class FirLightClassForSymbol( val lightMemberOrigin = LightMemberOriginForDeclaration(this.kotlinOrigin!!, JvmDeclarationOriginKind.OTHER) result.add( FirLightSimpleMethodForSymbol( - functionSymbol = ktFunctionSymbol, - lightMemberOrigin = lightMemberOrigin, - containingClass = this, - isTopLevel = false, - methodIndex = METHOD_INDEX_BASE, + ktFunctionSymbol, lightMemberOrigin, this, METHOD_INDEX_BASE, false, suppressStatic = false ) ) } - fun KtAnalysisSession.actuallyComesFromAny(functionSymbol: KtFunctionSymbol): Boolean { + fun actuallyComesFromAny(functionSymbol: KtFunctionSymbol): Boolean { require(functionSymbol.name.isFromAny) { "This function's name should one of three Any's function names, but it was ${functionSymbol.name}" } @@ -136,56 +132,52 @@ internal open class FirLightClassForSymbol( // NB: componentN and copy are added during RAW FIR, but synthetic members from `Any` are not. // That's why we use declared scope for 'component*' and 'copy', and member scope for 'equals/hashCode/toString' - analyzeWithSymbolAsContext(classOrObjectSymbol) { - val componentAndCopyFunctions = classOrObjectSymbol.getDeclaredMemberScope() - .getCallableSymbols { name -> DataClassResolver.isCopy(name) || DataClassResolver.isComponentLike(name) } - .filter { it.origin == KtSymbolOrigin.SOURCE_MEMBER_GENERATED } - .filterIsInstance() + val componentAndCopyFunctions = classOrObjectSymbol.getDeclaredMemberScope() + .getCallableSymbols { name -> DataClassResolver.isCopy(name) || DataClassResolver.isComponentLike(name) } + .filter { it.origin == KtSymbolOrigin.SOURCE_MEMBER_GENERATED } + .filterIsInstance() - createMethods(componentAndCopyFunctions, result) + createMethods(componentAndCopyFunctions, result) - // Compiler will generate 'equals/hashCode/toString' for data class if they are not final. - // We want to mimic that. - val nonFinalFunctionsFromAny = classOrObjectSymbol.getMemberScope() - .getCallableSymbols { name -> name.isFromAny } - .filterIsInstance() - .filterNot { it.modality == Modality.FINAL } - .filter { actuallyComesFromAny(it) } + // Compiler will generate 'equals/hashCode/toString' for data class if they are not final. + // We want to mimic that. + val nonFinalFunctionsFromAny = classOrObjectSymbol.getMemberScope() + .getCallableSymbols { name -> name.isFromAny } + .filterIsInstance() + .filterNot { it.modality == Modality.FINAL } + .filter { actuallyComesFromAny(it) } - val functionsFromAnyByName = nonFinalFunctionsFromAny.associateBy { it.name } + val functionsFromAnyByName = nonFinalFunctionsFromAny.associateBy { it.name } - // NB: functions from `Any` are not in an alphabetic order. - functionsFromAnyByName[TO_STRING]?.let { createMethodFromAny(it) } - functionsFromAnyByName[HASHCODE_NAME]?.let { createMethodFromAny(it) } - functionsFromAnyByName[EQUALS]?.let { createMethodFromAny(it) } - } + // NB: functions from `Any` are not in an alphabetic order. + functionsFromAnyByName[TO_STRING]?.let { createMethodFromAny(it) } + functionsFromAnyByName[HASHCODE_NAME]?.let { createMethodFromAny(it) } + functionsFromAnyByName[EQUALS]?.let { createMethodFromAny(it) } } private val Name.isFromAny: Boolean get() = this == EQUALS || this == HASHCODE_NAME || this == TO_STRING private fun addDelegatesToInterfaceMethods(result: MutableList) { - fun createDelegateMethod(ktFunctionSymbol: KtFunctionSymbol) { val kotlinOrigin = ktFunctionSymbol.psi as? KtDeclaration ?: kotlinOrigin!! val lightMemberOrigin = LightMemberOriginForDeclaration(kotlinOrigin, JvmDeclarationOriginKind.DELEGATION) result.add( FirLightSimpleMethodForSymbol( - functionSymbol = ktFunctionSymbol, - lightMemberOrigin = lightMemberOrigin, - containingClass = this, - isTopLevel = false, - methodIndex = METHOD_INDEX_FOR_NON_ORIGIN_METHOD, + ktFunctionSymbol, + lightMemberOrigin, + this, + METHOD_INDEX_FOR_NON_ORIGIN_METHOD, + false, + argumentsSkipMask = null, suppressStatic = false ) ) } - analyzeWithSymbolAsContext(classOrObjectSymbol) { - classOrObjectSymbol.getDelegatedMemberScope().getCallableSymbols().forEach { functionSymbol -> - if (functionSymbol is KtFunctionSymbol) { - createDelegateMethod(functionSymbol) - } + classOrObjectSymbol.getDelegatedMemberScope().getCallableSymbols().forEach { functionSymbol -> + if (functionSymbol is KtFunctionSymbol) { + createDelegateMethod(functionSymbol) } } } @@ -211,41 +203,39 @@ internal open class FirLightClassForSymbol( } private fun addPropertyBackingFields(result: MutableList) { - analyzeWithSymbolAsContext(classOrObjectSymbol) { - val propertySymbols = classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols() - .filterIsInstance() - .applyIf(isCompanionObject) { - // All fields for companion object of classes are generated to the containing class - // For interfaces, only @JvmField-annotated properties are generated to the containing class - // Probably, the same should work for const vals but it doesn't at the moment (see KT-28294) - filter { containingClass?.isInterface == true && !it.hasJvmFieldAnnotation() } - } - val propertyGroups = propertySymbols.groupBy { it.isFromPrimaryConstructor } - - val nameGenerator = FirLightField.FieldNameGenerator() - - fun addPropertyBackingField(propertySymbol: KtPropertySymbol) { - val isJvmField = propertySymbol.hasJvmFieldAnnotation() - val isLateInit = (propertySymbol as? KtKotlinPropertySymbol)?.isLateInit == true - - val forceStatic = classOrObjectSymbol.isObject - val takePropertyVisibility = !isCompanionObject && (isLateInit || isJvmField) - - createField( - declaration = propertySymbol, - nameGenerator = nameGenerator, - isTopLevel = false, - forceStatic = forceStatic, - takePropertyVisibility = takePropertyVisibility, - result = result - ) + val propertySymbols = classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols() + .filterIsInstance() + .applyIf(isCompanionObject) { + // All fields for companion object of classes are generated to the containing class + // For interfaces, only @JvmField-annotated properties are generated to the containing class + // Probably, the same should work for const vals but it doesn't at the moment (see KT-28294) + filter { containingClass?.isInterface == true && !it.hasJvmFieldAnnotation() } } + val propertyGroups = propertySymbols.groupBy { it.isFromPrimaryConstructor } - // First, properties from parameters - propertyGroups[true]?.forEach(::addPropertyBackingField) - // Then, regular member properties - propertyGroups[false]?.forEach(::addPropertyBackingField) + val nameGenerator = FirLightField.FieldNameGenerator() + + fun addPropertyBackingField(propertySymbol: KtPropertySymbol) { + val isJvmField = propertySymbol.hasJvmFieldAnnotation() + val isLateInit = (propertySymbol as? KtKotlinPropertySymbol)?.isLateInit == true + + val forceStatic = classOrObjectSymbol.isObject + val takePropertyVisibility = !isCompanionObject && (isLateInit || isJvmField) + + createField( + declaration = propertySymbol, + nameGenerator = nameGenerator, + isTopLevel = false, + forceStatic = forceStatic, + takePropertyVisibility = takePropertyVisibility, + result = result + ) } + + // First, properties from parameters + propertyGroups[true]?.forEach(::addPropertyBackingField) + // Then, regular member properties + propertyGroups[false]?.forEach(::addPropertyBackingField) } private fun addInstanceFieldIfNeeded(result: MutableList) { @@ -262,12 +252,10 @@ internal open class FirLightClassForSymbol( } private fun addFieldsForEnumEntries(result: MutableList) { - analyzeWithSymbolAsContext(classOrObjectSymbol) { - if (isEnum) { - classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols() - .filterIsInstance() - .mapTo(result) { FirLightFieldForEnumEntry(it, this@FirLightClassForSymbol, null) } - } + if (isEnum) { + classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols() + .filterIsInstance() + .mapTo(result) { FirLightFieldForEnumEntry(it, this@FirLightClassForSymbol, null) } } } diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightInlineClass.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightInlineClass.kt index d3bd24d5430..0c3953dd10a 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightInlineClass.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightInlineClass.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.light.classes.symbol import com.intellij.psi.PsiManager import com.intellij.psi.PsiMethod +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol @@ -17,6 +18,7 @@ import org.jetbrains.kotlin.light.classes.symbol.classes.createMethods import org.jetbrains.kotlin.light.classes.symbol.classes.createPropertyAccessors import org.jetbrains.kotlin.resolve.deprecation.DeprecationLevelValue +context(KtAnalysisSession) internal class FirLightInlineClass( private val classOrObjectSymbol: KtNamedClassOrObjectSymbol, manager: PsiManager @@ -29,32 +31,31 @@ internal class FirLightInlineClass( private val _ownMethods: List by lazyPub { val result = mutableListOf() - analyzeWithSymbolAsContext(classOrObjectSymbol) { - val declaredMemberScope = classOrObjectSymbol.getDeclaredMemberScope() - val applicableDeclarations = declaredMemberScope.getCallableSymbols() - .filter { - (it as? KtPropertySymbol)?.isOverride == true || (it as? KtFunctionSymbol)?.isOverride == true - } - .filterNot { - it.deprecationStatus?.deprecationLevel == DeprecationLevelValue.HIDDEN - } + val declaredMemberScope = classOrObjectSymbol.getDeclaredMemberScope() + val applicableDeclarations = declaredMemberScope.getCallableSymbols() + .filter { + (it as? KtPropertySymbol)?.isOverride == true || (it as? KtFunctionSymbol)?.isOverride == true + } + .filterNot { + it.deprecationStatus?.deprecationLevel == DeprecationLevelValue.HIDDEN + } - createMethods(applicableDeclarations, result, suppressStatic = false) + createMethods(applicableDeclarations, result, suppressStatic = false) - val inlineClassParameterSymbol = - declaredMemberScope.getConstructors().singleOrNull { it.isPrimary }?.valueParameters?.singleOrNull() - if (inlineClassParameterSymbol != null) { - val propertySymbol = declaredMemberScope.getCallableSymbols { it == inlineClassParameterSymbol.name } - .singleOrNull { it is KtPropertySymbol && it.isFromPrimaryConstructor } as? KtPropertySymbol - if (propertySymbol != null) { - // (inline or) value class primary constructor must have only final read-only (val) property parameter - // Even though the property parameter is mutable (for some reasons, e.g., testing or not checked yet), - // we can enforce immutability here. - createPropertyAccessors(result, propertySymbol, isTopLevel = false, isMutable = false) - } + val inlineClassParameterSymbol = + declaredMemberScope.getConstructors().singleOrNull { it.isPrimary }?.valueParameters?.singleOrNull() + if (inlineClassParameterSymbol != null) { + val propertySymbol = declaredMemberScope.getCallableSymbols { it == inlineClassParameterSymbol.name } + .singleOrNull { it is KtPropertySymbol && it.isFromPrimaryConstructor } as? KtPropertySymbol + if (propertySymbol != null) { + // (inline or) value class primary constructor must have only final read-only (val) property parameter + // Even though the property parameter is mutable (for some reasons, e.g., testing or not checked yet), + // we can enforce immutability here. + createPropertyAccessors(result, propertySymbol, isTopLevel = false, isMutable = false) } } + result } diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightInterfaceClassSymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightInterfaceClassSymbol.kt index 7098b188eca..30db7f4e095 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightInterfaceClassSymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightInterfaceClassSymbol.kt @@ -8,17 +8,19 @@ package org.jetbrains.kotlin.light.classes.symbol import com.intellij.psi.PsiManager import com.intellij.psi.PsiMethod import com.intellij.psi.PsiReferenceList -import org.jetbrains.kotlin.asJava.classes.lazyPub -import org.jetbrains.kotlin.asJava.elements.KtLightField -import org.jetbrains.kotlin.asJava.elements.KtLightMethod +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.lifetime.isValid import org.jetbrains.kotlin.analysis.api.symbols.KtClassKind import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol import org.jetbrains.kotlin.analysis.api.symbols.markers.isPrivateOrPrivateToThis +import org.jetbrains.kotlin.asJava.classes.lazyPub +import org.jetbrains.kotlin.asJava.elements.KtLightField +import org.jetbrains.kotlin.asJava.elements.KtLightMethod import org.jetbrains.kotlin.light.classes.symbol.classes.createInheritanceList import org.jetbrains.kotlin.light.classes.symbol.classes.createMethods +context(KtAnalysisSession) internal open class FirLightInterfaceClassSymbol( private val classOrObjectSymbol: KtNamedClassOrObjectSymbol, manager: PsiManager @@ -38,16 +40,12 @@ internal open class FirLightInterfaceClassSymbol( override fun getOwnFields(): List = _ownFields private val _ownMethods: List by lazyPub { - val result = mutableListOf() - analyzeWithSymbolAsContext(classOrObjectSymbol) { - val visibleDeclarations = classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols() - .filterNot { it is KtFunctionSymbol && it.visibility.isPrivateOrPrivateToThis() } - - createMethods(visibleDeclarations, result) - } + val visibleDeclarations = classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols() + .filterNot { it is KtFunctionSymbol && it.visibility.isPrivateOrPrivateToThis() } + createMethods(visibleDeclarations, result) addMethodsFromCompanionIfNeeded(result) result diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightInterfaceOrAnnotationClassSymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightInterfaceOrAnnotationClassSymbol.kt index d81783c4954..f3626ac6f04 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightInterfaceOrAnnotationClassSymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightInterfaceOrAnnotationClassSymbol.kt @@ -5,12 +5,17 @@ package org.jetbrains.kotlin.light.classes.symbol -import com.intellij.psi.* -import org.jetbrains.kotlin.asJava.classes.lazyPub +import com.intellij.psi.PsiManager +import com.intellij.psi.PsiModifier +import com.intellij.psi.PsiModifierList +import com.intellij.psi.PsiReferenceList +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.lifetime.isValid import org.jetbrains.kotlin.analysis.api.symbols.KtClassKind import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol +import org.jetbrains.kotlin.asJava.classes.lazyPub +context(KtAnalysisSession) internal abstract class FirLightInterfaceOrAnnotationClassSymbol( private val classOrObjectSymbol: KtNamedClassOrObjectSymbol, manager: PsiManager diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/KtFirBasedFakeLightClass.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/KtFirBasedFakeLightClass.kt index 7cf62f94bd4..e22ccf699a7 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/KtFirBasedFakeLightClass.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/KtFirBasedFakeLightClass.kt @@ -14,6 +14,9 @@ import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject //TODO Make fake class symbol based +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession +import org.jetbrains.kotlin.light.classes.symbol.classes.analyseForLightClasses + class KtFirBasedFakeLightClass(kotlinOrigin: KtClassOrObject) : KtFakeLightClass(kotlinOrigin) { @@ -30,6 +33,8 @@ class KtFirBasedFakeLightClass(kotlinOrigin: KtClassOrObject) : LightClassInheritanceHelper.getService(project).isInheritor(this, baseClass, checkDeep).ifSure { return it } val baseClassOrigin = (baseClass as? KtLightClass)?.kotlinOrigin ?: return false - return kotlinOrigin.checkIsInheritor(baseClassOrigin, checkDeep) + return analyseForLightClasses(baseClassOrigin) { + kotlinOrigin.checkIsInheritor(baseClassOrigin, checkDeep) + } } } \ No newline at end of file diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/analyseForLightClasses.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/analyseForLightClasses.kt index d024c64308e..0d4f2bde10d 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/analyseForLightClasses.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/analyseForLightClasses.kt @@ -8,7 +8,11 @@ package org.jetbrains.kotlin.light.classes.symbol.classes import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.analyze import org.jetbrains.kotlin.analysis.api.lifetime.KtAlwaysAccessibleLifetimeTokenFactory +import org.jetbrains.kotlin.analysis.project.structure.KtModule import org.jetbrains.kotlin.psi.KtElement internal inline fun analyseForLightClasses(context: KtElement, action: KtAnalysisSession.() -> R): R = - analyze(context, KtAlwaysAccessibleLifetimeTokenFactory, action) \ No newline at end of file + analyze(context, KtAlwaysAccessibleLifetimeTokenFactory, action) + +internal inline fun analyseForLightClasses(useSiteKtModule: KtModule, crossinline action: KtAnalysisSession.() -> R): R = + analyze(useSiteKtModule, KtAlwaysAccessibleLifetimeTokenFactory, action) \ No newline at end of file diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/firLightClassUtils.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/firLightClassUtils.kt index 8008e026833..9a360e48f0d 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/firLightClassUtils.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/firLightClassUtils.kt @@ -11,16 +11,17 @@ import com.intellij.psi.PsiReferenceList import com.intellij.psi.util.CachedValueProvider import com.intellij.psi.util.CachedValuesManager import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt -import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModificationTracker +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession +import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt import org.jetbrains.kotlin.analysis.api.symbols.* import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithMembers import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithTypeParameters import org.jetbrains.kotlin.analysis.api.symbols.markers.isPrivateOrPrivateToThis -import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt import org.jetbrains.kotlin.analysis.api.types.KtNonErrorClassType import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule import org.jetbrains.kotlin.analysis.project.structure.getKtModuleOfTypeSafe +import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModificationTracker import org.jetbrains.kotlin.asJava.builder.LightMemberOriginForDeclaration import org.jetbrains.kotlin.asJava.classes.* import org.jetbrains.kotlin.asJava.elements.KtLightField @@ -71,7 +72,9 @@ internal fun createFirLightClassNoCache(classOrObject: KtClassOrObject): KtLight } return when { - classOrObject is KtEnumEntry -> lightClassForEnumEntry(classOrObject) + classOrObject is KtEnumEntry -> analyseForLightClasses(classOrObject) { + lightClassForEnumEntry(classOrObject) + } classOrObject.hasModifier(INLINE_KEYWORD) -> { analyseForLightClasses(classOrObject) { classOrObject.getNamedClassOrObjectSymbol()?.let { FirLightInlineClass(it, classOrObject.manager) } @@ -85,7 +88,9 @@ internal fun createFirLightClassNoCache(classOrObject: KtClassOrObject): KtLight } } -internal fun KtClassOrObjectSymbol.createLightClassNoCache(manager: PsiManager): FirLightClassBase = when (this) { + +context(KtAnalysisSession) + internal fun KtClassOrObjectSymbol.createLightClassNoCache(manager: PsiManager): FirLightClassBase = when (this) { is KtAnonymousObjectSymbol -> FirLightAnonymousClassForSymbol(this, manager) is KtNamedClassOrObjectSymbol -> when (classKind) { KtClassKind.INTERFACE -> FirLightInterfaceClassSymbol(this, manager) @@ -94,7 +99,8 @@ internal fun KtClassOrObjectSymbol.createLightClassNoCache(manager: PsiManager): } } -private fun lightClassForEnumEntry(ktEnumEntry: KtEnumEntry): KtLightClass? { +context(KtAnalysisSession) + private fun lightClassForEnumEntry(ktEnumEntry: KtEnumEntry): KtLightClass? { if (ktEnumEntry.body == null) return null val firClass = ktEnumEntry @@ -109,7 +115,8 @@ private fun lightClassForEnumEntry(ktEnumEntry: KtEnumEntry): KtLightClass? { return (targetField as? FirLightFieldForEnumEntry)?.initializingClass as? KtLightClass } -internal fun FirLightClassBase.createConstructors( +context(KtAnalysisSession) + internal fun FirLightClassBase.createConstructors( declarations: Sequence, result: MutableList ) { @@ -119,7 +126,7 @@ internal fun FirLightClassBase.createConstructors( return } for (constructor in constructors) { - if (constructor.isHiddenOrSynthetic(project)) continue + if (constructor.isHiddenOrSynthetic()) continue result.add( FirLightConstructorForSymbol( constructorSymbol = constructor, @@ -137,7 +144,8 @@ internal fun FirLightClassBase.createConstructors( } } -private fun FirLightClassBase.shouldGenerateNoArgOverload( +context(KtAnalysisSession) + private fun FirLightClassBase.shouldGenerateNoArgOverload( primaryConstructor: KtConstructorSymbol, constructors: Iterable, ): Boolean { @@ -151,7 +159,8 @@ private fun FirLightClassBase.shouldGenerateNoArgOverload( !primaryConstructor.hasJvmOverloadsAnnotation() } -private fun FirLightClassBase.defaultConstructor(): KtLightMethod { +context(KtAnalysisSession) + private fun FirLightClassBase.defaultConstructor(): KtLightMethod { val classOrObject = kotlinOrigin val visibility = when { classOrObject is KtObjectDeclaration || classOrObject?.hasModifier(SEALED_KEYWORD) == true || isEnum -> PsiModifier.PRIVATE @@ -161,7 +170,8 @@ private fun FirLightClassBase.defaultConstructor(): KtLightMethod { return noArgConstructor(visibility, METHOD_INDEX_FOR_DEFAULT_CTOR) } -private fun FirLightClassBase.noArgConstructor( +context(KtAnalysisSession) + private fun FirLightClassBase.noArgConstructor( visibility: String, methodIndex: Int, ): KtLightMethod { @@ -177,11 +187,12 @@ private fun FirLightClassBase.noArgConstructor( ) } -internal fun FirLightClassBase.createMethods( +context(KtAnalysisSession) + internal fun FirLightClassBase.createMethods( declarations: Sequence, result: MutableList, isTopLevel: Boolean = false, - suppressStatic : Boolean = false + suppressStatic: Boolean = false ) { val declarationGroups = declarations.groupBy { it is KtPropertySymbol && it.isFromPrimaryConstructor } @@ -190,7 +201,7 @@ internal fun FirLightClassBase.createMethods( is KtFunctionSymbol -> { // TODO: check if it has expect modifier if (declaration.hasReifiedParameters || - declaration.isHiddenOrSynthetic(project) + declaration.isHiddenOrSynthetic() ) return var methodIndex = METHOD_INDEX_BASE @@ -216,12 +227,7 @@ internal fun FirLightClassBase.createMethods( result.add( FirLightSimpleMethodForSymbol( - functionSymbol = declaration, - lightMemberOrigin = null, - containingClass = this@createMethods, - isTopLevel = isTopLevel, - methodIndex = methodIndex++, - argumentsSkipMask = skipMask.copy() + declaration, null, this@createMethods, methodIndex++, isTopLevel, skipMask.copy() ) ) } @@ -234,7 +240,7 @@ internal fun FirLightClassBase.createMethods( suppressStatic = suppressStatic ) is KtConstructorSymbol -> error("Constructors should be handled separately and not passed to this function") - else -> { } + else -> {} } } @@ -248,7 +254,8 @@ internal fun FirLightClassBase.createMethods( } } -internal fun FirLightClassBase.createPropertyAccessors( +context(KtAnalysisSession) + internal fun FirLightClassBase.createPropertyAccessors( result: MutableList, declaration: KtPropertySymbol, isTopLevel: Boolean, @@ -269,8 +276,8 @@ internal fun FirLightClassBase.createPropertyAccessors( if (onlyJvmStatic && !hasJvmStaticAnnotation(siteTarget) && !declaration.hasJvmStaticAnnotation()) return false if (declaration.hasReifiedParameters) return false if (!hasBody && visibility.isPrivateOrPrivateToThis()) return false - if (declaration.isHiddenOrSynthetic(project, siteTarget)) return false - if (isHiddenOrSynthetic(project)) return false + if (declaration.isHiddenOrSynthetic(siteTarget)) return false + if (isHiddenOrSynthetic()) return false return true } @@ -326,7 +333,8 @@ internal fun FirLightClassBase.createPropertyAccessors( } } -internal fun FirLightClassBase.createField( +context(KtAnalysisSession) + internal fun FirLightClassBase.createField( declaration: KtPropertySymbol, nameGenerator: FirLightField.FieldNameGenerator, isTopLevel: Boolean, @@ -339,7 +347,7 @@ internal fun FirLightClassBase.createField( is KtSyntheticJavaPropertySymbol -> true is KtKotlinPropertySymbol -> when { property.modality == Modality.ABSTRACT -> false - property.isHiddenOrSynthetic(project) -> false + property.isHiddenOrSynthetic() -> false property.isLateInit -> true property.isDelegatedProperty -> true property.isFromPrimaryConstructor -> true @@ -369,7 +377,8 @@ internal fun FirLightClassBase.createField( ) } -internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, superTypes: List): PsiReferenceList { +context(KtAnalysisSession) + internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, superTypes: List): PsiReferenceList { val role = if (forExtendsList) PsiReferenceList.Role.EXTENDS_LIST else PsiReferenceList.Role.IMPLEMENTS_LIST @@ -400,16 +409,15 @@ internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, su .filter { it.needToAddTypeIntoList() } .mapNotNull { type -> if (type !is KtNonErrorClassType) return@mapNotNull null - analyzeWithSymbolAsContext(type.classSymbol) { - mapSuperType(type, this@createInheritanceList, kotlinCollectionAsIs = true) - } + mapSuperType(type, this@createInheritanceList, kotlinCollectionAsIs = true) } .forEach { listBuilder.addReference(it) } return listBuilder } -internal fun KtSymbolWithMembers.createInnerClasses( +context(KtAnalysisSession) + internal fun KtSymbolWithMembers.createInnerClasses( manager: PsiManager, containingClass: FirLightClassBase, classOrObject: KtClassOrObject? @@ -420,12 +428,11 @@ internal fun KtSymbolWithMembers.createInnerClasses( // inner classes with null names can't be searched for and can't be used from java anyway // we can't prohibit creating light classes with null names either since they can contain members - manager.project.analyzeWithSymbolAsContext(this) { - getDeclaredMemberScope().getClassifierSymbols().filterIsInstance().mapTo(result) { - it.createLightClassNoCache(manager) - } + getDeclaredMemberScope().getClassifierSymbols().filterIsInstance().mapTo(result) { + it.createLightClassNoCache(manager) } + val jvmDefaultMode = classOrObject?.getKtModuleOfTypeSafe()?.languageVersionSettings?.getFlag(JvmAnalysisFlags.jvmDefaultMode) ?: JvmDefaultMode.DEFAULT @@ -439,22 +446,21 @@ internal fun KtSymbolWithMembers.createInnerClasses( return result } +context(KtAnalysisSession) internal fun KtClassOrObject.checkIsInheritor(superClassOrigin: KtClassOrObject, checkDeep: Boolean): Boolean { if (this == superClassOrigin) return false - return analyseForLightClasses(this) { - if (!superClassOrigin.canBeAnalysed()) { - return false - } - val subClassSymbol = this@checkIsInheritor.getClassOrObjectSymbol() - val superClassSymbol = superClassOrigin.getClassOrObjectSymbol() + if (!superClassOrigin.canBeAnalysed()) { + return false + } + val subClassSymbol = this@checkIsInheritor.getClassOrObjectSymbol() + val superClassSymbol = superClassOrigin.getClassOrObjectSymbol() - if (subClassSymbol == superClassSymbol) return@analyseForLightClasses false + if (subClassSymbol == superClassSymbol) return false - if (checkDeep) { - subClassSymbol.isSubClassOf(superClassSymbol) - } else { - subClassSymbol.isDirectSubClassOf(superClassSymbol) - } + return if (checkDeep) { + subClassSymbol.isSubClassOf(superClassSymbol) + } else { + subClassSymbol.isDirectSubClassOf(superClassSymbol) } } diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/FirLightFieldEnumEntry.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/FirLightFieldEnumEntry.kt index 8e380bd11e0..733af584206 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/FirLightFieldEnumEntry.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/FirLightFieldEnumEntry.kt @@ -6,14 +6,16 @@ package org.jetbrains.kotlin.light.classes.symbol import com.intellij.psi.* +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession +import org.jetbrains.kotlin.analysis.api.lifetime.isValid +import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin import org.jetbrains.kotlin.asJava.classes.cannotModify import org.jetbrains.kotlin.asJava.classes.lazyPub -import org.jetbrains.kotlin.analysis.api.lifetime.isValid -import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol import org.jetbrains.kotlin.psi.KtEnumEntry import org.jetbrains.kotlin.utils.addToStdlib.ifTrue +context(KtAnalysisSession) internal class FirLightFieldForEnumEntry( private val enumEntrySymbol: KtEnumEntrySymbol, containingClass: FirLightClassForSymbol, @@ -64,9 +66,7 @@ internal class FirLightFieldForEnumEntry( override fun getName(): String = enumEntrySymbol.name.asString() private val _type: PsiType by lazyPub { - analyzeWithSymbolAsContext(enumEntrySymbol) { - enumEntrySymbol.returnType.asPsiType(this@FirLightFieldForEnumEntry) - } ?: nonExistentType() + enumEntrySymbol.returnType.asPsiType(this@FirLightFieldForEnumEntry) ?: nonExistentType() } override fun getType(): PsiType = _type diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/FirLightFieldForObjectSymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/FirLightFieldForObjectSymbol.kt index 8c72dceccc2..65228eaa1be 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/FirLightFieldForObjectSymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/FirLightFieldForObjectSymbol.kt @@ -7,13 +7,16 @@ package org.jetbrains.kotlin.light.classes.symbol import com.intellij.psi.* import org.jetbrains.annotations.NotNull +import org.jetbrains.kotlin.analysis.api.lifetime.isValid +import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin import org.jetbrains.kotlin.asJava.classes.KtLightClass import org.jetbrains.kotlin.asJava.classes.lazyPub -import org.jetbrains.kotlin.analysis.api.lifetime.isValid -import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol import org.jetbrains.kotlin.psi.KtDeclaration +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession + +context(KtAnalysisSession) internal class FirLightFieldForObjectSymbol( private val objectSymbol: KtNamedClassOrObjectSymbol, containingClass: KtLightClass, @@ -40,9 +43,8 @@ internal class FirLightFieldForObjectSymbol( override fun getModifierList(): PsiModifierList? = _modifierList private val _type: PsiType by lazyPub { - analyzeWithSymbolAsContext(objectSymbol) { - objectSymbol.buildSelfClassType().asPsiType(this@FirLightFieldForObjectSymbol) - } ?: nonExistentType() + objectSymbol.buildSelfClassType().asPsiType(this@FirLightFieldForObjectSymbol) + ?: nonExistentType() } private val _identifier: PsiIdentifier by lazyPub { diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/FirLightFieldForPropertySymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/FirLightFieldForPropertySymbol.kt index 38b42bdccda..8a970288f90 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/FirLightFieldForPropertySymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/FirLightFieldForPropertySymbol.kt @@ -6,20 +6,22 @@ package org.jetbrains.kotlin.light.classes.symbol import com.intellij.psi.* +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.KtConstantInitializerValue -import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin -import org.jetbrains.kotlin.asJava.classes.lazyPub -import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget +import org.jetbrains.kotlin.analysis.api.base.KtConstantValue import org.jetbrains.kotlin.analysis.api.lifetime.isValid import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol -import org.jetbrains.kotlin.analysis.api.base.KtConstantValue import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode +import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin +import org.jetbrains.kotlin.asJava.classes.lazyPub +import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.name.JvmNames.TRANSIENT_ANNOTATION_CLASS_ID import org.jetbrains.kotlin.name.JvmNames.VOLATILE_ANNOTATION_CLASS_ID import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtProperty +context(KtAnalysisSession) internal class FirLightFieldForPropertySymbol( private val propertySymbol: KtPropertySymbol, private val fieldName: String, @@ -33,16 +35,14 @@ internal class FirLightFieldForPropertySymbol( override val kotlinOrigin: KtDeclaration? = propertySymbol.psi as? KtDeclaration private val _returnedType: PsiType by lazyPub { - analyzeWithSymbolAsContext(propertySymbol) { - val isDelegated = (propertySymbol as? KtKotlinPropertySymbol)?.isDelegatedProperty == true - when { - isDelegated -> - (kotlinOrigin as? KtProperty)?.delegateExpression?.let { - it.getKtType()?.asPsiType(this@FirLightFieldForPropertySymbol, KtTypeMappingMode.RETURN_TYPE) - } - else -> { - propertySymbol.returnType.asPsiType(this@FirLightFieldForPropertySymbol, KtTypeMappingMode.RETURN_TYPE) + val isDelegated = (propertySymbol as? KtKotlinPropertySymbol)?.isDelegatedProperty == true + when { + isDelegated -> + (kotlinOrigin as? KtProperty)?.delegateExpression?.let { + it.getKtType()?.asPsiType(this@FirLightFieldForPropertySymbol, KtTypeMappingMode.RETURN_TYPE) } + else -> { + propertySymbol.returnType.asPsiType(this@FirLightFieldForPropertySymbol, KtTypeMappingMode.RETURN_TYPE) } } ?: nonExistentType() } @@ -94,9 +94,7 @@ internal class FirLightFieldForPropertySymbol( } val nullability = if (!(propertySymbol is KtKotlinPropertySymbol && propertySymbol.isLateInit)) { - analyzeWithSymbolAsContext(propertySymbol) { - getTypeNullability(propertySymbol.returnType) - } + getTypeNullability(propertySymbol.returnType) } else NullabilityType.Unknown val annotations = propertySymbol.computeAnnotations( diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/firLightUtils.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/firLightUtils.kt index 66ce0ef266c..8537ee78a56 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/firLightUtils.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/firLightUtils.kt @@ -88,19 +88,16 @@ internal fun KtSymbolWithModality.computeModalityForMethod( result.add(PsiModifier.STATIC) } } - +context(KtAnalysisSession) internal fun PsiElement.tryGetEffectiveVisibility(symbol: KtCallableSymbol): Visibility? { - if (symbol !is KtPropertySymbol && symbol !is KtFunctionSymbol) return null var visibility = (symbol as? KtSymbolWithVisibility)?.visibility - analyzeWithSymbolAsContext(symbol) { - for (overriddenSymbol in symbol.getAllOverriddenSymbols()) { - val newVisibility = (overriddenSymbol as? KtSymbolWithVisibility)?.visibility - if (newVisibility != null) { - visibility = newVisibility - } + for (overriddenSymbol in symbol.getAllOverriddenSymbols()) { + val newVisibility = (overriddenSymbol as? KtSymbolWithVisibility)?.visibility + if (newVisibility != null) { + visibility = newVisibility } } diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/lightClassUtils.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/lightClassUtils.kt index 394e11c147e..c17666825b4 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/lightClassUtils.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/lightClassUtils.kt @@ -5,34 +5,14 @@ package org.jetbrains.kotlin.light.classes.symbol -import com.intellij.openapi.project.Project import com.intellij.psi.JavaPsiFacade import com.intellij.psi.PsiElement import com.intellij.psi.PsiType import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt -import org.jetbrains.kotlin.analysis.api.KtAnalysisApiInternals -import org.jetbrains.kotlin.analysis.api.KtAnalysisSession -import org.jetbrains.kotlin.analysis.api.session.KtAnalysisSessionProvider -import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt @OptIn(KtAllowAnalysisOnEdt::class) internal inline fun allowLightClassesOnEdt(action: () -> E): E = allowAnalysisOnEdt(action) -internal inline fun PsiElement.analyzeWithSymbolAsContext( - contextSymbol: KtSymbol, - action: KtAnalysisSession.() -> R -): R { - return project.analyzeWithSymbolAsContext(contextSymbol, action) -} - -@OptIn(KtAnalysisApiInternals::class) -internal inline fun Project.analyzeWithSymbolAsContext( - contextSymbol: KtSymbol, - action: KtAnalysisSession.() -> R -): R { - return KtAnalysisSessionProvider.getInstance(this).analyzeWithSymbolAsContext(contextSymbol, action) -} - internal fun PsiElement.nonExistentType(): PsiType = JavaPsiFacade.getElementFactory(project).createTypeFromText("error.NonExistentClass", this) diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightAccessorMethodForSymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightAccessorMethodForSymbol.kt index b9dddec655f..6f867243543 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightAccessorMethodForSymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightAccessorMethodForSymbol.kt @@ -12,17 +12,16 @@ import org.jetbrains.kotlin.asJava.classes.METHOD_INDEX_FOR_SETTER import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.analysis.api.lifetime.isValid -import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyAccessorSymbol -import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol -import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol -import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode import org.jetbrains.kotlin.load.java.JvmAbi.getterName import org.jetbrains.kotlin.load.java.JvmAbi.setterName import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtParameter import org.jetbrains.kotlin.utils.addToStdlib.ifTrue +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession +import org.jetbrains.kotlin.analysis.api.symbols.* +context(KtAnalysisSession) internal class FirLightAccessorMethodForSymbol( private val propertyAccessorSymbol: KtPropertyAccessorSymbol, private val containingPropertySymbol: KtPropertySymbol, @@ -74,11 +73,7 @@ internal class FirLightAccessorMethodForSymbol( !(isParameter && (containingClass.isAnnotationType || containingClass.isEnum)) val nullabilityType = if (nullabilityApplicable) { - analyzeWithSymbolAsContext(containingPropertySymbol) { - getTypeNullability( - containingPropertySymbol.returnType - ) - } + getTypeNullability(containingPropertySymbol.returnType) } else NullabilityType.Unknown val annotationsFromProperty = containingPropertySymbol.computeAnnotations( @@ -152,13 +147,11 @@ internal class FirLightAccessorMethodForSymbol( private val _returnedType: PsiType by lazyPub { if (!isGetter) return@lazyPub PsiType.VOID - analyzeWithSymbolAsContext(containingPropertySymbol) { - containingPropertySymbol.returnType.asPsiType( - this@FirLightAccessorMethodForSymbol, - KtTypeMappingMode.RETURN_TYPE, - containingClass.isAnnotationType - ) - } ?: nonExistentType() + containingPropertySymbol.returnType.asPsiType( + this@FirLightAccessorMethodForSymbol, + KtTypeMappingMode.RETURN_TYPE, + containingClass.isAnnotationType + ) ?: nonExistentType() } override fun getReturnType(): PsiType = _returnedType @@ -179,9 +172,7 @@ internal class FirLightAccessorMethodForSymbol( if (propertyParameter != null) { builder.addParameter( FirLightSetterParameterForSymbol( - parameterSymbol = propertyParameter, - containingPropertySymbol = containingPropertySymbol, - containingMethod = this@FirLightAccessorMethodForSymbol + containingPropertySymbol, propertyParameter, this@FirLightAccessorMethodForSymbol ) ) } diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightConstructorForSymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightConstructorForSymbol.kt index 6854f848534..53984d223a6 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightConstructorForSymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightConstructorForSymbol.kt @@ -11,6 +11,9 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.analysis.api.lifetime.isValid import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession + +context(KtAnalysisSession) internal class FirLightConstructorForSymbol( private val constructorSymbol: KtConstructorSymbol, lightMemberOrigin: LightMemberOrigin?, diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightMethod.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightMethod.kt index a48b7739463..b61962817e7 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightMethod.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightMethod.kt @@ -26,6 +26,9 @@ import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper import org.jetbrains.kotlin.utils.addToStdlib.ifTrue +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession + +context(KtAnalysisSession) internal abstract class FirLightMethod( lightMemberOrigin: LightMemberOrigin?, containingClass: KtLightClass, diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightMethodForSymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightMethodForSymbol.kt index fc1a846bf3a..29373135601 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightMethodForSymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightMethodForSymbol.kt @@ -7,14 +7,16 @@ package org.jetbrains.kotlin.light.classes.symbol import com.intellij.psi.PsiIdentifier import com.intellij.psi.PsiParameterList -import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin -import org.jetbrains.kotlin.asJava.classes.lazyPub +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.lifetime.isValid import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionLikeSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol +import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin +import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.psi.KtDeclaration import java.util.* +context(KtAnalysisSession) internal abstract class FirLightMethodForSymbol( private val functionSymbol: KtFunctionLikeSymbol, lightMemberOrigin: LightMemberOrigin?, diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightNoArgConstructor.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightNoArgConstructor.kt index a730b906825..e33674ddfca 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightNoArgConstructor.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightNoArgConstructor.kt @@ -9,6 +9,9 @@ import com.intellij.psi.* import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin import org.jetbrains.kotlin.asJava.classes.lazyPub +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession + +context(KtAnalysisSession) internal class FirLightNoArgConstructor( lightMemberOrigin: LightMemberOrigin?, containingClass: FirLightClassBase, diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightSimpleMethodForSymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightSimpleMethodForSymbol.kt index 1607645179e..380b1ae7bb4 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightSimpleMethodForSymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightSimpleMethodForSymbol.kt @@ -6,17 +6,19 @@ package org.jetbrains.kotlin.light.classes.symbol import com.intellij.psi.* -import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin -import org.jetbrains.kotlin.asJava.classes.lazyPub +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.lifetime.isValid import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode +import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin +import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.JvmNames.STRICTFP_ANNOTATION_CLASS_ID import org.jetbrains.kotlin.name.JvmNames.SYNCHRONIZED_ANNOTATION_CLASS_ID import org.jetbrains.kotlin.utils.addToStdlib.ifTrue import java.util.* +context(KtAnalysisSession) internal class FirLightSimpleMethodForSymbol( private val functionSymbol: KtFunctionSymbol, lightMemberOrigin: LightMemberOrigin?, @@ -59,7 +61,7 @@ internal class FirLightSimpleMethodForSymbol( val nullability = if (isPrivate) { NullabilityType.Unknown } else { - analyzeWithSymbolAsContext(functionSymbol) l@{ + run l@{ val ktType = when { functionSymbol.isSuspend -> // Any? @@ -136,22 +138,19 @@ internal class FirLightSimpleMethodForSymbol( } private val _returnedType: PsiType by lazyPub { - analyzeWithSymbolAsContext(functionSymbol) { - val ktType = - when { - functionSymbol.isSuspend -> // Any? - analysisSession.builtinTypes.NULLABLE_ANY - isVoidReturnType -> - return@lazyPub PsiType.VOID - else -> - functionSymbol.returnType - } - ktType.asPsiType( - this@FirLightSimpleMethodForSymbol, - KtTypeMappingMode.RETURN_TYPE, - containingClass.isAnnotationType - ) - } ?: nonExistentType() + val ktType = when { + functionSymbol.isSuspend -> // Any? + analysisSession.builtinTypes.NULLABLE_ANY + isVoidReturnType -> + return@lazyPub PsiType.VOID + else -> + functionSymbol.returnType + } + ktType.asPsiType( + this@FirLightSimpleMethodForSymbol, + KtTypeMappingMode.RETURN_TYPE, + containingClass.isAnnotationType + ) ?: nonExistentType() } override fun getReturnType(): PsiType = _returnedType diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterBaseForSymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterBaseForSymbol.kt index 7be188eb988..122bbaa5460 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterBaseForSymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterBaseForSymbol.kt @@ -6,11 +6,13 @@ package org.jetbrains.kotlin.light.classes.symbol import com.intellij.psi.* -import org.jetbrains.kotlin.asJava.classes.lazyPub +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode +import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.psi.KtParameter +context(KtAnalysisSession) internal abstract class FirLightParameterBaseForSymbol( private val parameterSymbol: KtValueParameterSymbol, private val containingMethod: FirLightMethod @@ -34,19 +36,14 @@ internal abstract class FirLightParameterBaseForSymbol( val nullabilityApplicable = !containingMethod.containingClass.let { it.isAnnotationType || it.isEnum } && !containingMethod.hasModifierProperty(PsiModifier.PRIVATE) - return if (nullabilityApplicable) { - analyzeWithSymbolAsContext(parameterSymbol) { - getTypeNullability( - parameterSymbol.returnType - ) - } - } else NullabilityType.Unknown + return if (nullabilityApplicable) getTypeNullability(parameterSymbol.returnType) + else NullabilityType.Unknown } override fun getNameIdentifier(): PsiIdentifier = _identifier private val _type by lazyPub { - val convertedType = analyzeWithSymbolAsContext(parameterSymbol) { + val convertedType = run { val ktType = parameterSymbol.returnType val typeMappingMode = when { ktType.isSuspendFunctionType -> KtTypeMappingMode.DEFAULT diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterForReceiver.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterForReceiver.kt index 1ad9c5b8a91..484c460f965 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterForReceiver.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterForReceiver.kt @@ -9,16 +9,18 @@ import com.intellij.psi.PsiAnnotation import com.intellij.psi.PsiIdentifier import com.intellij.psi.PsiModifierList import com.intellij.psi.PsiType +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.annotations.annotations -import org.jetbrains.kotlin.asJava.classes.lazyPub -import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.analysis.api.lifetime.isValid import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol import org.jetbrains.kotlin.analysis.api.symbols.markers.KtNamedSymbol import org.jetbrains.kotlin.analysis.api.types.KtType +import org.jetbrains.kotlin.asJava.classes.lazyPub +import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.psi.KtParameter +context(KtAnalysisSession) internal class FirLightParameterForReceiver private constructor( private val receiverType: KtType, private val context: KtSymbol, @@ -27,11 +29,11 @@ internal class FirLightParameterForReceiver private constructor( ) : FirLightParameter(method) { companion object { + context (KtAnalysisSession) fun tryGet( callableSymbol: KtCallableSymbol, method: FirLightMethod ): FirLightParameterForReceiver? { - if (callableSymbol !is KtNamedSymbol) return null if (!callableSymbol.isExtension) return null @@ -71,9 +73,7 @@ internal class FirLightParameterForReceiver private constructor( } private val _type: PsiType by lazyPub { - analyzeWithSymbolAsContext(context) { - receiverType.asPsiType(this@FirLightParameterForReceiver) - } ?: nonExistentType() + receiverType.asPsiType(this@FirLightParameterForReceiver) ?: nonExistentType() } override fun getType(): PsiType = _type diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterForSymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterForSymbol.kt index 5f811a63246..37e351a3a6d 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterForSymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterForSymbol.kt @@ -13,6 +13,9 @@ import org.jetbrains.kotlin.analysis.api.lifetime.isValid import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol import org.jetbrains.kotlin.utils.addToStdlib.ifTrue +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession + +context(KtAnalysisSession) internal class FirLightParameterForSymbol( private val parameterSymbol: KtValueParameterSymbol, containingMethod: FirLightMethod diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterList.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterList.kt index e5d77291d9d..a3671276c6b 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterList.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterList.kt @@ -15,6 +15,9 @@ import org.jetbrains.kotlin.asJava.elements.KtLightElementBase import org.jetbrains.kotlin.psi.KtFunction import org.jetbrains.kotlin.psi.KtParameterList +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession + +context(KtAnalysisSession) internal class FirLightParameterList( private val parent: FirLightMethod, private val callableSymbol: KtCallableSymbol?, diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightSetterParameterForSymbol.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightSetterParameterForSymbol.kt index 405fa6fc743..ddcf69267c4 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightSetterParameterForSymbol.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightSetterParameterForSymbol.kt @@ -13,6 +13,9 @@ import org.jetbrains.kotlin.analysis.api.lifetime.isValid import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession + +context(KtAnalysisSession) internal class FirLightSetterParameterForSymbol( private val containingPropertySymbol: KtPropertySymbol, private val parameterSymbol: KtValueParameterSymbol, diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightSuspendContinuationParameter.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightSuspendContinuationParameter.kt index 780bb0d8ddf..2d4f5bb976b 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightSuspendContinuationParameter.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightSuspendContinuationParameter.kt @@ -18,6 +18,9 @@ import org.jetbrains.kotlin.codegen.coroutines.SUSPEND_FUNCTION_COMPLETION_PARAM import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.psi.KtParameter +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession + +context(KtAnalysisSession) internal class FirLightSuspendContinuationParameter( private val functionSymbol: KtFunctionSymbol, private val containingMethod: FirLightMethod, @@ -33,11 +36,9 @@ internal class FirLightSuspendContinuationParameter( override fun getType(): PsiType = _type private val _type by lazyPub { - analyzeWithSymbolAsContext(functionSymbol) { - buildClassType(StandardClassIds.Continuation) { - argument(functionSymbol.returnType) - }.asPsiType(this@FirLightSuspendContinuationParameter) - } ?: nonExistentType() + buildClassType(StandardClassIds.Continuation) { argument(functionSymbol.returnType) } + .asPsiType(this) + ?: nonExistentType() } override fun isVarArgs(): Boolean = false diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightTypeParameter.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightTypeParameter.kt index 011b9da0439..460e40775a4 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightTypeParameter.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightTypeParameter.kt @@ -13,6 +13,7 @@ import com.intellij.psi.impl.PsiClassImplUtil import com.intellij.psi.impl.light.LightElement import com.intellij.psi.javadoc.PsiDocComment import com.intellij.psi.search.SearchScope +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.lifetime.isValid import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol import org.jetbrains.kotlin.analysis.api.types.KtClassErrorType @@ -23,11 +24,15 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.asJava.elements.KtLightAbstractAnnotation import org.jetbrains.kotlin.asJava.elements.KtLightDeclaration import org.jetbrains.kotlin.idea.KotlinLanguage -import org.jetbrains.kotlin.light.classes.symbol.* +import org.jetbrains.kotlin.light.classes.symbol.FirLightTypeParameterListForSymbol +import org.jetbrains.kotlin.light.classes.symbol.basicIsEquivalentTo +import org.jetbrains.kotlin.light.classes.symbol.invalidAccess +import org.jetbrains.kotlin.light.classes.symbol.mapSuperType import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.psi.KtTypeParameter import org.jetbrains.kotlin.psi.psiUtil.startOffset +context(KtAnalysisSession) internal class FirLightTypeParameter( private val parent: FirLightTypeParameterListForSymbol, private val index: Int, @@ -58,20 +63,18 @@ internal class FirLightTypeParameter( language = language, role = PsiReferenceList.Role.EXTENDS_LIST ) - analyzeWithSymbolAsContext(typeParameterSymbol) { - typeParameterSymbol.upperBounds - .filter { type -> - when (type) { - is KtNonErrorClassType -> type.classId != StandardClassIds.Any - is KtClassErrorType -> false - else -> true - } + typeParameterSymbol.upperBounds + .filter { type -> + when (type) { + is KtNonErrorClassType -> type.classId != StandardClassIds.Any + is KtClassErrorType -> false + else -> true } - .mapNotNull { - mapSuperType(it, this@FirLightTypeParameter, kotlinCollectionAsIs = true) - } - .forEach { listBuilder.addReference(it) } - } + } + .mapNotNull { + mapSuperType(it, this@FirLightTypeParameter, kotlinCollectionAsIs = true) + } + .forEach { listBuilder.addReference(it) } listBuilder }