Rename ScriptingEnvironment to ScriptingHostConfiguration

idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptDefinitionsManager.kt

@@ -49,9 +49,9 @@ import kotlin.concurrent.write
 import kotlin.script.dependencies.Environment
 import kotlin.script.dependencies.ScriptContents
 import kotlin.script.experimental.api.KotlinType
-import kotlin.script.experimental.api.ScriptingEnvironment
+import kotlin.script.experimental.host.ScriptingHostConfiguration
-import kotlin.script.experimental.api.configurationDependencies
+import kotlin.script.experimental.host.configurationDependencies
-import kotlin.script.experimental.configuration.createScriptCompilationConfigurationFromAnnotatedBaseClass
+import kotlin.script.experimental.host.createScriptCompilationConfigurationFromAnnotatedBaseClass
 import kotlin.script.experimental.dependencies.DependenciesResolver
 import kotlin.script.experimental.dependencies.ScriptDependencies
 import kotlin.script.experimental.dependencies.asSuccess
@@ -208,7 +208,7 @@ fun loadDefinitionsFromTemplates(
                     )
                 }
                 template.annotations.firstIsInstanceOrNull<kotlin.script.experimental.annotations.KotlinScript>() != null -> {
-                    val hostEnvironment = ScriptingEnvironment {
+                    val hostConfiguration = ScriptingHostConfiguration {
                         include(defaultJvmScriptingEnvironment)
                         configurationDependencies(JvmDependency(classpath))
                     }
@@ -216,9 +216,9 @@ fun loadDefinitionsFromTemplates(
                         createScriptCompilationConfigurationFromAnnotatedBaseClass(
                             KotlinType(
                                 template
-                            ), hostEnvironment, KotlinScriptDefinition::class
+                            ), hostConfiguration, KotlinScriptDefinition::class
                         ),
-                        hostEnvironment
+                        hostConfiguration
                     )
                 }
                 else -> {

libraries/scripting/common/src/kotlin/script/experimental/host/configurationFromTemplate.kt

@@ -3,7 +3,7 @@
  * that can be found in the license/LICENSE.txt file.
  */
 
-package kotlin.script.experimental.configuration
+package kotlin.script.experimental.host
 
 import kotlin.reflect.KClass
 import kotlin.script.experimental.annotations.KotlinScript
@@ -18,17 +18,17 @@ private const val ILLEGAL_CONFIG_ANN_ARG =
 
 fun createScriptCompilationConfigurationFromAnnotatedBaseClass(
     baseClassType: KotlinType,
-    environment: ScriptingEnvironment,
+    hostConfiguration: ScriptingHostConfiguration,
     contextClass: KClass<*> = ScriptCompilationConfiguration::class,
     body: ScriptCompilationConfiguration.Builder.() -> Unit = {}
 ): ScriptCompilationConfiguration {
 
-    val getScriptingClass = environment[ScriptingEnvironment.getScriptingClass]
+    val getScriptingClass = hostConfiguration[ScriptingHostConfiguration.getScriptingClass]
         ?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Expecting 'getScriptingClass' parameter in the scripting environment")
 
     val baseClass: KClass<*> =
         try {
-            getScriptingClass(baseClassType, contextClass, environment)
+            getScriptingClass(baseClassType, contextClass, hostConfiguration)
         } catch (e: Throwable) {
             throw IllegalArgumentException("${ERROR_MSG_PREFIX}Unable to load base class $baseClassType", e)
         }

libraries/scripting/common/src/kotlin/script/experimental/host/scriptingEnvironment.kt

@@ -3,49 +3,51 @@
  * that can be found in the license/LICENSE.txt file.
  */
 
-package kotlin.script.experimental.api
+package kotlin.script.experimental.host
 
 import kotlin.reflect.KClass
+import kotlin.script.experimental.api.KotlinType
+import kotlin.script.experimental.api.ScriptDependency
 import kotlin.script.experimental.util.PropertiesCollection
 
-interface ScriptingEnvironmentKeys
+interface ScriptingHostConfigurationKeys
 
-class ScriptingEnvironment(baseScriptingEnvironments: Iterable<ScriptingEnvironment>, body: Builder.() -> Unit) :
+class ScriptingHostConfiguration(baseScriptingEnvironments: Iterable<ScriptingHostConfiguration>, body: Builder.() -> Unit) :
     PropertiesCollection(Builder(baseScriptingEnvironments).apply(body).data) {
 
     constructor(body: Builder.() -> Unit = {}) : this(emptyList(), body)
     constructor(
-        vararg baseScriptingEnvironments: ScriptingEnvironment, body: Builder.() -> Unit = {}
+        vararg baseConfigurations: ScriptingHostConfiguration, body: Builder.() -> Unit = {}
-    ) : this(baseScriptingEnvironments.asIterable(), body)
+    ) : this(baseConfigurations.asIterable(), body)
 
-    class Builder internal constructor(baseScriptingEnvironments: Iterable<ScriptingEnvironment>) : 
+    class Builder internal constructor(baseScriptingEnvironments: Iterable<ScriptingHostConfiguration>) :
-        ScriptingEnvironmentKeys, 
+        ScriptingHostConfigurationKeys,
         PropertiesCollection.Builder(baseScriptingEnvironments)
     
-    companion object : ScriptingEnvironmentKeys
+    companion object : ScriptingHostConfigurationKeys
 }
 
 // should contain all dependencies needed for baseClass and compilationConfigurator
-val ScriptingEnvironmentKeys.configurationDependencies by PropertiesCollection.key<List<ScriptDependency>>()
+val ScriptingHostConfigurationKeys.configurationDependencies by PropertiesCollection.key<List<ScriptDependency>>()
 
 // do not use configurationDependencies as script dependencies, so only the dependencies defined by compilationConfigurator will be used
 // (NOTE: in this case they should include the dependencies for the base class anyway, since this class is needed for script
 // compilation and instantiation, but compilationConfigurator could be excluded)
-val ScriptingEnvironmentKeys.isolatedDependencies by PropertiesCollection.key<Boolean>(false)
+val ScriptingHostConfigurationKeys.isolatedDependencies by PropertiesCollection.key<Boolean>(false)
 
 // a "class loader" for KotlinTypes
-val ScriptingEnvironmentKeys.getScriptingClass by PropertiesCollection.key<GetScriptingClass>()
+val ScriptingHostConfigurationKeys.getScriptingClass by PropertiesCollection.key<GetScriptingClass>()
 
 
 interface GetScriptingClass {
-    operator fun invoke(classType: KotlinType, contextClass: KClass<*>, environment: ScriptingEnvironment): KClass<*>
+    operator fun invoke(classType: KotlinType, contextClass: KClass<*>, hostConfiguration: ScriptingHostConfiguration): KClass<*>
 }
 
-fun ScriptingEnvironment.getScriptingClass(type: KotlinType, contextClass: KClass<*>): KClass<*> {
+fun ScriptingHostConfiguration.getScriptingClass(type: KotlinType, contextClass: KClass<*>): KClass<*> {
-    val getClass = get(ScriptingEnvironment.getScriptingClass)
+    val getClass = get(ScriptingHostConfiguration.getScriptingClass)
         ?: throw IllegalArgumentException("Expecting 'getScriptingClass' property in the scripting environment: unable to load scripting class $type")
     return getClass(type, contextClass, this)
 }
 
-fun ScriptingEnvironment.getScriptingClass(type: KotlinType, context: Any): KClass<*> = getScriptingClass(type, context::class)
+fun ScriptingHostConfiguration.getScriptingClass(type: KotlinType, context: Any): KClass<*> = getScriptingClass(type, context::class)
 

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

@@ -8,24 +8,24 @@ package kotlin.script.experimental.jvmhost
 import kotlin.script.experimental.api.KotlinType
 import kotlin.script.experimental.api.ScriptCompilationConfiguration
 import kotlin.script.experimental.api.ScriptEvaluator
-import kotlin.script.experimental.api.ScriptingEnvironment
+import kotlin.script.experimental.host.ScriptingHostConfiguration
-import kotlin.script.experimental.configuration.createScriptCompilationConfigurationFromAnnotatedBaseClass
+import kotlin.script.experimental.host.createScriptCompilationConfigurationFromAnnotatedBaseClass
 import kotlin.script.experimental.host.BasicScriptingHost
 import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment
 
 open class BasicJvmScriptingHost(
-    hostEnvironment: ScriptingEnvironment = defaultJvmScriptingEnvironment,
+    hostConfiguration: ScriptingHostConfiguration = defaultJvmScriptingEnvironment,
-    compiler: JvmScriptCompiler = JvmScriptCompiler(hostEnvironment),
+    compiler: JvmScriptCompiler = JvmScriptCompiler(hostConfiguration),
     evaluator: ScriptEvaluator = BasicJvmScriptEvaluator()
 ) : BasicScriptingHost(compiler, evaluator)
 
 
 inline fun <reified T : Any> createBasicScriptCompilationConfigurationFromAnnotatedBaseClass(
-    hostEnvironment: ScriptingEnvironment = defaultJvmScriptingEnvironment,
+    hostConfiguration: ScriptingHostConfiguration = defaultJvmScriptingEnvironment,
     noinline body: ScriptCompilationConfiguration.Builder.() -> Unit = {}
 ): ScriptCompilationConfiguration = createScriptCompilationConfigurationFromAnnotatedBaseClass(
     KotlinType(T::class),
-    hostEnvironment,
+    hostConfiguration,
     ScriptCompilationConfiguration::class,
     body
 )

libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJVMCompilerImpl.kt

@@ -38,7 +38,9 @@ import java.io.File
 import java.net.URLClassLoader
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.dependencies.DependenciesResolver
+import kotlin.script.experimental.host.ScriptingHostConfiguration
 import kotlin.script.experimental.host.getMergedScriptText
+import kotlin.script.experimental.host.getScriptingClass
 import kotlin.script.experimental.jvm.JvmDependency
 import kotlin.script.experimental.jvm.impl.BridgeDependenciesResolver
 import kotlin.script.experimental.jvm.javaHome
@@ -74,7 +76,7 @@ class KJvmCompiledScript<out ScriptBase : Any>(
     }
 }
 
-class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompilerProxy {
+class KJvmCompilerImpl(val hostConfiguration: ScriptingHostConfiguration) : KJvmCompilerProxy {
 
     override fun compile(
         script: ScriptSource,
@@ -104,13 +106,13 @@ class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompiler
             val kotlinCompilerConfiguration = org.jetbrains.kotlin.config.CompilerConfiguration().apply {
                 add(
                     JVMConfigurationKeys.SCRIPT_DEFINITIONS,
-                    BridgeScriptDefinition(scriptCompilationConfiguration, hostEnvironment, ::updateClasspath)
+                    BridgeScriptDefinition(scriptCompilationConfiguration, hostConfiguration, ::updateClasspath)
                 )
                 put<MessageCollector>(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
                 put(JVMConfigurationKeys.RETAIN_OUTPUT_IN_MEMORY, true)
 
                 var isModularJava = false
-                getFirstFromChainOrNull(ScriptCompilationConfiguration.jvm.javaHome, updatedConfiguration, hostEnvironment)?.let {
+                getFirstFromChainOrNull(ScriptCompilationConfiguration.jvm.javaHome, updatedConfiguration, hostConfiguration)?.let {
                     put(JVMConfigurationKeys.JDK_HOME, it)
                     isModularJava = CoreJrtFileSystem.isModularJdk(it)
                 }
@@ -238,10 +240,10 @@ class ScriptDiagnosticsMessageCollector : MessageCollector {
 
 internal class BridgeScriptDefinition(
     scriptCompilationConfiguration: ScriptCompilationConfiguration,
-    hostEnvironment: ScriptingEnvironment,
+    hostConfiguration: ScriptingHostConfiguration,
     updateClasspath: (List<File>) -> Unit
 ) : KotlinScriptDefinition(
-    hostEnvironment.getScriptingClass(
+    hostConfiguration.getScriptingClass(
         scriptCompilationConfiguration.getOrError(ScriptCompilationConfiguration.baseClass),
         BridgeScriptDefinition::class
     )

libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/jvmHostUtil.kt

@@ -5,14 +5,14 @@
 
 package kotlin.script.experimental.jvmhost.impl
 
-import kotlin.script.experimental.api.ScriptingEnvironment
+import kotlin.script.experimental.host.ScriptingHostConfiguration
 import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment
 
-fun ScriptingEnvironment.withDefaults(): ScriptingEnvironment =
+fun ScriptingHostConfiguration.withDefaults(): ScriptingHostConfiguration =
     if (this == defaultJvmScriptingEnvironment || defaultJvmScriptingEnvironment.properties.all {
             this.properties.containsKey(it.key)
         }) {
         this
     } else {
-        ScriptingEnvironment(defaultJvmScriptingEnvironment, this)
+        ScriptingHostConfiguration(defaultJvmScriptingEnvironment, this)
     }

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

@@ -8,6 +8,7 @@
 package kotlin.script.experimental.jvmhost
 
 import kotlin.script.experimental.api.*
+import kotlin.script.experimental.host.ScriptingHostConfiguration
 import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment
 import kotlin.script.experimental.jvmhost.impl.KJvmCompilerImpl
 import kotlin.script.experimental.jvmhost.impl.withDefaults
@@ -29,8 +30,8 @@ interface CompiledJvmScriptsCache {
 }
 
 open class JvmScriptCompiler(
-    hostEnvironment: ScriptingEnvironment = defaultJvmScriptingEnvironment,
+    hostConfiguration: ScriptingHostConfiguration = defaultJvmScriptingEnvironment,
-    val compilerProxy: KJvmCompilerProxy = KJvmCompilerImpl(hostEnvironment.withDefaults()),
+    val compilerProxy: KJvmCompilerProxy = KJvmCompilerImpl(hostConfiguration.withDefaults()),
     val cache: CompiledJvmScriptsCache = CompiledJvmScriptsCache.NoCache
 ) : ScriptCompiler {
 

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

@@ -8,6 +8,7 @@ package kotlin.script.experimental.jvm
 import org.jetbrains.kotlin.script.util.scriptCompilationClasspathFromContext
 import java.io.File
 import kotlin.script.experimental.api.*
+import kotlin.script.experimental.host.ScriptingHostConfiguration
 import kotlin.script.experimental.util.PropertiesCollection
 
 data class JvmDependency(val classpath: List<File>) : ScriptDependency {
@@ -37,7 +38,7 @@ fun JvmScriptCompilationConfigurationBuilder.dependenciesFromClassloader(
     )
 }
 
-val JvmScriptCompilationConfigurationKeys.javaHome by PropertiesCollection.keyCopy(ScriptingEnvironment.jvm.javaHome)
+val JvmScriptCompilationConfigurationKeys.javaHome by PropertiesCollection.keyCopy(ScriptingHostConfiguration.jvm.javaHome)
 
 @Suppress("unused")
 val ScriptCompilationConfigurationKeys.jvm

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

@@ -9,24 +9,25 @@ import java.io.File
 import java.net.URLClassLoader
 import kotlin.reflect.KClass
 import kotlin.script.experimental.api.*
+import kotlin.script.experimental.host.*
 import kotlin.script.experimental.util.PropertiesCollection
 
-interface JvmScriptingEnvironmentKeys
+interface JvmScriptingHostConfigurationKeys
 
-open class JvmScriptingEnvironmentBuilder : JvmScriptingEnvironmentKeys, PropertiesCollection.Builder() {
+open class JvmScriptingHostConfigurationBuilder : JvmScriptingHostConfigurationKeys, PropertiesCollection.Builder() {
 
-    companion object : PropertiesCollection.Builder.BuilderExtension<JvmScriptingEnvironmentBuilder>, JvmScriptingEnvironmentKeys {
+    companion object : PropertiesCollection.Builder.BuilderExtension<JvmScriptingHostConfigurationBuilder>, JvmScriptingHostConfigurationKeys {
-        override fun get() = JvmScriptingEnvironmentBuilder()
+        override fun get() = JvmScriptingHostConfigurationBuilder()
     }
 }
 
-val JvmScriptingEnvironmentKeys.javaHome by PropertiesCollection.key<File>(File(System.getProperty("java.home")))
+val JvmScriptingHostConfigurationKeys.javaHome by PropertiesCollection.key<File>(File(System.getProperty("java.home")))
 
 @Suppress("unused")
-val ScriptingEnvironmentKeys.jvm
+val ScriptingHostConfigurationKeys.jvm
-    get() = JvmScriptingEnvironmentBuilder
+    get() = JvmScriptingHostConfigurationBuilder
 
-val defaultJvmScriptingEnvironment = ScriptingEnvironment {
+val defaultJvmScriptingEnvironment = ScriptingHostConfiguration {
     getScriptingClass(JvmGetScriptingClass())
 }
 
@@ -38,7 +39,7 @@ class JvmGetScriptingClass : GetScriptingClass {
     private var baseClassLoader: ClassLoader? = null
 
     @Synchronized
-    override fun invoke(classType: KotlinType, contextClass: KClass<*>, environment: ScriptingEnvironment): KClass<*> {
+    override fun invoke(classType: KotlinType, contextClass: KClass<*>, hostConfiguration: ScriptingHostConfiguration): KClass<*> {
 
         // checking if class already loaded in the same context
         val contextClassloader = contextClass.java.classLoader
@@ -49,7 +50,7 @@ class JvmGetScriptingClass : GetScriptingClass {
             if (actualClassLoadersChain.any { it == fromClass.java.classLoader }) return fromClass
         }
 
-        val newDeps = environment[ScriptingEnvironment.configurationDependencies]
+        val newDeps = hostConfiguration[ScriptingHostConfiguration.configurationDependencies]
         if (dependencies == null) {
             dependencies = newDeps
         } else {

plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/KotlinScriptDefinitionAdapterFromNewAPI.kt

@@ -16,6 +16,8 @@ import kotlin.reflect.KType
 import kotlin.reflect.full.starProjectedType
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.dependencies.DependenciesResolver
+import kotlin.script.experimental.host.ScriptingHostConfiguration
+import kotlin.script.experimental.host.getScriptingClass
 import kotlin.script.experimental.jvm.impl.BridgeDependenciesResolver
 import kotlin.script.experimental.location.ScriptExpectedLocation
 import kotlin.script.experimental.util.getOrError
@@ -25,7 +27,7 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
 
     protected abstract val scriptCompilationConfiguration: ScriptCompilationConfiguration
 
-    protected abstract val hostEnvironment: ScriptingEnvironment
+    protected abstract val hostConfiguration: ScriptingHostConfiguration
 
     abstract val scriptFileExtensionWithDot: String
 
@@ -83,7 +85,7 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
         )
 
     private val scriptingClassGetter by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        hostEnvironment[ScriptingEnvironment.getScriptingClass]
+        hostConfiguration[ScriptingHostConfiguration.getScriptingClass]
             ?: throw IllegalArgumentException("Expecting 'getScriptingClass' property in the scripting environment")
     }
 
@@ -91,14 +93,14 @@ abstract class KotlinScriptDefinitionAdapterFromNewAPIBase : KotlinScriptDefinit
         scriptingClassGetter(
             type,
             KotlinScriptDefinition::class, // Assuming that the KotlinScriptDefinition class is loaded in the proper classloader
-            hostEnvironment
+            hostConfiguration
         )
 }
 
 
 class KotlinScriptDefinitionAdapterFromNewAPI(
     override val scriptCompilationConfiguration: ScriptCompilationConfiguration,
-    override val hostEnvironment: ScriptingEnvironment
+    override val hostConfiguration: ScriptingHostConfiguration
 ) : KotlinScriptDefinitionAdapterFromNewAPIBase() {
 
     override val name: String get() = scriptCompilationConfiguration[ScriptCompilationConfiguration.displayName] ?: super.name

plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/LazyScriptDefinitionFromDiscoveredClass.kt

@@ -16,7 +16,9 @@ import java.io.File
 import kotlin.script.experimental.annotations.KotlinScript
 import kotlin.script.experimental.annotations.KotlinScriptFileExtension
 import kotlin.script.experimental.api.*
-import kotlin.script.experimental.configuration.createScriptCompilationConfigurationFromAnnotatedBaseClass
+import kotlin.script.experimental.host.ScriptingHostConfiguration
+import kotlin.script.experimental.host.configurationDependencies
+import kotlin.script.experimental.host.createScriptCompilationConfigurationFromAnnotatedBaseClass
 import kotlin.script.experimental.jvm.JvmDependency
 import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment
 
@@ -34,8 +36,8 @@ class LazyScriptDefinitionFromDiscoveredClass internal constructor(
         messageCollector: MessageCollector
     ) : this(loadAnnotationsFromClass(classBytes), className, classpath, messageCollector)
 
-    override val hostEnvironment: ScriptingEnvironment by lazy(LazyThreadSafetyMode.PUBLICATION) {
+    override val hostConfiguration: ScriptingHostConfiguration by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        ScriptingEnvironment {
+        ScriptingHostConfiguration {
             include(defaultJvmScriptingEnvironment)
             configurationDependencies(JvmDependency(classpath))
         }
@@ -49,7 +51,7 @@ class LazyScriptDefinitionFromDiscoveredClass internal constructor(
         try {
             createScriptCompilationConfigurationFromAnnotatedBaseClass(
                 KotlinType(className),
-                hostEnvironment,
+                hostConfiguration,
                 LazyScriptDefinitionFromDiscoveredClass::class
             )
         } catch (ex: ClassNotFoundException) {

plugins/scripting/scripting-cli/src/org/jetbrains/kotlin/scripting/compiler/plugin/ScriptiDefinitionsFromClasspathDiscoverySource.kt

@@ -18,7 +18,7 @@ import java.util.jar.JarFile
 import kotlin.coroutines.experimental.buildSequence
 import kotlin.script.experimental.annotations.KotlinScript
 import kotlin.script.experimental.api.KotlinType
-import kotlin.script.experimental.configuration.createScriptCompilationConfigurationFromAnnotatedBaseClass
+import kotlin.script.experimental.host.createScriptCompilationConfigurationFromAnnotatedBaseClass
 import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment
 import kotlin.script.templates.ScriptTemplateDefinition