[workspace model] Add rename dependency if module name changes

GitOrigin-RevId: bd7680c68806c9743df49a48b0d8e136a07a4860

platform/workspaceModel-ide-tests/testSrc/com/intellij/workspace/jps/LegacyBridgeModulesTest.kt

@@ -158,6 +158,60 @@ class LegacyBridgeModulesTest {
       assertTrue(newNameFile.exists())
     }
 
+  @Test
+  fun `test rename module and all dependencies in other modules`() =
+    WriteCommandAction.runWriteCommandAction(project) {
+      val checkModuleDependency = { moduleName: String, dependencyModuleName: String ->
+        assertNotNull(WorkspaceModel.getInstance(project).entityStore.current.entities(ModuleEntity::class.java)
+                        .first { it.persistentId().name == moduleName }.dependencies
+                        .find { it is ModuleDependencyItem.Exportable.ModuleDependency && it.module.name == dependencyModuleName })
+      }
+
+      val antModuleName = "ant"
+      val mavenModuleName = "maven"
+      val gradleModuleName = "gradle"
+      val moduleManager = ModuleManager.getInstance(project)
+
+      val iprFile = File(project.projectFilePath!!)
+      val antModuleFile = File(project.basePath, "$antModuleName.iml")
+      val mavenModuleFile = File(project.basePath, "$mavenModuleName.iml")
+      val gradleModuleFile = File(project.basePath, "$gradleModuleName.iml")
+
+      val (antModule, mavenModule) = moduleManager.modifiableModel.let { model ->
+        val antModule = model.newModule(antModuleFile.path, ModuleType.EMPTY.id)
+        val mavenModule = model.newModule(mavenModuleFile.path, ModuleType.EMPTY.id)
+        model.commit()
+        Pair(antModule, mavenModule)
+      }
+      ModuleRootModificationUtil.addDependency(mavenModule, antModule)
+      checkModuleDependency(mavenModuleName, antModuleName)
+
+      StoreUtil.saveDocumentsAndProjectSettings(project)
+      var fileText = iprFile.readText()
+      assertEquals(2, listOf(antModuleName, mavenModuleName).filter { fileText.contains(it) }.size)
+
+      assertTrue(antModuleFile.exists())
+      assertTrue(mavenModuleFile.exists())
+      assertTrue(mavenModuleFile.readText().contains(antModuleName))
+
+      moduleManager.modifiableModel.let { model ->
+        model.renameModule(antModule, gradleModuleName)
+        model.commit()
+      }
+      checkModuleDependency(mavenModuleName, gradleModuleName)
+
+      StoreUtil.saveDocumentsAndProjectSettings(project)
+      fileText = iprFile.readText()
+      assertEquals(2, listOf(mavenModuleName, gradleModuleName).filter { fileText.contains(it) }.size)
+
+      assertFalse(antModuleFile.exists())
+      assertTrue(gradleModuleFile.exists())
+      assertTrue(mavenModuleFile.exists())
+      fileText = mavenModuleFile.readText()
+      assertFalse(fileText.contains(antModuleName))
+      assertFalse(fileText.contains(antModuleName))
+    }
+
   @Test
   fun `test remove and add module with the same name`() =
     WriteCommandAction.runWriteCommandAction(project) {

platform/workspaceModel-ide/src/com/intellij/workspace/legacyBridge/intellij/LegacyBridgeModifiableModuleModel.kt

@@ -161,19 +161,49 @@ internal class LegacyBridgeModifiableModuleModel(
 
     moduleManager.setNewModuleInstances(myModulesToAdd.values.toList())
 
+    val changedModuleIdsMap = mutableMapOf<ModuleId, ModuleId>()
     for (entry in myNewNameToModule.entries) {
       val entity = storage.resolve(entry.value.moduleEntityId) ?:
         error("Unable to resolve module by id: ${entry.value.moduleEntityId}")
       diff.modifyEntity(ModifiableModuleEntity::class.java, entity) {
         name = entry.key
+        changedModuleIdsMap[entry.value.moduleEntityId] = this.persistentId()
       }
     }
+    updateModuleDependencyIfNeeded(changedModuleIdsMap)
 
     WorkspaceModel.getInstance(project).updateProjectModel {
       it.addDiff(diff)
     }
   }
 
+  private fun updateModuleDependencyIfNeeded(changedModulesIdMap: Map<ModuleId, ModuleId>) {
+    if (changedModulesIdMap.isEmpty()) return
+
+    // Walkthrough the whole modules and update dependencies for them
+    entityStoreOnDiff.current.entities(ModuleEntity::class.java).forEach { moduleEntity ->
+      var containsOldDependency = false
+      val newDependencies = moduleEntity.dependencies.map {
+        when(it) {
+          is ModuleDependencyItem.Exportable.ModuleDependency -> {
+            val newModuleId = changedModulesIdMap[it.module]
+            if (newModuleId != null) {
+              containsOldDependency = true
+              it.copy(module = newModuleId)
+            } else it
+          }
+          else -> it
+        }
+      }
+
+      if (containsOldDependency) {
+        diff.modifyEntity(ModifiableModuleEntity::class.java, moduleEntity) {
+          dependencies = newDependencies
+        }
+      }
+    }
+  }
+
   override fun renameModule(module: Module, newName: String) {
     module as LegacyBridgeModule