Kotlin dynamically compile a class from source code at runtime

Question

Is it possible to compile and instantiate Kotlin class at runtime? I'm talking about something like that but using Kotlin API: How do I programmatically compile and instantiate a Java class?

As example: I'm getting full class definition as String:

val example = "package example\n" +
        "\n" +
        "fun main(args: Array<String>) {\n" +
        "    println(\"Hello World\")\n" +
        "}\n"

And then inserting it into some class.kt and running it so I'm getting "Hello World" printed in console at runtime.

maybe [reflection](https://kotlinlang.org/docs/reference/reflection.html) — Stefan Golubović, Mar 21 '18 at 21:09
What is the benefit of composing the class at runtime? Why can't it be abstracted with arguments passed in to set it up? — Jared Farrish, Mar 23 '18 at 19:33
Not a proper answer, but have a look at https://github.com/JetBrains/kotlin/blob/master/compiler/tests/org/jetbrains/kotlin/scripts/ScriptTest.kt for a possible guide to doing this. — Robert Elliot, Oct 31 '18 at 12:02

score 2 · Answer 1 · answered Mar 23 '18 at 19:21

You might want to look at Kotlin Scripting, see https://github.com/andrewoma/kotlin-script

Alternatively, you'll need to write your own eval(kotlin-code-string-here) method which will dump the text inside blah.kt file for example, compile it using an external Kotlin compiler into blah.class then dynamically load those classes into the runtime using the Java Classloader doing something like this:

MainClass.class.classLoader.loadClass("com.mypackage.MyClass")

This might be very slow and unreliable.

Another no so great option is to make use of Rhino and run JavaScript inside your Kotlin code. So once again, you'll have an eval(kotlin-code-string-here) method which will dump the content to a blah.kt file, then you would use a Kotlin2JS compiler to compile it to JavaScript and directly execute the JavaScript inside Kotlin using Rhino which is not great either.

Another option is to make use of Kotlin Scripting or an external Kotlin compiler (in both cases, the Kotlin compiler will have to start up) and doing something like this will also allow you to execute dynamically, albeit, only on Unix systems.

Runtime.getRuntime().exec("""  "kotlin code here" > blah.kts | sh""")

I'm not aware of a clean solution for this, Kotlin was not designed to be run like like PHP / JavaScript / Python which just interprets text dynamically, it has to compile to bytecode first before it can do anything on the JVM; so in each scenario, you will need to compile that code first in one way or another, whether to bytecode or to javascript and in both cases load it into you application using the Java Classloader or Rhino.

Ugh. Forking a Kotlin compiler does not count as dynamic evaluation. — Travis Well, Oct 16 '18 at 21:51

score 2 · Answer 2 · answered Mar 06 '20 at 17:57

Please check this solution for dependencies, jar resources, etc. Code below isn't enough for successful execution.

However, to compile dynamic class you can do the following:

val classLoader = Thread.currentThread().contextClassLoader

val engineManager = ScriptEngineManager(classLoader)

setIdeaIoUseFallback() // hack to have ability to do this from IntelliJ Idea context

val ktsEngine: ScriptEngine = engineManager.getEngineByExtension("kts")

ktsEngine.eval("object MyClass { val number = 123 } ")

println(ktsEngine.eval("MyClass.number"))

Please note: there is code injection possible here. Please be careful and use dedicated process or dedicated ClassLoader for this.

AlexO · Answer 3 · 2022-08-25T13:40:23.993

KotlinScript can be used to compile Kotlin source code (e.g. to generate a jar file that can then be loaded).

Here's a Java project which demonstrates this (code would be cleaner in Kotlin):

https://github.com/alexoooo/sample-kotlin-compile/blob/main/src/main/java/io/github/alexoooo/sample/compile/KotlinCompilerFacade.java

Note that the code you provide would be generated as a nested class (inside the script).

Here is a Kotlin version:

@KotlinScript
object KotlinDynamicCompiler {
    //-----------------------------------------------------------------------------------------------------------------
    const val scriptClassName = "__"
    const val classNamePrefix = "${scriptClassName}$"

    private val baseClassType: KotlinType = KotlinType(KotlinDynamicCompiler::class.java.kotlin)
    private val contextClass: KClass<*> = ScriptCompilationConfiguration::class.java.kotlin


    //-----------------------------------------------------------------------------------------------------------------
    fun compile(
        kotlinCode: String, outputJarFile: Path, classpathLocations: List<Path>, classLoader: ClassLoader
    ): String? {
        Files.createDirectories(outputJarFile.parent)

        val scriptCompilationConfiguration = createCompilationConfigurationFromTemplate(
            baseClassType, defaultJvmScriptingHostConfiguration, contextClass
        ) {
            jvm {
                val classloaderClasspath: List<File> = classpathFromClassloader(classLoader, false)!!
                val classpathFiles = classloaderClasspath + classpathLocations.map { it.toFile() }
                updateClasspath(classpathFiles)
            }

            hostConfiguration(ScriptingHostConfiguration (defaultJvmScriptingHostConfiguration) {
                jvm {
                    compilationCache(
                        CompiledScriptJarsCache { _, _ ->
                            outputJarFile.toFile()
                        }
                    )
                }
            })
        }

        val scriptCompilerProxy = ScriptJvmCompilerIsolated(defaultJvmScriptingHostConfiguration)

        val result = scriptCompilerProxy.compile(
            kotlinCode.toScriptSource(KotlinCode.scriptClassName), scriptCompilationConfiguration)

        val errors = result.reports.filter { it.severity == ScriptDiagnostic.Severity.ERROR }

        return when {
            errors.isEmpty() -> null
            else -> errors.joinToString(" | ")
        }
    }
}

Kotlin dynamically compile a class from source code at runtime

3 Answers3

Linked