Only configure runtimes that will actually be used

Closes #95.

Author: ctrueden

src/commonMain/kotlin/jvm.kt

@@ -127,12 +127,22 @@ class JvmRuntimeConfig(recognizedArgs: Array<String>) :
         mainArgs += vars.calculate(config.jvmMainArgs, hints)
         debugList("Main arguments calculated:", mainArgs)
 
-        this.java = java
-
         // If -XstartOnFirstThread is given, we'd like to issue a RUNLOOP:main directive.
         // But we should only do this if --jaunch-runloop wasn't also given, since that
         // is the more direct and runtime-agnostic way of setting the RUNLOOP mode.
         skipRunLoop = "runloop" in config.internalFlags
+
+        this.java = java
+        configured = true
+    }
+
+    override fun rawConfigValues(config: JaunchConfig): List<Array<String>> {
+        return listOf(
+            config.jvmClasspath,
+            config.jvmRuntimeArgs,
+            config.jvmMainClass,
+            config.jvmMainArgs
+        )
     }
 
     override fun injectInto(vars: Vars) {

src/commonMain/kotlin/main.kt

@@ -101,7 +101,7 @@ fun main(args: Array<String>) {
     val nonGlobalDirectives = executeGlobalDirectives(globalDirectiveFunctions,
         configDirectives, userArgs)
 
-    val runtimes = configureRuntimes(config, configDir, hints, vars)
+    val runtimes = configureRuntimes(config, configDir, configDirectives, launchDirectives, hints, vars)
 
     debugBanner("BUILDING ARGUMENT LISTS")
 
@@ -377,6 +377,8 @@ private fun applyModeHints(
 private fun configureRuntimes(
     config: JaunchConfig,
     configDir: File,
+    configDirectives: List<String>,
+    launchDirectives: List<String>,
     hints: MutableSet<String>,
     vars: Vars
 ): List<RuntimeConfig> {
@@ -385,10 +387,34 @@ private fun configureRuntimes(
     if (config.jvmEnabled == true) runtimes += JvmRuntimeConfig(config.jvmRecognizedArgs)
     if (config.pythonEnabled == true) runtimes += PythonRuntimeConfig(config.pythonRecognizedArgs)
 
-    // Discover the runtime installations.
+    // Discover the runtime installations - but only for runtimes that are actually needed.
+    for (r in runtimes) {
+        // Check if this runtime will be used for any launch or config directives.
+        if (
+            r.directive in launchDirectives ||
+            configDirectives.any { r.supportedDirectives.containsKey(it) }
+        ) {
+            debugBanner("CONFIGURING RUNTIME: ${r.directive}")
+            r.configure(configDir, config, hints, vars)
+        }
+        else {
+            debugBanner("SKIPPING DORMANT RUNTIME: ${r.directive}")
+        }
+    }
+
+    // Now configure any runtimes that are DEPENDENCIES of the now-configured ones.
     for (r in runtimes) {
-        debugBanner("CONFIGURING RUNTIME: ${r.directive}")
-        r.configure(configDir, config, hints, vars)
+        if (r.configured) continue
+        val needed = runtimes.any { active ->
+            active.configured && active.dependsOn(r, config)
+        }
+        if (needed) {
+            debugBanner("CONFIGURING RUNTIME DEPENDENCY: ${r.directive}")
+            r.configure(configDir, config, hints, vars)
+        }
+        else {
+            debugBanner("SKIPPING UNNEEDED RUNTIME: ${r.directive}")
+        }
     }
 
     return runtimes

src/commonMain/kotlin/python.kt

@@ -112,6 +112,15 @@ class PythonRuntimeConfig(recognizedArgs: Array<String>) :
         debugList("Main arguments calculated:", mainArgs)
 
         this.python = python
+        configured = true
+    }
+
+    override fun rawConfigValues(config: JaunchConfig): List<Array<String>> {
+        return listOf(
+            config.pythonRuntimeArgs,
+            config.pythonScriptPath,
+            config.pythonMainArgs
+        )
     }
 
     override fun injectInto(vars: Vars) {

src/commonMain/kotlin/runtime.kt

@@ -16,6 +16,7 @@ abstract class RuntimeConfig(
     val runtimeArgs = mutableListOf<String>()
     val mainArgs = mutableListOf<String>()
     var mainProgram: String? = null
+    var configured = false
 
     /** Dictionary of supported directives and their associated implementations. */
     abstract val supportedDirectives: DirectivesMap
@@ -37,6 +38,12 @@ abstract class RuntimeConfig(
         vars: Vars
     )
 
+    /**
+     * Returns the list of raw config value arrays that this runtime uses.
+     * These will be checked for variable references to other runtimes.
+     */
+    protected abstract fun rawConfigValues(config: JaunchConfig): List<Array<String>>
+
     /** Populate variables with information about this runtime. */
     abstract fun injectInto(vars: Vars)
 
@@ -65,13 +72,26 @@ abstract class RuntimeConfig(
         }.firstOrNull { it > 0 } ?: 0
     }
 
+    /**
+     * Check if this runtime depends on the given dependency runtime.
+     * A runtime depends on another if any of its raw config values reference
+     * variables from that runtime's namespace (e.g., `${jvm.libjvmPath}` or `@{jvm.runtimeArgs}`).
+     */
+    fun dependsOn(dependency: RuntimeConfig, config: JaunchConfig): Boolean {
+        val pattern = Regex("""[$@]\{${dependency.prefix}\.[^}]+}""")
+        return rawConfigValues(config).any { configArray ->
+            configArray.any { value -> pattern.containsMatchIn(value) }
+        }
+    }
+
     /**
      * Attempt to execute the given directive.
      * @param directive The directive to maybe execute.
      * @param args The arguments passed by the user, which the directive might wish to examine.
      * @return true iff the directive was successfully executed.
      */
     fun tryDirective(directive: String, args: ProgramArgs): Boolean {
+        if (!configured) return false
         val doDirective = supportedDirectives[directive] ?: return false
         debug("$prefix: executing directive: $directive")
         doDirective(args)