LC: rename KtLightClassForFacade to ...Impl

before introducing a common interface for light class for facade This is a mechanical refactoring.
2021-05-04 12:58:16 -07:00
parent c14a890e7e
commit efba90c6f1
29 changed files with 83 additions and 85 deletions
@@ -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> {
@@ -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
        }
@@ -53,4 +53,4 @@ class FacadeCache(private val project: Project) {
            return ServiceManager.getService(project, FacadeCache::class.java)
        }
    }
-}
+}
@@ -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))
        }
    }
 }
@@ -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) {
-                    containingClass = object : LightClass(containingClass as KtLightClassForFacade, KotlinLanguage.INSTANCE) {
+                if (containingClass is KtLightClassForFacadeImpl) {
+                    containingClass = object : LightClass(containingClass as KtLightClassForFacadeImpl, KotlinLanguage.INSTANCE) {
                        override fun getName(): String? = currentFileName
                    }
                    createWrapper = true
@@ -100,4 +100,4 @@ open class KtLightClassForLocalDeclaration(
            return if (declaration is KtClass) declaration.toLightClass() else null
        }
    }
-}
+}
@@ -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)
-}
+}
@@ -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)
@@ -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)
@@ -291,4 +291,4 @@ fun computeExpression(expression: PsiElement): Any? {

    if (constant.isError) return null
    return evalConstantValue(constant.toConstantValue(TypeUtils.NO_EXPECTED_TYPE))
-}
+}
@@ -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}")
    }

@@ -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 {
@@ -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,9 +71,9 @@ 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()
    }
-}
+}
@@ -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
@@ -270,4 +270,4 @@ class FirLightClassForFacade(
    override fun getStartOffsetInParent() = firstFileInFacade.startOffsetInParent

    override fun isWritable() = files.all { it.isWritable }
-}
+}
@@ -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 ->
@@ -157,4 +157,4 @@ open class KotlinIconProviderBase : IconProvider(), DumbAware {
            else -> unwrapped?.takeIf { it != this }?.getBaseIcon()
        }
    }
-}
+}
@@ -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 {
@@ -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()

@@ -175,4 +175,4 @@ class KotlinFieldBreakpointType :
    }

    override fun isSuspendThreadSupported() = true
-}
+}
@@ -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 {
@@ -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
    }
@@ -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
    }

@@ -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(
@@ -408,4 +408,4 @@ class MoveKotlinDeclarationsProcessor(
    }

    override fun getCommandName(): String = KotlinBundle.message("text.move.declarations")
-}
+}
@@ -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
        }
@@ -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)
    }
-}
+}
@@ -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)
            }

@@ -139,4 +139,4 @@ class RenameKotlinClassifierProcessor : RenameKotlinPsiProcessor() {
        return processFoundReferences(element, references)
    }

-}
+}
@@ -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))
@@ -112,4 +112,4 @@ class KotlinTestFinder : JavaTestFinder() {

        return TestFinderHelper.getSortedElements(classesWithProximities, true)
    }
-}
+}
@@ -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}" }
    }

@@ -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!!
@@ -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)
@@ -181,4 +181,4 @@ object UltraLightChecker {
        }
        lightClass.fields.forEach { checkDescriptorLeakOnElement(it) }
    }
-}
+}
@@ -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) {
@@ -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
@@ -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))
    }
@@ -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()
@@ -392,4 +392,4 @@ private fun reportConvertFailure(psiMethod: PsiMethod): Nothing {
    }

    throw report
-}
+}