Merge pull request #643 from modelix/feature/modelix-832

MODELIX-832: MPSLanguageRepository returns "unknown" Concept for unknown concepts

Author: slisson

bulk-model-sync-lib/src/commonMain/kotlin/org/modelix/model/sync/bulk/ModelImporter.kt

@@ -252,7 +252,7 @@ class ModelImporter(
                 } else {
                     nodeAtIndex
                 }
-                check(childNode.getConceptReference() == expectedConcept) { "Unexpected concept change" }
+                check(childNode.getConceptReference() == expectedConcept) { "Unexpected concept change from $expectedConcept to ${childNode.getConceptReference()}" }
 
                 syncNode(childNode, expected, progressReporter)
             }

model-api/src/commonMain/kotlin/org/modelix/model/api/INode.kt

@@ -121,7 +121,11 @@ interface INode {
     }
 
     fun addNewChildren(role: String?, index: Int, concepts: List<IConceptReference?>): List<INode> {
-        return concepts.map { addNewChild(role, index, it) }
+        return concepts.mapIndexed { i, it -> addNewChild(role, if (index >= 0) index + i else index, it) }
+    }
+
+    fun addNewChildren(link: IChildLink, index: Int, concepts: List<IConceptReference?>): List<INode> {
+        return concepts.mapIndexed { i, it -> addNewChild(link, if (index >= 0) index + i else index, it) }
     }
 
     /**

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

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2024.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.modelix.model.mpsadapters
+
+import org.modelix.model.api.BuiltinLanguages
+import org.modelix.model.api.ConceptReference
+import org.modelix.model.api.ILanguageRepository
+
+class ConceptResolutionTest : MpsAdaptersTestBase("SimpleProject") {
+
+    fun `test resolution of Module concept`() {
+        val conceptUID = BuiltinLanguages.MPSRepositoryConcepts.Module.getReference().getUID()
+        val moduleConcept = ILanguageRepository.resolveConcept(ConceptReference(conceptUID))
+
+        // There was an issue where MPSLanguageRepository resolved a concept even though it wasn't loaded and no
+        // metamodel information was available. If a concept can be resolved then it should provide more information
+        // than just the ID that it extracted from the concept reference.
+        assertEquals("Module", moduleConcept.getShortName())
+        assertContainsElements(moduleConcept.getOwnChildLinks().map { it.getSimpleName() }, "models")
+    }
+
+    fun `test MPSLanguageRepository cannot resolve the Module concept`() {
+        val conceptUID = BuiltinLanguages.MPSRepositoryConcepts.Module.getReference().getUID()
+        val moduleConcept = MPSLanguageRepository(mpsProject.repository).resolveConcept(conceptUID)
+
+        // After making the repository language part of this plugin, this assertion will fail and this test can just be removed.
+        assertNull(moduleConcept)
+    }
+}

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

@@ -42,7 +42,7 @@ data class MPSConcept(val concept: SAbstractConceptAdapter) : IConcept {
             is SInterfaceConceptAdapterById -> concept.id
             else -> error("Unknown concept type: $concept")
         }
-        return "mps:" + id.serialize()
+        return UID_PREFIX + id.serialize()
     }
 
     override fun getShortName(): String {
@@ -118,4 +118,18 @@ data class MPSConcept(val concept: SAbstractConceptAdapter) : IConcept {
             else -> null
         }
     }
+
+    companion object {
+        private const val UID_PREFIX = "mps:"
+
+        fun tryParseUID(uid: String): MPSConcept? {
+            if (!uid.startsWith(UID_PREFIX)) return null
+            val conceptId = SConceptId.deserialize(uid.substringAfter(UID_PREFIX))
+
+            // For interface concepts `SInterfaceConceptAdapterById(conceptId, "")` would be correct, but we don't have
+            // that information. Assuming that this concept is used to create new nodes SConceptAdapterById is the
+            // better default.
+            return MPSConcept(SConceptAdapterById(conceptId, ""))
+        }
+    }
 }

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

@@ -20,6 +20,7 @@ import jetbrains.mps.smodel.adapter.ids.SConceptId
 import jetbrains.mps.smodel.adapter.structure.MetaAdapterFactory
 import jetbrains.mps.smodel.language.ConceptRegistry
 import jetbrains.mps.smodel.language.LanguageRegistry
+import jetbrains.mps.smodel.runtime.illegal.IllegalConceptDescriptor
 import org.jetbrains.mps.openapi.language.SAbstractConcept
 import org.jetbrains.mps.openapi.module.SRepository
 import org.modelix.model.api.IConcept
@@ -38,6 +39,8 @@ data class MPSLanguageRepository(private val repository: SRepository) : ILanguag
 
         val conceptDescriptor = ConceptRegistry.getInstance().getConceptDescriptor(conceptId)
 
+        if (conceptDescriptor is IllegalConceptDescriptor) return null
+
         return MPSConcept(MetaAdapterFactory.getAbstractConcept(conceptDescriptor))
     }
 

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

@@ -145,10 +145,41 @@ data class MPSNode(val node: SNode) : IDefaultNodeAdapter {
 
     override fun addNewChild(role: IChildLink, index: Int, concept: IConceptReference?): INode {
         val repo = checkNotNull(node.model?.repository)
-        val targetConcept = concept?.let { MPSLanguageRepository(repo).resolveConcept(it.getUID()) }
+        val targetConcept = concept?.let {
+            MPSLanguageRepository(repo).resolveConcept(it.getUID())
+                ?: MPSConcept.tryParseUID(it.getUID())
+        }
+
+        // A null value for the concept would default to BaseConcept, but then BaseConcept should be used explicitly.
+        checkNotNull(targetConcept) { "MPS concept not found: $concept" }
+
         return addNewChild(role, index, targetConcept)
     }
 
+    override fun addNewChildren(role: String?, index: Int, concepts: List<IConceptReference?>): List<INode> {
+        requireNotNull(role) { "containment link required" }
+        val link = MPSChildLink(getMPSContainmentLink(role))
+        return addNewChildren(link, index, concepts)
+    }
+
+    override fun addNewChildren(link: IChildLink, index: Int, concepts: List<IConceptReference?>): List<INode> {
+        return concepts.mapIndexed { i, it -> addNewChild(link, if (index >= 0) index + i else index, it) }
+    }
+
+    @Deprecated("use IChildLink instead of String")
+    override fun addNewChild(role: String?, index: Int, concept: IConcept?): INode {
+        requireNotNull(role) { "containment link required" }
+        val link = MPSChildLink(getMPSContainmentLink(role))
+        return addNewChild(link, index, concept)
+    }
+
+    @Deprecated("use IChildLink instead of String")
+    override fun addNewChild(role: String?, index: Int, concept: IConceptReference?): INode {
+        requireNotNull(role) { "containment link required" }
+        val link = MPSChildLink(getMPSContainmentLink(role))
+        return addNewChild(link, index, concept)
+    }
+
     override fun getReferenceTarget(link: IReferenceLink): INode? {
         if (link is MPSReferenceLink) {
             DependencyTracking.accessed(MPSReferenceDependency(node, link.link))
@@ -207,7 +238,11 @@ data class MPSNode(val node: SNode) : IDefaultNodeAdapter {
 
     private fun getMPSContainmentLink(childLink: IChildLink): SContainmentLink = when (childLink) {
         is MPSChildLink -> childLink.link
-        else -> node.concept.containmentLinks.find { MPSChildLink(it).getUID() == childLink.getUID() }
-            ?: SContainmentLinkAdapterById(SContainmentLinkId.deserialize(childLink.getUID()), "")
+        else -> getMPSContainmentLink(childLink.getUID())
+    }
+
+    private fun getMPSContainmentLink(uid: String): SContainmentLink {
+        return node.concept.containmentLinks.find { MPSChildLink(it).getUID() == uid }
+            ?: SContainmentLinkAdapterById(SContainmentLinkId.deserialize(uid), "")
     }
 }