[ULC] Add LanguageVersionSettings to CliLightClassGenerationSupport

+ refactoring

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

@@ -28,9 +28,11 @@ import org.jetbrains.kotlin.asJava.builder.LightClassDataHolder
 import org.jetbrains.kotlin.asJava.classes.*
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
 
 typealias LightClassBuilder = (LightClassConstructionContext) -> LightClassBuilderResult
 
@@ -49,18 +51,57 @@ abstract class LightClassGenerationSupport {
 
     abstract fun analyzeWithContent(element: KtClassOrObject): BindingContext
 
-    abstract fun createUltraLightClass(element: KtClassOrObject): KtUltraLightClass?
+    protected abstract fun getUltraLightClassSupport(element: KtElement): KtUltraLightSupport
 
-    abstract fun createUltraLightClassForScript(script: KtScript): KtUltraLightClassForScript?
+    fun createConstantEvaluator(expression: KtExpression): ConstantExpressionEvaluator = getUltraLightClassSupport(expression).run {
+        ConstantExpressionEvaluator(moduleDescriptor, languageVersionSettings, expression.project)
+    }
 
-    abstract fun getUltraLightClassSupport(element: KtElement): KtUltraLightSupport
-
-    abstract fun createUltraLightClassForFacade(
+    fun createUltraLightClassForFacade(
         manager: PsiManager,
         facadeClassFqName: FqName,
         lightClassDataCache: CachedValue<LightClassDataHolder.ForFacade>,
-        files: Collection<KtFile>
-    ): KtUltraLightClassForFacade?
+        files: Collection<KtFile>,
+    ): KtUltraLightClassForFacade? {
+
+        if (files.any { it.isScript() }) return null
+
+        val filesToSupports: List<Pair<KtFile, KtUltraLightSupport>> = files.map {
+            it to getUltraLightClassSupport(it)
+        }
+
+        return KtUltraLightClassForFacade(
+            manager,
+            facadeClassFqName,
+            lightClassDataCache,
+            files,
+            filesToSupports
+        )
+    }
+
+    fun createUltraLightClass(element: KtClassOrObject): KtUltraLightClass? {
+        if (element.shouldNotBeVisibleAsLightClass()) {
+            return null
+        }
+
+        return getUltraLightClassSupport(element).let { support ->
+            when {
+                element is KtObjectDeclaration && element.isObjectLiteral() ->
+                    KtUltraLightClassForAnonymousDeclaration(element, support)
+
+                element.safeIsLocal() ->
+                    KtUltraLightClassForLocalDeclaration(element, support)
+
+                (element.hasModifier(KtTokens.INLINE_KEYWORD)) ->
+                    KtUltraLightInlineClass(element, support)
+
+                else -> KtUltraLightClass(element, support)
+            }
+        }
+    }
+
+    fun createUltraLightClassForScript(script: KtScript): KtUltraLightClassForScript? =
+        KtUltraLightClassForScript(script, support = getUltraLightClassSupport(script))
 
     companion object {
         @JvmStatic

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

@@ -6,12 +6,11 @@
 package org.jetbrains.kotlin.asJava.classes
 
 import org.jetbrains.annotations.TestOnly
-import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver
 
 interface KtUltraLightSupport {
@@ -20,9 +19,9 @@ interface KtUltraLightSupport {
     val typeMapper: KotlinTypeMapper
     val moduleDescriptor: ModuleDescriptor
     val isReleasedCoroutine: Boolean
-    fun possiblyHasAlias(file: KtFile, shortName: Name): Boolean
+    val languageVersionSettings: LanguageVersionSettings
 
-    fun getConstantEvaluator(expression: KtExpression): ConstantExpressionEvaluator
+    fun possiblyHasAlias(file: KtFile, shortName: Name): Boolean
 
     companion object {
         // This property may be removed once IntelliJ versions earlier than 2018.3 become unsupported
@@ -32,30 +31,3 @@ interface KtUltraLightSupport {
         var forceUsingOldLightClasses = false
     }
 }
-
-class UltraLightSupportViaService(private val ktElement: KtElement) : KtUltraLightSupport {
-
-    private val serviceProvidedSupport: KtUltraLightSupport
-        get() = LightClassGenerationSupport.getInstance(ktElement.project).getUltraLightClassSupport(ktElement)
-
-    override val moduleName: String
-        get() = serviceProvidedSupport.moduleName
-
-    override val deprecationResolver: DeprecationResolver
-        get() = serviceProvidedSupport.deprecationResolver
-
-    override val typeMapper: KotlinTypeMapper
-        get() = serviceProvidedSupport.typeMapper
-
-    override val moduleDescriptor: ModuleDescriptor
-        get() = serviceProvidedSupport.moduleDescriptor
-
-    override val isReleasedCoroutine: Boolean
-        get() = serviceProvidedSupport.isReleasedCoroutine
-
-    override fun possiblyHasAlias(file: KtFile, shortName: Name): Boolean =
-        serviceProvidedSupport.possiblyHasAlias(file, shortName)
-
-    override fun getConstantEvaluator(expression: KtExpression): ConstantExpressionEvaluator =
-        serviceProvidedSupport.getConstantEvaluator(expression)
-}

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

@@ -282,9 +282,7 @@ fun computeExpression(expression: PsiElement): Any? {
     }
 
     val generationSupport = LightClassGenerationSupport.getInstance(expressionToCompute.project)
-    val evaluator = generationSupport
-        .getUltraLightClassSupport(expressionToCompute)
-        .getConstantEvaluator(expressionToCompute)
+    val evaluator = generationSupport.createConstantEvaluator(expressionToCompute)
 
     val constant = runReadAction {
         val evaluatorTrace = DelegatingBindingTrace(generationSupport.analyze(expressionToCompute), "Evaluating annotation argument")