Refactor: split *LightClassGenerationSupport into separate files

Move cli binding trace implementation to top level

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

@@ -0,0 +1,167 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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.cli.jvm.compiler
+
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiManager
+import com.intellij.psi.search.GlobalSearchScope
+import com.intellij.psi.search.PsiSearchScopeUtil
+import com.intellij.util.Function
+import com.intellij.util.SmartList
+import com.intellij.util.containers.ContainerUtil
+import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
+import org.jetbrains.kotlin.asJava.classes.KtLightClass
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForScript
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
+import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
+import org.jetbrains.kotlin.load.java.components.FilesByFacadeFqNameIndexer
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtScript
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
+import org.jetbrains.kotlin.resolve.lazy.ResolveSessionUtils
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
+
+class CliKotlinAsJavaSupport(
+    project: Project,
+    private val traceHolder: CliTraceHolder
+): KotlinAsJavaSupport() {
+    private val psiManager = PsiManager.getInstance(project)
+
+    override fun getFacadeClassesInPackage(packageFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass> {
+        return findFacadeFilesInPackage(packageFqName, scope)
+            .groupBy { it.javaFileFacadeFqName }
+            .mapNotNull {
+                KtLightClassForFacade.createForFacade(
+                    psiManager,
+                    it.key,
+                    scope,
+                    it.value
+                )
+            }
+    }
+
+    override fun getFacadeNames(packageFqName: FqName, scope: GlobalSearchScope): Collection<String> {
+        return findFacadeFilesInPackage(packageFqName, scope)
+            .map { it.javaFileFacadeFqName.shortName().asString() }
+    }
+
+    private fun findFacadeFilesInPackage(
+        packageFqName: FqName,
+        scope: GlobalSearchScope
+    ) = traceHolder.bindingContext.get(FilesByFacadeFqNameIndexer.FACADE_FILES_BY_PACKAGE_NAME, packageFqName)
+        ?.filter { PsiSearchScopeUtil.isInScope(scope, it) }
+        .orEmpty()
+
+    override fun getFacadeClasses(facadeFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass> {
+        val filesForFacade = findFilesForFacade(facadeFqName, scope)
+        if (filesForFacade.isEmpty()) return emptyList()
+
+        return listOfNotNull<PsiClass>(
+            KtLightClassForFacade.createForFacade(
+                psiManager,
+                facadeFqName,
+                scope,
+                filesForFacade
+            )
+        )
+    }
+
+    override fun getScriptClasses(scriptFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass> {
+        if (scriptFqName.isRoot) {
+            return emptyList()
+        }
+
+        return findFilesForPackage(scriptFqName.parent(), scope).mapNotNull { file ->
+            file.script?.takeIf { it.fqName == scriptFqName }?.let { it -> getLightClassForScript(it) }
+        }
+    }
+
+    override fun getKotlinInternalClasses(fqName: FqName, scope: GlobalSearchScope): Collection<PsiClass> {
+        //
+        return emptyList()
+    }
+
+    override fun findFilesForFacade(facadeFqName: FqName, scope: GlobalSearchScope): Collection<KtFile> {
+        if (facadeFqName.isRoot) return emptyList()
+
+        return traceHolder.bindingContext.get(FilesByFacadeFqNameIndexer.FACADE_FILES_BY_FQ_NAME, facadeFqName)?.filter {
+            PsiSearchScopeUtil.isInScope(scope, it)
+        } ?: emptyList()
+    }
+
+
+    override fun findClassOrObjectDeclarationsInPackage(
+        packageFqName: FqName, searchScope: GlobalSearchScope
+    ): Collection<KtClassOrObject> {
+        val files = findFilesForPackage(packageFqName, searchScope)
+        val result = SmartList<KtClassOrObject>()
+        for (file in files) {
+            for (declaration in file.declarations) {
+                if (declaration is KtClassOrObject) {
+                    result.add(declaration)
+                }
+            }
+        }
+        return result
+    }
+
+    override fun packageExists(fqName: FqName, scope: GlobalSearchScope): Boolean {
+        return !traceHolder.module.getPackage(fqName).isEmpty()
+    }
+
+    override fun getSubPackages(fqn: FqName, scope: GlobalSearchScope): Collection<FqName> {
+        val packageView = traceHolder.module.getPackage(fqn)
+        val members = packageView.memberScope.getContributedDescriptors(
+            DescriptorKindFilter.PACKAGES,
+            MemberScope.ALL_NAME_FILTER
+        )
+        return ContainerUtil.mapNotNull(
+            members,
+            object : Function<DeclarationDescriptor, FqName> {
+                override fun `fun`(member: DeclarationDescriptor): FqName? {
+                    if (member is PackageViewDescriptor) {
+                        return member.fqName
+                    }
+                    return null
+                }
+            })
+    }
+
+    override fun getLightClass(classOrObject: KtClassOrObject): KtLightClass? =
+        KtLightClassForSourceDeclaration.create(classOrObject)
+
+    override fun getLightClassForScript(script: KtScript): KtLightClassForScript? =
+        KtLightClassForScript.create(script)
+
+
+    override fun findClassOrObjectDeclarations(fqName: FqName, searchScope: GlobalSearchScope): Collection<KtClassOrObject> {
+        return ResolveSessionUtils.getClassDescriptorsByFqName(traceHolder.module, fqName).mapNotNull {
+            val element = DescriptorToSourceUtils.getSourceFromDescriptor(it)
+            if (element is KtClassOrObject && PsiSearchScopeUtil.isInScope(
+                    searchScope,
+                    element
+                )
+            ) {
+                element
+            }
+            else null
+        }
+    }
+
+    override fun findFilesForPackage(fqName: FqName, searchScope: GlobalSearchScope): Collection<KtFile> {
+        return traceHolder.bindingContext.get(BindingContext.PACKAGE_TO_FILES, fqName)?.filter {
+            PsiSearchScopeUtil.isInScope(searchScope, it)
+        } ?: emptyList()
+    }
+}

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

@@ -16,41 +16,15 @@
 
 package org.jetbrains.kotlin.cli.jvm.compiler
 
-import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiClass
-import com.intellij.psi.PsiManager
-import com.intellij.psi.search.GlobalSearchScope
-import com.intellij.psi.search.PsiSearchScopeUtil
-import com.intellij.util.Function
-import com.intellij.util.SmartList
-import com.intellij.util.containers.ContainerUtil
-import org.jetbrains.annotations.TestOnly
-import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
 import org.jetbrains.kotlin.asJava.LightClassBuilder
 import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
 import org.jetbrains.kotlin.asJava.builder.InvalidLightClassDataHolder
 import org.jetbrains.kotlin.asJava.builder.LightClassConstructionContext
 import org.jetbrains.kotlin.asJava.builder.LightClassDataHolder
 import org.jetbrains.kotlin.asJava.builder.LightClassDataHolderImpl
-import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForScript
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
-import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
-import org.jetbrains.kotlin.load.java.components.FilesByFacadeFqNameIndexer
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
-import org.jetbrains.kotlin.resolve.lazy.ResolveSessionUtils
-import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.MemberScope
-import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice
-import org.jetbrains.kotlin.util.slicedMap.WritableSlice
-import kotlin.properties.Delegates
+import org.jetbrains.kotlin.resolve.BindingContext
 
 /**
  * This class solves the problem of interdependency between analyzing Kotlin code and generating JetLightClasses
@@ -102,179 +76,4 @@ class CliLightClassGenerationSupport(private val traceHolder: CliTraceHolder) :
     override fun analyzeWithContent(element: KtClassOrObject) = traceHolder.bindingContext
 }
 
-class CliTraceHolder : CodeAnalyzerInitializer {
-    var bindingContext: BindingContext by Delegates.notNull()
-        private set
-    var module: ModuleDescriptor by Delegates.notNull()
-        private set
 
-
-    override fun initialize(trace: BindingTrace, module: ModuleDescriptor, codeAnalyzer: KotlinCodeAnalyzer) {
-        this.bindingContext = trace.bindingContext
-        this.module = module
-
-        if (trace !is CliBindingTrace) {
-            throw IllegalArgumentException("Shared trace is expected to be subclass of ${CliBindingTrace::class.java.simpleName} class")
-        }
-
-        trace.setKotlinCodeAnalyzer(codeAnalyzer)
-    }
-
-    override fun createTrace(): BindingTraceContext {
-        return NoScopeRecordCliBindingTrace()
-    }
-
-    // TODO: needs better name + list of keys to skip somewhere
-    class NoScopeRecordCliBindingTrace : CliBindingTrace() {
-        override fun <K, V> record(slice: WritableSlice<K, V>, key: K, value: V) {
-            if (slice === BindingContext.LEXICAL_SCOPE || slice == BindingContext.DATA_FLOW_INFO_BEFORE) {
-                // In the compiler there's no need to keep scopes
-                return
-            }
-            super.record(slice, key, value)
-        }
-
-        override fun toString(): String {
-            return NoScopeRecordCliBindingTrace::class.java.name
-        }
-    }
-
-    open class CliBindingTrace @TestOnly constructor() : BindingTraceContext() {
-        private var kotlinCodeAnalyzer: KotlinCodeAnalyzer? = null
-
-        override fun toString(): String {
-            return CliBindingTrace::class.java.name
-        }
-
-        fun setKotlinCodeAnalyzer(kotlinCodeAnalyzer: KotlinCodeAnalyzer) {
-            this.kotlinCodeAnalyzer = kotlinCodeAnalyzer
-        }
-
-        override fun <K, V> get(slice: ReadOnlySlice<K, V>, key: K): V? {
-            val value = super.get(slice, key)
-
-            if (value == null) {
-                if (BindingContext.FUNCTION === slice || BindingContext.VARIABLE === slice) {
-                    if (key is KtDeclaration) {
-                        if (!KtPsiUtil.isLocal(key)) {
-                            kotlinCodeAnalyzer!!.resolveToDescriptor(key)
-                            return super.get<K, V>(slice, key)
-                        }
-                    }
-                }
-            }
-
-            return value
-        }
-    }
-}
-
-
-class CliKotlinAsJavaSupport(
-    project: Project,
-    private val traceHolder: CliTraceHolder
-): KotlinAsJavaSupport() {
-    private val psiManager = PsiManager.getInstance(project)
-
-    override fun getFacadeClassesInPackage(packageFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass> {
-        return findFacadeFilesInPackage(packageFqName, scope)
-            .groupBy { it.javaFileFacadeFqName }
-            .mapNotNull { KtLightClassForFacade.createForFacade(psiManager, it.key, scope, it.value) }
-    }
-
-    override fun getFacadeNames(packageFqName: FqName, scope: GlobalSearchScope): Collection<String> {
-        return findFacadeFilesInPackage(packageFqName, scope)
-            .map { it.javaFileFacadeFqName.shortName().asString() }
-    }
-
-    private fun findFacadeFilesInPackage(
-        packageFqName: FqName,
-        scope: GlobalSearchScope
-    ) = traceHolder.bindingContext.get(FilesByFacadeFqNameIndexer.FACADE_FILES_BY_PACKAGE_NAME, packageFqName)
-        ?.filter { PsiSearchScopeUtil.isInScope(scope, it) }
-        .orEmpty()
-
-    override fun getFacadeClasses(facadeFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass> {
-        val filesForFacade = findFilesForFacade(facadeFqName, scope)
-        if (filesForFacade.isEmpty()) return emptyList()
-
-        return listOfNotNull<PsiClass>(
-            KtLightClassForFacade.createForFacade(psiManager, facadeFqName, scope, filesForFacade))
-    }
-
-    override fun getScriptClasses(scriptFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass> {
-        if (scriptFqName.isRoot) {
-            return emptyList()
-        }
-
-        return findFilesForPackage(scriptFqName.parent(), scope).mapNotNull { file ->
-            file.script?.takeIf { it.fqName == scriptFqName }?.let { it -> getLightClassForScript(it) }
-        }
-    }
-
-    override fun getKotlinInternalClasses(fqName: FqName, scope: GlobalSearchScope): Collection<PsiClass> {
-        //
-        return emptyList()
-    }
-
-    override fun findFilesForFacade(facadeFqName: FqName, scope: GlobalSearchScope): Collection<KtFile> {
-        if (facadeFqName.isRoot) return emptyList()
-
-        return traceHolder.bindingContext.get(FilesByFacadeFqNameIndexer.FACADE_FILES_BY_FQ_NAME, facadeFqName)?.filter {
-            PsiSearchScopeUtil.isInScope(scope, it)
-        } ?: emptyList()
-    }
-
-
-    override fun findClassOrObjectDeclarationsInPackage(
-        packageFqName: FqName, searchScope: GlobalSearchScope): Collection<KtClassOrObject> {
-        val files = findFilesForPackage(packageFqName, searchScope)
-        val result = SmartList<KtClassOrObject>()
-        for (file in files) {
-            for (declaration in file.declarations) {
-                if (declaration is KtClassOrObject) {
-                    result.add(declaration)
-                }
-            }
-        }
-        return result
-    }
-
-    override fun packageExists(fqName: FqName, scope: GlobalSearchScope): Boolean {
-        return !traceHolder.module.getPackage(fqName).isEmpty()
-    }
-
-    override fun getSubPackages(fqn: FqName, scope: GlobalSearchScope): Collection<FqName> {
-        val packageView = traceHolder.module.getPackage(fqn)
-        val members = packageView.memberScope.getContributedDescriptors(DescriptorKindFilter.PACKAGES, MemberScope.ALL_NAME_FILTER)
-        return ContainerUtil.mapNotNull(members, object : Function<DeclarationDescriptor, FqName> {
-            override fun `fun`(member: DeclarationDescriptor): FqName? {
-                if (member is PackageViewDescriptor) {
-                    return member.fqName
-                }
-                return null
-            }
-        })
-    }
-
-    override fun getLightClass(classOrObject: KtClassOrObject): KtLightClass? = KtLightClassForSourceDeclaration.create(classOrObject)
-
-    override fun getLightClassForScript(script: KtScript): KtLightClassForScript? = KtLightClassForScript.create(script)
-
-
-    override fun findClassOrObjectDeclarations(fqName: FqName, searchScope: GlobalSearchScope): Collection<KtClassOrObject> {
-        return ResolveSessionUtils.getClassDescriptorsByFqName(traceHolder.module, fqName).mapNotNull {
-            val element = DescriptorToSourceUtils.getSourceFromDescriptor(it)
-            if (element is KtClassOrObject && PsiSearchScopeUtil.isInScope(searchScope, element)) {
-                element
-            }
-            else null
-        }
-    }
-
-    override fun findFilesForPackage(fqName: FqName, searchScope: GlobalSearchScope): Collection<KtFile> {
-        return traceHolder.bindingContext.get(BindingContext.PACKAGE_TO_FILES, fqName)?.filter {
-            PsiSearchScopeUtil.isInScope(searchScope, it)
-        } ?: emptyList()
-    }
-}

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

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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.cli.jvm.compiler
+
+import org.jetbrains.annotations.TestOnly
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtPsiUtil
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.BindingTraceContext
+import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
+import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
+import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice
+import org.jetbrains.kotlin.util.slicedMap.WritableSlice
+import kotlin.properties.Delegates
+
+class CliTraceHolder : CodeAnalyzerInitializer {
+    var bindingContext: BindingContext by Delegates.notNull()
+        private set
+    var module: ModuleDescriptor by Delegates.notNull()
+        private set
+
+
+    override fun initialize(trace: BindingTrace, module: ModuleDescriptor, codeAnalyzer: KotlinCodeAnalyzer) {
+        this.bindingContext = trace.bindingContext
+        this.module = module
+
+        if (trace !is CliBindingTrace) {
+            throw IllegalArgumentException("Shared trace is expected to be subclass of ${CliBindingTrace::class.java.simpleName} class")
+        }
+
+        trace.setKotlinCodeAnalyzer(codeAnalyzer)
+    }
+
+    override fun createTrace(): BindingTraceContext {
+        return NoScopeRecordCliBindingTrace()
+    }
+}
+
+
+// TODO: needs better name + list of keys to skip somewhere
+class NoScopeRecordCliBindingTrace : CliBindingTrace() {
+    override fun <K, V> record(slice: WritableSlice<K, V>, key: K, value: V) {
+        if (slice === BindingContext.LEXICAL_SCOPE || slice == BindingContext.DATA_FLOW_INFO_BEFORE) {
+            // In the compiler there's no need to keep scopes
+            return
+        }
+        super.record(slice, key, value)
+    }
+
+    override fun toString(): String {
+        return NoScopeRecordCliBindingTrace::class.java.name
+    }
+}
+
+open class CliBindingTrace @TestOnly constructor() : BindingTraceContext() {
+    private var kotlinCodeAnalyzer: KotlinCodeAnalyzer? = null
+
+    override fun toString(): String {
+        return CliBindingTrace::class.java.name
+    }
+
+    fun setKotlinCodeAnalyzer(kotlinCodeAnalyzer: KotlinCodeAnalyzer) {
+        this.kotlinCodeAnalyzer = kotlinCodeAnalyzer
+    }
+
+    override fun <K, V> get(slice: ReadOnlySlice<K, V>, key: K): V? {
+        val value = super.get(slice, key)
+
+        if (value == null) {
+            if (BindingContext.FUNCTION === slice || BindingContext.VARIABLE === slice) {
+                if (key is KtDeclaration) {
+                    if (!KtPsiUtil.isLocal(key)) {
+                        kotlinCodeAnalyzer!!.resolveToDescriptor(key)
+                        return super.get<K, V>(slice, key)
+                    }
+                }
+            }
+        }
+
+        return value
+    }
+}

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

@@ -372,12 +372,12 @@ object KotlinToJVMBytecodeCompiler {
             // of the compiled modules (.class) to the list of scopes of the source module
             val scope = if (moduleOutputs.isEmpty()) sourcesOnly else sourcesOnly.uniteWith(DirectoriesScope(project, moduleOutputs))
             TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-                    project,
-                    sourceFiles,
-                    CliTraceHolder.NoScopeRecordCliBindingTrace(),
-                    environment.configuration,
-                    environment::createPackagePartProvider,
-                    sourceModuleSearchScope = scope
+                project,
+                sourceFiles,
+                NoScopeRecordCliBindingTrace(),
+                environment.configuration,
+                environment::createPackagePartProvider,
+                sourceModuleSearchScope = scope
             )
         }
 

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplCodeAnalyzer.kt

@@ -22,8 +22,8 @@ import org.jetbrains.kotlin.cli.common.repl.CompiledReplCodeLine
 import org.jetbrains.kotlin.cli.common.repl.ILineId
 import org.jetbrains.kotlin.cli.common.repl.ReplCodeLine
 import org.jetbrains.kotlin.cli.common.repl.ReplHistory
-import org.jetbrains.kotlin.cli.jvm.compiler.CliTraceHolder
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor
@@ -56,7 +56,7 @@ class ReplCodeAnalyzer(environment: KotlinCoreEnvironment) {
 
     val module: ModuleDescriptorImpl
 
-    val trace: BindingTraceContext = CliTraceHolder.NoScopeRecordCliBindingTrace()
+    val trace: BindingTraceContext = NoScopeRecordCliBindingTrace()
 
     init {
         // Module source scope is empty because all binary classes are in the dependency module, and all source classes are guaranteed

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

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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
+
+import com.intellij.openapi.components.ServiceManager
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiClass
+import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.asJava.classes.KtLightClass
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtScript
+
+abstract class KotlinAsJavaSupport {
+    // Returns only immediately declared classes/objects, package classes are not included (they have no declarations)
+    abstract fun findClassOrObjectDeclarationsInPackage(
+        packageFqName: FqName,
+        searchScope: GlobalSearchScope
+    ): Collection<KtClassOrObject>
+
+    /*
+    * Finds files whose package declaration is exactly {@code fqName}. For example, if a file declares
+    *     package a.b.c
+    * it will not be returned for fqName "a.b"
+    *
+    * If the resulting collection is empty, it means that this package has not other declarations than sub-packages
+    */
+    abstract fun findFilesForPackage(fqName: FqName, searchScope: GlobalSearchScope): Collection<KtFile>
+
+    abstract fun findClassOrObjectDeclarations(fqName: FqName, searchScope: GlobalSearchScope): Collection<KtClassOrObject>
+
+    abstract fun packageExists(fqName: FqName, scope: GlobalSearchScope): Boolean
+
+    abstract fun getSubPackages(fqn: FqName, scope: GlobalSearchScope): Collection<FqName>
+
+    abstract fun getLightClass(classOrObject: KtClassOrObject): KtLightClass?
+
+    abstract fun getLightClassForScript(script: KtScript): KtLightClass?
+
+    abstract fun getFacadeClasses(facadeFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass>
+
+    abstract fun getScriptClasses(scriptFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass>
+
+    abstract fun getKotlinInternalClasses(fqName: FqName, scope: GlobalSearchScope): Collection<PsiClass>
+
+    abstract fun getFacadeClassesInPackage(packageFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass>
+
+    abstract fun getFacadeNames(packageFqName: FqName, scope: GlobalSearchScope): Collection<String>
+
+    abstract fun findFilesForFacade(facadeFqName: FqName, scope: GlobalSearchScope): Collection<KtFile>
+
+    companion object {
+        @JvmStatic
+        fun getInstance(project: Project): KotlinAsJavaSupport {
+            return ServiceManager.getService(
+                project,
+                KotlinAsJavaSupport::class.java
+            )
+        }
+    }
+}

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

@@ -18,66 +18,15 @@ package org.jetbrains.kotlin.asJava
 
 import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiClass
-import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.asJava.builder.LightClassBuilderResult
 import org.jetbrains.kotlin.asJava.builder.LightClassConstructionContext
 import org.jetbrains.kotlin.asJava.builder.LightClassDataHolder
-import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForScript
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 
 typealias LightClassBuilder = (LightClassConstructionContext) -> LightClassBuilderResult
 
-abstract class KotlinAsJavaSupport {
-    // Returns only immediately declared classes/objects, package classes are not included (they have no declarations)
-    abstract fun findClassOrObjectDeclarationsInPackage(
-        packageFqName: FqName,
-        searchScope: GlobalSearchScope
-    ): Collection<KtClassOrObject>
-
-    /*
-    * Finds files whose package declaration is exactly {@code fqName}. For example, if a file declares
-    *     package a.b.c
-    * it will not be returned for fqName "a.b"
-    *
-    * If the resulting collection is empty, it means that this package has not other declarations than sub-packages
-    */
-    abstract fun findFilesForPackage(fqName: FqName, searchScope: GlobalSearchScope): Collection<KtFile>
-
-    abstract fun findClassOrObjectDeclarations(fqName: FqName, searchScope: GlobalSearchScope): Collection<KtClassOrObject>
-
-    abstract fun packageExists(fqName: FqName, scope: GlobalSearchScope): Boolean
-
-    abstract fun getSubPackages(fqn: FqName, scope: GlobalSearchScope): Collection<FqName>
-
-    abstract fun getLightClass(classOrObject: KtClassOrObject): KtLightClass?
-
-    abstract fun getLightClassForScript(script: KtScript): KtLightClassForScript?
-
-    abstract fun getFacadeClasses(facadeFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass>
-
-    abstract fun getScriptClasses(scriptFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass>
-
-    abstract fun getKotlinInternalClasses(fqName: FqName, scope: GlobalSearchScope): Collection<PsiClass>
-
-    abstract fun getFacadeClassesInPackage(packageFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass>
-
-    abstract fun getFacadeNames(packageFqName: FqName, scope: GlobalSearchScope): Collection<String>
-
-    abstract fun findFilesForFacade(facadeFqName: FqName, scope: GlobalSearchScope): Collection<KtFile>
-
-    companion object {
-        @JvmStatic
-        fun getInstance(project: Project): KotlinAsJavaSupport {
-            return ServiceManager.getService(project, KotlinAsJavaSupport::class.java)
-        }
-    }
-}
-
 abstract class LightClassGenerationSupport {
     abstract fun createDataHolderForClass(classOrObject: KtClassOrObject, builder: LightClassBuilder): LightClassDataHolder.ForClass
 

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt

@@ -21,7 +21,7 @@ import com.intellij.openapi.util.text.StringUtil
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.analyzer.common.CommonAnalyzerFacade
-import org.jetbrains.kotlin.cli.jvm.compiler.CliTraceHolder
+import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.container.get
@@ -104,7 +104,7 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
 
             val separateModules = groupedByModule.size == 1 && groupedByModule.keys.single() == null
             val result = analyzeModuleContents(
-                moduleContext, ktFiles, CliTraceHolder.NoScopeRecordCliBindingTrace(),
+                moduleContext, ktFiles, NoScopeRecordCliBindingTrace(),
                 languageVersionSettings, separateModules, loadJvmTarget(testFilesInModule)
             )
             if (oldModule != result.moduleDescriptor) {

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java

@@ -35,9 +35,9 @@ import org.jetbrains.kotlin.checkers.CheckerTestUtil;
 import org.jetbrains.kotlin.checkers.CompilerTestLanguageVersionSettings;
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsKt;
-import org.jetbrains.kotlin.cli.jvm.compiler.CliTraceHolder;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.config.*;
@@ -466,7 +466,7 @@ public abstract class CodegenTestCase extends KtUsefulTestCase {
             try {
                 GenerationState generationState = GenerationUtils.compileFiles(
                         myFiles.getPsiFiles(), myEnvironment, getClassBuilderFactory(),
-                        new CliTraceHolder.NoScopeRecordCliBindingTrace()
+                        new NoScopeRecordCliBindingTrace()
                 );
                 classFileFactory = generationState.getFactory();
 

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/GenerationUtils.kt

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.codegen
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
 import org.jetbrains.kotlin.cli.common.output.outputUtils.writeAllTo
-import org.jetbrains.kotlin.cli.jvm.compiler.CliTraceHolder
+import org.jetbrains.kotlin.cli.jvm.compiler.CliBindingTrace
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.CompilerConfiguration
@@ -48,7 +48,7 @@ object GenerationUtils {
         files: List<KtFile>,
         environment: KotlinCoreEnvironment,
         classBuilderFactory: ClassBuilderFactory = ClassBuilderFactories.TEST,
-        trace: BindingTrace = CliTraceHolder.CliBindingTrace()
+        trace: BindingTrace = CliBindingTrace()
     ): GenerationState =
         compileFiles(files, environment.configuration, classBuilderFactory, environment::createPackagePartProvider, trace)
 
@@ -59,7 +59,7 @@ object GenerationUtils {
         configuration: CompilerConfiguration,
         classBuilderFactory: ClassBuilderFactory,
         packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
-        trace: BindingTrace = CliTraceHolder.CliBindingTrace()
+        trace: BindingTrace = CliBindingTrace()
     ): GenerationState {
         val analysisResult =
             JvmResolveUtil.analyzeAndCheckForErrors(files.first().project, files, configuration, packagePartProvider, trace)

compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java

@@ -21,9 +21,9 @@ import com.intellij.openapi.util.io.FileUtil;
 import junit.framework.ComparisonFailure;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
-import org.jetbrains.kotlin.cli.jvm.compiler.CliTraceHolder;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace;
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM;
 import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
@@ -189,7 +189,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
                 KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
         registerJavacIfNeeded(environment);
         AnalysisResult result = TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-                environment.getProject(), environment.getSourceFiles(), new CliTraceHolder.NoScopeRecordCliBindingTrace(),
+                environment.getProject(), environment.getSourceFiles(), new NoScopeRecordCliBindingTrace(),
                 configuration, environment::createPackagePartProvider
         );
 

compiler/tests-common/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt

@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.renderer
 
 import com.intellij.openapi.editor.impl.DocumentImpl
 import com.intellij.openapi.util.io.FileUtil
-import org.jetbrains.kotlin.cli.jvm.compiler.CliTraceHolder
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
@@ -60,7 +60,7 @@ abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment() {
         val container = createContainerForLazyResolve(
             context,
             FileBasedDeclarationProviderFactory(context.storageManager, listOf(psiFile)),
-            CliTraceHolder.NoScopeRecordCliBindingTrace(),
+            NoScopeRecordCliBindingTrace(),
             JvmPlatform,
             JvmTarget.JVM_1_6,
             targetEnvironment,

compiler/tests-common/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.kt

@@ -19,8 +19,9 @@ package org.jetbrains.kotlin.resolve.lazy
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.AnalysisResult
-import org.jetbrains.kotlin.cli.jvm.compiler.CliTraceHolder
+import org.jetbrains.kotlin.cli.jvm.compiler.CliBindingTrace
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.container.ComponentProvider
@@ -35,7 +36,7 @@ object JvmResolveUtil {
     @JvmOverloads
     fun createContainer(environment: KotlinCoreEnvironment, files: Collection<KtFile> = emptyList()): ComponentProvider =
         TopDownAnalyzerFacadeForJVM.createContainer(
-            environment.project, files, CliTraceHolder.NoScopeRecordCliBindingTrace(),
+            environment.project, files, NoScopeRecordCliBindingTrace(),
             environment.configuration, { PackagePartProvider.Empty }, ::FileBasedDeclarationProviderFactory
         )
 
@@ -53,7 +54,7 @@ object JvmResolveUtil {
         files: Collection<KtFile>,
         configuration: CompilerConfiguration,
         packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
-        trace: BindingTrace = CliTraceHolder.CliBindingTrace()
+        trace: BindingTrace = CliBindingTrace()
     ): AnalysisResult {
         for (file in files) {
             AnalyzingUtils.checkForSyntacticErrors(file)
@@ -85,7 +86,7 @@ object JvmResolveUtil {
         files: Collection<KtFile>,
         configuration: CompilerConfiguration,
         packagePartProviderFactory: (GlobalSearchScope) -> PackagePartProvider,
-        trace: BindingTrace = CliTraceHolder.CliBindingTrace()
+        trace: BindingTrace = CliBindingTrace()
     ): AnalysisResult {
         return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
             project, files, trace, configuration, packagePartProviderFactory