feat(mps-model-adapters): handle root nodes and free-floating nodes in MPSNode.replaceNode

Author: Oleksandr Dzhychko

mps-model-adapters-plugin/src/test/kotlin/org/modelix/model/mpsadapters/ReplaceNodeTest.kt

@@ -1,14 +1,23 @@
 package org.modelix.model.mpsadapters
 
+import jetbrains.mps.smodel.SNode
+import jetbrains.mps.smodel.adapter.MetaAdapterByDeclaration
 import org.modelix.model.api.BuiltinLanguages
 import org.modelix.model.api.ConceptReference
+import org.modelix.model.api.INode
 import org.modelix.model.api.IReplaceableNode
 
 class ReplaceNodeTest : MpsAdaptersTestBase("SimpleProject") {
 
-    fun `test replace node`() = runCommandOnEDT {
+    private val sampleConcept = MetaAdapterByDeclaration.asInstanceConcept(
+        MPSConcept.tryParseUID(BuiltinLanguages.jetbrains_mps_lang_core.BaseConcept.getUID())!!.concept,
+    )
+
+    fun `test replace node with parent and module (aka regular node)`() = runCommandOnEDT {
         val rootNode = getRootUnderTest()
         val nodeToReplace = rootNode.allChildren.first() as IReplaceableNode
+        val oldContainmentLink = nodeToReplace.getContainmentLink()
+        val nodesToKeep = rootNode.allChildren.drop(1)
         val oldProperties = nodeToReplace.getAllProperties().toSet()
         check(oldProperties.isNotEmpty()) { "Test should replace node with properties." }
         val oldReferences = nodeToReplace.getAllReferenceTargetRefs().toSet()
@@ -19,25 +28,62 @@ class ReplaceNodeTest : MpsAdaptersTestBase("SimpleProject") {
 
         val newNode = nodeToReplace.replaceNode(newConcept)
 
+        assertEquals(listOf(newNode) + nodesToKeep, rootNode.allChildren.toList())
+        assertEquals((nodeToReplace as MPSNode).node.nodeId, (newNode as MPSNode).node.nodeId)
+        assertEquals(oldContainmentLink, newNode.getContainmentLink())
+        assertEquals(newConcept, newNode.getConceptReference())
         assertEquals(oldProperties, newNode.getAllProperties().toSet())
         assertEquals(oldReferences, newNode.getAllReferenceTargetRefs().toSet())
         assertEquals(oldChildren, newNode.allChildren.toList())
-        assertEquals(newConcept, newNode.getConceptReference())
     }
 
-    fun `test fail to replace node without parent`() = runCommandOnEDT {
+    fun `test replace node without parent but with module (aka root node)`() = runCommandOnEDT {
         val rootNode = getRootUnderTest()
-        val oldChildren = rootNode.allChildren.toList()
-        check(oldChildren.isNotEmpty()) { "Test should replace node with children." }
+        val oldContainmentLink = rootNode.getContainmentLink()
+        val model = getModelUnderTest()
+        val newConcept = ConceptReference("mps:f3061a53-9226-4cc5-a443-f952ceaf5816/1083245097125")
 
-        val newConcept = ConceptReference(BuiltinLanguages.jetbrains_mps_lang_core.BaseConcept.getUID())
+        val newNode = rootNode.replaceNode(newConcept)
 
-        val expectedMessage = "Cannot replace node `Class1` because it has no parent."
-        assertThrows(IllegalArgumentException::class.java, expectedMessage) {
-            rootNode.replaceNode(newConcept)
-        }
-        // Assert that precondition is check before children are deleted.
-        assertEquals(oldChildren, rootNode.allChildren.toList())
+        assertEquals(listOf(newNode), model.getChildren(BuiltinLanguages.MPSRepositoryConcepts.Model.rootNodes))
+        assertEquals((rootNode as MPSNode).node.nodeId, (newNode as MPSNode).node.nodeId)
+        assertEquals(oldContainmentLink, newNode.getContainmentLink())
+        assertEquals(newConcept, newNode.getConceptReference())
+    }
+
+    fun `test replace node without parent and without module (aka free-floating node)`() = runCommandOnEDT {
+        val untouchedRootNode = getRootUnderTest()
+        val model = getModelUnderTest()
+        val freeFloatingSNode = SNode(sampleConcept)
+        val freeFloatingNode = MPSNode(freeFloatingSNode)
+        val oldContainmentLink = freeFloatingNode.getContainmentLink()
+        val newConcept = ConceptReference("mps:f3061a53-9226-4cc5-a443-f952ceaf5816/1083245097125")
+
+        val newNode = freeFloatingNode.replaceNode(newConcept)
+
+        assertEquals(listOf(untouchedRootNode), model.getChildren(BuiltinLanguages.MPSRepositoryConcepts.Model.rootNodes))
+        assertEquals(freeFloatingNode.node.nodeId, (newNode as MPSNode).node.nodeId)
+        assertEquals(oldContainmentLink, newNode.getContainmentLink())
+        assertEquals(newConcept, newNode.getConceptReference())
+    }
+
+    fun `test replace node with parent but without module (aka descendant of free-floating node)`() = runCommandOnEDT {
+        val freeFloatingSNode = SNode(sampleConcept)
+        val freeFloatingNode = MPSNode(freeFloatingSNode)
+        val nodeToReplace = freeFloatingNode.addNewChild(
+            BuiltinLanguages.MPSRepositoryConcepts.Model.usedLanguages,
+            -1,
+            BuiltinLanguages.jetbrains_mps_lang_core.BaseConcept,
+        ) as IReplaceableNode
+        val oldContainmentLink = nodeToReplace.getContainmentLink()
+        val newConcept = ConceptReference("mps:f3061a53-9226-4cc5-a443-f952ceaf5816/1083245097125")
+
+        val newNode = nodeToReplace.replaceNode(newConcept)
+
+        assertEquals(listOf(newNode), freeFloatingNode.allChildren.toList())
+        assertEquals((nodeToReplace as MPSNode).node.nodeId, (newNode as MPSNode).node.nodeId)
+        assertEquals(oldContainmentLink, newNode.getContainmentLink())
+        assertEquals(newConcept, newNode.getConceptReference())
     }
 
     fun `test fail to replace node with null concept`() = runCommandOnEDT {
@@ -61,11 +107,13 @@ class ReplaceNodeTest : MpsAdaptersTestBase("SimpleProject") {
         }
     }
 
-    private fun getRootUnderTest(): IReplaceableNode {
+    private fun getModelUnderTest(): INode {
         val repositoryNode = MPSRepositoryAsNode(mpsProject.repository)
         val module = repositoryNode.getChildren(BuiltinLanguages.MPSRepositoryConcepts.Repository.modules)
             .single { it.getPropertyValue(BuiltinLanguages.jetbrains_mps_lang_core.INamedConcept.name) == "Solution1" }
-        val model = module.getChildren(BuiltinLanguages.MPSRepositoryConcepts.Module.models).single()
-        return model.getChildren(BuiltinLanguages.MPSRepositoryConcepts.Model.rootNodes).single() as IReplaceableNode
+        return module.getChildren(BuiltinLanguages.MPSRepositoryConcepts.Module.models).single()
     }
+
+    private fun getRootUnderTest(): IReplaceableNode = getModelUnderTest()
+        .getChildren(BuiltinLanguages.MPSRepositoryConcepts.Model.rootNodes).single() as IReplaceableNode
 }

mps-model-adapters/src/main/kotlin/org/modelix/model/mpsadapters/MPSNode.kt

@@ -61,15 +61,31 @@ data class MPSNode(val node: SNode) : IDefaultNodeAdapter, IReplaceableNode {
 
     override fun replaceNode(concept: ConceptReference?): INode {
         requireNotNull(concept) { "Cannot replace node `$node` with a null concept. Explicitly specify a concept (e.g., `BaseConcept`)." }
-        val parent = requireNotNull(node.parent) { "Cannot replace node `$node` because it has no parent." }
-
         val mpsConcept = MPSConcept.tryParseUID(concept.uid)
         requireNotNull(mpsConcept) { "Concept UID `${concept.uid}` cannot be parsed as MPS concept." }
         val sConcept = MetaAdapterByDeclaration.asInstanceConcept(mpsConcept.concept)
 
-        val id = node.nodeId
-        val model = checkNotNull(node.model) { "Node is not part of a model" }
-        val newNode = model.createNode(sConcept, id)
+        val maybeModel = node.model
+        val maybeParent = node.parent
+        val containmentLink = getMPSContainmentLink(getContainmentLink())
+        val maybeNextSibling = node.nextSibling
+        // The existing node needs to be deleted before the replacing node is created,
+        // because `SModel.createNode` will not use the provided ID if it already exists.
+        node.delete()
+
+        val newNode = if (maybeModel != null) {
+            maybeModel.createNode(sConcept, node.nodeId)
+        } else {
+            jetbrains.mps.smodel.SNode(sConcept, node.nodeId)
+        }
+
+        if (maybeParent != null) {
+            // When `maybeNextSibling` is `null`, `replacingNode` is inserted as a last child.
+            maybeParent.insertChildBefore(containmentLink, newNode, maybeNextSibling)
+        } else if (maybeModel != null) {
+            maybeModel.addRootNode(newNode)
+        }
+
         node.properties.forEach { newNode.setProperty(it, node.getProperty(it)) }
         node.references.forEach { newNode.setReference(it.link, it.targetNodeReference) }
         node.children.forEach { child ->
@@ -78,8 +94,6 @@ data class MPSNode(val node: SNode) : IDefaultNodeAdapter, IReplaceableNode {
             newNode.addChild(link, child)
         }
 
-        parent.insertChildBefore(getMPSContainmentLink(getContainmentLink()), newNode, node)
-        node.delete()
         return MPSNode(newNode)
     }