add support for multiplatform projects.

todo: should/can the compiler args be read from the gradle files?

Author: koush

server/src/main/kotlin/org/javacs/kt/Compiler.kt

@@ -72,6 +72,9 @@ import kotlin.script.experimental.jvm.JvmDependency
 import org.javacs.kt.util.KotlinLSException
 import org.javacs.kt.util.KotlinNullableNotNullManager
 import org.javacs.kt.util.LoggingMessageCollector
+import org.jetbrains.kotlin.config.*
+import java.util.*
+
 
 private val GRADLE_DSL_DEPENDENCY_PATTERN = Regex("^gradle-(?:kotlin-dsl|core).*\\.jar$")
 
@@ -93,7 +96,17 @@ private class CompilationEnvironment(
             parentDisposable = disposable,
             // Not to be confused with the CompilerConfiguration in the language server Configuration
             configuration = KotlinCompilerConfiguration().apply {
+                val langFeatures = mutableMapOf<LanguageFeature, LanguageFeature.State>()
+                langFeatures[LanguageFeature.MultiPlatformProjects] = LanguageFeature.State.ENABLED
+                val languageVersionSettings = LanguageVersionSettingsImpl(
+                    LanguageVersion.LATEST_STABLE,
+                    ApiVersion.createByLanguageVersion(LanguageVersion.LATEST_STABLE),
+                    emptyMap(),
+                    langFeatures
+                )
+
                 put(CommonConfigurationKeys.MODULE_NAME, JvmProtoBufUtil.DEFAULT_MODULE_NAME)
+                put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, languageVersionSettings)
                 put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, LoggingMessageCollector)
                 add(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS, ScriptingCompilerConfigurationComponentRegistrar())
                 addJvmClasspathRoots(classPath.map { it.toFile() })
@@ -331,3 +344,49 @@ private fun describeExpression(expression: String): String = expression.lines().
         (lines.take(3) + listOf("...", lines.last())).joinToString(separator = "\n")
     }
 }
+
+class LanguageVersionSettingsImpl @JvmOverloads constructor(
+    override val languageVersion: LanguageVersion,
+    override val apiVersion: ApiVersion,
+    analysisFlags: Map<AnalysisFlag<*>, Any?> = emptyMap(),
+    specificFeatures: Map<LanguageFeature, LanguageFeature.State> = emptyMap()
+) : LanguageVersionSettings {
+    private val analysisFlags: Map<AnalysisFlag<*>, *> = Collections.unmodifiableMap(analysisFlags)
+    private val specificFeatures: Map<LanguageFeature, LanguageFeature.State> = Collections.unmodifiableMap(specificFeatures)
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <T> getFlag(flag: AnalysisFlag<T>): T = analysisFlags[flag] as T? ?: flag.defaultValue
+
+    override fun getFeatureSupport(feature: LanguageFeature): LanguageFeature.State {
+        specificFeatures[feature]?.let { return it }
+
+        val since = feature.sinceVersion
+        if (since != null && languageVersion >= since && apiVersion >= feature.sinceApiVersion) {
+            return feature.defaultState
+        }
+
+        return LanguageFeature.State.DISABLED
+    }
+
+    override fun toString() = buildString {
+        append("Language = $languageVersion, API = $apiVersion")
+        specificFeatures.forEach { (feature, state) ->
+            val char = when (state) {
+                LanguageFeature.State.ENABLED -> '+'
+                LanguageFeature.State.ENABLED_WITH_WARNING -> '~'
+                LanguageFeature.State.ENABLED_WITH_ERROR, LanguageFeature.State.DISABLED -> '-'
+            }
+            append(" $char$feature")
+        }
+    }
+
+    override fun isPreRelease(): Boolean = languageVersion.isPreRelease() ||
+        specificFeatures.any { (feature, state) ->
+            state == LanguageFeature.State.ENABLED && feature.forcesPreReleaseBinariesIfEnabled()
+        }
+
+    companion object {
+        @JvmField
+        val DEFAULT = LanguageVersionSettingsImpl(LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE)
+    }
+}