LC: rename KtLightClassForFacade to ...Impl

before introducing a common interface for light class for facade

This is a mechanical refactoring.

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

@@ -37,7 +37,7 @@ class CliKotlinAsJavaSupport(
         return findFacadeFilesInPackage(packageFqName, scope)
             .groupBy { it.javaFileFacadeFqName }
             .mapNotNull { (facadeClassFqName, _) ->
-                KtLightClassForFacade.createForFacade(psiManager, facadeClassFqName, scope)
+                KtLightClassForFacadeImpl.createForFacade(psiManager, facadeClassFqName, scope)
             }
     }
 
@@ -54,7 +54,7 @@ class CliKotlinAsJavaSupport(
         .orEmpty()
 
     override fun getFacadeClasses(facadeFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass> {
-        return listOfNotNull(KtLightClassForFacade.createForFacade(psiManager, facadeFqName, scope))
+        return listOfNotNull(KtLightClassForFacadeImpl.createForFacade(psiManager, facadeFqName, scope))
     }
 
     override fun getScriptClasses(scriptFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass> {

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: KtLightClassForFacade?) {
+private data class ValueWrapper(val value: KtLightClassForFacadeImpl?) {
     companion object {
         val Null = ValueWrapper(null)
     }
@@ -27,7 +27,7 @@ class FacadeCache(private val project: Project) {
     private inner class FacadeCacheData {
         val cache = object : SLRUCache<FacadeCacheKey, ValueWrapper>(20, 30) {
             override fun createValue(key: FacadeCacheKey): ValueWrapper =
-                KtLightClassForFacade.createForFacadeNoCache(key.fqName, key.searchScope, project)
+                KtLightClassForFacadeImpl.createForFacadeNoCache(key.fqName, key.searchScope, project)
                     ?.let { ValueWrapper(it) }
                     ?: ValueWrapper.Null
         }
@@ -42,7 +42,7 @@ class FacadeCache(private val project: Project) {
         }, false
     )
 
-    operator fun get(qualifiedName: FqName, searchScope: GlobalSearchScope): KtLightClassForFacade? {
+    operator fun get(qualifiedName: FqName, searchScope: GlobalSearchScope): KtLightClassForFacadeImpl? {
         synchronized(cachedValue) {
             return cachedValue.value.cache.get(FacadeCacheKey(qualifiedName, searchScope)).value
         }

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

@@ -17,9 +17,7 @@
 package org.jetbrains.kotlin.asJava.classes
 
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.util.Comparing
 import com.intellij.openapi.util.TextRange
-import com.intellij.openapi.util.registry.Registry
 import com.intellij.psi.*
 import com.intellij.psi.impl.PsiSuperMethodImplUtil
 import com.intellij.psi.impl.java.stubs.PsiJavaFileStub
@@ -47,7 +45,7 @@ import org.jetbrains.kotlin.psi.KtStringTemplateExpression
 import org.jetbrains.kotlin.psi.psiUtil.siblings
 import javax.swing.Icon
 
-open class KtLightClassForFacade constructor(
+open class KtLightClassForFacadeImpl constructor(
     manager: PsiManager,
     protected val facadeClassFqName: FqName,
     myLightClassDataCache: CachedValue<LightClassDataHolder.ForFacade>,
@@ -186,13 +184,13 @@ open class KtLightClassForFacade constructor(
 
     override fun isValid() = files.all { it.isValid && it.hasTopLevelCallables() && facadeClassFqName == it.javaFileFacadeFqName }
 
-    override fun copy() = KtLightClassForFacade(manager, facadeClassFqName, lightClassDataCache, files)
+    override fun copy() = KtLightClassForFacadeImpl(manager, facadeClassFqName, lightClassDataCache, files)
 
     override fun getNavigationElement() = firstFileInFacade
 
     override fun isEquivalentTo(another: PsiElement?): Boolean =
         equals(another) ||
-                (another is KtLightClassForFacade && another.facadeClassFqName == facadeClassFqName)
+                (another is KtLightClassForFacadeImpl && another.facadeClassFqName == facadeClassFqName)
 
     override fun getElementIcon(flags: Int): Icon? = throw UnsupportedOperationException("This should be done by JetIconProvider")
 
@@ -226,7 +224,7 @@ open class KtLightClassForFacade constructor(
             return false
         }
 
-        val lightClass = other as KtLightClassForFacade
+        val lightClass = other as KtLightClassForFacadeImpl
         if (this === other) return true
 
         if (this.hashCode != lightClass.hashCode) return false
@@ -237,7 +235,7 @@ open class KtLightClassForFacade constructor(
         return true
     }
 
-    override fun toString() = "${KtLightClassForFacade::class.java.simpleName}:$facadeClassFqName"
+    override fun toString() = "${KtLightClassForFacadeImpl::class.java.simpleName}:$facadeClassFqName"
 
     override val originKind: LightClassOriginKind
         get() = LightClassOriginKind.SOURCE
@@ -256,7 +254,7 @@ open class KtLightClassForFacade constructor(
 
     companion object {
 
-        fun createForFacadeNoCache(fqName: FqName, searchScope: GlobalSearchScope, project: Project): KtLightClassForFacade? {
+        fun createForFacadeNoCache(fqName: FqName, searchScope: GlobalSearchScope, project: Project): KtLightClassForFacadeImpl? {
 
             val sources = KotlinAsJavaSupport.getInstance(project).findFilesForFacade(fqName, searchScope)
                 .filterNot { it.isCompiled }
@@ -272,7 +270,7 @@ open class KtLightClassForFacade constructor(
             return LightClassGenerationSupport.getInstance(project).run {
                 if (useUltraLightClasses) createUltraLightClassForFacade(manager, fqName, stubValue, sources)
                     ?: error { "Unable to create UL class for facade" }
-                else KtLightClassForFacade(manager, fqName, stubValue, sources)
+                else KtLightClassForFacadeImpl(manager, fqName, stubValue, sources)
             }
         }
 
@@ -280,7 +278,7 @@ open class KtLightClassForFacade constructor(
             manager: PsiManager,
             facadeClassFqName: FqName,
             searchScope: GlobalSearchScope
-        ): KtLightClassForFacade? {
+        ): KtLightClassForFacadeImpl? {
             return FacadeCache.getInstance(manager.project)[facadeClassFqName, searchScope]
         }
 
@@ -288,12 +286,12 @@ open class KtLightClassForFacade constructor(
             manager: PsiManager,
             facadeClassFqName: FqName,
             file: KtFile
-        ): KtLightClassForFacade {
+        ): KtLightClassForFacadeImpl {
             // 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
             )
-            return KtLightClassForFacade(manager, facadeClassFqName, cachedValue, listOf(file))
+            return KtLightClassForFacadeImpl(manager, facadeClassFqName, cachedValue, listOf(file))
         }
     }
 }

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 KtLightClassForFacade) {
+                if (containingClass is KtLightClassForFacadeImpl) {
-                    containingClass = object : LightClass(containingClass as KtLightClassForFacade, KotlinLanguage.INSTANCE) {
+                    containingClass = object : LightClass(containingClass as KtLightClassForFacadeImpl, KotlinLanguage.INSTANCE) {
                         override fun getName(): String? = currentFileName
                     }
                     createWrapper = true

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

@@ -29,7 +29,7 @@ class KtUltraLightClassForFacade(
     lightClassDataCache: CachedValue<LightClassDataHolder.ForFacade>,
     files: Collection<KtFile>,
     private val filesWithSupports: Collection<Pair<KtFile, KtUltraLightSupport>>
-) : KtLightClassForFacade(manager, facadeClassFqName, lightClassDataCache, files) {
+) : KtLightClassForFacadeImpl(manager, facadeClassFqName, lightClassDataCache, files) {
 
     override fun getDelegate(): PsiClass = invalidAccess()
 
@@ -147,6 +147,6 @@ class KtUltraLightClassForFacade(
 
     override fun getOwnMethods() = _ownMethods
 
-    override fun copy(): KtLightClassForFacade =
+    override fun copy(): KtLightClassForFacadeImpl =
         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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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 KtLightClassForFacade) {
+        if (lightClass() is KtLightClassForFacadeImpl) {
             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 KtLightClassForFacade && this in it.files } as? KtLightClass
+            .firstOrNull { it is KtLightClassForFacadeImpl && 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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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 KtLightClassForFacade -> this.files.first()
+        is KtLightClassForFacadeImpl -> 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/IDEKotlinAsJavaSupport.kt

@@ -52,7 +52,7 @@ open class IDEKotlinAsJavaSupport(private val project: Project) : KotlinAsJavaSu
         manager: PsiManager,
         facadeClassFqName: FqName,
         searchScope: GlobalSearchScope
-    ): KtLightClass? = KtLightClassForFacade.createForFacade(psiManager, facadeClassFqName, searchScope)
+    ): KtLightClass? = KtLightClassForFacadeImpl.createForFacade(psiManager, facadeClassFqName, searchScope)
 
     override fun getFacadeNames(packageFqName: FqName, scope: GlobalSearchScope): Collection<String> {
         val facadeFilesInPackage = project.runReadActionInSmartMode {

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

@@ -9,7 +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
 import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
@@ -52,7 +52,7 @@ class KtFileClassProviderImpl(val project: Project) : KtFileClassProvider {
         val facadeClasses = when {
             file.analysisContext != null && file.hasTopLevelCallables() ->
                 listOf(
-                    KtLightClassForFacade.createForSyntheticFile(
+                    KtLightClassForFacadeImpl.createForSyntheticFile(
                         PsiManager.getInstance(
                             file.project
                         ), fileClassFqName, file
@@ -71,7 +71,7 @@ class KtFileClassProviderImpl(val project: Project) : KtFileClassProvider {
         }
 
         facadeClasses.filterTo(result) {
-            it is KtLightClassForFacade && file in it.files
+            it is KtLightClassForFacadeImpl && 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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.*
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
@@ -256,7 +256,7 @@ class FirLightClassForFacade(
 
     override fun hashCode() = facadeClassFqName.hashCode()
 
-    override fun toString() = "${KtLightClassForFacade::class.java.simpleName}:$facadeClassFqName"
+    override fun toString() = "${KtLightClassForFacadeImpl::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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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 KtLightClassForFacade -> KotlinIconsIndependent.FILE
+            is KtLightClassForFacadeImpl -> 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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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 KtLightClassForFacade -> KotlinBundle.message("find.usages.facade.class")
+            is KtLightClassForFacadeImpl -> 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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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 KtLightClassForFacade -> psiClass.files.asSequence().mapNotNull {
+                    is KtLightClassForFacadeImpl -> 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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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 KtLightClassForFacade) {
+    if (this is KtLightClassForFacadeImpl) {
         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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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 KtLightClassForFacade -> files.singleOrNull()
+        is KtLightClassForFacadeImpl -> 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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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 KtLightClassForFacade -> psi.files.firstOrNull()
+        is KtLightClassForFacadeImpl -> 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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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? KtLightClassForFacade
+                    val facadeContainer = lightElement.parent as? KtLightClassForFacadeImpl
                     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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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 KtLightClassForFacade) {
+        if (element is KtLightClassForFacadeImpl) {
             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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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 KtLightClassForFacade) PackagePartClassUtils.getFilePartShortName(newName) else newName
+        val newPsiClassName = if (psiClass is KtLightClassForFacadeImpl) 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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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 KtLightClassForFacade -> element
+                is KtLightClassForFacadeImpl -> 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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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 KtLightClassForFacade) {
+                if (eachClass is KtLightClassForFacadeImpl) {
                     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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration
 import org.jetbrains.kotlin.idea.caches.lightClasses.KtLightClassForDecompiledDeclaration
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
@@ -46,7 +46,7 @@ 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 KtLightClassForFacade) { "Should be an explicit light class, but was $fqName ${psiClass::class.java}" }
+        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}" }
     }
 

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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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 KtLightClassForFacade) return
+        if (modifierListOwner is KtLightClassForFacadeImpl) return
 
         modifierListOwner.clsDelegate.modifierList!!.annotations.groupBy { delegateAnnotation ->
             delegateAnnotation.qualifiedName!!

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

@@ -67,13 +67,13 @@ object UltraLightChecker {
         fqName: FqName,
         searchScope: GlobalSearchScope,
         project: Project
-    ): KtLightClassForFacade? {
+    ): KtLightClassForFacadeImpl? {
 
         val oldForceFlag = KtUltraLightSupport.forceUsingOldLightClasses
         KtUltraLightSupport.forceUsingOldLightClasses = true
-        val gold = KtLightClassForFacade.createForFacadeNoCache(fqName, searchScope, project)
+        val gold = KtLightClassForFacadeImpl.createForFacadeNoCache(fqName, searchScope, project)
         KtUltraLightSupport.forceUsingOldLightClasses = false
-        val ultraLightClass = KtLightClassForFacade.createForFacadeNoCache(fqName, searchScope, project) ?: return null
+        val ultraLightClass = KtLightClassForFacadeImpl.createForFacadeNoCache(fqName, searchScope, project) ?: return null
         KtUltraLightSupport.forceUsingOldLightClasses = oldForceFlag
 
         checkClassEquivalenceByRendering(gold, ultraLightClass)

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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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 KtLightClassForFacade -> return listOf(target.fqName.parent().render() + ".*")
+        is KtLightClassForFacadeImpl -> return listOf(target.fqName.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 KtLightClassForFacade -> return listOf(target.fqName.parent().render() + ".*")
+        is KtLightClassForFacadeImpl -> return listOf(target.fqName.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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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<KtLightClassForFacade>()?.fqName?.parent()?.asString()?.let { "$it.*" }
+                ?: target.safeAs<KtLightClassForFacadeImpl>()?.fqName?.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 KtLightClassForFacade
+            if (target is KtLightClassForFacadeImpl
                 || 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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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 KtLightClassForFacade) return convertDeclaration(element, null, elementTypes(requiredType))
+        if (element is KtLightClassForFacadeImpl) 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.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacadeImpl
 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? KtLightClassForFacade)?.let { facade ->
+            (javaPsi as? KtLightClassForFacadeImpl)?.let { facade ->
                 return@ktDeclarations facade.files.flatMap { file -> file.declarations }
             }
             emptyList()