[scripting] Move earlierScripts to the frontend descriptor

^KT-20488 fixed

compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt

@@ -79,10 +79,7 @@ class ScriptCodegen private constructor(
             classBuilder: ClassBuilder,
             methodContext: MethodContext
     ) {
-        val jvmSignature = typeMapper.mapScriptSignature(
+        val jvmSignature = typeMapper.mapScriptSignature(scriptDescriptor)
-            scriptDescriptor,
-            scriptContext.earlierScripts
-        )
         val asmMethod = jvmSignature.asmMethod
 
         scriptContext.resultFieldInfo?.let { resultFieldInfo ->
@@ -129,7 +126,7 @@ class ScriptCodegen private constructor(
                 field.store(value, iv)
             }
 
-            if (!scriptContext.earlierScripts.isEmpty()) {
+            if (scriptContext.scriptDescriptor.isReplScript) {
                 val scriptsParamIndex = frameMap.enterTemp(AsmUtil.getArrayType(OBJECT_TYPE))
 
                 scriptContext.earlierScripts.forEachIndexed { earlierScriptIndex, earlierScript ->

compiler/backend/src/org/jetbrains/kotlin/codegen/context/ScriptContext.kt

@@ -67,8 +67,10 @@ class ScriptContext(
         }
     }
 
+    private val ctorExplicitParametersStart = if (scriptDescriptor.earlierScriptsConstructorParameter == null) 0 else 1
+
     private val ctorImplicitReceiversParametersStart =
-        (scriptDescriptor.getSuperClassNotAny()?.unsubstitutedPrimaryConstructor?.valueParameters?.size ?: 0)
+        ctorExplicitParametersStart + (scriptDescriptor.getSuperClassNotAny()?.unsubstitutedPrimaryConstructor?.valueParameters?.size ?: 0)
 
     private val ctorProvidedPropertiesParametersStart =
         ctorImplicitReceiversParametersStart + scriptDescriptor.implicitReceivers.size

compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt

@@ -1204,15 +1204,11 @@ class KotlinTypeMapper @JvmOverloads constructor(
         return Method(name, desc)
     }
 
-    fun mapScriptSignature(script: ScriptDescriptor, importedScripts: List<ScriptDescriptor>): JvmMethodSignature {
+    fun mapScriptSignature(script: ScriptDescriptor): JvmMethodSignature {
         val sw = BothSignatureWriter(BothSignatureWriter.Mode.METHOD)
 
         sw.writeParametersStart()
 
-        if (importedScripts.isNotEmpty()) {
-            writeParameter(sw, script.module.builtIns.array.defaultType, null)
-        }
-
         for (valueParameter in script.unsubstitutedPrimaryConstructor.valueParameters) {
             writeParameter(sw, valueParameter.type, null)/* callableDescriptor = */
         }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/repl/GenericReplEvaluator.kt

@@ -75,14 +75,14 @@ open class GenericReplEvaluator(
             val useScriptArgs = currentScriptArgs?.scriptArgs
             val useScriptArgsTypes = currentScriptArgs?.scriptArgsTypes?.map { it.java }
 
-            val hasHistory = historyActor.effectiveHistory.isNotEmpty()
+            val constructorParams: Array<Class<*>> =
+                arrayOf<Class<*>>(Array<Any>::class.java) +
+                        (useScriptArgs?.mapIndexed { i, it -> useScriptArgsTypes?.getOrNull(i) ?: it?.javaClass ?: Any::class.java } ?: emptyList())
 
-            val constructorParams: Array<Class<*>> = (if (hasHistory) arrayOf<Class<*>>(Array<Any>::class.java) else emptyArray<Class<*>>()) +
+            val constructorArgs: Array<out Any?> = arrayOf(
-                                                     (useScriptArgs?.mapIndexed { i, it -> useScriptArgsTypes?.getOrNull(i) ?: it?.javaClass ?: Any::class.java } ?: emptyList())
+                historyActor.effectiveHistory.map { it.instance }.takeIf { it.isNotEmpty() }?.toTypedArray(),
-
+                *(useScriptArgs.orEmpty())
-            val constructorArgs: Array<out Any?> = if (hasHistory) arrayOf(historyActor.effectiveHistory.map { it.instance }.takeIf { it.isNotEmpty() }?.toTypedArray(),
+            )
-                                                                           *(useScriptArgs.orEmpty()))
-                                                   else useScriptArgs.orEmpty()
 
             // TODO: try/catch ?
             val scriptInstanceConstructor = scriptClass.getConstructor(*constructorParams)

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ScriptGenerator.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.psi2ir.generators
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.ParameterDescriptor
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.assertCast
 import org.jetbrains.kotlin.ir.builders.declarations.IrFunctionBuilder
@@ -86,19 +87,9 @@ class ScriptGenerator(declarationGenerator: DeclarationGenerator) : DeclarationG
             irScript.earlierScripts?.forEach {
                 context.symbolTable.introduceValueParameter(it.owner.thisReceiver)
             }
-            irScript.earlierScriptsParameter = irScript.earlierScripts?.takeIf { it.isNotEmpty() }?.let {
-                val baseType = context.irBuiltIns.anyType
-                val arrayType = baseType.toArrayOrPrimitiveArrayType(context.irBuiltIns)
-                context.irFactory.createValueParameter(
-                    UNDEFINED_OFFSET, UNDEFINED_OFFSET, IrDeclarationOrigin.SCRIPT_EARLIER_SCRIPTS, IrValueParameterSymbolImpl(),
-                    Name.special("<earlierScripts>"), parametersIndex++,
-                    arrayType, null,
-                    false, false, false, false
-                ).also { it.parent = irScript }
-            }
 
-            irScript.explicitCallParameters = descriptor.explicitConstructorParameters.map { valueParameterDescriptor ->
+            fun createValueParameter(valueParameterDescriptor: ValueParameterDescriptor): IrValueParameter {
-                context.irFactory.createValueParameter(
+                return context.irFactory.createValueParameter(
                     UNDEFINED_OFFSET, UNDEFINED_OFFSET,
                     IrDeclarationOrigin.SCRIPT_CALL_PARAMETER, IrValueParameterSymbolImpl(),
                     valueParameterDescriptor.name, parametersIndex++,
@@ -108,6 +99,10 @@ class ScriptGenerator(declarationGenerator: DeclarationGenerator) : DeclarationG
                 ).also { it.parent = irScript }
             }
 
+            irScript.earlierScriptsParameter = descriptor.earlierScriptsConstructorParameter?.let(::createValueParameter)
+
+            irScript.explicitCallParameters = descriptor.explicitConstructorParameters.map(::createValueParameter)
+
             irScript.implicitReceiversParameters = descriptor.implicitReceivers.map {
                 makeParameter(it.thisAsReceiverParameter, IrDeclarationOrigin.SCRIPT_IMPLICIT_RECEIVER, parametersIndex++)
             }

core/descriptors/src/org/jetbrains/kotlin/descriptors/ScriptDescriptor.java

@@ -37,6 +37,9 @@ public interface ScriptDescriptor extends ClassDescriptor {
     @Nullable
     PropertyDescriptor getResultValue();
 
+    @Nullable
+    ValueParameterDescriptor getEarlierScriptsConstructorParameter();
+
     @NotNull
     List<ValueParameterDescriptor> getExplicitConstructorParameters();
 
@@ -45,4 +48,6 @@ public interface ScriptDescriptor extends ClassDescriptor {
 
     @NotNull
     List<ValueParameterDescriptor> getScriptProvidedPropertiesParameters();
+
+    boolean isReplScript();
 }

libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/repl/legacyReplEvaluation.kt

@@ -47,9 +47,7 @@ class JvmReplEvaluator(
         val lastSnippetClass = history.peek()?.item?.first
         val historyBeforeSnippet = history.previousItems(compileResult.lineId).map { it.second }.toList()
         val currentConfiguration = ScriptEvaluationConfiguration(baseScriptEvaluationConfiguration) {
-            if (historyBeforeSnippet.isNotEmpty()) {
+            previousSnippets.put(historyBeforeSnippet)
-                previousSnippets.put(historyBeforeSnippet)
-            }
             if (lastSnippetClass != null) {
                 jvm {
                     baseClassLoader(lastSnippetClass.java.classLoader)

libraries/scripting/jvm/src/kotlin/script/experimental/jvm/BasicJvmReplEvaluator.kt

@@ -37,9 +37,7 @@ class BasicJvmReplEvaluator(val scriptEvaluator: ScriptEvaluator = BasicJvmScrip
         val lastSnippetClass = history.lastItem()?.first
         val historyBeforeSnippet = history.items.map { it.second }
         val currentConfiguration = ScriptEvaluationConfiguration(configuration) {
-            if (historyBeforeSnippet.isNotEmpty()) {
+            previousSnippets.put(historyBeforeSnippet)
-                previousSnippets.put(historyBeforeSnippet)
-            }
             if (lastSnippetClass != null) {
                 jvm {
                     lastSnippetClassLoader(lastSnippetClass.java.classLoader)

libraries/scripting/jvm/src/kotlin/script/experimental/jvm/BasicJvmScriptEvaluator.kt

@@ -19,12 +19,16 @@ open class BasicJvmScriptEvaluator : ScriptEvaluator {
 
             // configuration shared between all module scripts
             val sharedConfiguration = scriptEvaluationConfiguration.getOrPrepareShared(scriptClass.java.classLoader)
-
+            val configurationForOtherScripts by lazy {
+                sharedConfiguration.with {
+                    reset(ScriptEvaluationConfiguration.previousSnippets)
+                }
+            }
             val sharedScripts = sharedConfiguration[ScriptEvaluationConfiguration.jvm.scriptsInstancesSharingMap]
 
             sharedScripts?.get(scriptClass)?.asSuccess()
                 ?: compiledScript.otherScripts.mapSuccess {
-                    invoke(it, sharedConfiguration)
+                    invoke(it, configurationForOtherScripts)
                 }.onSuccess { importedScriptsEvalResults ->
 
                     val refinedEvalConfiguration =
@@ -70,9 +74,7 @@ open class BasicJvmScriptEvaluator : ScriptEvaluator {
         val args = ArrayList<Any?>()
 
         refinedEvalConfiguration[ScriptEvaluationConfiguration.previousSnippets]?.let {
-            if (it.isNotEmpty()) {
+            args.add(it.toTypedArray())
-                args.add(it.toTypedArray())
-            }
         }
 
         refinedEvalConfiguration[ScriptEvaluationConfiguration.constructorArgs]?.let {

plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/definitions/ScriptPriorities.java

@@ -17,4 +17,8 @@ public class ScriptPriorities {
         Integer priority = script.getUserData(PRIORITY_KEY);
         return priority == null ? 0 : priority;
     }
+
+    public static boolean isReplScript(@NotNull KtScript script) {
+        return script.getUserData(PRIORITY_KEY) != null;
+    }
 }

plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/resolve/LazyScriptDescriptor.kt

@@ -40,10 +40,7 @@ import org.jetbrains.kotlin.resolve.scopes.LexicalScopeImpl
 import org.jetbrains.kotlin.resolve.scopes.LexicalScopeKind
 import org.jetbrains.kotlin.resolve.scopes.utils.addImportingScope
 import org.jetbrains.kotlin.resolve.source.toSourceElement
-import org.jetbrains.kotlin.scripting.definitions.ScriptDefinition
+import org.jetbrains.kotlin.scripting.definitions.*
-import org.jetbrains.kotlin.scripting.definitions.ScriptDependenciesProvider
-import org.jetbrains.kotlin.scripting.definitions.ScriptPriorities
-import org.jetbrains.kotlin.scripting.definitions.findScriptCompilationConfiguration
 import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.types.typeUtil.isNothing
 import org.jetbrains.kotlin.types.typeUtil.isUnit
@@ -120,6 +117,7 @@ class LazyScriptDescriptor(
     override fun getSource() = sourceElement
 
     private val priority: Int = ScriptPriorities.getScriptPriority(scriptInfo.script)
+    private val isReplScript: Boolean = ScriptPriorities.isReplScript(scriptInfo.script)
 
     override fun getPriority() = priority
 
@@ -290,6 +288,7 @@ class LazyScriptDescriptor(
 
     internal class ConstructorWithParams(
         val constructor: ClassConstructorDescriptorImpl,
+        val earlierScriptsParameter: ValueParameterDescriptor?,
         val baseClassConstructorParameters: List<ValueParameterDescriptor>,
         val implicitReceiversParameters: List<ValueParameterDescriptor>,
         val scriptProvidedPropertiesParameters: List<ValueParameterDescriptor>
@@ -305,46 +304,60 @@ class LazyScriptDescriptor(
                 val receiverName =
                     if (receiver is ScriptDescriptor) "${LazyScriptClassMemberScope.IMPORTED_SCRIPT_PARAM_NAME_PREFIX}${receiver.name}"
                     else "${LazyScriptClassMemberScope.IMPLICIT_RECEIVER_PARAM_NAME_PREFIX}$idx"
-                receiverName to receiver.defaultType
+                Name.identifier(receiverName) to receiver.defaultType
             }
 
         val providedPropertiesParamTypes =
             scriptProvidedProperties().map {
-                it.name.identifier to it.type
+                it.name to it.type
             }
         val constructorDescriptor = ClassConstructorDescriptorImpl.create(this, inheritedAnnotations, true, source)
 
-        var paramsIndexBase = baseExplicitParameters.lastIndex + 1
+        var paramsIndexBase = 0
 
-        fun createValueParameter(param: Pair<String, org.jetbrains.kotlin.types.KotlinType>) =
+        fun createValueParameter(param: Pair<Name, org.jetbrains.kotlin.types.KotlinType>) =
             ValueParameterDescriptorImpl(
                 constructorDescriptor,
                 null,
                 paramsIndexBase++,
                 Annotations.EMPTY,
-                Name.identifier(param.first),
+                param.first,
                 param.second,
                 declaresDefaultValue = false, isCrossinline = false, isNoinline = false, varargElementType = null,
                 source = SourceElement.NO_SOURCE
             )
 
-        val explicitParameters = baseExplicitParameters.map { it.copy(constructorDescriptor, it.name, it.index) }
+        val earlierScriptsParameter = if (isReplScript) {
+            createValueParameter(Name.special("<earlierScripts>") to builtIns.array.defaultType)
+        } else null
+
+        val explicitParameters = baseExplicitParameters.map { it.copy(constructorDescriptor, it.name, paramsIndexBase++) }
         val implicitReceiversParameters = implicitReceiversParamTypes.map(::createValueParameter)
         val providedPropertiesParameters = providedPropertiesParamTypes.map(::createValueParameter)
 
         constructorDescriptor.initialize(
-            explicitParameters + implicitReceiversParameters + providedPropertiesParameters, DescriptorVisibilities.PUBLIC
+            buildList {
+                earlierScriptsParameter?.let { add(it) }
+                addAll(explicitParameters)
+                addAll(implicitReceiversParameters)
+                addAll(providedPropertiesParameters)
+            },
+            DescriptorVisibilities.PUBLIC
         )
         constructorDescriptor.returnType = defaultType()
 
         ConstructorWithParams(
             constructorDescriptor,
+            earlierScriptsParameter = earlierScriptsParameter,
             baseClassConstructorParameters = explicitParameters,
             implicitReceiversParameters = implicitReceiversParameters,
             scriptProvidedPropertiesParameters = providedPropertiesParameters
         )
     }
 
+    override fun getEarlierScriptsConstructorParameter(): ValueParameterDescriptor? =
+        scriptPrimaryConstructorWithParams().earlierScriptsParameter
+
     override fun getExplicitConstructorParameters(): List<ValueParameterDescriptor> =
         scriptPrimaryConstructorWithParams().baseClassConstructorParameters
 
@@ -384,4 +397,8 @@ class LazyScriptDescriptor(
 
     override val annotations: Annotations
         get() = scriptClassAnnotations()
+
+    override fun isReplScript(): Boolean {
+        return isReplScript
+    }
 }

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/repl/ReplCodeAnalyzer.kt

@@ -100,12 +100,20 @@ open class ReplCodeAnalyzerBase(
 
     fun reset(): List<SourceCodeByReplLine> = replState.reset()
 
-    fun analyzeReplLine(psiFile: KtFile, codeLine: ReplCodeLine): ReplLineAnalysisResult {
+    protected fun prepareForAnalyze(
+        psiFile: KtFile,
+        priority: Int
+    ) {
         topDownAnalysisContext.scripts.clear()
         trace.clearDiagnostics()
 
-        psiFile.script!!.putUserData(ScriptPriorities.PRIORITY_KEY, codeLine.no)
+        val script = psiFile.script!!
 
+        script.putUserData(ScriptPriorities.PRIORITY_KEY, priority)
+    }
+
+    fun analyzeReplLine(psiFile: KtFile, codeLine: ReplCodeLine): ReplLineAnalysisResult {
+        prepareForAnalyze(psiFile, codeLine.no)
         return doAnalyze(psiFile, emptyList(), codeLine.toSourceCode())
     }
 
@@ -115,11 +123,7 @@ open class ReplCodeAnalyzerBase(
         codeLine: SourceCode,
         priority: Int
     ): ReplLineAnalysisResult {
-        topDownAnalysisContext.scripts.clear()
+        prepareForAnalyze(psiFile, priority)
-        trace.clearDiagnostics()
-
-        psiFile.script!!.putUserData(ScriptPriorities.PRIORITY_KEY, priority)
-
         return doAnalyze(psiFile, importedScripts, codeLine.addNo(priority))
     }
 

plugins/scripting/scripting-ide-services-test/build.gradle.kts

@@ -28,6 +28,7 @@ dependencies {
 
     testImplementation(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core"))
     testImplementation(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core-jvm"))
+    testImplementation(project(":kotlin-reflect"))
     testRuntimeOnly(project(":kotlin-compiler"))
     testRuntimeOnly(commonDep("org.jetbrains.intellij.deps", "trove4j"))
     testRuntimeOnly(project(":kotlin-scripting-ide-common")) { isTransitive = false }

plugins/scripting/scripting-ide-services-test/test/org/jetbrains/kotlin/scripting/ide_services/JvmReplTest.kt

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.config.Services
 import org.jetbrains.kotlin.scripting.ide_services.test_util.*
 import java.io.File
 import kotlin.io.path.*
+import kotlin.reflect.full.isSubclassOf
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.jvm.impl.KJvmCompiledScript
 import kotlin.script.experimental.jvm.jvm
@@ -325,6 +326,20 @@ class JvmIdeServicesTest : TestCase() {
             }
     }
 
+    fun testAnonymousObjectReflection() {
+        JvmTestRepl()
+            .use { repl ->
+                assertEvalResult(repl, "42", 42)
+                assertEvalUnit(repl, "val sim = object : ArrayList<String>() {}")
+
+                val compiledSnippet = checkCompile(repl, "sim")
+                val evalResult = repl.eval(compiledSnippet!!)
+
+                val a = (evalResult.valueOrThrow().get().result as ResultValue.Value).value!!
+                assertTrue(a::class.isSubclassOf(List::class))
+            }
+    }
+
     @OptIn(ExperimentalPathApi::class)
     companion object {
         private const val MODULE_PATH = "plugins/scripting/scripting-ide-services-test"

plugins/scripting/scripting-ide-services/src/org/jetbrains/kotlin/scripting/ide_services/compiler/impl/IdeLikeReplCodeAnalyzer.kt

@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.resolve.calls.tower.ImplicitsExtensionsResolutionFil
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
 import org.jetbrains.kotlin.scripting.compiler.plugin.repl.ReplCodeAnalyzerBase
-import org.jetbrains.kotlin.scripting.definitions.ScriptPriorities
 
 class IdeLikeReplCodeAnalyzer(
     private val environment: KotlinCoreEnvironment,
@@ -44,11 +43,7 @@ class IdeLikeReplCodeAnalyzer(
         importedScripts: List<KtFile>,
         priority: Int
     ): ReplLineAnalysisResultWithStateless {
-        topDownAnalysisContext.scripts.clear()
+        prepareForAnalyze(psiFile, priority)
-        trace.clearDiagnostics()
-
-        psiFile.script!!.putUserData(ScriptPriorities.PRIORITY_KEY, priority)
-
         return doStatelessAnalyze(psiFile, importedScripts)
     }