[FIR IDE] Remove LightClassProvider

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliKotlinAsJavaSupport.kt

@@ -12,10 +12,7 @@ import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.search.PsiSearchScopeUtil
 import com.intellij.util.SmartList
 import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
-import org.jetbrains.kotlin.asJava.classes.KtLightClass
+import org.jetbrains.kotlin.asJava.classes.*
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForScript
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
 import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
 import org.jetbrains.kotlin.load.java.components.FilesByFacadeFqNameIndexer
@@ -81,6 +78,8 @@ class CliKotlinAsJavaSupport(
         }.orEmpty()
     }
 
+    override fun getFakeLightClass(classOrObject: KtClassOrObject): KtFakeLightClass =
+        KtDescriptorBasedFakeLightClass(classOrObject)
 
     override fun findClassOrObjectDeclarationsInPackage(
         packageFqName: FqName, searchScope: GlobalSearchScope

compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinAsJavaSupport.kt

@@ -9,6 +9,7 @@ import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiClass
 import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightClass
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtClassOrObject
@@ -53,6 +54,8 @@ abstract class KotlinAsJavaSupport {
 
     abstract fun findFilesForFacade(facadeFqName: FqName, scope: GlobalSearchScope): Collection<KtFile>
 
+    abstract fun getFakeLightClass(classOrObject: KtClassOrObject): KtFakeLightClass
+
     companion object {
         @JvmStatic
         fun getInstance(project: Project): KotlinAsJavaSupport {

compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtFakeLightClass.kt

@@ -3,7 +3,7 @@
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
-package org.jetbrains.kotlin.idea.caches.lightClasses
+package org.jetbrains.kotlin.asJava.classes
 
 import com.intellij.ide.highlighter.JavaFileType
 import com.intellij.openapi.project.Project
@@ -11,53 +11,85 @@ import com.intellij.psi.*
 import com.intellij.psi.impl.PsiClassImplUtil
 import com.intellij.psi.impl.light.AbstractLightClass
 import com.intellij.psi.impl.light.LightMethod
+import com.intellij.psi.search.SearchScope
 import com.intellij.util.IncorrectOperationException
-import org.jetbrains.kotlin.asJava.classes.KtLightClass
+import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
 import org.jetbrains.kotlin.asJava.elements.KtLightElement
+import org.jetbrains.kotlin.asJava.toFakeLightClass
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.idea.KotlinLanguage
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.isFakeLightClassInheritor
 import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
+import org.jetbrains.kotlin.resolve.DescriptorUtils
 import javax.swing.Icon
 
 // Used as a placeholder when actual light class does not exist (expect-classes, for example)
 // The main purpose is to allow search of inheritors within hierarchies containing such classes
-class KtFakeLightClass(override val kotlinOrigin: KtClassOrObject) :
+abstract class KtFakeLightClass(override val kotlinOrigin: KtClassOrObject) :
     AbstractLightClass(kotlinOrigin.manager, KotlinLanguage.INSTANCE),
     KtLightClass {
-    private val _delegate by lazy { DummyJavaPsiFactory.createDummyClass(kotlinOrigin.project) }
+
-    private val _containingClass by lazy { kotlinOrigin.containingClassOrObject?.let { KtFakeLightClass(it) } }
+    private val _delegate: PsiClass by lazy { DummyJavaPsiFactory.createDummyClass(kotlinOrigin.project) }
 
     override val clsDelegate get() = _delegate
     override val originKind get() = LightClassOriginKind.SOURCE
 
-    override fun getName() = kotlinOrigin.name
+    override fun getName(): String? = kotlinOrigin.name
+    override fun getDelegate(): PsiClass = _delegate
+    abstract override fun copy(): KtFakeLightClass
 
-    override fun getDelegate() = _delegate
+    override fun getQualifiedName(): String? = kotlinOrigin.fqName?.asString()
-    override fun copy() = KtFakeLightClass(kotlinOrigin)
+    abstract override fun getContainingClass(): KtFakeLightClass?
+    override fun getNavigationElement(): PsiElement = kotlinOrigin.navigationElement
+    override fun getIcon(flags: Int): Icon? = kotlinOrigin.getIcon(flags)
+    override fun getContainingFile(): PsiFile = kotlinOrigin.containingFile
+    override fun getUseScope(): SearchScope = kotlinOrigin.useScope
 
-    override fun getQualifiedName() = kotlinOrigin.fqName?.asString()
+    abstract override fun isInheritor(baseClass: PsiClass, checkDeep: Boolean): Boolean
-    override fun getContainingClass() = _containingClass
-    override fun getNavigationElement() = kotlinOrigin.navigationElement
-    override fun getIcon(flags: Int) = kotlinOrigin.getIcon(flags)
-    override fun getContainingFile() = kotlinOrigin.containingFile
-    override fun getUseScope() = kotlinOrigin.useScope
-
-    override fun isInheritor(baseClass: PsiClass, checkDeep: Boolean): Boolean =
-        isFakeLightClassInheritor(baseClass, checkDeep)
 
     override fun isEquivalentTo(another: PsiElement?): Boolean = PsiClassImplUtil.isClassEquivalentTo(this, another)
 }
 
+class KtDescriptorBasedFakeLightClass(kotlinOrigin: KtClassOrObject) : KtFakeLightClass(kotlinOrigin) {
+
+    override fun copy(): KtFakeLightClass = KtDescriptorBasedFakeLightClass(kotlinOrigin)
+
+    private val _containingClass: KtFakeLightClass? by lazy {
+        kotlinOrigin.containingClassOrObject?.let { KtDescriptorBasedFakeLightClass(it) }
+    }
+    override fun getContainingClass(): KtFakeLightClass? = _containingClass
+
+    override fun isInheritor(baseClass: PsiClass, checkDeep: Boolean): Boolean {
+        if (manager.areElementsEquivalent(baseClass, this)) return false
+        LightClassInheritanceHelper.getService(project).isInheritor(this, baseClass, checkDeep).ifSure { return it }
+
+        val baseKtClass = (baseClass as? KtLightClass)?.kotlinOrigin ?: return false
+
+        val generationSupport = LightClassGenerationSupport.getInstance(project)
+
+        val baseDescriptor = generationSupport.resolveToDescriptor(baseKtClass) as? ClassDescriptor ?: return false
+        val thisDescriptor = generationSupport.resolveToDescriptor(kotlinOrigin) as? ClassDescriptor ?: return false
+
+        val thisFqName = DescriptorUtils.getFqName(thisDescriptor).asString()
+        val baseFqName = DescriptorUtils.getFqName(baseDescriptor).asString()
+        if (thisFqName == baseFqName) return false
+
+        return if (checkDeep)
+            DescriptorUtils.isSubclass(thisDescriptor, baseDescriptor)
+        else
+            DescriptorUtils.isDirectSubclass(thisDescriptor, baseDescriptor)
+    }
+}
+
 class KtFakeLightMethod private constructor(
     val ktDeclaration: KtNamedDeclaration,
     ktClassOrObject: KtClassOrObject
 ) : LightMethod(
     ktDeclaration.manager,
     DummyJavaPsiFactory.createDummyVoidMethod(ktDeclaration.project),
-    KtFakeLightClass(ktClassOrObject),
+    ktClassOrObject.toFakeLightClass(),
     KotlinLanguage.INSTANCE
 ), KtLightElement<KtNamedDeclaration, PsiMethod> {
     override val kotlinOrigin get() = ktDeclaration
@@ -92,7 +124,7 @@ private object DummyJavaPsiFactory {
             ?: throw IncorrectOperationException("Method was not created. Method name: $name; return type: $canonicalText")
     }
 
-    fun createDummyClass(project: Project): PsiClass = PsiElementFactory.SERVICE.getInstance(project).createClass("dummy")
+    fun createDummyClass(project: Project): PsiClass = PsiElementFactory.getInstance(project).createClass("dummy")
 
     private fun createDummyJavaFile(project: Project, text: String): PsiJavaFile {
         return PsiFileFactory.getInstance(project).createFileFromText(

compiler/light-classes/src/org/jetbrains/kotlin/asJava/lightClassUtils.kt

@@ -19,10 +19,7 @@ package org.jetbrains.kotlin.asJava
 import com.intellij.psi.*
 import com.intellij.psi.impl.light.LightField
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.asJava.classes.KtLightClass
+import org.jetbrains.kotlin.asJava.classes.*
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
-import org.jetbrains.kotlin.asJava.classes.KtUltraLightElementWithNullabilityAnnotation
-import org.jetbrains.kotlin.asJava.classes.runReadAction
 import org.jetbrains.kotlin.asJava.elements.PsiElementWithOrigin
 import org.jetbrains.kotlin.asJava.elements.*
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
@@ -54,6 +51,8 @@ fun KtClassOrObject.toLightClassWithBuiltinMapping(): PsiClass? {
     return JavaPsiFacade.getInstance(project).findClass(javaClassFqName.asString(), searchScope)
 }
 
+fun KtClassOrObject.toFakeLightClass(): KtFakeLightClass = KotlinAsJavaSupport.getInstance(project).getFakeLightClass(this)
+
 fun KtFile.findFacadeClass(): KtLightClass? {
     return KotlinAsJavaSupport.getInstance(project)
             .getFacadeClassesInPackage(packageFqName, this.useScope as? GlobalSearchScope ?: GlobalSearchScope.projectScope(project))

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/IdeLightClassInheritanceHelper.kt

@@ -39,14 +39,16 @@ class IdeLightClassInheritanceHelper : LightClassInheritanceHelper {
         if (lightClass.manager.areElementsEquivalent(baseClass, lightClass)) return NO_MATCH
 
         val classOrObject = lightClass.kotlinOrigin ?: return UNSURE
+
+        if (checkDeep && baseClass.qualifiedName == CommonClassNames.JAVA_LANG_OBJECT) {
+            return MATCH
+        }
+
         val entries = classOrObject.superTypeListEntries
         val hasSuperClass = entries.any { it is KtSuperTypeCallEntry }
         if (baseClass.qualifiedName == classOrObject.defaultJavaAncestorQualifiedName() && (!hasSuperClass || checkDeep)) {
             return MATCH
         }
-        if (checkDeep && baseClass.qualifiedName == CommonClassNames.JAVA_LANG_OBJECT) {
-            return MATCH
-        }
         val amongEntries = isAmongEntries(baseClass, entries)
         return when {
             !checkDeep -> amongEntries

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/decompiledDeclarations/KtLightClassForDecompiledDeclaration.kt

@@ -10,28 +10,27 @@ import com.intellij.psi.*
 import com.intellij.psi.impl.PsiClassImplUtil
 import com.intellij.psi.impl.PsiImplUtil
 import com.intellij.psi.impl.PsiSuperMethodImplUtil
-import com.intellij.psi.impl.source.PsiExtensibleClass
 import com.intellij.psi.javadoc.PsiDocComment
 import com.intellij.psi.scope.PsiScopeProcessor
 import com.intellij.psi.util.PsiUtil
 import org.jetbrains.annotations.NonNls
 import org.jetbrains.kotlin.analyzer.KotlinModificationTrackerService
 import org.jetbrains.kotlin.asJava.classes.KotlinClassInnerStuffCache
-import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.asJava.classes.LightClassesLazyCreator
 import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.asJava.elements.KtLightElementBase
+import org.jetbrains.kotlin.idea.caches.lightClasses.decompiledDeclarations.KtLightEnumEntryForDecompiledDeclaration
+import org.jetbrains.kotlin.idea.caches.lightClasses.decompiledDeclarations.KtLightFieldForDecompiledDeclaration
+import org.jetbrains.kotlin.idea.caches.lightClasses.decompiledDeclarations.KtLightMethodForDecompiledDeclaration
 import org.jetbrains.kotlin.idea.decompiler.classFile.KtClsFile
 import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind
 import org.jetbrains.kotlin.psi.KtClassOrObject
-import org.jetbrains.kotlin.idea.caches.lightClasses.decompiledDeclarations.*
 
 open class KtLightClassForDecompiledDeclaration(
     override val clsDelegate: PsiClass,
     private val clsParent: PsiElement,
     private val file: KtClsFile,
-    final override val kotlinOrigin: KtClassOrObject?
+    kotlinOrigin: KtClassOrObject?
-) : KtLightElementBase(clsParent), PsiClass, KtLightClass, PsiExtensibleClass {
+) : KtLightClassForDecompiledDeclarationBase(clsDelegate, clsParent, kotlinOrigin) {
 
     private val myInnersCache = KotlinClassInnerStuffCache(
         myClass = this,

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDEKotlinAsJavaSupport.kt

@@ -250,6 +250,8 @@ open class IDEKotlinAsJavaSupport(private val project: Project) : KotlinAsJavaSu
         }
     }
 
+    override fun getFakeLightClass(classOrObject: KtClassOrObject): KtFakeLightClass =
+        KtDescriptorBasedFakeLightClass(classOrObject)
 
     // NOTE: this is a hacky solution to the following problem:
     // when building this light class resolver will be built by the first file in the list

idea/idea-fir/src/org/jetbrains/kotlin/idea/caches/resolve/IDEKotlinAsJavaSupport.kt

@@ -6,21 +6,15 @@
 package org.jetbrains.kotlin.idea.caches.resolve
 
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.util.Key
-import com.intellij.openapi.util.UserDataHolder
 import com.intellij.psi.PsiManager
 import com.intellij.psi.search.GlobalSearchScope
-import com.intellij.psi.util.CachedValueProvider
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightClass
-import com.intellij.psi.util.CachedValuesManager
-import org.jetbrains.kotlin.analyzer.KotlinModificationTrackerService
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.idea.asJava.FirLightClassForFacade
+import org.jetbrains.kotlin.idea.asJava.KtFirBasedFakeLightClass
-import org.jetbrains.kotlin.idea.asJava.classes.createFirLightClassNoCache
 import org.jetbrains.kotlin.idea.asJava.classes.getOrCreateFirLightClass
 import org.jetbrains.kotlin.idea.asJava.classes.getOrCreateFirLightFacade
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtClassOrObject
-import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtScript
 
 class IDEKotlinAsJavaFirSupport(project: Project) : IDEKotlinAsJavaSupport(project) {
@@ -38,4 +32,7 @@ class IDEKotlinAsJavaFirSupport(project: Project) : IDEKotlinAsJavaSupport(proje
 
     override fun createLightClassForSourceDeclaration(classOrObject: KtClassOrObject): KtLightClass? =
         getOrCreateFirLightClass(classOrObject)
+
+    override fun getFakeLightClass(classOrObject: KtClassOrObject): KtFakeLightClass =
+        KtFirBasedFakeLightClass(classOrObject)
 }

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/LightClassProviderFirImpl.kt

@@ -1,57 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.idea.asJava
-
-import com.intellij.psi.*
-import com.intellij.psi.impl.InheritanceImplUtil
-import org.jetbrains.kotlin.asJava.*
-import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.idea.caches.lightClasses.KtFakeLightClass
-import org.jetbrains.kotlin.idea.caches.lightClasses.KtFakeLightMethod
-import org.jetbrains.kotlin.psi.*
-
-class LightClassProviderFirImpl : LightClassProvider {
-    override fun getLightFieldForCompanionObject(companionObject: KtClassOrObject): PsiField? =
-        LightClassUtil.getLightFieldForCompanionObject(companionObject)
-
-    override fun getLightClassMethods(function: KtFunction): List<PsiMethod> =
-        LightClassUtil.getLightClassMethods(function)
-
-    override fun getLightClassParameterDeclarations(parameter: KtParameter): List<PsiNamedElement> =
-        LightClassUtil.getLightClassPropertyMethods(parameter).allDeclarations
-
-    override fun getLightClassPropertyDeclarations(property: KtProperty): List<PsiNamedElement> =
-        LightClassUtil.getLightClassPropertyMethods(property).allDeclarations
-
-    override fun toLightClassWithBuiltinMapping(classOrObject: KtClassOrObject): PsiClass? =
-        classOrObject.toLightClassWithBuiltinMapping()
-
-    override fun toLightMethods(psiElement: PsiElement): List<PsiMethod> =
-        psiElement.toLightMethods()
-
-    override fun toLightClass(classOrObject: KtClassOrObject): KtLightClass? =
-        classOrObject.toLightClass()
-
-    override fun toLightElements(ktElement: KtElement): List<PsiNamedElement> =
-        ktElement.toLightElements()
-
-    override fun createKtFakeLightClass(kotlinOrigin: KtClassOrObject): PsiClass? =
-        KtFakeLightClass(kotlinOrigin)
-
-    override fun getRepresentativeLightMethod(psiElement: PsiElement): PsiMethod? =
-        psiElement.getRepresentativeLightMethod()
-
-    override fun isKtFakeLightClass(psiClass: PsiClass): Boolean =
-        psiClass is KtFakeLightClass
-
-    override fun isKtLightClassForDecompiledDeclaration(psiClass: PsiClass): Boolean = false //TODO
-
-    override fun createKtFakeLightMethod(ktDeclaration: KtNamedDeclaration): PsiMethod? =
-        KtFakeLightMethod.get(ktDeclaration)
-
-    override fun isFakeLightClassInheritor(ktFakeLightClass: KtFakeLightClass, baseClass: PsiClass, checkDeep: Boolean): Boolean =
-        InheritanceImplUtil.isInheritor(ktFakeLightClass, baseClass, checkDeep)
-}

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForClassOrObjectSymbol.kt

@@ -132,6 +132,7 @@ internal abstract class FirLightClassForClassOrObjectSymbol(
 
     override fun isValid(): Boolean = kotlinOrigin?.isValid ?: true
 
+    //TODO: Implement inheritance check via symbols
     override fun isInheritor(baseClass: PsiClass, checkDeep: Boolean): Boolean =
         InheritanceImplUtil.isInheritor(this, baseClass, checkDeep)
 

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/KtFirBasedFakeLightClass.kt

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.asJava
+
+import com.intellij.psi.PsiClass
+import com.intellij.psi.impl.InheritanceImplUtil
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightClass
+import org.jetbrains.kotlin.asJava.classes.KtLightClass
+import org.jetbrains.kotlin.asJava.classes.LightClassInheritanceHelper
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
+
+//TODO Make fake class symbol based
+class KtFirBasedFakeLightClass(kotlinOrigin: KtClassOrObject) : KtFakeLightClass(kotlinOrigin) {
+    override fun copy(): KtFakeLightClass = KtFirBasedFakeLightClass(kotlinOrigin)
+
+    private val _containingClass: KtFakeLightClass? by lazy {
+        kotlinOrigin.containingClassOrObject?.let { KtFirBasedFakeLightClass(it) }
+    }
+
+    override fun getContainingClass(): KtFakeLightClass? = _containingClass
+
+    override fun isInheritor(baseClass: PsiClass, checkDeep: Boolean): Boolean {
+        //TODO Implement correct inheritance check with symbols
+        if (manager.areElementsEquivalent(baseClass, this)) return false
+        LightClassInheritanceHelper.getService(project).isInheritor(this, baseClass, checkDeep).ifSure { return it }
+
+        if ((baseClass as? KtLightClass)?.kotlinOrigin == null) return false
+        return InheritanceImplUtil.isInheritor(this, baseClass, checkDeep)
+    }
+}

idea/idea-frontend-independent/src/org/jetbrains/kotlin/idea/KotlinIconProviderBase.kt

@@ -18,9 +18,9 @@ import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration
 import org.jetbrains.kotlin.asJava.unwrapped
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedIsKtLightClassForDecompiledDeclaration
 import org.jetbrains.kotlin.idea.KotlinIconsIndependent.ACTUAL
 import org.jetbrains.kotlin.idea.KotlinIconsIndependent.EXPECT
+import org.jetbrains.kotlin.idea.caches.lightClasses.KtLightClassForDecompiledDeclarationBase
 import org.jetbrains.kotlin.idea.util.ifTrue
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
@@ -149,7 +149,7 @@ open class KotlinIconProviderBase : IconProvider(), DumbAware {
             is KtProperty -> if (isVar) KotlinIconsIndependent.FIELD_VAR else KotlinIconsIndependent.FIELD_VAL
             is KtClassInitializer -> KotlinIconsIndependent.CLASS_INITIALIZER
             is KtTypeAlias -> KotlinIconsIndependent.TYPE_ALIAS
-            is PsiClass -> providedIsKtLightClassForDecompiledDeclaration().ifTrue {
+            is PsiClass -> (this is KtLightClassForDecompiledDeclarationBase).ifTrue {
                 val origin = (this as? KtLightClass)?.kotlinOrigin
                 //TODO (light classes for decompiled files): correct presentation
                 if (origin != null) origin.getBaseIcon() else KotlinIconsIndependent.CLASS

idea/idea-frontend-independent/src/org/jetbrains/kotlin/idea/asJava/LightClassProvider.kt

@@ -1,93 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.idea.asJava
-
-import com.intellij.openapi.components.ServiceManager
-import com.intellij.openapi.project.Project
-import com.intellij.psi.*
-import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.idea.caches.lightClasses.KtFakeLightClass
-import org.jetbrains.kotlin.psi.*
-
-interface LightClassProvider {
-
-    fun getLightFieldForCompanionObject(companionObject: KtClassOrObject): PsiField?
-
-    fun getLightClassMethods(function: KtFunction): List<PsiMethod>
-
-    fun getLightClassParameterDeclarations(parameter: KtParameter): List<PsiNamedElement>
-
-    fun getLightClassPropertyDeclarations(property: KtProperty): List<PsiNamedElement>
-
-    fun toLightClassWithBuiltinMapping(classOrObject: KtClassOrObject): PsiClass?
-
-    fun toLightMethods(psiElement: PsiElement): List<PsiMethod>
-
-    fun toLightClass(classOrObject: KtClassOrObject): KtLightClass?
-
-    fun toLightElements(ktElement: KtElement): List<PsiNamedElement>
-
-    fun createKtFakeLightClass(kotlinOrigin: KtClassOrObject): PsiClass?
-
-    fun getRepresentativeLightMethod(psiElement: PsiElement): PsiMethod?
-
-    fun isKtFakeLightClass(psiClass: PsiClass): Boolean
-
-    fun isKtLightClassForDecompiledDeclaration(psiClass: PsiClass): Boolean
-
-    fun createKtFakeLightMethod(ktDeclaration: KtNamedDeclaration): PsiMethod?
-
-    fun isFakeLightClassInheritor(ktFakeLightClass: KtFakeLightClass, baseClass: PsiClass, checkDeep: Boolean): Boolean
-
-    companion object {
-
-        fun getInstance(project: Project): LightClassProvider {
-            return ServiceManager.getService(project, LightClassProvider::class.java)
-        }
-
-        fun providedGetLightFieldForCompanionObject(companionObject: KtClassOrObject): PsiField? =
-            getInstance(companionObject.project).getLightFieldForCompanionObject(companionObject)
-
-        fun providedGetLightClassMethods(function: KtFunction): List<PsiMethod> =
-            getInstance(function.project).getLightClassMethods(function)
-
-        fun providedGetLightClassParameterDeclarations(parameter: KtParameter): List<PsiNamedElement> =
-            getInstance(parameter.project).getLightClassParameterDeclarations(parameter)
-
-        fun providedGetLightClassPropertyDeclarations(property: KtProperty): List<PsiNamedElement> =
-            getInstance(property.project).getLightClassPropertyDeclarations(property)
-
-        fun KtClassOrObject.providedToLightClassWithBuiltinMapping(): PsiClass? =
-            getInstance(project).toLightClassWithBuiltinMapping(this)
-
-        fun PsiElement.providedToLightMethods(): List<PsiMethod> =
-            getInstance(project).toLightMethods(this)
-
-        fun KtClassOrObject.providedToLightClass(): KtLightClass? =
-            getInstance(project).toLightClass(this)
-
-        fun KtElement.providedToLightElements(): List<PsiNamedElement> =
-            getInstance(project).toLightElements(this)
-
-        fun providedCreateKtFakeLightClass(kotlinOrigin: KtClassOrObject): PsiClass? =
-            getInstance(kotlinOrigin.project).createKtFakeLightClass(kotlinOrigin)
-
-        fun PsiClass.providedIsKtFakeLightClass(): Boolean =
-            getInstance(project).isKtFakeLightClass(this)
-
-        fun PsiClass.providedIsKtLightClassForDecompiledDeclaration(): Boolean =
-            getInstance(project).isKtLightClassForDecompiledDeclaration(this)
-
-        fun providedCreateKtFakeLightMethod(ktDeclaration: KtNamedDeclaration): PsiMethod? =
-            getInstance(ktDeclaration.project).createKtFakeLightMethod(ktDeclaration)
-
-        fun PsiElement.providedGetRepresentativeLightMethod(): PsiMethod? =
-            getInstance(project).getRepresentativeLightMethod(this)
-
-        fun KtFakeLightClass.isFakeLightClassInheritor(baseClass: PsiClass, checkDeep: Boolean): Boolean =
-            getInstance(project).isFakeLightClassInheritor(this, baseClass, checkDeep)
-    }
-}

idea/idea-frontend-independent/src/org/jetbrains/kotlin/idea/caches/lightClasses/KtLightClassForDecompiledDeclarationBase.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.caches.lightClasses
+
+import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiElement
+import com.intellij.psi.impl.source.PsiExtensibleClass
+import org.jetbrains.kotlin.asJava.classes.KtLightClass
+import org.jetbrains.kotlin.asJava.elements.KtLightElementBase
+import org.jetbrains.kotlin.psi.KtClassOrObject
+
+abstract class KtLightClassForDecompiledDeclarationBase(
+    override val clsDelegate: PsiClass,
+    clsParent: PsiElement,
+    final override val kotlinOrigin: KtClassOrObject?
+) : KtLightElementBase(clsParent), PsiClass, KtLightClass, PsiExtensibleClass

idea/idea-frontend-independent/src/org/jetbrains/kotlin/idea/findUsages/KotlinFindUsagesHandlerFactory.kt

@@ -27,7 +27,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.ui.Messages
 import com.intellij.psi.PsiElement
 import com.intellij.psi.search.searches.OverridingMethodsSearch
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedToLightMethods
+import org.jetbrains.kotlin.asJava.toLightMethods
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.idea.KotlinBundleIndependent
 import org.jetbrains.kotlin.idea.findUsages.KotlinFindUsagesSupport.Companion.checkSuperMethods
@@ -92,7 +92,7 @@ class KotlinFindUsagesHandlerFactory(project: Project) : FindUsagesHandlerFactor
                     }
                     val function = element.ownerFunction
                     if (function != null && function.isOverridable()) {
-                        val psiMethod = function.providedToLightMethods().singleOrNull()
+                        val psiMethod = function.toLightMethods().singleOrNull()
                         if (psiMethod != null) {
                             val hasOverridden = OverridingMethodsSearch.search(psiMethod).any()
                             if (hasOverridden && askWhetherShouldSearchForParameterInOverridingMethods(element)) {

idea/idea-frontend-independent/src/org/jetbrains/kotlin/idea/findUsages/dialogs/KotlinFindClassUsagesDialog.java

@@ -31,7 +31,6 @@ import com.intellij.ui.SimpleColoredComponent;
 import com.intellij.ui.StateRestoringCheckBox;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider;
 import org.jetbrains.kotlin.asJava.LightClassUtilsKt;
 import org.jetbrains.kotlin.idea.KotlinBundleIndependent;
 import org.jetbrains.kotlin.idea.findUsages.KotlinClassFindUsagesOptions;
@@ -42,6 +41,8 @@ import org.jetbrains.kotlin.psi.psiUtil.PsiUtilsKt;
 
 import javax.swing.*;
 
+import static org.jetbrains.kotlin.asJava.LightClassUtilsKt.toLightClass;
+
 public class KotlinFindClassUsagesDialog extends FindClassUsagesDialog {
     private StateRestoringCheckBox constructorUsages;
     private StateRestoringCheckBox derivedClasses;
@@ -64,7 +65,7 @@ public class KotlinFindClassUsagesDialog extends FindClassUsagesDialog {
 
     @NotNull
     private static PsiClass getRepresentingPsiClass(@NotNull KtClassOrObject classOrObject) {
-        PsiClass lightClass = LightClassProvider.Companion.providedToLightClass(classOrObject);
+        PsiClass lightClass = toLightClass(classOrObject);
         if (lightClass != null) return lightClass;
 
         // TODO: Remove this code when light classes are generated for builtins

idea/idea-frontend-independent/src/org/jetbrains/kotlin/idea/findUsages/findUsageUtils.kt

@@ -27,8 +27,8 @@ import com.intellij.psi.search.searches.ReferencesSearch
 import com.intellij.usageView.UsageInfo
 import com.intellij.usages.UsageViewManager
 import com.intellij.util.Query
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedToLightClass
+import org.jetbrains.kotlin.asJava.toLightClass
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedToLightElements
+import org.jetbrains.kotlin.asJava.toLightElements
 import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.psi.KtConstructor
 import org.jetbrains.kotlin.psi.KtDeclaration
@@ -44,9 +44,9 @@ fun KtDeclaration.processAllExactUsages(
         if (reference is KtReference) return listOf(this)
         return SmartList<PsiElement>().also { list ->
             list += this
-            list += providedToLightElements()
+            list += toLightElements()
             if (this is KtConstructor<*>) {
-                list.addIfNotNull(getContainingClassOrObject().providedToLightClass())
+                list.addIfNotNull(getContainingClassOrObject().toLightClass())
             }
         }
     }

idea/idea-frontend-independent/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt

@@ -29,8 +29,8 @@ import com.intellij.psi.search.searches.ReferencesSearch
 import com.intellij.usageView.UsageInfo
 import com.intellij.util.FilteredQuery
 import com.intellij.util.Processor
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedToLightClass
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
+import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.idea.findUsages.KotlinClassFindUsagesOptions
 import org.jetbrains.kotlin.idea.findUsages.KotlinFindUsagesHandlerFactory
 import org.jetbrains.kotlin.idea.findUsages.KotlinFindUsagesSupport.Companion.isCallReceiverRefersToCompanionObject
@@ -98,7 +98,7 @@ class KotlinFindClassUsagesHandler(
             }
 
             if (kotlinOptions.searchConstructorUsages) {
-                classOrObject.providedToLightClass()?.constructors?.filterIsInstance<KtLightMethod>()?.forEach { constructor ->
+                classOrObject.toLightClass()?.constructors?.filterIsInstance<KtLightMethod>()?.forEach { constructor ->
                     val scope = constructor.useScope.intersectWith(options.searchScope)
                     var query = MethodReferencesSearch.search(constructor, scope, true)
                     if (kotlinOptions.isSkipImportStatements) {
@@ -184,7 +184,7 @@ class KotlinFindClassUsagesHandler(
     override fun getStringsToSearch(element: PsiElement): Collection<String> {
         val psiClass = when (element) {
             is PsiClass -> element
-            is KtClassOrObject -> getElement().providedToLightClass()
+            is KtClassOrObject -> getElement().toLightClass()
             else -> null
         } ?: return Collections.emptyList()
 

idea/idea-frontend-independent/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.kt

@@ -30,7 +30,7 @@ import com.intellij.psi.search.searches.ReferencesSearch
 import com.intellij.usageView.UsageInfo
 import com.intellij.util.*
 import org.jetbrains.annotations.TestOnly
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedToLightMethods
+import org.jetbrains.kotlin.asJava.toLightMethods
 import org.jetbrains.kotlin.idea.KotlinBundleIndependent
 import org.jetbrains.kotlin.idea.findUsages.*
 import org.jetbrains.kotlin.idea.findUsages.KotlinFindUsagesSupport.Companion.getTopMostOverriddenElementsToHighlight
@@ -71,7 +71,7 @@ abstract class KotlinFindMemberUsagesHandler<T : KtNamedDeclaration> protected c
             mustOpenInNewTab: Boolean
         ): AbstractFindUsagesDialog {
             val options = factory.findFunctionOptions
-            val lightMethod = getElement().providedToLightMethods().firstOrNull()
+            val lightMethod = getElement().toLightMethods().firstOrNull()
             if (lightMethod != null) {
                 return KotlinFindFunctionUsagesDialog(lightMethod, project, options, toShowInNewTab, mustOpenInNewTab, isSingleFile, this)
             }
@@ -236,7 +236,7 @@ abstract class KotlinFindMemberUsagesHandler<T : KtNamedDeclaration> protected c
                         else -> options.searchScope
                     }
 
-                    for (psiMethod in element.providedToLightMethods().filterDataClassComponentsIfDisabled(kotlinSearchOptions)) {
+                    for (psiMethod in element.toLightMethods().filterDataClassComponentsIfDisabled(kotlinSearchOptions)) {
                         addTask {
                             applyQueryFilters(
                                 element,

idea/idea-frontend-independent/src/org/jetbrains/kotlin/idea/search/declarationsSearch/classInheritorsSearch.kt

@@ -22,14 +22,15 @@ import com.intellij.psi.PsiModifier
 import com.intellij.psi.search.searches.ClassInheritorsSearch
 import com.intellij.util.EmptyQuery
 import com.intellij.util.Query
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedCreateKtFakeLightClass
+import org.jetbrains.kotlin.asJava.toLightClassWithBuiltinMapping
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedToLightClassWithBuiltinMapping
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightClass
+import org.jetbrains.kotlin.asJava.toFakeLightClass
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.psi.KtClassOrObject
 
 fun HierarchySearchRequest<*>.searchInheritors(): Query<PsiClass> {
     val psiClass: PsiClass = when (originalElement) {
-        is KtClassOrObject -> runReadAction { originalElement.providedToLightClassWithBuiltinMapping() ?: providedCreateKtFakeLightClass(originalElement) }
+        is KtClassOrObject -> runReadAction { originalElement.toLightClassWithBuiltinMapping() ?: originalElement.toFakeLightClass() }
         is PsiClass -> originalElement
         else -> null
     } ?: return EmptyQuery.getEmptyQuery()

idea/idea-frontend-independent/src/org/jetbrains/kotlin/idea/search/declarationsSearch/overridersSearch.kt

@@ -19,10 +19,8 @@ import com.intellij.util.MergeQuery
 import com.intellij.util.Processor
 import com.intellij.util.Query
 import org.jetbrains.kotlin.asJava.*
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedCreateKtFakeLightMethod
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightClass
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedGetRepresentativeLightMethod
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightMethod
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedIsKtFakeLightClass
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedToLightMethods
 import org.jetbrains.kotlin.idea.search.KotlinSearchUsagesSupport.Companion.findDeepestSuperMethodsNoWrapping
 import org.jetbrains.kotlin.idea.search.KotlinSearchUsagesSupport.Companion.forEachKotlinOverride
 import org.jetbrains.kotlin.idea.search.KotlinSearchUsagesSupport.Companion.forEachOverridingMethod
@@ -41,7 +39,7 @@ fun PsiElement.isOverridableElement(): Boolean = when (this) {
 }
 
 fun HierarchySearchRequest<*>.searchOverriders(): Query<PsiMethod> {
-    val psiMethods = runReadAction { originalElement.providedToLightMethods() }
+    val psiMethods = runReadAction { originalElement.toLightMethods() }
     if (psiMethods.isEmpty()) return EmptyQuery.getEmptyQuery()
 
     return psiMethods
@@ -104,10 +102,10 @@ fun PsiElement.toPossiblyFakeLightMethods(): List<PsiMethod> {
 
     val element = unwrapped ?: return emptyList()
 
-    val lightMethods = element.providedToLightMethods()
+    val lightMethods = element.toLightMethods()
     if (lightMethods.isNotEmpty()) return lightMethods
 
-    return if (element is KtNamedDeclaration) listOfNotNull(providedCreateKtFakeLightMethod(element)) else emptyList()
+    return if (element is KtNamedDeclaration) listOfNotNull(KtFakeLightMethod.get(element)) else emptyList()
 }
 
 fun KtNamedDeclaration.forEachOverridingElement(
@@ -116,7 +114,7 @@ fun KtNamedDeclaration.forEachOverridingElement(
 ): Boolean {
     val ktClass = runReadAction { containingClassOrObject as? KtClass } ?: return true
 
-    providedToLightMethods().forEach { baseMethod ->
+    toLightMethods().forEach { baseMethod ->
         if (!OverridingMethodsSearch.search(baseMethod, scope.excludeKotlinSources(), true).all { processor(baseMethod, it) }) return false
     }
 
@@ -148,7 +146,7 @@ fun PsiMethod.forEachOverridingMethodCompat(
 fun PsiClass.forEachDeclaredMemberOverride(processor: (superMember: PsiElement, overridingMember: PsiElement) -> Boolean) {
     val scope = runReadAction { useScope }
 
-    if (!providedIsKtFakeLightClass()) {
+    if (this !is KtFakeLightClass) {
         AllOverridingMethodsSearch.search(this, scope.excludeKotlinSources()).all { processor(it.first, it.second) }
     }
 
@@ -159,4 +157,4 @@ fun PsiClass.forEachDeclaredMemberOverride(processor: (superMember: PsiElement,
 }
 
 fun findDeepestSuperMethodsKotlinAware(method: PsiElement) =
-    findDeepestSuperMethodsNoWrapping(method).mapNotNull { it.providedGetRepresentativeLightMethod() }
+    findDeepestSuperMethodsNoWrapping(method).mapNotNull { it.getRepresentativeLightMethod() }

idea/idea-frontend-independent/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinDefinitionsSearcher.kt

@@ -28,9 +28,10 @@ import com.intellij.util.QueryExecutor
 import com.intellij.util.containers.ContainerUtil
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
+import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.asJava.unwrapped
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedCreateKtFakeLightClass
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightClass
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedToLightClass
+import org.jetbrains.kotlin.asJava.toFakeLightClass
 import org.jetbrains.kotlin.idea.search.KotlinSearchUsagesSupport.Companion.actualsForExpected
 import org.jetbrains.kotlin.idea.search.KotlinSearchUsagesSupport.Companion.forEachOverridingMethod
 import org.jetbrains.kotlin.idea.search.KotlinSearchUsagesSupport.Companion.isExpectDeclaration
@@ -107,9 +108,7 @@ class KotlinDefinitionsSearcher : QueryExecutor<PsiElement, DefinitionsScopedSea
         }
 
         private fun processClassImplementations(klass: KtClass, consumer: Processor<PsiElement>): Boolean {
-            val psiClass = runReadAction { klass.providedToLightClass() ?: providedCreateKtFakeLightClass(klass) }
+            val psiClass = runReadAction { klass.toLightClass() ?: klass.toFakeLightClass() }
-                as? KtLightClass
-                ?: return false //TODO Implement FIR support for not nullable providedCreateKtFakeLightClass
 
             val searchScope = runReadAction { psiClass.useScope }
             if (searchScope is LocalSearchScope) {

idea/idea-frontend-independent/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinOverridingMethodReferenceSearcher.kt

@@ -14,7 +14,7 @@ import com.intellij.psi.search.searches.MethodReferencesSearch
 import com.intellij.psi.util.MethodSignatureUtil
 import com.intellij.psi.util.TypeConversionUtil
 import com.intellij.util.Processor
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedToLightMethods
+import org.jetbrains.kotlin.asJava.toLightMethods
 import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import org.jetbrains.kotlin.idea.references.SyntheticPropertyAccessorReference
 import org.jetbrains.kotlin.idea.references.readWriteAccess
@@ -106,7 +106,7 @@ class KotlinOverridingMethodReferenceSearcher : MethodUsagesSearcher() {
                 }
 
                 fun countNonFinalLightMethods() = refElement
-                    .providedToLightMethods()
+                    .toLightMethods()
                     .filterNot { it.hasModifierProperty(PsiModifier.FINAL) }
 
                 val lightMethods = when (refElement) {

idea/idea-frontend-independent/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReferencesSearcher.kt

@@ -25,17 +25,16 @@ import com.intellij.psi.search.searches.MethodReferencesSearch
 import com.intellij.psi.search.searches.ReferencesSearch
 import com.intellij.util.Processor
 import com.intellij.util.containers.nullize
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedGetLightClassMethods
+import org.jetbrains.kotlin.asJava.LightClassUtil.getLightClassMethods
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedGetLightClassParameterDeclarations
+import org.jetbrains.kotlin.asJava.LightClassUtil.getLightClassPropertyMethods
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedGetLightClassPropertyDeclarations
+import org.jetbrains.kotlin.asJava.LightClassUtil.getLightFieldForCompanionObject
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedGetLightFieldForCompanionObject
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedToLightClass
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedToLightElements
 import org.jetbrains.kotlin.asJava.elements.KtLightField
 import org.jetbrains.kotlin.asJava.elements.KtLightMember
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
 import org.jetbrains.kotlin.asJava.elements.KtLightParameter
 import org.jetbrains.kotlin.asJava.namedUnwrappedElement
+import org.jetbrains.kotlin.asJava.toLightClass
+import org.jetbrains.kotlin.asJava.toLightElements
 import org.jetbrains.kotlin.idea.findUsages.KotlinFindUsagesSupport.Companion.sourcesAndLibraries
 import org.jetbrains.kotlin.idea.search.KotlinSearchUsagesSupport.Companion.dataClassComponentMethodName
 import org.jetbrains.kotlin.idea.search.KotlinSearchUsagesSupport.Companion.expectedDeclarationIfAny
@@ -75,7 +74,7 @@ data class KotlinReferencesSearchOptions(
         ): SearchScope {
             val kotlinOptions = (parameters as? KotlinAwareReferencesSearchParameters)?.kotlinOptions ?: Empty
             val elements = if (elementToSearch is KtDeclaration && !isOnlyKotlinSearch(parameters.scopeDeterminedByUser)) {
-                elementToSearch.providedToLightElements().filterDataClassComponentsIfDisabled(kotlinOptions).nullize()
+                elementToSearch.toLightElements().filterDataClassComponentsIfDisabled(kotlinOptions).nullize()
             } else {
                 null
             } ?: listOf(elementToSearch)
@@ -262,7 +261,7 @@ class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, ReferencesSearc
                 is KtNamedFunction, is KtSecondaryConstructor -> {
                     val name = (element as KtFunction).name
                     if (name != null) {
-                        val methods = providedGetLightClassMethods(element)
+                        val methods = getLightClassMethods(element)
                         for (method in methods) {
                             searchNamedElement(method)
                         }
@@ -272,7 +271,7 @@ class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, ReferencesSearc
                 }
 
                 is KtProperty -> {
-                    val propertyDeclarations = providedGetLightClassPropertyDeclarations(element)
+                    val propertyDeclarations = getLightClassPropertyMethods(element).allDeclarations
                     propertyDeclarations.forEach { searchNamedElement(it) }
                     processStaticsFromCompanionObject(element)
                 }
@@ -281,7 +280,7 @@ class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, ReferencesSearc
                     searchPropertyAccessorMethods(element)
                     if (element.getStrictParentOfType<KtPrimaryConstructor>() != null) {
                         // Simple parameters without val and var shouldn't be processed here because of local search scope
-                        val parameterDeclarations = providedGetLightClassParameterDeclarations(element)
+                        val parameterDeclarations = getLightClassPropertyMethods(element).allDeclarations
                         parameterDeclarations.filterDataClassComponentsIfDisabled(kotlinOptions).forEach { searchNamedElement(it) }
                     }
                 }
@@ -310,19 +309,19 @@ class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, ReferencesSearc
         }
 
         private fun searchPropertyAccessorMethods(origin: KtParameter) {
-            origin.providedToLightElements().filterDataClassComponentsIfDisabled(kotlinOptions).forEach { searchNamedElement(it) }
+            origin.toLightElements().filterDataClassComponentsIfDisabled(kotlinOptions).forEach { searchNamedElement(it) }
         }
 
         private fun processKtClassOrObject(element: KtClassOrObject) {
             val className = element.name ?: return
-            val lightClass = element.providedToLightClass() ?: return
+            val lightClass = element.toLightClass() ?: return
             searchNamedElement(lightClass, className)
 
             if (element is KtObjectDeclaration && element.isCompanion()) {
-                providedGetLightFieldForCompanionObject(element)?.let { searchNamedElement(it) }
+                getLightFieldForCompanionObject(element)?.let { searchNamedElement(it) }
 
                 if (kotlinOptions.acceptCompanionObjectMembers) {
-                    val originLightClass = element.getStrictParentOfType<KtClass>()?.providedToLightClass()
+                    val originLightClass = element.getStrictParentOfType<KtClass>()?.toLightClass()
                     if (originLightClass != null) {
                         val lightDeclarations: List<KtLightMember<*>?> =
                             originLightClass.methods.map { it as? KtLightMethod } + originLightClass.fields.map { it as? KtLightField }
@@ -342,7 +341,7 @@ class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, ReferencesSearc
                 is KtParameter -> {
                     val componentMethodName = element.dataClassComponentMethodName
                     if (componentMethodName != null) {
-                        val containingClass = element.getStrictParentOfType<KtClassOrObject>()?.providedToLightClass()
+                        val containingClass = element.getStrictParentOfType<KtClassOrObject>()?.toLightClass()
                         searchDataClassComponentUsages(
                             containingClass = containingClass,
                             componentMethodName = componentMethodName,
@@ -392,7 +391,7 @@ class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, ReferencesSearc
                 .firstOrNull() as? KtObjectDeclaration ?: return emptyList()
             if (!originObject.isCompanion()) return emptyList()
             val originClass = originObject.getStrictParentOfType<KtClass>()
-            val originLightClass = originClass?.providedToLightClass() ?: return emptyList()
+            val originLightClass = originClass?.toLightClass() ?: return emptyList()
             val allMethods = originLightClass.allMethods
             return allMethods.filter { it is KtLightMethod && it.kotlinOrigin == declaration }
         }

idea/idea-frontend-independent/src/org/jetbrains/kotlin/idea/search/usagesSearch/ExpressionsOfTypeProcessor.kt

@@ -23,8 +23,8 @@ import com.intellij.psi.search.searches.ReferencesSearch
 import com.intellij.util.Processor
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.KtNodeTypes
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedToLightClass
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
+import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.diagnostics.PsiDiagnosticUtils
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.KotlinLanguage
@@ -582,7 +582,7 @@ class ExpressionsOfTypeProcessor(
                 val parent = typeRefParent.parent
                 if (parent is KtSuperTypeCallEntry) {
                     val classOrObject = (parent.parent as KtSuperTypeList).parent as KtClassOrObject
-                    val psiClass = classOrObject.providedToLightClass()
+                    val psiClass = classOrObject.toLightClass()
                     psiClass?.let { addClassToProcess(it) }
                     return true
                 }
@@ -591,7 +591,7 @@ class ExpressionsOfTypeProcessor(
             is KtSuperTypeListEntry -> { // super-interface name in the list of bases
                 if (typeRef == typeRefParent.typeReference) {
                     val classOrObject = (typeRefParent.parent as KtSuperTypeList).parent as KtClassOrObject
-                    val psiClass = classOrObject.providedToLightClass()
+                    val psiClass = classOrObject.toLightClass()
                     psiClass?.let { addClassToProcess(it) }
                     return true
                 }

idea/idea-frontend-independent/src/org/jetbrains/kotlin/idea/search/usagesSearch/utilsIndependent.kt

@@ -12,8 +12,8 @@ import com.intellij.psi.search.searches.MethodReferencesSearch
 import com.intellij.psi.search.searches.ReferencesSearch
 import org.jetbrains.kotlin.asJava.elements.KtLightElement
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
+import org.jetbrains.kotlin.asJava.toLightMethods
 import org.jetbrains.kotlin.asJava.unwrapped
-import org.jetbrains.kotlin.idea.asJava.LightClassProvider.Companion.providedToLightMethods
 import org.jetbrains.kotlin.idea.search.KotlinSearchUsagesSupport
 import org.jetbrains.kotlin.idea.search.KotlinSearchUsagesSupport.Companion.createConstructorHandle
 import org.jetbrains.kotlin.idea.search.declarationsSearch.HierarchySearchRequest
@@ -117,7 +117,7 @@ private fun processClassDelegationCallsToSpecifiedConstructor(
 }
 
 fun PsiElement.searchReferencesOrMethodReferences(): Collection<PsiReference> {
-    val lightMethods = providedToLightMethods()
+    val lightMethods = toLightMethods()
     return if (lightMethods.isNotEmpty()) {
         lightMethods.flatMapTo(LinkedHashSet()) { MethodReferencesSearch.search(it) }
     } else {

idea/idea-gradle/src/org/jetbrains/kotlin/idea/run/kotlinTestClassUtils.kt

@@ -9,8 +9,9 @@ import com.intellij.execution.Location
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiMethod
 import org.jetbrains.kotlin.asJava.elements.KtLightElement
-import org.jetbrains.kotlin.idea.caches.lightClasses.KtFakeLightClass
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightClass
-import org.jetbrains.kotlin.idea.caches.lightClasses.KtFakeLightMethod
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightMethod
+import org.jetbrains.kotlin.asJava.toFakeLightClass
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtNamedFunction
@@ -31,5 +32,5 @@ internal fun getTestClassForKotlinTest(location: Location<*>): PsiClass? {
         else -> psi
     }
     val owner = leaf?.getParentOfType<KtDeclaration>(false) as? KtClassOrObject ?: return null
-    return KtFakeLightClass(owner)
+    return owner.toFakeLightClass()
 }

idea/resources-fir/META-INF/plugin.xml

@@ -116,9 +116,6 @@ The Kotlin FIR plugin provides language support in IntelliJ IDEA and Android Stu
     <projectService serviceImplementation="org.jetbrains.kotlin.idea.fir.low.level.api.FirIdeResolveStateService"/>
     <projectService serviceImplementation="org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade"/>
 
-    <projectService serviceInterface="org.jetbrains.kotlin.idea.asJava.LightClassProvider"
-                    serviceImplementation="org.jetbrains.kotlin.idea.asJava.LightClassProviderFirImpl"/>
-
     <projectService serviceInterface="org.jetbrains.kotlin.psi.KtFileClassProvider"
                     serviceImplementation="org.jetbrains.kotlin.idea.caches.resolve.KtFileClassProviderImpl"/>
 

idea/resources/META-INF/plugin-common.xml

@@ -213,9 +213,6 @@
     <projectService serviceInterface="org.jetbrains.kotlin.asJava.KotlinAsJavaSupport"
                     serviceImplementation="org.jetbrains.kotlin.idea.caches.resolve.IDEKotlinAsJavaSupport"/>
 
-    <projectService serviceInterface="org.jetbrains.kotlin.idea.asJava.LightClassProvider"
-                    serviceImplementation="org.jetbrains.kotlin.idea.asJava.LightClassProviderImpl"/>
-
     <projectService serviceInterface="org.jetbrains.kotlin.psi.KtFileClassProvider"
                     serviceImplementation="org.jetbrains.kotlin.idea.caches.resolve.KtFileClassProviderImpl"/>
 

idea/src/org/jetbrains/kotlin/idea/asJava/LightClassProviderImpl.kt

@@ -1,76 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.idea.asJava
-
-import com.intellij.psi.*
-import org.jetbrains.kotlin.asJava.*
-import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.asJava.classes.LightClassInheritanceHelper
-import org.jetbrains.kotlin.idea.caches.lightClasses.KtFakeLightClass
-import org.jetbrains.kotlin.idea.caches.lightClasses.KtFakeLightMethod
-import org.jetbrains.kotlin.idea.caches.lightClasses.KtLightClassForDecompiledDeclaration
-import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.DescriptorUtils
-
-class LightClassProviderImpl : LightClassProvider {
-    override fun getLightFieldForCompanionObject(companionObject: KtClassOrObject): PsiField? =
-        LightClassUtil.getLightFieldForCompanionObject(companionObject)
-
-    override fun getLightClassMethods(function: KtFunction): List<PsiMethod> =
-        LightClassUtil.getLightClassMethods(function)
-
-    override fun getLightClassParameterDeclarations(parameter: KtParameter): List<PsiNamedElement> =
-        LightClassUtil.getLightClassPropertyMethods(parameter).allDeclarations
-
-    override fun getLightClassPropertyDeclarations(property: KtProperty): List<PsiNamedElement> =
-        LightClassUtil.getLightClassPropertyMethods(property).allDeclarations
-
-    override fun toLightClassWithBuiltinMapping(classOrObject: KtClassOrObject): PsiClass? =
-        classOrObject.toLightClassWithBuiltinMapping()
-
-    override fun toLightMethods(psiElement: PsiElement): List<PsiMethod> =
-        psiElement.toLightMethods()
-
-    override fun toLightClass(classOrObject: KtClassOrObject): KtLightClass? =
-        classOrObject.toLightClass()
-
-    override fun toLightElements(ktElement: KtElement): List<PsiNamedElement> =
-        ktElement.toLightElements()
-
-    override fun createKtFakeLightClass(kotlinOrigin: KtClassOrObject): PsiClass? =
-        KtFakeLightClass(kotlinOrigin)
-
-    override fun getRepresentativeLightMethod(psiElement: PsiElement): PsiMethod? =
-        psiElement.getRepresentativeLightMethod()
-
-    override fun isKtFakeLightClass(psiClass: PsiClass): Boolean =
-        psiClass is KtFakeLightClass
-
-    override fun isKtLightClassForDecompiledDeclaration(psiClass: PsiClass): Boolean =
-        psiClass is KtLightClassForDecompiledDeclaration
-
-    override fun createKtFakeLightMethod(ktDeclaration: KtNamedDeclaration): PsiMethod? =
-        KtFakeLightMethod.get(ktDeclaration)
-
-    override fun isFakeLightClassInheritor(ktFakeLightClass: KtFakeLightClass, baseClass: PsiClass, checkDeep: Boolean): Boolean {
-        if (ktFakeLightClass.manager.areElementsEquivalent(baseClass, ktFakeLightClass)) return false
-        LightClassInheritanceHelper.getService(ktFakeLightClass.project).isInheritor(ktFakeLightClass, baseClass, checkDeep).ifSure { return it }
-
-        val baseKtClass = (baseClass as? KtLightClass)?.kotlinOrigin ?: return false
-        val baseDescriptor = baseKtClass.resolveToDescriptorIfAny() ?: return false
-        val thisDescriptor = ktFakeLightClass.kotlinOrigin.resolveToDescriptorIfAny() ?: return false
-
-        val thisFqName = DescriptorUtils.getFqName(thisDescriptor).asString()
-        val baseFqName = DescriptorUtils.getFqName(baseDescriptor).asString()
-        if (thisFqName == baseFqName) return false
-
-        return if (checkDeep)
-            DescriptorUtils.isSubclass(thisDescriptor, baseDescriptor)
-        else
-            DescriptorUtils.isDirectSubclass(thisDescriptor, baseDescriptor)
-    }
-}

idea/src/org/jetbrains/kotlin/idea/hierarchy/KotlinTypeHierarchyProvider.kt

@@ -17,7 +17,8 @@ import com.intellij.psi.*
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
-import org.jetbrains.kotlin.idea.caches.lightClasses.KtFakeLightClass
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightClass
+import org.jetbrains.kotlin.asJava.toFakeLightClass
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
 import org.jetbrains.kotlin.idea.project.platform
 import org.jetbrains.kotlin.idea.search.allScope
@@ -44,7 +45,7 @@ class KotlinTypeHierarchyProvider : JavaTypeHierarchyProvider() {
                 )
             }
         }
-        return classOrObject.toLightClass() ?: KtFakeLightClass(classOrObject)
+        return classOrObject.toLightClass() ?: classOrObject.toFakeLightClass()
     }
 
     private fun getTargetByReference(

idea/src/org/jetbrains/kotlin/idea/highlighter/markers/JavaPsiUtils.kt

@@ -23,8 +23,9 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiMethod
 import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.asJava.toLightClass
-import org.jetbrains.kotlin.idea.caches.lightClasses.KtFakeLightClass
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightClass
-import org.jetbrains.kotlin.idea.caches.lightClasses.KtFakeLightMethod
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightMethod
+import org.jetbrains.kotlin.asJava.toFakeLightClass
 import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.psi.KtNamedFunction
@@ -48,7 +49,7 @@ internal tailrec fun getPsiClass(element: PsiElement?): PsiClass? {
     return when {
         element == null -> null
         element is PsiClass -> element
-        element is KtClass -> element.toLightClass() ?: KtFakeLightClass(element)
+        element is KtClass -> element.toLightClass() ?: element.toFakeLightClass()
         element.parent is KtClass -> getPsiClass(element.parent)
         else -> null
     }

idea/src/org/jetbrains/kotlin/idea/highlighter/markers/KotlinLineMarkerProvider.kt

@@ -28,8 +28,9 @@ import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.idea.KotlinBundle
-import org.jetbrains.kotlin.idea.caches.lightClasses.KtFakeLightClass
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightClass
-import org.jetbrains.kotlin.idea.caches.lightClasses.KtFakeLightMethod
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightMethod
+import org.jetbrains.kotlin.asJava.toFakeLightClass
 import org.jetbrains.kotlin.idea.core.isInheritable
 import org.jetbrains.kotlin.idea.core.isOverridable
 import org.jetbrains.kotlin.idea.editor.fixers.startLine
@@ -292,7 +293,7 @@ private fun collectInheritedClassMarker(element: KtClass, result: LineMarkerInfo
         return
     }
 
-    val lightClass = element.toLightClass() ?: KtFakeLightClass(element)
+    val lightClass = element.toLightClass() ?: element.toFakeLightClass()
 
     if (ClassInheritorsSearch.search(lightClass, false).findFirst() == null) return
 

idea/src/org/jetbrains/kotlin/idea/search/declarationsSearch/overridersSearchUtils.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.asJava.*
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.isOverridable
-import org.jetbrains.kotlin.idea.caches.lightClasses.KtFakeLightMethod
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightMethod
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
 import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde

idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinDirectInheritorsSearcher.kt

@@ -23,7 +23,8 @@ import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.search.searches.DirectClassInheritorsSearch
 import com.intellij.util.Processor
 import org.jetbrains.kotlin.asJava.toLightClassWithBuiltinMapping
-import org.jetbrains.kotlin.idea.caches.lightClasses.KtFakeLightClass
+import org.jetbrains.kotlin.asJava.classes.KtFakeLightClass
+import org.jetbrains.kotlin.asJava.toFakeLightClass
 import org.jetbrains.kotlin.idea.search.fileScope
 import org.jetbrains.kotlin.idea.stubindex.KotlinSourceFilterScope
 import org.jetbrains.kotlin.idea.stubindex.KotlinSuperClassIndex
@@ -64,7 +65,7 @@ open class KotlinDirectInheritorsSearcher : QueryExecutorBase<PsiClass, DirectCl
             names.forEach { name ->
                 KotlinSuperClassIndex.getInstance()
                     .get(name, baseClass.project, noLibrarySourceScope).asSequence()
-                    .mapNotNull { candidate -> candidate.toLightClassWithBuiltinMapping() ?: KtFakeLightClass(candidate) }
+                    .mapNotNull { candidate -> candidate.toLightClassWithBuiltinMapping() ?: candidate.toFakeLightClass() }
                     .filter { candidate -> candidate.isInheritor(baseClass, false) }
                     .forEach { candidate -> consumer.process(candidate) }
             }

idea/testData/findUsages/kotlin/findClassUsages/javaDerivedClassUsages1.0.kt

@@ -16,4 +16,5 @@ interface Z: A {
 
 }
 
-// DISABLE-ERRORS
+// DISABLE-ERRORS
+// FIR_COMPARISON

idea/testData/highlighter/NamedArguments.kt

@@ -1,4 +1,4 @@
-@Suppress(<info descr="null" textAttributesKey="KOTLIN_ANNOTATION_ATTRIBUTE_NAME_ATTRIBUTES">names =</info> ["foo"])
+<info descr="null" textAttributesKey="KOTLIN_ANNOTATION">@Suppress</info>(<info descr="null" textAttributesKey="KOTLIN_ANNOTATION_ATTRIBUTE_NAME_ATTRIBUTES">names =</info> ["foo"])
 fun <info descr="null" textAttributesKey="KOTLIN_FUNCTION_DECLARATION">foo</info>(<info descr="null" textAttributesKey="KOTLIN_PARAMETER">p1</info>: <info descr="null" textAttributesKey="KOTLIN_CLASS">Int</info>, <info descr="null" textAttributesKey="KOTLIN_PARAMETER">p2</info>: <info descr="null" textAttributesKey="KOTLIN_CLASS">String</info>): <info descr="null" textAttributesKey="KOTLIN_CLASS">String</info> {
     return <info descr="null" textAttributesKey="KOTLIN_PARAMETER">p2</info> + <info descr="null" textAttributesKey="KOTLIN_PARAMETER">p1</info>
 }
@@ -6,3 +6,5 @@ fun <info descr="null" textAttributesKey="KOTLIN_FUNCTION_DECLARATION">foo</info
 fun <info descr="null" textAttributesKey="KOTLIN_FUNCTION_DECLARATION">bar</info>() {
     <info descr="null" textAttributesKey="KOTLIN_PACKAGE_FUNCTION_CALL">foo</info>(1, <info descr="null" textAttributesKey="KOTLIN_NAMED_ARGUMENT">p2 =</info> "")
 }
+
+// IGNORE_FIR