LC: introduce light class interface for facade

so that FIR-based light class for facade can work well in LC utils

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

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.name.FqName
 
 private data class FacadeCacheKey(val fqName: FqName, val searchScope: GlobalSearchScope)
 
-private data class ValueWrapper(val value: KtLightClassForFacadeImpl?) {
+private data class ValueWrapper(val value: KtLightClassForFacade?) {
     companion object {
         val Null = ValueWrapper(null)
     }
@@ -42,7 +42,7 @@ class FacadeCache(private val project: Project) {
         }, false
     )
 
-    operator fun get(qualifiedName: FqName, searchScope: GlobalSearchScope): KtLightClassForFacadeImpl? {
+    operator fun get(qualifiedName: FqName, searchScope: GlobalSearchScope): KtLightClassForFacade? {
         synchronized(cachedValue) {
             return cachedValue.value.cache.get(FacadeCacheKey(qualifiedName, searchScope)).value
         }

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

@@ -0,0 +1,16 @@
+/*
+ * 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.asJava.classes
+
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.KtFile
+
+interface KtLightClassForFacade : KtLightClass {
+    val facadeClassFqName: FqName
+    val files: Collection<KtFile>
+
+    override fun getName() = facadeClassFqName.shortName().asString()
+}

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

@@ -47,10 +47,10 @@ import javax.swing.Icon
 
 open class KtLightClassForFacadeImpl constructor(
     manager: PsiManager,
-    protected val facadeClassFqName: FqName,
+    override val facadeClassFqName: FqName,
     myLightClassDataCache: CachedValue<LightClassDataHolder.ForFacade>,
-    files: Collection<KtFile>
-) : KtLazyLightClass(manager) {
+    override val files: Collection<KtFile>
+) : KtLazyLightClass(manager), KtLightClassForFacade {
 
     protected open val lightClassDataCache: CachedValue<LightClassDataHolder.ForFacade> = myLightClassDataCache
 
@@ -60,8 +60,6 @@ open class KtLightClassForFacadeImpl constructor(
     override val lightClassData
         get() = lightClassDataCache.value.findDataForFacade(facadeClassFqName)
 
-    val files: Collection<KtFile> = files.toSet()
-
     private val firstFileInFacade by lazyPub { files.iterator().next() }
 
     private val hashCode: Int =
@@ -138,7 +136,7 @@ open class KtLightClassForFacadeImpl constructor(
 
     override fun getRBrace(): PsiElement? = null
 
-    override fun getName() = facadeClassFqName.shortName().asString()
+    override fun getName() = super<KtLightClassForFacade>.getName()
 
     override fun setName(name: String): PsiElement? {
         for (file in files) {
@@ -184,13 +182,14 @@ open class KtLightClassForFacadeImpl constructor(
 
     override fun isValid() = files.all { it.isValid && it.hasTopLevelCallables() && facadeClassFqName == it.javaFileFacadeFqName }
 
-    override fun copy() = KtLightClassForFacadeImpl(manager, facadeClassFqName, lightClassDataCache, files)
+    override fun copy(): KtLightClassForFacade =
+        KtLightClassForFacadeImpl(manager, facadeClassFqName, lightClassDataCache, files)
 
     override fun getNavigationElement() = firstFileInFacade
 
     override fun isEquivalentTo(another: PsiElement?): Boolean =
         equals(another) ||
-                (another is KtLightClassForFacadeImpl && another.facadeClassFqName == facadeClassFqName)
+                (another is KtLightClassForFacade && another.facadeClassFqName == facadeClassFqName)
 
     override fun getElementIcon(flags: Int): Icon? = throw UnsupportedOperationException("This should be done by JetIconProvider")
 
@@ -254,7 +253,7 @@ open class KtLightClassForFacadeImpl constructor(
 
     companion object {
 
-        fun createForFacadeNoCache(fqName: FqName, searchScope: GlobalSearchScope, project: Project): KtLightClassForFacadeImpl? {
+        fun createForFacadeNoCache(fqName: FqName, searchScope: GlobalSearchScope, project: Project): KtLightClassForFacade? {
 
             val sources = KotlinAsJavaSupport.getInstance(project).findFilesForFacade(fqName, searchScope)
                 .filterNot { it.isCompiled }
@@ -278,7 +277,7 @@ open class KtLightClassForFacadeImpl constructor(
             manager: PsiManager,
             facadeClassFqName: FqName,
             searchScope: GlobalSearchScope
-        ): KtLightClassForFacadeImpl? {
+        ): KtLightClassForFacade? {
             return FacadeCache.getInstance(manager.project)[facadeClassFqName, searchScope]
         }
 
@@ -286,7 +285,7 @@ open class KtLightClassForFacadeImpl constructor(
             manager: PsiManager,
             facadeClassFqName: FqName,
             file: KtFile
-        ): KtLightClassForFacadeImpl {
+        ): KtLightClassForFacade {
             // TODO: refactor, using cached value doesn't make sense for this case
             val cachedValue = CachedValuesManager.getManager(manager.project).createCachedValue(
                 LightClassDataProviderForFileFacade.ByFile(manager.project, facadeClassFqName, file), false

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

@@ -41,8 +41,8 @@ open class KtLightClassForLocalDeclaration(
 
                 var createWrapper = forceMethodWrapping
                 // Use PsiClass wrapper instead of package light class to avoid names like "FooPackage" in Type Hierarchy and related views
-                if (containingClass is KtLightClassForFacadeImpl) {
-                    containingClass = object : LightClass(containingClass as KtLightClassForFacadeImpl, KotlinLanguage.INSTANCE) {
+                if (containingClass is KtLightClassForFacade) {
+                    containingClass = object : LightClass(containingClass as KtLightClassForFacade, KotlinLanguage.INSTANCE) {
                         override fun getName(): String? = currentFileName
                     }
                     createWrapper = true

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

@@ -147,6 +147,6 @@ class KtUltraLightClassForFacade(
 
     override fun getOwnMethods() = _ownMethods
 
-    override fun copy(): KtLightClassForFacadeImpl =
+    override fun copy(): KtLightClassForFacade =
         KtUltraLightClassForFacade(manager, facadeClassFqName, lightClassDataCache, files, filesWithSupports)
 }

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

@@ -35,7 +35,7 @@ import com.intellij.psi.util.PsiUtil
 import com.intellij.reference.SoftReference
 import com.intellij.util.AstLoadingFilter
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtFile
@@ -127,7 +127,7 @@ open class FakeFileForLightClass(
     override fun isEquivalentTo(another: PsiElement?) = this == another
 
     override fun setPackageName(packageName: String) {
-        if (lightClass() is KtLightClassForFacadeImpl) {
+        if (lightClass() is KtLightClassForFacade) {
             ktFile.packageDirective?.fqName = FqName(packageName)
         } else {
             super.setPackageName(packageName)

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

@@ -56,7 +56,7 @@ fun KtClassOrObject.toFakeLightClass(): KtFakeLightClass = KotlinAsJavaSupport.g
 fun KtFile.findFacadeClass(): KtLightClass? {
     return KotlinAsJavaSupport.getInstance(project)
             .getFacadeClassesInPackage(packageFqName, this.useScope as? GlobalSearchScope ?: GlobalSearchScope.projectScope(project))
-            .firstOrNull { it is KtLightClassForFacadeImpl && this in it.files } as? KtLightClass
+            .firstOrNull { it is KtLightClassForFacade && this in it.files } as? KtLightClass
 }
 
 fun KtScript.toLightClass(): KtLightClass? = KotlinAsJavaSupport.getInstance(project).getLightClassForScript(this)

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/project/getModuleInfo.kt

@@ -15,7 +15,7 @@ import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.analyzer.ModuleInfo
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.elements.KtLightElement
 import org.jetbrains.kotlin.idea.caches.lightClasses.KtLightClassForDecompiledDeclaration
 import org.jetbrains.kotlin.idea.core.isInTestSourceContentKotlinAware
@@ -211,7 +211,7 @@ private fun <T> KtLightElement<*, *>.processLightElement(c: ModuleInfoCollector<
     }
 
     val element = kotlinOrigin ?: when (this) {
-        is KtLightClassForFacadeImpl -> this.files.first()
+        is KtLightClassForFacade -> this.files.first()
         else -> return c.onFailure("Light element without origin is referenced by resolve:\n$this\n${this.clsDelegate.text}")
     }
 

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

@@ -9,6 +9,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiManager
 import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
@@ -71,7 +72,7 @@ class KtFileClassProviderImpl(val project: Project) : KtFileClassProvider {
         }
 
         facadeClasses.filterTo(result) {
-            it is KtLightClassForFacadeImpl && file in it.files
+            it is KtLightClassForFacade && file in it.files
         }
 
         return result.toTypedArray()

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

@@ -11,7 +11,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.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.*
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.idea.asJava.classes.analyseForLightClasses
 import org.jetbrains.kotlin.idea.asJava.classes.createField
 import org.jetbrains.kotlin.idea.asJava.classes.createMethods
-import org.jetbrains.kotlin.idea.frontend.api.analyse
 import org.jetbrains.kotlin.idea.frontend.api.fir.analyzeWithSymbolAsContext
 import org.jetbrains.kotlin.idea.frontend.api.scopes.KtDeclarationScope
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol
@@ -35,9 +34,9 @@ import org.jetbrains.kotlin.psi.KtFile
 
 class FirLightClassForFacade(
     manager: PsiManager,
-    private val facadeClassFqName: FqName,
-    private val files: Collection<KtFile>
-) : FirLightClassBase(manager) {
+    override val facadeClassFqName: FqName,
+    override val files: Collection<KtFile>
+) : FirLightClassBase(manager), KtLightClassForFacade {
 
     init {
         require(files.isNotEmpty())
@@ -215,7 +214,7 @@ class FirLightClassForFacade(
 
     override fun isInheritorDeep(baseClass: PsiClass?, classToByPass: PsiClass?): Boolean = false
 
-    override fun getName(): String = facadeClassFqName.shortName().asString()
+    override fun getName() = super<KtLightClassForFacade>.getName()
 
     override fun getQualifiedName() = facadeClassFqName.asString()
 
@@ -256,7 +255,7 @@ class FirLightClassForFacade(
 
     override fun hashCode() = facadeClassFqName.hashCode()
 
-    override fun toString() = "${KtLightClassForFacadeImpl::class.java.simpleName}:$facadeClassFqName"
+    override fun toString() = "${FirLightClassForFacade::class.java.simpleName}:$facadeClassFqName"
 
     override val originKind: LightClassOriginKind
         get() = LightClassOriginKind.SOURCE

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

@@ -15,7 +15,7 @@ import com.intellij.psi.PsiElement
 import com.intellij.ui.RowIcon
 import com.intellij.util.PlatformIcons
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+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.KotlinIconsIndependent.ACTUAL
@@ -120,7 +120,7 @@ open class KotlinIconProviderBase : IconProvider(), DumbAware {
 
         fun PsiElement.getBaseIcon(): Icon? = when (this) {
             is KtPackageDirective -> PlatformIcons.PACKAGE_ICON
-            is KtLightClassForFacadeImpl -> KotlinIconsIndependent.FILE
+            is KtLightClassForFacade -> KotlinIconsIndependent.FILE
             is KtLightClassForSourceDeclaration -> navigationElement.getBaseIcon()
             is KtNamedFunction -> when {
                 receiverTypeReference != null ->

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

@@ -27,7 +27,7 @@ import com.intellij.refactoring.util.RefactoringDescriptionLocation
 import com.intellij.usageView.UsageViewLongNameLocation
 import com.intellij.usageView.UsageViewShortNameLocation
 import com.intellij.usageView.UsageViewTypeLocation
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.idea.KotlinBundle
 import org.jetbrains.kotlin.idea.KotlinLanguage
@@ -165,7 +165,7 @@ open class KotlinElementDescriptionProviderBase : ElementDescriptionProvider {
             is KtTypeAlias -> KotlinBundle.message("find.usages.type.alias")
             is KtLabeledExpression -> KotlinBundle.message("find.usages.label")
             is KtImportAlias -> KotlinBundle.message("find.usages.import.alias")
-            is KtLightClassForFacadeImpl -> KotlinBundle.message("find.usages.facade.class")
+            is KtLightClassForFacade -> KotlinBundle.message("find.usages.facade.class")
             else -> {
                 //TODO Implement in FIR
                 when {

idea/jvm-debugger/jvm-debugger-core/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpointType.kt

@@ -24,7 +24,7 @@ import com.intellij.xdebugger.breakpoints.XLineBreakpointType
 import com.intellij.xdebugger.breakpoints.ui.XBreakpointCustomPropertiesPanel
 import com.intellij.xdebugger.evaluation.XDebuggerEditorsProvider
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration
 import org.jetbrains.kotlin.idea.debugger.KotlinDebuggerCoreBundle
 import org.jetbrains.kotlin.idea.debugger.breakpoints.dialog.AddFieldBreakpointDialog
@@ -89,7 +89,7 @@ class KotlinFieldBreakpointType :
                 }
 
                 result = when (psiClass) {
-                    is KtLightClassForFacadeImpl -> psiClass.files.asSequence().mapNotNull {
+                    is KtLightClassForFacade -> psiClass.files.asSequence().mapNotNull {
                         createBreakpointIfPropertyExists(it, it, className, fieldName)
                     }.firstOrNull()
 

idea/jvm-debugger/jvm-debugger-core/src/org/jetbrains/kotlin/idea/debugger/breakpoints/dialog/fieldBreakpointDialogUtil.kt

@@ -18,13 +18,13 @@ package org.jetbrains.kotlin.idea.debugger.breakpoints.dialog
 
 import com.intellij.psi.PsiClass
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor
 import org.jetbrains.kotlin.idea.core.util.DescriptorMemberChooserObject
 import org.jetbrains.kotlin.psi.KtProperty
 
 fun PsiClass.collectProperties(): Array<DescriptorMemberChooserObject> {
-    if (this is KtLightClassForFacadeImpl) {
+    if (this is KtLightClassForFacade) {
         val result = arrayListOf<DescriptorMemberChooserObject>()
         this.files.forEach {
             it.declarations.filterIsInstance<KtProperty>().forEach {

idea/src/org/jetbrains/kotlin/idea/projectView/projectViewProviders.kt

@@ -15,7 +15,7 @@ import com.intellij.openapi.roots.ProjectRootManager
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.idea.KotlinIconProviderBase
 import org.jetbrains.kotlin.psi.KtClassBody
 import org.jetbrains.kotlin.psi.KtClassOrObject
@@ -55,7 +55,7 @@ class KotlinExpandNodeProjectViewProvider : TreeStructureProvider, DumbAware {
 
     private fun Any.asKtFile(): KtFile? = when (this) {
         is KtFile -> this
-        is KtLightClassForFacadeImpl -> files.singleOrNull()
+        is KtLightClassForFacade -> files.singleOrNull()
         is KtLightClass -> kotlinOrigin?.containingFile as? KtFile
         else -> null
     }

idea/src/org/jetbrains/kotlin/idea/quickfix/crossLanguage/KotlinElementActionsFactory.kt

@@ -19,7 +19,7 @@ import com.intellij.psi.*
 import com.intellij.psi.impl.source.tree.java.PsiReferenceExpressionImpl
 import com.intellij.psi.util.PropertyUtil
 import com.intellij.psi.util.PropertyUtilBase
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration
 import org.jetbrains.kotlin.asJava.elements.KtLightElement
 import org.jetbrains.kotlin.asJava.toLightMethods
@@ -143,7 +143,7 @@ class KotlinElementActionsFactory : JvmElementActionsFactory() {
     private fun JvmClass.toKtClassOrFile(): KtElement? = when (val psi = sourceElement) {
         is KtClassOrObject -> psi
         is KtLightClassForSourceDeclaration -> psi.kotlinOrigin
-        is KtLightClassForFacadeImpl -> psi.files.firstOrNull()
+        is KtLightClassForFacade -> psi.files.firstOrNull()
         else -> null
     }
 

idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveDeclarations/MoveKotlinDeclarationsProcessor.kt

@@ -31,7 +31,7 @@ import com.intellij.util.IncorrectOperationException
 import com.intellij.util.containers.MultiMap
 import gnu.trove.THashMap
 import gnu.trove.TObjectHashingStrategy
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.elements.KtLightDeclaration
 import org.jetbrains.kotlin.asJava.findFacadeClass
 import org.jetbrains.kotlin.asJava.namedUnwrappedElement
@@ -236,7 +236,7 @@ class MoveKotlinDeclarationsProcessor(
                         )
                     }
 
-                    val facadeContainer = lightElement.parent as? KtLightClassForFacadeImpl
+                    val facadeContainer = lightElement.parent as? KtLightClassForFacade
                     if (facadeContainer != null) {
                         val oldFqNameWithFacade = StringUtil.getQualifiedName(facadeContainer.qualifiedName, elementName)
                         val newFqNameWithFacade = StringUtil.getQualifiedName(

idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/KotlinMoveFilesOrDirectoriesHandler.kt

@@ -15,7 +15,7 @@ import com.intellij.refactoring.move.MoveCallback
 import com.intellij.refactoring.move.MoveHandler
 import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesHandler
 import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesUtil
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.idea.refactoring.move.logFusForMoveRefactoring
 import org.jetbrains.kotlin.idea.refactoring.move.moveDeclarations.ui.KotlinAwareMoveFilesOrDirectoriesDialog
 import org.jetbrains.kotlin.idea.refactoring.move.moveDeclarations.ui.KotlinAwareMoveFilesOrDirectoriesModel
@@ -100,7 +100,7 @@ class KotlinMoveFilesOrDirectoriesHandler : MoveFilesOrDirectoriesHandler() {
         reference: PsiReference?,
         editor: Editor?
     ): Boolean {
-        if (element is KtLightClassForFacadeImpl) {
+        if (element is KtLightClassForFacade) {
             doMove(project, element.files.toTypedArray(), dataContext?.getData(LangDataKeys.TARGET_PSI_ELEMENT), null)
             return true
         }

idea/src/org/jetbrains/kotlin/idea/refactoring/rename/KotlinAutomaticTestRenamerFactory.kt

@@ -21,7 +21,7 @@ import com.intellij.psi.PsiElement
 import com.intellij.refactoring.rename.naming.AutomaticRenamer
 import com.intellij.refactoring.rename.naming.AutomaticTestRenamerFactory
 import com.intellij.usageView.UsageInfo
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration
 import org.jetbrains.kotlin.asJava.findFacadeClass
 import org.jetbrains.kotlin.asJava.toLightClass
@@ -46,7 +46,7 @@ class KotlinAutomaticTestRenamerFactory : AutomaticTestRenamerFactory() {
 
     override fun createRenamer(element: PsiElement, newName: String, usages: MutableCollection<UsageInfo>): AutomaticRenamer {
         val psiClass = getPsiClass(element)!!
-        val newPsiClassName = if (psiClass is KtLightClassForFacadeImpl) PackagePartClassUtils.getFilePartShortName(newName) else newName
+        val newPsiClassName = if (psiClass is KtLightClassForFacade) PackagePartClassUtils.getFilePartShortName(newName) else newName
         return super.createRenamer(psiClass, newPsiClassName, usages)
     }
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinClassifierProcessor.kt

@@ -12,7 +12,7 @@ import com.intellij.psi.search.SearchScope
 import com.intellij.refactoring.listeners.RefactoringElementListener
 import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration
 import org.jetbrains.kotlin.asJava.namedUnwrappedElement
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
@@ -101,7 +101,7 @@ class RenameKotlinClassifierProcessor : RenameKotlinPsiProcessor() {
         is KtLightClass ->
             when (element) {
                 is KtLightClassForSourceDeclaration -> element.kotlinOrigin
-                is KtLightClassForFacadeImpl -> element
+                is KtLightClassForFacade -> element
                 else -> throw AssertionError("Should not be suggested to rename element of type " + element::class.java + " " + element)
             }
 

idea/src/org/jetbrains/kotlin/idea/testIntegration/KotlinTestFinder.kt

@@ -26,7 +26,7 @@ import com.intellij.psi.search.PsiShortNamesCache
 import com.intellij.testIntegration.JavaTestFinder
 import com.intellij.testIntegration.TestFinderHelper
 import com.intellij.util.CommonProcessors
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration
 import org.jetbrains.kotlin.asJava.findFacadeClass
 import org.jetbrains.kotlin.asJava.toLightClass
@@ -68,7 +68,7 @@ class KotlinTestFinder : JavaTestFinder() {
             for (eachClass in cache.getClassesByName(candidateNameWithWeight.first, scope)) {
                 if (eachClass.isAnnotationType || frameworks.isTestClass(eachClass)) continue
 
-                if (eachClass is KtLightClassForFacadeImpl) {
+                if (eachClass is KtLightClassForFacade) {
                     eachClass.files.mapTo(classesWithWeights) { Pair.create(it, candidateNameWithWeight.second) }
                 } else if (eachClass.isPhysical || eachClass is KtLightClassForSourceDeclaration) {
                     classesWithWeights.add(Pair.create(eachClass, candidateNameWithWeight.second))

idea/tests/org/jetbrains/kotlin/asJava/LightClassesClasspathSortingTest.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.asJava
 import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.impl.ResolveScopeManager
 import com.intellij.testFramework.LightProjectDescriptor
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration
 import org.jetbrains.kotlin.idea.caches.lightClasses.KtLightClassForDecompiledDeclaration
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
@@ -46,8 +46,12 @@ class LightClassesClasspathSortingTest : KotlinLightCodeInsightFixtureTestCase()
         val psiClass = JavaPsiFacade.getInstance(project).findClass(fqName, ResolveScopeManager.getElementResolveScope(file))
 
         assertNotNull(psiClass, "Can't find class for $fqName")
-        assert(psiClass is KtLightClassForSourceDeclaration || psiClass is KtLightClassForFacadeImpl) { "Should be an explicit light class, but was $fqName ${psiClass::class.java}" }
-        assert(psiClass !is KtLightClassForDecompiledDeclaration) { "Should not be decompiled light class: $fqName ${psiClass::class.java}" }
+        assert(psiClass is KtLightClassForSourceDeclaration || psiClass is KtLightClassForFacade) {
+            "Should be an explicit light class, but was $fqName ${psiClass::class.java}"
+        }
+        assert(psiClass !is KtLightClassForDecompiledDeclaration) {
+            "Should not be decompiled light class: $fqName ${psiClass::class.java}"
+        }
     }
 
     override fun getProjectDescriptor(): LightProjectDescriptor {

idea/tests/org/jetbrains/kotlin/idea/caches/resolve/AbstractIdeLightClassTest.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.asJava.LightClassTestCommon
 import org.jetbrains.kotlin.asJava.builder.LightClassConstructionContext
 import org.jetbrains.kotlin.asJava.builder.StubComputationTracker
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.elements.*
 import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
@@ -271,7 +271,7 @@ object LightClassLazinessChecker {
     }
 
     private fun checkAnnotationConsistency(modifierListOwner: KtLightElement<*, PsiModifierListOwner>) {
-        if (modifierListOwner is KtLightClassForFacadeImpl) return
+        if (modifierListOwner is KtLightClassForFacade) return
 
         modifierListOwner.clsDelegate.modifierList!!.annotations.groupBy { delegateAnnotation ->
             delegateAnnotation.qualifiedName!!

idea/tests/org/jetbrains/kotlin/idea/perf/UltraLightChecker.kt

@@ -67,7 +67,7 @@ object UltraLightChecker {
         fqName: FqName,
         searchScope: GlobalSearchScope,
         project: Project
-    ): KtLightClassForFacadeImpl? {
+    ): KtLightClassForFacade? {
 
         val oldForceFlag = KtUltraLightSupport.forceUsingOldLightClasses
         KtUltraLightSupport.forceUsingOldLightClasses = true

j2k/src/org/jetbrains/kotlin/j2k/importConversion.kt

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.j2k
 
 import com.intellij.psi.*
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.elements.KtLightDeclaration
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
@@ -84,7 +84,7 @@ private fun Converter.convertImport(fqName: FqName, ref: PsiJavaCodeReferenceEle
 
 private fun Converter.convertStaticImportOnDemand(fqName: FqName, target: PsiElement?): List<String> {
     when (target) {
-        is KtLightClassForFacadeImpl -> return listOf(target.fqName.parent().render() + ".*")
+        is KtLightClassForFacade -> return listOf(target.facadeClassFqName.parent().render() + ".*")
 
         is KtLightClass -> {
             val kotlinOrigin = target.kotlinOrigin
@@ -144,7 +144,7 @@ private fun convertStaticExplicitImport(fqName: FqName, target: PsiElement?): Li
 
 private fun convertNonStaticImport(fqName: FqName, isOnDemand: Boolean, target: PsiElement?): List<String> {
     when (target) {
-        is KtLightClassForFacadeImpl -> return listOf(target.fqName.parent().render() + ".*")
+        is KtLightClassForFacade -> return listOf(target.facadeClassFqName.parent().render() + ".*")
 
         is KtLightClass -> {
             if (!isOnDemand) {

nj2k/src/org/jetbrains/kotlin/nj2k/JavaToJKTreeBuilder.kt

@@ -31,7 +31,7 @@ import com.intellij.psi.infos.MethodCandidateInfo
 import com.intellij.psi.javadoc.PsiDocComment
 import com.intellij.psi.tree.IElementType
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.elements.KtLightElement
 import org.jetbrains.kotlin.asJava.elements.KtLightField
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
@@ -137,7 +137,7 @@ class JavaToJKTreeBuilder constructor(
         val name =
             target.safeAs<KtLightElement<*, *>>()?.kotlinOrigin?.getKotlinFqName()?.asString()
                 ?: target.safeAs<KtLightClass>()?.containingFile?.safeAs<KtFile>()?.packageFqName?.asString()?.let { "$it.*" }
-                ?: target.safeAs<KtLightClassForFacadeImpl>()?.fqName?.parent()?.asString()?.let { "$it.*" }
+                ?: target.safeAs<KtLightClassForFacade>()?.facadeClassFqName?.parent()?.asString()?.let { "$it.*" }
                 ?: target.safeAs<KtLightClassForDecompiledDeclaration>()?.fqName()?.parent()?.asString()?.let { "$it.*" }
                 ?: rawName
 
@@ -467,7 +467,7 @@ class JavaToJKTreeBuilder constructor(
         fun PsiReferenceExpression.toJK(): JKExpression {
             if (this is PsiMethodReferenceExpression) return toJK()
             val target = resolve()
-            if (target is KtLightClassForFacadeImpl
+            if (target is KtLightClassForFacade
                 || target is KtLightClassForDecompiledDeclaration
             ) return JKStubExpression()
             if (target is KtLightField

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/KotlinUastLanguagePlugin.kt

@@ -27,7 +27,7 @@ import com.intellij.psi.impl.source.tree.LeafPsiElement
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.elements.*
 import org.jetbrains.kotlin.asJava.findFacadeClass
 import org.jetbrains.kotlin.asJava.toLightClass
@@ -87,7 +87,7 @@ class KotlinUastLanguagePlugin : UastLanguagePlugin {
     override fun convertElementWithParent(element: PsiElement, requiredType: Class<out UElement>?): UElement? {
         if (!element.isJvmElement) return null
         if (element is PsiFile) return convertDeclaration(element, null, elementTypes(requiredType))
-        if (element is KtLightClassForFacadeImpl) return convertDeclaration(element, null, elementTypes(requiredType))
+        if (element is KtLightClassForFacade) return convertDeclaration(element, null, elementTypes(requiredType))
 
         return convertDeclarationOrElement(element, null, elementTypes(requiredType))
     }

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/declarations/KotlinUClass.kt

@@ -19,7 +19,7 @@ package org.jetbrains.uast.kotlin
 import com.intellij.psi.*
 import com.intellij.psi.impl.light.LightPsiClassBuilder
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForScript
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
 import org.jetbrains.kotlin.load.java.JvmAbi
@@ -172,7 +172,7 @@ open class KotlinUClass private constructor(
 
         val ktDeclarations: List<KtDeclaration> = run ktDeclarations@{
             ktClass?.let { return@ktDeclarations it.declarations }
-            (javaPsi as? KtLightClassForFacadeImpl)?.let { facade ->
+            (javaPsi as? KtLightClassForFacade)?.let { facade ->
                 return@ktDeclarations facade.files.flatMap { file -> file.declarations }
             }
             emptyList()