MPP: Create android source roots automatically when requested

#KT-26764 Fixed

idea/idea-android/src/org/jetbrains/kotlin/android/configure/KotlinAndroidGradleMPPModuleDataService.kt

@@ -8,15 +8,20 @@ package org.jetbrains.kotlin.android.configure
 import com.android.tools.idea.gradle.project.model.AndroidModuleModel
 import com.android.tools.idea.gradle.util.ContentEntries.findParentContentEntry
 import com.android.tools.idea.io.FilePaths
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.externalSystem.ExternalSystemModulePropertyManager
 import com.intellij.openapi.externalSystem.model.DataNode
 import com.intellij.openapi.externalSystem.model.ProjectKeys
 import com.intellij.openapi.externalSystem.model.project.ModuleData
 import com.intellij.openapi.externalSystem.model.project.ProjectData
 import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider
 import com.intellij.openapi.externalSystem.service.project.manage.AbstractProjectDataService
+import com.intellij.openapi.externalSystem.service.project.manage.ContentRootDataService.CREATE_EMPTY_DIRECTORIES
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
+import com.intellij.openapi.module.Module
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.ModifiableRootModel
+import com.intellij.openapi.vfs.VfsUtil
 import com.intellij.util.containers.stream
 import org.jetbrains.jps.model.java.JavaResourceRootType
 import org.jetbrains.jps.model.java.JavaSourceRootType
@@ -28,10 +33,25 @@ import org.jetbrains.kotlin.idea.configuration.KotlinSourceSetDataService
 import org.jetbrains.kotlin.idea.configuration.kotlinAndroidSourceSets
 import org.jetbrains.kotlin.idea.facet.KotlinFacet
 import java.io.File
+import java.io.IOException
 
 class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<ModuleData, Void>() {
     override fun getTargetDataKey() = ProjectKeys.MODULE
 
+    private fun shouldCreateEmptySourceRoots(
+        moduleDataNode: DataNode<ModuleData>,
+        module: Module
+    ): Boolean {
+        val projectDataNode = ExternalSystemApiUtil.findParent(moduleDataNode, ProjectKeys.PROJECT) ?: return false
+        if (projectDataNode.getUserData<Boolean>(CREATE_EMPTY_DIRECTORIES) == true) return true
+
+        val projectSystemId = projectDataNode.data.owner
+        val externalSystemSettings = ExternalSystemApiUtil.getSettings(module.project, projectSystemId)
+
+        val path = ExternalSystemModulePropertyManager.getInstance(module).getRootProjectPath() ?: return false
+        return externalSystemSettings.getLinkedProjectSettings(path)?.isCreateEmptyContentRootDirectories ?: false
+    }
+
     override fun postProcess(
         toImport: MutableCollection<DataNode<ModuleData>>,
         projectData: ProjectData?,
@@ -42,6 +62,7 @@ class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<Modul
             val projectNode = ExternalSystemApiUtil.findParent(nodeToImport, ProjectKeys.PROJECT) ?: continue
             val moduleData = nodeToImport.data
             val module = modelsProvider.findIdeModule(moduleData) ?: continue
+            val shouldCreateEmptySourceRoots = shouldCreateEmptySourceRoots(nodeToImport, module)
             val androidModel = AndroidModuleModel.get(module) ?: continue
             val variantName = androidModel.selectedVariant.name
             val sourceSetInfo = nodeToImport.kotlinAndroidSourceSets?.firstOrNull { it.kotlinModule.name == variantName } ?: continue
@@ -51,8 +72,8 @@ class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<Modul
                 if (sourceSet.platform == KotlinPlatform.ANDROID) {
                     val sourceType = if (sourceSet.isTestModule) JavaSourceRootType.TEST_SOURCE else JavaSourceRootType.SOURCE
                     val resourceType = if (sourceSet.isTestModule) JavaResourceRootType.TEST_RESOURCE else JavaResourceRootType.RESOURCE
-                    sourceSet.sourceDirs.forEach { addSourceRoot(it, sourceType, rootModel) }
+                    sourceSet.sourceDirs.forEach { addSourceRoot(it, sourceType, rootModel, shouldCreateEmptySourceRoots) }
-                    sourceSet.resourceDirs.forEach { addSourceRoot(it, resourceType, rootModel) }
+                    sourceSet.resourceDirs.forEach { addSourceRoot(it, resourceType, rootModel, shouldCreateEmptySourceRoots) }
                 } else {
                     val sourceSetId = sourceSetInfo.sourceSetIdsByName[sourceSet.name] ?: continue
                     val sourceSetData = ExternalSystemApiUtil.findFirstRecursively(projectNode) {
@@ -75,10 +96,24 @@ class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<Modul
     private fun addSourceRoot(
         sourceRoot: File,
         type: JpsModuleSourceRootType<*>,
-        rootModel: ModifiableRootModel
+        rootModel: ModifiableRootModel,
+        shouldCreateEmptySourceRoots: Boolean
     ) {
         val parent = findParentContentEntry(sourceRoot, rootModel.contentEntries.stream()) ?: return
         val url = FilePaths.pathToIdeaUrl(sourceRoot)
         parent.addSourceFolder(url, type)
+        if (shouldCreateEmptySourceRoots) {
+            ExternalSystemApiUtil.doWriteAction {
+                try {
+                    VfsUtil.createDirectoryIfMissing(sourceRoot.path)
+                } catch (e: IOException) {
+                    LOG.warn(String.format("Unable to create directory for the path: %s", sourceRoot.path), e)
+                }
+            }
+        }
+    }
+
+    companion object {
+        private val LOG = Logger.getInstance(KotlinAndroidGradleMPPModuleDataService::class.java)
     }
 }

idea/idea-android/src/org/jetbrains/kotlin/android/configure/KotlinAndroidGradleMPPModuleDataService.kt.173

@@ -7,15 +7,21 @@ package org.jetbrains.kotlin.android.configure
 
 import com.android.tools.idea.gradle.project.model.AndroidModuleModel
 import com.android.tools.idea.gradle.util.FilePaths
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.externalSystem.ExternalSystemModulePropertyManager
 import com.intellij.openapi.externalSystem.model.DataNode
 import com.intellij.openapi.externalSystem.model.ProjectKeys
 import com.intellij.openapi.externalSystem.model.project.ModuleData
 import com.intellij.openapi.externalSystem.model.project.ProjectData
 import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider
 import com.intellij.openapi.externalSystem.service.project.manage.AbstractProjectDataService
+import com.intellij.openapi.externalSystem.service.project.manage.ContentRootDataService.CREATE_EMPTY_DIRECTORIES
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
+import com.intellij.openapi.module.Module
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.ModifiableRootModel
+import com.intellij.openapi.vfs.VfsUtil
+import com.intellij.util.containers.stream
 import org.jetbrains.jps.model.java.JavaResourceRootType
 import org.jetbrains.jps.model.java.JavaSourceRootType
 import org.jetbrains.jps.model.module.JpsModuleSourceRootType
@@ -26,10 +32,25 @@ import org.jetbrains.kotlin.idea.configuration.KotlinSourceSetDataService
 import org.jetbrains.kotlin.idea.configuration.kotlinAndroidSourceSets
 import org.jetbrains.kotlin.idea.facet.KotlinFacet
 import java.io.File
+import java.io.IOException
 
 class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<ModuleData, Void>() {
     override fun getTargetDataKey() = ProjectKeys.MODULE
 
+    private fun shouldCreateEmptySourceRoots(
+        moduleDataNode: DataNode<ModuleData>,
+        module: Module
+    ): Boolean {
+        val projectDataNode = ExternalSystemApiUtil.findParent(moduleDataNode, ProjectKeys.PROJECT) ?: return false
+        if (projectDataNode.getUserData<Boolean>(CREATE_EMPTY_DIRECTORIES) == true) return true
+
+        val projectSystemId = projectDataNode.data.owner
+        val externalSystemSettings = ExternalSystemApiUtil.getSettings(module.project, projectSystemId)
+
+        val path = ExternalSystemModulePropertyManager.getInstance(module).getRootProjectPath() ?: return false
+        return externalSystemSettings.getLinkedProjectSettings(path)?.isCreateEmptyContentRootDirectories ?: false
+    }
+
     override fun postProcess(
         toImport: MutableCollection<DataNode<ModuleData>>,
         projectData: ProjectData?,
@@ -40,6 +61,7 @@ class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<Modul
             val projectNode = ExternalSystemApiUtil.findParent(nodeToImport, ProjectKeys.PROJECT) ?: continue
             val moduleData = nodeToImport.data
             val module = modelsProvider.findIdeModule(moduleData) ?: continue
+            val shouldCreateEmptySourceRoots = shouldCreateEmptySourceRoots(nodeToImport, module)
             val androidModel = AndroidModuleModel.get(module) ?: continue
             val variantName = androidModel.selectedVariant.name
             val sourceSetInfo = nodeToImport.kotlinAndroidSourceSets?.firstOrNull { it.kotlinModule.name == variantName } ?: continue
@@ -49,8 +71,8 @@ class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<Modul
                 if (sourceSet.platform == KotlinPlatform.ANDROID) {
                     val sourceType = if (sourceSet.isTestModule) JavaSourceRootType.TEST_SOURCE else JavaSourceRootType.SOURCE
                     val resourceType = if (sourceSet.isTestModule) JavaResourceRootType.TEST_RESOURCE else JavaResourceRootType.RESOURCE
-                    sourceSet.sourceDirs.forEach { addSourceRoot(it, sourceType, rootModel) }
+                    sourceSet.sourceDirs.forEach { addSourceRoot(it, sourceType, rootModel, shouldCreateEmptySourceRoots) }
-                    sourceSet.resourceDirs.forEach { addSourceRoot(it, resourceType, rootModel) }
+                    sourceSet.resourceDirs.forEach { addSourceRoot(it, resourceType, rootModel, shouldCreateEmptySourceRoots) }
                 } else {
                     val sourceSetId = sourceSetInfo.sourceSetIdsByName[sourceSet.name] ?: continue
                     val sourceSetData = ExternalSystemApiUtil.findFirstRecursively(projectNode) {
@@ -73,10 +95,24 @@ class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<Modul
     private fun addSourceRoot(
         sourceRoot: File,
         type: JpsModuleSourceRootType<*>,
-        rootModel: ModifiableRootModel
+        rootModel: ModifiableRootModel,
+        shouldCreateEmptySourceRoots: Boolean
     ) {
         val parent = FilePaths.findParentContentEntry(sourceRoot, rootModel.contentEntries) ?: return
         val url = FilePaths.pathToIdeaUrl(sourceRoot)
         parent.addSourceFolder(url, type)
+        if (shouldCreateEmptySourceRoots) {
+            ExternalSystemApiUtil.doWriteAction {
+                try {
+                    VfsUtil.createDirectoryIfMissing(sourceRoot.path)
+                } catch (e: IOException) {
+                    LOG.warn(String.format("Unable to create directory for the path: %s", sourceRoot.path), e)
+                }
+            }
+        }
+    }
+
+    companion object {
+        private val LOG = Logger.getInstance(KotlinAndroidGradleMPPModuleDataService::class.java)
     }
 }

idea/idea-android/src/org/jetbrains/kotlin/android/configure/KotlinAndroidGradleMPPModuleDataService.kt.181

@@ -8,15 +8,20 @@ package org.jetbrains.kotlin.android.configure
 import com.android.tools.idea.gradle.project.model.AndroidModuleModel
 import com.android.tools.idea.gradle.util.ContentEntries.findParentContentEntry
 import com.android.tools.idea.gradle.util.FilePaths
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.externalSystem.ExternalSystemModulePropertyManager
 import com.intellij.openapi.externalSystem.model.DataNode
 import com.intellij.openapi.externalSystem.model.ProjectKeys
 import com.intellij.openapi.externalSystem.model.project.ModuleData
 import com.intellij.openapi.externalSystem.model.project.ProjectData
 import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider
 import com.intellij.openapi.externalSystem.service.project.manage.AbstractProjectDataService
+import com.intellij.openapi.externalSystem.service.project.manage.ContentRootDataService.CREATE_EMPTY_DIRECTORIES
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
+import com.intellij.openapi.module.Module
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.ModifiableRootModel
+import com.intellij.openapi.vfs.VfsUtil
 import com.intellij.util.containers.stream
 import org.jetbrains.jps.model.java.JavaResourceRootType
 import org.jetbrains.jps.model.java.JavaSourceRootType
@@ -28,10 +33,25 @@ import org.jetbrains.kotlin.idea.configuration.KotlinSourceSetDataService
 import org.jetbrains.kotlin.idea.configuration.kotlinAndroidSourceSets
 import org.jetbrains.kotlin.idea.facet.KotlinFacet
 import java.io.File
+import java.io.IOException
 
 class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<ModuleData, Void>() {
     override fun getTargetDataKey() = ProjectKeys.MODULE
 
+    private fun shouldCreateEmptySourceRoots(
+        moduleDataNode: DataNode<ModuleData>,
+        module: Module
+    ): Boolean {
+        val projectDataNode = ExternalSystemApiUtil.findParent(moduleDataNode, ProjectKeys.PROJECT) ?: return false
+        if (projectDataNode.getUserData<Boolean>(CREATE_EMPTY_DIRECTORIES) == true) return true
+
+        val projectSystemId = projectDataNode.data.owner
+        val externalSystemSettings = ExternalSystemApiUtil.getSettings(module.project, projectSystemId)
+
+        val path = ExternalSystemModulePropertyManager.getInstance(module).getRootProjectPath() ?: return false
+        return externalSystemSettings.getLinkedProjectSettings(path)?.isCreateEmptyContentRootDirectories ?: false
+    }
+
     override fun postProcess(
         toImport: MutableCollection<DataNode<ModuleData>>,
         projectData: ProjectData?,
@@ -42,6 +62,7 @@ class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<Modul
             val projectNode = ExternalSystemApiUtil.findParent(nodeToImport, ProjectKeys.PROJECT) ?: continue
             val moduleData = nodeToImport.data
             val module = modelsProvider.findIdeModule(moduleData) ?: continue
+            val shouldCreateEmptySourceRoots = shouldCreateEmptySourceRoots(nodeToImport, module)
             val androidModel = AndroidModuleModel.get(module) ?: continue
             val variantName = androidModel.selectedVariant.name
             val sourceSetInfo = nodeToImport.kotlinAndroidSourceSets?.firstOrNull { it.kotlinModule.name == variantName } ?: continue
@@ -51,8 +72,8 @@ class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<Modul
                 if (sourceSet.platform == KotlinPlatform.ANDROID) {
                     val sourceType = if (sourceSet.isTestModule) JavaSourceRootType.TEST_SOURCE else JavaSourceRootType.SOURCE
                     val resourceType = if (sourceSet.isTestModule) JavaResourceRootType.TEST_RESOURCE else JavaResourceRootType.RESOURCE
-                    sourceSet.sourceDirs.forEach { addSourceRoot(it, sourceType, rootModel) }
+                    sourceSet.sourceDirs.forEach { addSourceRoot(it, sourceType, rootModel, shouldCreateEmptySourceRoots) }
-                    sourceSet.resourceDirs.forEach { addSourceRoot(it, resourceType, rootModel) }
+                    sourceSet.resourceDirs.forEach { addSourceRoot(it, resourceType, rootModel, shouldCreateEmptySourceRoots) }
                 } else {
                     val sourceSetId = sourceSetInfo.sourceSetIdsByName[sourceSet.name] ?: continue
                     val sourceSetData = ExternalSystemApiUtil.findFirstRecursively(projectNode) {
@@ -75,10 +96,24 @@ class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<Modul
     private fun addSourceRoot(
         sourceRoot: File,
         type: JpsModuleSourceRootType<*>,
-        rootModel: ModifiableRootModel
+        rootModel: ModifiableRootModel,
+        shouldCreateEmptySourceRoots: Boolean
     ) {
         val parent = findParentContentEntry(sourceRoot, rootModel.contentEntries.stream()) ?: return
         val url = FilePaths.pathToIdeaUrl(sourceRoot)
         parent.addSourceFolder(url, type)
+        if (shouldCreateEmptySourceRoots) {
+            ExternalSystemApiUtil.doWriteAction {
+                try {
+                    VfsUtil.createDirectoryIfMissing(sourceRoot.path)
+                } catch (e: IOException) {
+                    LOG.warn(String.format("Unable to create directory for the path: %s", sourceRoot.path), e)
+                }
+            }
+        }
+    }
+
+    companion object {
+        private val LOG = Logger.getInstance(KotlinAndroidGradleMPPModuleDataService::class.java)
     }
 }

idea/idea-android/src/org/jetbrains/kotlin/android/configure/KotlinAndroidGradleMPPModuleDataService.kt.as31

@@ -8,6 +8,8 @@ package org.jetbrains.kotlin.android.configure
 import com.android.tools.idea.gradle.project.model.AndroidModuleModel
 import com.android.tools.idea.gradle.util.ContentEntries.findParentContentEntry
 import com.android.tools.idea.io.FilePaths
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.externalSystem.ExternalSystemModulePropertyManager
 import com.intellij.openapi.externalSystem.model.DataNode
 import com.intellij.openapi.externalSystem.model.ProjectKeys
 import com.intellij.openapi.externalSystem.model.project.ContentRootData
@@ -16,9 +18,12 @@ import com.intellij.openapi.externalSystem.model.project.ProjectData
 import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider
 import com.intellij.openapi.externalSystem.service.project.manage.AbstractProjectDataService
 import com.intellij.openapi.externalSystem.service.project.manage.ContentRootDataService
+import com.intellij.openapi.externalSystem.service.project.manage.ContentRootDataService.CREATE_EMPTY_DIRECTORIES
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
+import com.intellij.openapi.module.Module
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.ModifiableRootModel
+import com.intellij.openapi.vfs.VfsUtil
 import com.intellij.util.containers.stream
 import org.jetbrains.jps.model.java.JavaResourceRootType
 import org.jetbrains.jps.model.java.JavaSourceRootType
@@ -32,10 +37,25 @@ import org.jetbrains.kotlin.idea.configuration.kotlinAndroidSourceSets
 import org.jetbrains.plugins.gradle.model.data.GradleSourceSetData
 import org.jetbrains.kotlin.idea.facet.KotlinFacet
 import java.io.File
+import java.io.IOException
 
 class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<ModuleData, Void>() {
     override fun getTargetDataKey() = ProjectKeys.MODULE
 
+    private fun shouldCreateEmptySourceRoots(
+        moduleDataNode: DataNode<ModuleData>,
+        module: Module
+    ): Boolean {
+        val projectDataNode = ExternalSystemApiUtil.findParent(moduleDataNode, ProjectKeys.PROJECT) ?: return false
+        if (projectDataNode.getUserData<Boolean>(CREATE_EMPTY_DIRECTORIES) == true) return true
+
+        val projectSystemId = projectDataNode.data.owner
+        val externalSystemSettings = ExternalSystemApiUtil.getSettings(module.project, projectSystemId)
+
+        val path = ExternalSystemModulePropertyManager.getInstance(module).getRootProjectPath() ?: return false
+        return externalSystemSettings.getLinkedProjectSettings(path)?.isCreateEmptyContentRootDirectories ?: false
+    }
+
     override fun postProcess(
         toImport: MutableCollection<DataNode<ModuleData>>,
         projectData: ProjectData?,
@@ -55,6 +75,7 @@ class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<Modul
 
             val moduleData = nodeToImport.data
             val module = modelsProvider.findIdeModule(moduleData) ?: continue
+            val shouldCreateEmptySourceRoots = shouldCreateEmptySourceRoots(nodeToImport, module)
             val androidModel = AndroidModuleModel.get(module) ?: continue
             val variantName = androidModel.selectedVariant.name
             val sourceSetInfo = nodeToImport.kotlinAndroidSourceSets?.firstOrNull { it.kotlinModule.name == variantName } ?: continue
@@ -64,8 +85,8 @@ class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<Modul
                 if (sourceSet.platform == KotlinPlatform.ANDROID) {
                     val sourceType = if (sourceSet.isTestModule) JavaSourceRootType.TEST_SOURCE else JavaSourceRootType.SOURCE
                     val resourceType = if (sourceSet.isTestModule) JavaResourceRootType.TEST_RESOURCE else JavaResourceRootType.RESOURCE
-                    sourceSet.sourceDirs.forEach { addSourceRoot(it, sourceType, rootModel) }
+                    sourceSet.sourceDirs.forEach { addSourceRoot(it, sourceType, rootModel, shouldCreateEmptySourceRoots) }
-                    sourceSet.resourceDirs.forEach { addSourceRoot(it, resourceType, rootModel) }
+                    sourceSet.resourceDirs.forEach { addSourceRoot(it, resourceType, rootModel, shouldCreateEmptySourceRoots) }
                 } else {
                     val sourceSetId = sourceSetInfo.sourceSetIdsByName[sourceSet.name] ?: continue
                     val sourceSetData = ExternalSystemApiUtil.findFirstRecursively(projectNode) {
@@ -90,10 +111,24 @@ class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<Modul
     private fun addSourceRoot(
         sourceRoot: File,
         type: JpsModuleSourceRootType<*>,
-        rootModel: ModifiableRootModel
+        rootModel: ModifiableRootModel,
+        shouldCreateEmptySourceRoots: Boolean
     ) {
         val parent = findParentContentEntry(sourceRoot, rootModel.contentEntries.stream()) ?: return
         val url = FilePaths.pathToIdeaUrl(sourceRoot)
         parent.addSourceFolder(url, type)
+        if (shouldCreateEmptySourceRoots) {
+            ExternalSystemApiUtil.doWriteAction {
+                try {
+                    VfsUtil.createDirectoryIfMissing(sourceRoot.path)
+                } catch (e: IOException) {
+                    LOG.warn(String.format("Unable to create directory for the path: %s", sourceRoot.path), e)
+                }
+            }
+        }
+    }
+
+    companion object {
+        private val LOG = Logger.getInstance(KotlinAndroidGradleMPPModuleDataService::class.java)
     }
 }

idea/idea-android/src/org/jetbrains/kotlin/android/configure/KotlinAndroidGradleMPPModuleDataService.kt.as32

@@ -8,15 +8,20 @@ package org.jetbrains.kotlin.android.configure
 import com.android.tools.idea.gradle.project.model.AndroidModuleModel
 import com.android.tools.idea.gradle.util.ContentEntries.findParentContentEntry
 import com.android.tools.idea.io.FilePaths
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.externalSystem.ExternalSystemModulePropertyManager
 import com.intellij.openapi.externalSystem.model.DataNode
 import com.intellij.openapi.externalSystem.model.ProjectKeys
 import com.intellij.openapi.externalSystem.model.project.ModuleData
 import com.intellij.openapi.externalSystem.model.project.ProjectData
 import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider
 import com.intellij.openapi.externalSystem.service.project.manage.AbstractProjectDataService
+import com.intellij.openapi.externalSystem.service.project.manage.ContentRootDataService.CREATE_EMPTY_DIRECTORIES
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
+import com.intellij.openapi.module.Module
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.ModifiableRootModel
+import com.intellij.openapi.vfs.VfsUtil
 import com.intellij.util.containers.stream
 import org.jetbrains.jps.model.java.JavaResourceRootType
 import org.jetbrains.jps.model.java.JavaSourceRootType
@@ -28,10 +33,25 @@ import org.jetbrains.kotlin.idea.configuration.KotlinSourceSetDataService
 import org.jetbrains.kotlin.idea.configuration.kotlinAndroidSourceSets
 import org.jetbrains.kotlin.idea.facet.KotlinFacet
 import java.io.File
+import java.io.IOException
 
 class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<ModuleData, Void>() {
     override fun getTargetDataKey() = ProjectKeys.MODULE
 
+    private fun shouldCreateEmptySourceRoots(
+        moduleDataNode: DataNode<ModuleData>,
+        module: Module
+    ): Boolean {
+        val projectDataNode = ExternalSystemApiUtil.findParent(moduleDataNode, ProjectKeys.PROJECT) ?: return false
+        if (projectDataNode.getUserData<Boolean>(CREATE_EMPTY_DIRECTORIES) == true) return true
+
+        val projectSystemId = projectDataNode.data.owner
+        val externalSystemSettings = ExternalSystemApiUtil.getSettings(module.project, projectSystemId)
+
+        val path = ExternalSystemModulePropertyManager.getInstance(module).getRootProjectPath() ?: return false
+        return externalSystemSettings.getLinkedProjectSettings(path)?.isCreateEmptyContentRootDirectories ?: false
+    }
+
     override fun postProcess(
         toImport: MutableCollection<DataNode<ModuleData>>,
         projectData: ProjectData?,
@@ -42,6 +62,7 @@ class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<Modul
             val projectNode = ExternalSystemApiUtil.findParent(nodeToImport, ProjectKeys.PROJECT) ?: continue
             val moduleData = nodeToImport.data
             val module = modelsProvider.findIdeModule(moduleData) ?: continue
+            val shouldCreateEmptySourceRoots = shouldCreateEmptySourceRoots(nodeToImport, module)
             val androidModel = AndroidModuleModel.get(module) ?: continue
             val variantName = androidModel.selectedVariant.name
             val sourceSetInfo = nodeToImport.kotlinAndroidSourceSets?.firstOrNull { it.kotlinModule.name == variantName } ?: continue
@@ -51,8 +72,8 @@ class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<Modul
                 if (sourceSet.platform == KotlinPlatform.ANDROID) {
                     val sourceType = if (sourceSet.isTestModule) JavaSourceRootType.TEST_SOURCE else JavaSourceRootType.SOURCE
                     val resourceType = if (sourceSet.isTestModule) JavaResourceRootType.TEST_RESOURCE else JavaResourceRootType.RESOURCE
-                    sourceSet.sourceDirs.forEach { addSourceRoot(it, sourceType, rootModel) }
+                    sourceSet.sourceDirs.forEach { addSourceRoot(it, sourceType, rootModel, shouldCreateEmptySourceRoots) }
-                    sourceSet.resourceDirs.forEach { addSourceRoot(it, resourceType, rootModel) }
+                    sourceSet.resourceDirs.forEach { addSourceRoot(it, resourceType, rootModel, shouldCreateEmptySourceRoots) }
                 } else {
                     val sourceSetId = sourceSetInfo.sourceSetIdsByName[sourceSet.name] ?: continue
                     val sourceSetData = ExternalSystemApiUtil.findFirstRecursively(projectNode) {
@@ -75,10 +96,24 @@ class KotlinAndroidGradleMPPModuleDataService : AbstractProjectDataService<Modul
     private fun addSourceRoot(
         sourceRoot: File,
         type: JpsModuleSourceRootType<*>,
-        rootModel: ModifiableRootModel
+        rootModel: ModifiableRootModel,
+        shouldCreateEmptySourceRoots: Boolean
     ) {
         val parent = findParentContentEntry(sourceRoot, rootModel.contentEntries.stream()) ?: return
         val url = FilePaths.pathToIdeaUrl(sourceRoot)
         parent.addSourceFolder(url, type)
+        if (shouldCreateEmptySourceRoots) {
+            ExternalSystemApiUtil.doWriteAction {
+                try {
+                    VfsUtil.createDirectoryIfMissing(sourceRoot.path)
+                } catch (e: IOException) {
+                    LOG.warn(String.format("Unable to create directory for the path: %s", sourceRoot.path), e)
+                }
+            }
+        }
+    }
+
+    companion object {
+        private val LOG = Logger.getInstance(KotlinAndroidGradleMPPModuleDataService::class.java)
     }
 }