modules tree: fixed condition for recreating module nodes.

Don't recreate module node if it was under root and its parent group wasn't changed. Do recreate module node if it was a parent node for other modules and its name was changed.

platform/lang-impl/src/com/intellij/ide/projectView/impl/ModuleGroupingTreeHelper.kt

@@ -104,17 +104,16 @@ class ModuleGroupingTreeHelper<N: MutableTreeNode> private constructor(
    * If [bulkOperation] is true, no events will be fired and new node will be added into arbitrary place in the children list
    */
   private fun insertModuleNode(moduleNode: N, parentNode: N, module: Module, model: DefaultTreeModel, bulkOperation: Boolean) {
-    val moduleAsGroup = grouper.getModuleAsGroupPath(module)
+    val moduleAsGroup = moduleAsGroup(module)
     if (moduleAsGroup != null) {
-      val moduleGroup = ModuleGroup(moduleAsGroup)
-      val oldModuleGroupNode = nodeForGroup[moduleGroup]
+      val oldModuleGroupNode = nodeForGroup[moduleAsGroup]
       if (oldModuleGroupNode != null) {
         moveChildren(oldModuleGroupNode, moduleNode, model)
         model.removeNodeFromParent(oldModuleGroupNode)
         removeNode(oldModuleGroupNode)
       }
-      nodeForGroup[moduleGroup] = moduleNode
-      nodeData[moduleNode] = ModuleTreeNodeData(module, moduleGroup)
+      nodeForGroup[moduleAsGroup] = moduleNode
+      nodeData[moduleNode] = ModuleTreeNodeData(module, moduleAsGroup)
     }
     else {
       nodeData[moduleNode] = ModuleTreeNodeData(module, null)
@@ -123,6 +122,8 @@ class ModuleGroupingTreeHelper<N: MutableTreeNode> private constructor(
     insertNode(moduleNode, parentNode, model, bulkOperation)
   }
 
+  private fun moduleAsGroup(module: Module) = grouper.getModuleAsGroupPath(module)?.let(::ModuleGroup)
+
   private fun moveChildren(fromNode: N, toNode: N, model: DefaultTreeModel) {
     val children = TreeUtil.listChildren(fromNode)
     moveChildren(children, toNode, model)
@@ -182,14 +183,16 @@ class ModuleGroupingTreeHelper<N: MutableTreeNode> private constructor(
   fun moveModuleNodeToProperGroup(node: N, module: Module, rootNode: N, model: DefaultTreeModel, tree: JTree): N {
     val actualGroup = ModuleGroup(grouper.getGroupPath(module))
     val parent = node.parent
-    val expectedParent = if (groupingEnabled) nodeForGroup[actualGroup] else rootNode
-    if (expectedParent == parent) return node
+    val nodeAsGroup = nodeData[node]?.group
+    val expectedParent = if (groupingEnabled && !actualGroup.groupPathList.isEmpty()) nodeForGroup[actualGroup] else rootNode
+    if (expectedParent == parent && nodeAsGroup == moduleAsGroup(module)) {
+      return node
+    }
 
     val selectionPath = tree.selectionPath
     val wasSelected = selectionPath?.lastPathComponent == node
     model.removeNodeFromParent(node)
 
-    val nodeAsGroup = nodeData[node]?.group
     removeNode(node)
     if (nodeAsGroup != null) {
       val childrenToKeep = TreeUtil.listChildren(node).filter { it in nodeData }

platform/lang-impl/testSources/com/intellij/ide/projectView/ModuleGroupingTreeHelperTest.kt

@@ -181,6 +181,14 @@ class ModuleGroupingTreeHelperTest: PlatformTestCase() {
              b""")
   }
 
+  fun `test do not move node if its group wasn't changed`() {
+    val nodes = createHelper().createModuleNodes("a", "a.main")
+    nodes.forEach {
+      val newNode = createHelperFromTree().moveModuleNodeToProperGroup(it.first, it.second, root, model, tree)
+      assertSame(it.first, newNode)
+    }
+  }
+
   private fun moveModuleNodeToProperGroupAndCheckResult(node: Pair<MockModuleTreeNode, Module>,
                                                         expected: String) {
     val helper = createHelperFromTree()