Support run configuration for iOS simulator in MPP plugin for AS

buildSrc/prepare-deps/cocoa-common-binaries/build.gradle.kts

@@ -0,0 +1,83 @@
+import com.github.jk1.tcdeps.KotlinScriptDslAdapter.tc
+import com.github.jk1.tcdeps.KotlinScriptDslAdapter.teamcityServer
+
+plugins {
+    base
+    id("com.github.jk1.tcdeps") version "1.2"
+}
+
+rootProject.apply {
+    from(project.file("../../../gradle/kotlinUltimateProperties.gradle.kts"))
+    from(project.file("../../../gradle/kotlinUltimateTools.gradle.kts"))
+}
+
+repositories {
+    teamcityServer {
+        setUrl("https://buildserver.labs.intellij.net")
+        credentials {
+            username = "guest"
+            password = "guest"
+        }
+    }
+}
+
+val clionVersion: String by rootProject.extra
+val clionCocoaCommonArtifacts: List<String> by rootProject.extra
+val clionCocoaCommonBinariesDir: File by rootProject.extra
+val clionCocoaCommonBinaries: Configuration by configurations.creating
+
+val ultimateTools: Map<String, Any> by rootProject.extensions
+val handleSymlink: (FileCopyDetails, File) -> Boolean by ultimateTools
+
+dependencies {
+    clionCocoaCommonArtifacts.forEach { clionCocoaCommonBinaries(tc(it)) }
+}
+
+val downloadCLionCocoaCommonBinaries: Task by downloading(
+    clionCocoaCommonBinaries,
+    clionCocoaCommonBinariesDir,
+    pathRemap = { it.replace("-$clionVersion", "") }
+) { config, tempDir ->
+    config.map {
+        when {
+            it.name.endsWith(".tar") -> {
+                val dir = File(tempDir, it.name)
+                dir.mkdir()
+                project.exec {
+                    setCommandLine("tar", "xf", it.absolutePath, "-C", dir.absolutePath)
+                }
+                files(dir.absolutePath)
+            }
+            else -> it
+        }
+    }
+}
+
+tasks["build"].dependsOn(downloadCLionCocoaCommonBinaries)
+
+fun Project.downloading(
+    sourceConfiguration: Configuration,
+    targetDir: File,
+    pathRemap: (String) -> String = { it },
+    extractor: (Configuration, File) -> Any = { it, _ -> it }
+) = tasks.creating {
+    // don't re-check status of the artifact at the remote server if the artifact is already downloaded
+    val isUpToDate = targetDir.isDirectory && targetDir.walkTopDown().firstOrNull { !it.isDirectory } != null
+    outputs.upToDateWhen { isUpToDate }
+
+    if (!isUpToDate) {
+        doFirst {
+            copy {
+                from(extractor(sourceConfiguration, temporaryDir))
+                into(targetDir)
+                includeEmptyDirs = false
+                duplicatesStrategy = DuplicatesStrategy.FAIL
+                eachFile {
+                    if (!handleSymlink(this, targetDir)) {
+                        path = pathRemap(path)
+                    }
+                }
+            }
+        }
+    }
+}

gradle/kotlinUltimateProperties.gradle.kts

@@ -84,6 +84,18 @@ val appcodeJavaPluginDownloadUrl: URL? by rootProject.extra(
 )
 val xCodeCompatPluginVersion by rootProject.extra(rootProject.extra["versions.xcode-compat"] as String)
 
+val clionCocoaCommonArtifacts: List<String> by rootProject.extra(
+    listOf("$clionRepo:$clionVersion:cocoa-common-binaries/Bridge.framework.tar",
+           "$clionRepo:$clionVersion:cocoa-common-binaries/JBDevice.framework.tar",
+           "$clionRepo:$clionVersion:cocoa-common-binaries/libObjCHelper.dylib")
+)
+val clionCocoaCommonBinariesDir: File by rootProject.extra(
+    externalDepsDir(
+        "cocoa-common-binaries",
+        "cidr-cocoaCommon-binaries-$clionVersion"
+    )
+)
+
 if (rootProject.extra.has("versions.nativeDebug")) {
     val nativeDebugVersion: String = rootProject.extra["versions.nativeDebug"] as String
     rootProject.extra["nativeDebugVersion"] = nativeDebugVersion

gradle/kotlinUltimateTools.gradle.kts

@@ -11,7 +11,8 @@ val ultimateTools: Map<String, KFunction<Any>> = listOf<KFunction<Any>>(
 
     ::addCidrDeps,
     ::addIdeaNativeModuleDeps,
-    ::addKotlinGradleToolingDeps
+    ::addKotlinGradleToolingDeps,
+    ::handleSymlink
 ).map { it.name to it }.toMap()
 
 rootProject.extensions.add("ultimateTools", ultimateTools)
@@ -52,7 +53,7 @@ val javaApiArtifacts = listOf("java-api", "java-impl")
 data class IDE(val name: String, val version: String)
 
 fun guessIDEParams(): IDE {
-    if (rootProject.extra.has("versions.cidrForAS")) {
+    if (rootProject.extra.has("versions.androidStudioBuild")) {
         return IDE("android-studio-ide", rootProject.extra["versions.androidStudioBuild"] as String)
     }
 
@@ -218,3 +219,40 @@ fun addKotlinGradleToolingDepsStandalone(project: Project) = with(project) {
 
 fun addKotlinGradleToolingDeps(project: Project) =
     if (isStandaloneBuild) addKotlinGradleToolingDepsStandalone(project) else addKotlinGradleToolingDepsComposite(project)
+
+fun handleSymlink(details: FileCopyDetails, targetDir: File): Boolean = with(details) {
+    val symlink = file.toPath().firstParentSymlink()
+    if (symlink != null) {
+        exclude()
+        val destPath = relativeTo(targetDir, symlink)
+        if (java.nio.file.Files.notExists(destPath, java.nio.file.LinkOption.NOFOLLOW_LINKS)) {
+            if (java.nio.file.Files.notExists(destPath.parent)) {
+                project.mkdir(destPath.parent)
+            }
+            java.nio.file.Files.createSymbolicLink(destPath, java.nio.file.Files.readSymbolicLink(symlink))
+        }
+        return true
+    }
+    return false
+}
+
+fun java.nio.file.Path.firstParentSymlink(): java.nio.file.Path? {
+    var cur: java.nio.file.Path? = this
+    @Suppress("SENSELESS_COMPARISON")
+    while (cur != null) {
+        if (java.nio.file.Files.isSymbolicLink(cur)) break
+        cur = cur.parent
+    }
+    return cur
+}
+
+fun FileCopyDetails.relativeTo(targetDir: File, symlink: java.nio.file.Path): java.nio.file.Path {
+    var srcRoot = file.toPath()
+    var cur = java.nio.file.Paths.get(relativePath.pathString)
+    @Suppress("SENSELESS_COMPARISON")
+    while (cur != null) {
+        srcRoot = srcRoot.parent
+        cur = cur.parent
+    }
+    return targetDir.toPath().resolve(srcRoot.relativize(symlink))
+}

ide/android-studio-native/build.gradle.kts

@@ -2,6 +2,12 @@ plugins {
     kotlin("jvm")
 }
 
+val clionVersion: String by rootProject.extra
+
+repositories {
+    maven("https://repo.labs.intellij.net/intellij-proprietary-modules")
+}
+
 val ultimateTools: Map<String, Any> by rootProject.extensions
 val addCidrDeps: (Project) -> Unit by ultimateTools
 
@@ -29,6 +35,9 @@ dependencies {
         "java-api",
         "java-impl"
     ) }
+
+    implementation("com.jetbrains.intellij.cidr:cidr-cocoa-common:$clionVersion") { isTransitive = false }
+    implementation("com.jetbrains.intellij.cidr:cidr-xcode-model-core:$clionVersion") { isTransitive = false }
 }
 
 

ide/android-studio-native/resources/META-INF/plugin.xml

@@ -1,4 +1,5 @@
-<idea-plugin>
+<idea-plugin xmlns:xi="http://www.w3.org/2001/XInclude">
+  <xi:include href="/META-INF/CocoaCommonPlugin.xml" xpointer="xpointer(/idea-plugin/*)"/>
   <id>org.jetbrains.mobile-mpp</id>
   <name>Mobile Multiplatform</name>
   <version>0.1</version>
@@ -12,10 +13,19 @@
       <implementation-class>com.jetbrains.konan.MPPWorkspace</implementation-class>
     </component>
   </project-components>
+  <application-components>
+    <component>
+      <implementation-class>com.jetbrains.cidr.xcode.frameworks.AppleSdkManager</implementation-class>
+    </component>
+  </application-components>
 
   <extensions defaultExtensionNs="com.intellij">
+    <applicationService serviceInterface="com.jetbrains.cidr.OCPathManagerCustomization"
+                        serviceImplementation="com.jetbrains.mpp.PathManagerCustomization" overrides="true"/>
+
     <externalProjectDataService implementation="com.jetbrains.konan.MPPProjectDataService"/>
     <configurationType implementation="com.jetbrains.mpp.MobileRunConfigurationType"/>
     <stepsBeforeRunProvider implementation="com.jetbrains.mpp.BuildIOSAppTaskProvider"/>
+    <executionTargetProvider implementation="com.jetbrains.mpp.execution.DeviceExecutionTargetProvider"/>
   </extensions>
 </idea-plugin>

ide/android-studio-native/src/com/jetbrains/mpp/AppleRunConfiguration.kt

@@ -6,18 +6,24 @@
 package com.jetbrains.mpp
 
 import com.intellij.execution.BeforeRunTask
+import com.intellij.execution.ExecutionTarget
 import com.intellij.execution.Executor
-import com.intellij.execution.configurations.ConfigurationFactory
-import com.intellij.execution.configurations.LocatableConfigurationBase
-import com.intellij.execution.configurations.RunConfiguration
-import com.intellij.execution.configurations.RunProfileState
+import com.intellij.execution.configurations.*
 import com.intellij.execution.runners.ExecutionEnvironment
+import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
+import com.intellij.openapi.module.Module
 import com.intellij.openapi.options.SettingsEditor
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.io.FileUtil
 import com.jetbrains.konan.MPPWorkspace
+import com.jetbrains.mpp.execution.AppleDevice
+import com.jetbrains.mpp.execution.AppleSimulator
+import com.jetbrains.mpp.execution.Device
 import org.jdom.Element
+import org.jetbrains.kotlin.idea.util.projectStructure.allModules
+import java.io.File
 
-class MobileRunConfiguration(project: Project, configurationFactory: ConfigurationFactory, name: String) :
+class AppleRunConfiguration(project: Project, configurationFactory: ConfigurationFactory, name: String) :
     LocatableConfigurationBase<Element>(project, configurationFactory, name) {
 
     var xcodeproj: String? = MPPWorkspace.getInstance(project).xcproject
@@ -26,17 +32,24 @@ class MobileRunConfiguration(project: Project, configurationFactory: Configurati
 
     val xcodeSdk: String = "iphonesimulator" // TODO: Use provided.
 
-    val iosBuildDirectory = "./ios_build" // TODO: Allow configuration.
+    val iosBuildDirectory = "ios_build" // TODO: Allow configuration.
+
+    val workingDirectory = project.basePath?.let { File(it) }
 
     override fun getConfigurationEditor(): SettingsEditor<out RunConfiguration> = MobileRunConfigurationEditor(project)
 
-    override fun getState(executor: Executor, environment: ExecutionEnvironment): RunProfileState? {
-        return MobileCommandLineState(environment, xcodeproj)
-    }
+    override fun getState(executor: Executor, environment: ExecutionEnvironment): RunProfileState? =
+        (environment.executionTarget as? Device)?.createState(this, environment)
 
     override fun getBeforeRunTasks(): MutableList<BeforeRunTask<*>> {
         val result = mutableListOf<BeforeRunTask<*>>()
         xcodeproj?.let { result.add(BuildIOSAppTask()) }
         return result
     }
+
+    override fun canRunOn(target: ExecutionTarget): Boolean = target is Device
+
+    fun getProductBundle(environment: ExecutionEnvironment): File {
+        return workingDirectory!!.resolve(iosBuildDirectory).resolve("Debug-iphonesimulator/$xcodeScheme.app")
+    }
 }

ide/android-studio-native/src/com/jetbrains/mpp/BuildIOSAppTaskProvider.kt

@@ -19,8 +19,10 @@ import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.util.Key
 import com.intellij.openapi.util.io.FileUtil
 import com.jetbrains.cidr.execution.CidrBuildConfiguration
+import com.jetbrains.cidr.execution.ExecutionResult
 import com.jetbrains.cidr.execution.build.CidrBuild
 import com.jetbrains.cidr.execution.build.CidrBuild.startProcess
+import com.jetbrains.cidr.execution.build.CidrBuildResult
 import com.jetbrains.cidr.execution.build.CidrBuildTaskType
 import java.io.File
 import java.util.regex.Pattern
@@ -63,7 +65,7 @@ class BuildIOSAppTaskProvider : BeforeRunTaskProvider<BuildIOSAppTask>() {
     override fun getId() = BUILD_IOS_APP_TASK_ID
 
     override fun createTask(runConfiguration: RunConfiguration): BuildIOSAppTask? =
-        if (runConfiguration is MobileRunConfiguration) BuildIOSAppTask() else null
+        if (runConfiguration is AppleRunConfiguration) BuildIOSAppTask() else null
 
     override fun executeTask(
         context: DataContext,
@@ -71,7 +73,7 @@ class BuildIOSAppTaskProvider : BeforeRunTaskProvider<BuildIOSAppTask>() {
         environment: ExecutionEnvironment,
         task: BuildIOSAppTask
     ): Boolean {
-        if (configuration !is MobileRunConfiguration) return false
+        if (configuration !is AppleRunConfiguration) return false
         val workDirectory = configuration.project.basePath ?: return false
         val xcodeprojFile = getXcodeprojFile(workDirectory, configuration.xcodeproj) ?: return false
 
@@ -93,17 +95,13 @@ class BuildIOSAppTaskProvider : BeforeRunTaskProvider<BuildIOSAppTask>() {
 
         buildContext.processHandler.addProcessListener(BuildProcessListener(buildContext))
 
-        ApplicationManager.getApplication().executeOnPooledThread {
+        val future = ApplicationManager.getApplication().executeOnPooledThread<ExecutionResult<CidrBuildResult>> {
             CidrBuild.execute(configuration.project, buildContext) {
                 startProcess(configuration.project, buildContext, emptyList())
             }
         }
 
-        if (xcodeprojFile.absolutePath.contains("xcodeproj")) {
-            return false // TODO: Let execution to continue once run configuration is ready.
-        }
-
-        return true
+        return future.get().get().succeeded
     }
 
     private fun createBuildProcess(

ide/android-studio-native/src/com/jetbrains/mpp/MobileCommandLineState.kt

@@ -1,23 +0,0 @@
-/*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package com.jetbrains.mpp
-
-import com.intellij.execution.configurations.CommandLineState
-import com.intellij.execution.configurations.GeneralCommandLine
-import com.intellij.execution.process.ColoredProcessHandler
-import com.intellij.execution.process.ProcessHandler
-import com.intellij.execution.runners.ExecutionEnvironment
-import com.intellij.openapi.util.io.FileUtil
-import java.io.File
-
-class MobileCommandLineState(environment: ExecutionEnvironment, private val xcodeproj: String?) : CommandLineState(environment) {
-    override fun startProcess(): ProcessHandler {
-        val cl = GeneralCommandLine()
-        cl.workDirectory = File(FileUtil.join(environment.project.basePath!!, xcodeproj))
-        cl.exePath = "/bin/ls"
-        return ColoredProcessHandler(cl)
-    }
-}

ide/android-studio-native/src/com/jetbrains/mpp/MobileRunConfigurationEditor.kt

@@ -11,8 +11,8 @@ import java.awt.GridBagLayout
 import javax.swing.JComponent
 import javax.swing.JPanel
 
-class MobileRunConfigurationEditor(project: Project) : SettingsEditor<MobileRunConfiguration>() {
-    override fun resetEditorFrom(configuration: MobileRunConfiguration) {
+class MobileRunConfigurationEditor(project: Project) : SettingsEditor<AppleRunConfiguration>() {
+    override fun resetEditorFrom(configuration: AppleRunConfiguration) {
     }
 
     override fun createEditor(): JComponent {
@@ -20,6 +20,6 @@ class MobileRunConfigurationEditor(project: Project) : SettingsEditor<MobileRunC
         return panel
     }
 
-    override fun applyEditorTo(configuration: MobileRunConfiguration) {
+    override fun applyEditorTo(configuration: AppleRunConfiguration) {
     }
 }

ide/android-studio-native/src/com/jetbrains/mpp/MobileRunConfigurationType.kt

@@ -20,7 +20,7 @@ class MobileRunConfigurationType : ConfigurationTypeBase(
     init {
         addFactory(object : ConfigurationFactory(this) {
             override fun createTemplateConfiguration(project: Project): RunConfiguration =
-                MobileRunConfiguration(project, this, name)
+                AppleRunConfiguration(project, this, name)
         })
     }
 }

ide/android-studio-native/src/com/jetbrains/mpp/PathManagerCustomizer.kt

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package com.jetbrains.mpp
+
+import com.intellij.openapi.application.PathManager
+import com.intellij.openapi.util.io.FileUtil
+import com.jetbrains.cidr.OCPathManagerCustomization
+import java.io.File
+
+class PathManagerCustomization : OCPathManagerCustomization() {
+    override fun getBinFile(relativePath: String): File =
+        File(FileUtil.join(PathManager.getPluginsPath(), "mobile-mpp", "native", relativePath)).also {
+            FileUtil.setExecutable(it) // FIXME omit when CLion build script is corrected
+        }
+}

ide/android-studio-native/src/com/jetbrains/mpp/execution/AppleDevice.kt

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package com.jetbrains.mpp.execution
+
+import com.intellij.execution.configurations.GeneralCommandLine
+import com.intellij.execution.configurations.RunConfiguration
+import com.intellij.execution.runners.ExecutionEnvironment
+import com.intellij.openapi.project.Project
+import com.jetbrains.cidr.execution.CidrCommandLineState
+import com.jetbrains.cidr.execution.CidrConsoleBuilder
+import com.jetbrains.cidr.execution.simulatorSupport.SimulatorConfiguration
+import com.jetbrains.cidr.execution.testing.CidrLauncher
+import com.jetbrains.cidr.xcode.frameworks.buildSystem.ArchitectureValue
+import com.jetbrains.mpp.AppleRunConfiguration
+import java.io.File
+
+abstract class AppleDevice(id: String, name: String, osVersion: String) : Device(id, name, "iOS", osVersion) {
+    override fun createState(configuration: AppleRunConfiguration, environment: ExecutionEnvironment): CidrCommandLineState =
+        CidrCommandLineState(environment, createLauncher(configuration, environment)).also {
+            it.consoleBuilder = CidrConsoleBuilder(configuration.project, null, configuration.project.basePath?.let { File(it) })
+        }
+
+    protected abstract fun createLauncher(configuration: AppleRunConfiguration, environment: ExecutionEnvironment): CidrLauncher
+
+    abstract fun createCommandLine(bundle: File, project: Project): GeneralCommandLine
+    override fun canRun(configuration: RunConfiguration): Boolean =
+        configuration is AppleRunConfiguration
+
+    abstract val arch: ArchitectureValue
+}
+
+class AppleSimulator(private val raw: SimulatorConfiguration) : AppleDevice(
+    raw.udid,
+    raw.name,
+    raw.version
+) {
+    override fun createLauncher(configuration: AppleRunConfiguration, environment: ExecutionEnvironment): CidrLauncher =
+        AppleSimulatorLauncher(configuration, environment, this, raw)
+
+    override fun createCommandLine(bundle: File, project: Project): GeneralCommandLine =
+        GeneralCommandLine(bundle.absolutePath)
+
+    override val arch: ArchitectureValue
+        get() = raw.launchArchitecture
+}

ide/android-studio-native/src/com/jetbrains/mpp/execution/AppleInstaller.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package com.jetbrains.mpp.execution
+
+import com.intellij.execution.configurations.GeneralCommandLine
+import com.intellij.execution.configurations.SimpleProgramParameters
+import com.intellij.execution.runners.ExecutionEnvironment
+import com.jetbrains.cidr.execution.OCCommandLineConfigurator
+import com.jetbrains.cidr.execution.OCInstaller
+import com.jetbrains.cidr.execution.simulatorSupport.SimulatorConfiguration
+import com.jetbrains.cidr.xcode.frameworks.ApplePlatform
+import com.jetbrains.cidr.xcode.frameworks.AppleSdkManager
+import com.jetbrains.mpp.AppleRunConfiguration
+import java.io.File
+
+abstract class AppleInstaller(
+    private val configuration: AppleRunConfiguration,
+    environment: ExecutionEnvironment,
+    appBundle: File
+) : OCInstaller(environment, appBundle, appBundle, false) {
+
+    override fun doInstall(): GeneralCommandLine {
+        val device = myEnvironment.executionTarget as AppleDevice
+        val commandLine = device.createCommandLine(bundle, project)
+
+        val params = SimpleProgramParameters().also {
+            it.workingDirectory = File(commandLine.exePath).parentFile.parent
+            it.isPassParentEnvs = false
+        }
+        val platform = AppleSdkManager.getInstance().findPlatformByType(
+            if (device is AppleSimulator) ApplePlatform.Type.IOS_SIMULATOR
+            else ApplePlatform.Type.IOS
+        )!!
+
+        val configurator = OCCommandLineConfigurator(project, params, platform, device.arch, null, false)
+        configurator.configureCommandLine(commandLine)
+
+        return commandLine
+    }
+
+    override fun getRunConfiguration(): AppleRunConfiguration = configuration
+}
+
+class AppleSimulatorInstaller(
+    configuration: AppleRunConfiguration,
+    environment: ExecutionEnvironment,
+    appBundle: File,
+    raw: SimulatorConfiguration
+) : AppleInstaller(configuration, environment, appBundle) {
+    override fun getAppWorkingDir(): File? = null
+}

ide/android-studio-native/src/com/jetbrains/mpp/execution/AppleLauncher.kt

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package com.jetbrains.mpp.execution
+
+import com.intellij.execution.configurations.CommandLineState
+import com.intellij.execution.process.ProcessHandler
+import com.intellij.execution.runners.ExecutionEnvironment
+import com.intellij.openapi.project.Project
+import com.intellij.xdebugger.XDebugSession
+import com.jetbrains.cidr.execution.RunParameters
+import com.jetbrains.cidr.execution.TrivialRunParameters
+import com.jetbrains.cidr.execution.debugger.CidrDebugProcess
+import com.jetbrains.cidr.execution.debugger.IPhoneSimulatorDebugProcess
+import com.jetbrains.cidr.execution.debugger.backend.LLDBDriverConfiguration
+import com.jetbrains.cidr.execution.simulatorSupport.SimulatorConfiguration
+import com.jetbrains.cidr.execution.simulatorSupport.SimulatorProcessHandler
+import com.jetbrains.cidr.execution.testing.CidrLauncher
+import com.jetbrains.mpp.AppleRunConfiguration
+import java.io.File
+
+abstract class AppleLauncher(
+    val configuration: AppleRunConfiguration,
+    val environment: ExecutionEnvironment,
+    val device: AppleDevice
+) : CidrLauncher() {
+    override fun getProject(): Project = configuration.project
+
+    override fun createDebugProcess(state: CommandLineState, session: XDebugSession): CidrDebugProcess {
+        val parameters = createRunParameters(state)
+        val process = createDebugProcess(parameters, session, state)
+        configProcessHandler(process.processHandler, process.isDetachDefault, true, project)
+        return process
+    }
+
+    protected fun createRunParameters(state: CommandLineState): RunParameters {
+        val bundle = configuration.getProductBundle(state.environment)
+        val installer = createInstaller(bundle)
+        val configuration = LLDBDriverConfiguration()
+        return TrivialRunParameters(configuration, installer, device.arch.type)
+    }
+
+    protected abstract fun createInstaller(bundle: File): AppleInstaller
+    protected abstract fun createDebugProcess(parameters: RunParameters, session: XDebugSession, state: CommandLineState): CidrDebugProcess
+}
+
+class AppleSimulatorLauncher(
+    configuration: AppleRunConfiguration,
+    environment: ExecutionEnvironment,
+    device: AppleSimulator,
+    private val raw: SimulatorConfiguration
+) : AppleLauncher(configuration, environment, device) {
+
+    override fun createInstaller(bundle: File): AppleInstaller =
+        AppleSimulatorInstaller(configuration, environment, bundle, raw)
+
+    override fun createProcess(state: CommandLineState): ProcessHandler {
+        val parameters = createRunParameters(state)
+        val handler = SimulatorProcessHandler(parameters, null, device.id, false, false, true)
+        configProcessHandler(handler, false, true, project)
+        return handler
+    }
+
+    override fun createDebugProcess(parameters: RunParameters, session: XDebugSession, state: CommandLineState): CidrDebugProcess =
+        object : IPhoneSimulatorDebugProcess(parameters, session, state.consoleBuilder, false) {
+            override fun createSimulatorProcessHandler(params: RunParameters, allowConcurrentSessions: Boolean) =
+                SimulatorProcessHandler(params, null, device.id, true, allowConcurrentSessions, true)
+        }
+}

ide/android-studio-native/src/com/jetbrains/mpp/execution/Device.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package com.jetbrains.mpp.execution
+
+import com.intellij.execution.ExecutionTarget
+import com.intellij.execution.configurations.CommandLineState
+import com.intellij.execution.configurations.RunConfiguration
+import com.intellij.execution.runners.ExecutionEnvironment
+import com.jetbrains.mpp.AppleRunConfiguration
+import javax.swing.Icon
+
+abstract class Device(
+    private val uniqueID: String,
+    val name: String,
+    val osName: String,
+    val osVersion: String
+) : ExecutionTarget() {
+    override fun getId(): String = uniqueID
+    override fun getDisplayName(): String = "$name | $osName $osVersion"
+    override fun getIcon(): Icon? = null
+
+    abstract fun createState(configuration: AppleRunConfiguration, environment: ExecutionEnvironment): CommandLineState
+}

ide/android-studio-native/src/com/jetbrains/mpp/execution/DeviceExecutionTargetProvider.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package com.jetbrains.mpp.execution
+
+import com.intellij.execution.ExecutionTarget
+import com.intellij.execution.ExecutionTargetProvider
+import com.intellij.execution.configurations.RunConfiguration
+import com.intellij.openapi.project.Project
+import com.jetbrains.cidr.execution.simulatorSupport.SimulatorsRegistry
+import com.jetbrains.mpp.AppleRunConfiguration
+
+class DeviceExecutionTargetProvider : ExecutionTargetProvider() {
+    override fun getTargets(project: Project, configuration: RunConfiguration): List<ExecutionTarget> {
+        if (configuration !is AppleRunConfiguration) {
+            return emptyList()
+        }
+
+        return SimulatorsRegistry.getInstance().configurations.map(::AppleSimulator)
+    }
+}

prepare/mobile-mpp-plugin/build.gradle.kts

@@ -3,24 +3,46 @@ plugins {
 }
 
 val artifactsForCidrDir: File by rootProject.extra
+val clionCocoaCommonBinariesDir: File by rootProject.extra
 val mobileMppPluginDir: File by rootProject.extra
 
+val ultimateTools: Map<String, Any> by rootProject.extensions
+val handleSymlink: (FileCopyDetails, File) -> Boolean by ultimateTools
+
 val mainModule = ":kotlin-ultimate:ide:android-studio-native"
 
 dependencies {
     embedded(project(mainModule)) { isTransitive = false }
 }
 
-val mobileMppPluginTask: Copy = task<Copy>("mobileMppPlugin") {
-    into(mobileMppPluginDir)
-
-    into("lib") {
-        val jarTask = project("$mainModule").tasks.findByName("jar")!!
-        dependsOn(jarTask)
-        from(jarTask.outputs.files.singleFile)
+val copyAppCodeBinaries: Task by tasks.creating(Copy::class) {
+    val targetDir = File(mobileMppPluginDir, "native")
+    into(targetDir)
+    from(clionCocoaCommonBinariesDir)
+    eachFile {
+        handleSymlink(this, targetDir)
     }
 }
 
+val copyAppCodeModules: Task by tasks.creating(Copy::class) {
+    into(File(mobileMppPluginDir, "lib"))
+    project("$mainModule").configurations["compileClasspath"].forEach {
+        if (it.name.startsWith("cidr")) {
+            from(it.absolutePath)
+        }
+    }
+}
+
+val mobileMppPluginTask: Copy = task<Copy>("mobileMppPlugin") {
+    into(File(mobileMppPluginDir, "lib"))
+
+    val jarTask = project("$mainModule").tasks.findByName("jar")!!
+    dependsOn(jarTask)
+    from(jarTask.outputs.files.singleFile)
+
+    dependsOn(copyAppCodeBinaries, copyAppCodeModules)
+}
+
 val zipMobileMppPluginTask: Zip = task<Zip>("zipMobileMppPlugin") {
     val pluginNumber: String = findProperty("mobileMppPluginNumber")?.toString() ?: "SNAPSHOT"
     val destinationFile: File = artifactsForCidrDir.resolve("mobile-mpp-plugin-$pluginNumber.zip").canonicalFile
@@ -28,7 +50,7 @@ val zipMobileMppPluginTask: Zip = task<Zip>("zipMobileMppPlugin") {
     destinationDirectory.set(destinationFile.parentFile)
     archiveFileName.set(destinationFile.name)
 
-    from(mobileMppPluginTask)
+    from(mobileMppPluginDir)
     into("mobile-mpp")
 
     doLast {

versions.properties.as36

@@ -1,26 +0,0 @@
-# Dev Kotlin version:
-versions.ideaPluginForCidr=1.3.70-dev-972
-versions.ideaPluginForCidr.ide=IJ2019.2-1
-versions.ideaPluginForCidr.repo=Kotlin_KotlinDev_Aggregate
-
-versions.appcode=192.7142.40
-versions.appcode.strict=true
-versions.appcode.repo=ijplatform_IjPlatform192_CIDR_AppCode_PublicInstallers
-versions.xcode-compat=0.2.5
-
-versions.clion=192.7142.39
-versions.clion.strict=true
-versions.clion.repo=ijplatform_IjPlatform192_CIDR_CLion_PublicInstallers
-
-versions.nativeDebug=192.5728.12
-versions.nativeDebug.repo=ijplatform_IjPlatform192_Idea_InstallersForEapRelease
-
-versions.lldbFrontend.hash=a04617bf697726124f958411e2dd401e4aced0b6
-versions.lldbFrontend.macos.artifact=LLDBFrontend
-versions.lldbFrontend.macos.repo=ijplatform_master_CIDR_InternalTools_LLDBFrontendOsX
-versions.lldbFrontend.windows.artifact=lldb-frontend.zip!x64/bin/LLDBFrontend.exe
-versions.lldbFrontend.windows.repo=ijplatform_master_CIDR_InternalTools_LLDBFrontendWin
-versions.lldbFrontend.linux.artifact=LLDBFrontend
-versions.lldbFrontend.linux.repo=ijplatform_master_CIDR_InternalTools_LLDBFrontendLinux
-
-versions.cidrForAS=193.4944

versions.properties.as40

@@ -8,9 +8,9 @@ versions.appcode.strict=true
 versions.appcode.repo=ijplatform_IjPlatform192_CIDR_AppCode_PublicInstallers
 versions.xcode-compat=0.2.5
 
-versions.clion=192.7142.39
+versions.clion=193.6329
 versions.clion.strict=true
-versions.clion.repo=ijplatform_IjPlatform192_CIDR_CLion_PublicInstallers
+versions.clion.repo=ijplatform_IjPlatform193_CIDR_CLion_Installers
 
 versions.nativeDebug=192.5728.12
 versions.nativeDebug.repo=ijplatform_IjPlatform192_Idea_InstallersForEapRelease
@@ -21,6 +21,4 @@ versions.lldbFrontend.macos.repo=ijplatform_master_CIDR_InternalTools_LLDBFronte
 versions.lldbFrontend.windows.artifact=lldb-frontend.zip!x64/bin/LLDBFrontend.exe
 versions.lldbFrontend.windows.repo=ijplatform_master_CIDR_InternalTools_LLDBFrontendWin
 versions.lldbFrontend.linux.artifact=LLDBFrontend
-versions.lldbFrontend.linux.repo=ijplatform_master_CIDR_InternalTools_LLDBFrontendLinux
-
-versions.cidrForAS=193.4944
+versions.lldbFrontend.linux.repo=ijplatform_master_CIDR_InternalTools_LLDBFrontendLinux