K1 Scripting: treat inaccessible provided props classes as Any

So if classloaders for, e.g., REPL are not configured properly,
making classes of specified provided properties inaccessible,
we can still access the values using Any type for them.
This allows, e.g., solving tricky problems with properties
generated from JSR-223 bindings.
Note that this is K1-only functionality, since JSR-223 is not
yet supported in K2

#KT-67747 fixed

(cherry picked from commit 5d724e6)

Author: ligee

libraries/scripting/jsr223-test/test/kotlin/script/experimental/jsr223/test/KotlinJsr223ScriptEngineIT.kt

@@ -20,6 +20,7 @@ import java.nio.file.Files.createTempDirectory
 import java.nio.file.Files.createTempFile
 import javax.script.*
 import kotlin.script.experimental.jvmhost.jsr223.KotlinJsr223ScriptEngineImpl
+import kotlin.script.templates.standard.ScriptTemplateWithBindings
 
 // duplicating it here to avoid dependency on the implementation - it may interfere with tests
 private const val KOTLIN_JSR223_RESOLVE_FROM_CLASSLOADER_PROPERTY = "kotlin.jsr223.experimental.resolve.dependencies.from.context.classloader"
@@ -33,6 +34,11 @@ fun callLambda(x: Int, aFunction: (Int) -> Int): Int = aFunction.invoke(x)
 @Suppress("unused") // accessed from the tests below
 inline fun inlineCallLambda(x: Int, aFunction: (Int) -> Int): Int = aFunction.invoke(x)
 
+@Suppress("unused", "UNCHECKED_CAST") // accessed from the tests below
+fun ScriptTemplateWithBindings.myFunFromBindings(n: Int): Int =
+    (bindings["myFunFromBindings"] as (Int) -> Int).invoke(n)
+
+
 class KotlinJsr223ScriptEngineIT {
 
     init {
@@ -343,6 +349,36 @@ obj
         Assert.assertEquals(7, res3)
     }
 
+    @Test
+    fun testEvalInEvalWithBindingsWithLambda() {
+        // the problem (KT-67747) is only reproducible with INDY lambdas
+        withProperty(
+            "kotlin.script.base.compiler.arguments",
+            getPropertyValue = { listOfNotNull(it?.takeIf(String::isNotBlank), "-Xlambdas=indy").joinToString(" ") }
+        ) {
+            val engine = ScriptEngineManager().getEngineByExtension("kts")!!
+            // code here is somewhat similar to one used in Spring's KotlinScriptTemplateTests
+            val res1 = engine.eval(
+                """
+            fun f(script: String): Int {
+                val bindings = javax.script.SimpleBindings()
+                bindings.put("myFunFromBindings", { i: Int -> i * 7 })
+                return eval(script, bindings) as Int
+            }
+            """.trimIndent()
+            )
+            Assert.assertNull(res1)
+            // Note that direct call to the lambda stored in bindings is not possible, so the additional helper
+            // [kotlin.script.experimental.jsr223.test.myFunFromBindings] is used (as in Spring)
+            val script = """
+            import kotlin.script.experimental.jsr223.test.*
+            myFunFromBindings(6)
+            """.trimIndent()
+            val res2 = (engine as Invocable).invokeFunction("f", script)
+            Assert.assertEquals(42, res2)
+        }
+    }
+
     @Test
     fun `kotlin script evaluation should support functional return types`() {
         val scriptEngine = ScriptEngineManager().getEngineByExtension("kts")!!
@@ -470,3 +506,20 @@ fun assertThrows(exceptionClass: Class<*>, body: () -> Unit) {
         }
     }
 }
+
+internal fun <T> withProperty(name: String, getPropertyValue: (String?) -> String?, body: () -> T): T {
+    val prevPropertyVal = System.getProperty(name)
+    val value = getPropertyValue(prevPropertyVal)
+    when (value) {
+        null -> System.clearProperty(name)
+        else -> System.setProperty(name, value)
+    }
+    try {
+        return body()
+    } finally {
+        when (prevPropertyVal) {
+            null -> System.clearProperty(name)
+            else -> System.setProperty(name, prevPropertyVal)
+        }
+    }
+}

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

@@ -221,6 +221,7 @@ class LazyScriptDescriptor(
             }
         }
 
+        // TODO: we may want to treat getScriptingClass call here the same way as in scriptProvidedProperties
         scriptCompilationConfiguration()[ScriptCompilationConfiguration.implicitReceivers]?.mapNotNullTo(res) { receiver ->
             findTypeDescriptor(getScriptingClass(receiver), Errors.MISSING_SCRIPT_RECEIVER_CLASS)
         }
@@ -262,7 +263,18 @@ class LazyScriptDescriptor(
     private val scriptProvidedProperties: () -> List<ScriptProvidedPropertyDescriptor> = resolveSession.storageManager.createLazyValue {
         scriptCompilationConfiguration()[ScriptCompilationConfiguration.providedProperties].orEmpty()
             .mapNotNull { (name, type) ->
-                findTypeDescriptor(getScriptingClass(type), Errors.MISSING_SCRIPT_PROVIDED_PROPERTY_CLASS)?.let {
+                val propertyClass = try {
+                    getScriptingClass(type)
+                } catch (e: IllegalArgumentException) {
+                    // IAE here means that we're unable to access the class of the property, but we can treat it as Any
+                    null
+                }
+                val propertyType =
+                    // If we cannot load the class for the property type, replacing it with Any allows keeping the property avoiding
+                    // possibly risky deleting at this place and also still allows using it from the script with a cast
+                    if (propertyClass == null) builtIns.any
+                    else findTypeDescriptor(propertyClass, Errors.MISSING_SCRIPT_PROVIDED_PROPERTY_CLASS)
+                propertyType?.let {
                     name.toValidJvmIdentifier() to
                             it.defaultType.makeNullableAsSpecified(type.isNullable).replaceArgumentsWithStarProjections()
                 }