fix(mps-model-adapters): references to non-existing project modules were still resolvable

A project contains a list of references to modules it contains.
If the target module exists but isn't registered in the project,
an `MPSProjectModuleReference` was still resolved to an `MPSProjectAsNode`.

Author: slisson

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

@@ -7,6 +7,7 @@ import jetbrains.mps.smodel.ModelImports
 import org.jetbrains.mps.openapi.model.SNodeReference
 import org.jetbrains.mps.openapi.module.SRepository
 import org.jetbrains.mps.openapi.persistence.PersistenceFacade
+import org.modelix.model.api.BuiltinLanguages
 import org.modelix.model.api.ChildLinkReferenceByUID
 import org.modelix.model.api.IBranch
 import org.modelix.model.api.IConcept
@@ -264,48 +265,19 @@ data class MPSArea(val repository: SRepository) : IArea, IAreaReference {
     }
 
     private fun resolveMPSProjectReference(ref: INodeReference): MPSProjectAsNode? {
-        val projectName = (MPSProjectReference.tryConvert(ref) ?: return null).projectName
-
-        val project = MPSProjectAsNode.getContextProjects().find { it.getName() == projectName }
-
-        return project?.let { MPSProjectAsNode(it) }
+        return MPSRepositoryAsNode(repository)
+            .getChildren(BuiltinLanguages.MPSRepositoryConcepts.Repository.projects.toReference())
+            .find { it.getNodeReference() == ref }
+            ?.let { it as MPSProjectAsNode }
     }
 
     private fun resolveMPSProjectModuleReference(ref: INodeReference): MPSProjectModuleAsNode? {
-        val serialized = ref.serialize()
-        val moduleRef = if (ref is MPSProjectModuleReference) {
-            ref.moduleRef
-        } else {
-            val serializedModuleRef = serialized
-                .substringAfter("${MPSProjectModuleReference.PREFIX}:")
-                .substringBefore(MPSProjectModuleReference.SEPARATOR)
-            MPSReferenceParser.parseSModuleReference(serializedModuleRef)
-        }
-
-        val projectRef = if (ref is MPSProjectModuleReference) {
-            ref.projectRef
-        } else {
-            // XXX Prefix of `projectRef` is not checked.
-            // `projectRef` might actually be a ref to anything.
-            // This might trigger unexpected resolution results and undefined behavior.
-            // Similar missing checks exist for other references in `MPSArea`.
-            // See https://issues.modelix.org/issue/MODELIX-923
-            val projectRef = serialized.substringAfter(MPSProjectModuleReference.SEPARATOR)
-            NodeReference(projectRef)
-        }
-
-        val resolvedNodeForProject = resolveNode(projectRef)?.asWritableNode() ?: return null
-        check(resolvedNodeForProject is MPSProjectAsNode) {
-            "Resolved node `$resolvedNodeForProject` does not represent a project."
-        }
-        val resolvedProject = resolvedNodeForProject.project
-
-        return moduleRef.resolve(repository)?.let {
-            MPSProjectModuleAsNode(
-                project = resolvedProject,
-                module = it,
-            )
-        }
+        val ref = MPSProjectModuleReference.tryConvert(ref) ?: return null
+        val project = resolveNode(ref.projectRef)?.asWritableNode() ?: return null
+        return project
+            .getChildren(BuiltinLanguages.MPSRepositoryConcepts.Project.projectModules.toReference())
+            .find { it.getNodeReference() == ref }
+            ?.let { it as MPSProjectModuleAsNode }
     }
 
     private fun resolveMPSSingleLanguageDependencyReference(ref: INodeReference): MPSSingleLanguageDependencyAsNode? {

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

@@ -11,6 +11,7 @@ import org.modelix.model.api.IPropertyReference
 import org.modelix.model.api.IReferenceLinkReference
 import org.modelix.model.api.IWritableNode
 import org.modelix.mps.api.ModelixMpsApi
+import org.modelix.mps.multiplatform.model.MPSModuleReference
 
 data class MPSProjectAsNode(val project: IMPSProject) : MPSGenericNodeAdapter<IMPSProject>() {
 
@@ -74,13 +75,18 @@ data class MPSProjectAsNode(val project: IMPSProject) : MPSGenericNodeAdapter<IM
                 }
 
                 override fun addNew(element: IMPSProject, index: Int, sourceNode: SpecWithResolvedConcept): IWritableNode {
-                    val targetModule = requireNotNull(sourceNode.getNode().getReferenceTarget(BuiltinLanguages.MPSRepositoryConcepts.ModuleReference.module.toReference())) {
+                    val targetModuleRef = requireNotNull(sourceNode.getNode().getReferenceTargetRef(BuiltinLanguages.MPSRepositoryConcepts.ModuleReference.module.toReference())) {
                         "Reference to module isn't set"
                     }
-                    val targetName = targetModule.getPropertyValue(BuiltinLanguages.jetbrains_mps_lang_core.INamedConcept.name.toReference())
-                    val targetId = requireNotNull(targetModule.getPropertyValue(BuiltinLanguages.MPSRepositoryConcepts.Module.id.toReference())) {
-                        "Module ID isn't set: $targetModule"
-                    }.let { ModuleId.fromString(it) }
+                    val mpsTargetModuleRef = requireNotNull(MPSModuleReference.tryConvert(targetModuleRef)) {
+                        "Not an MPS module reference: $targetModuleRef"
+                    }
+                    val targetModule = sourceNode.getNode().getReferenceTarget(BuiltinLanguages.MPSRepositoryConcepts.ModuleReference.module.toReference())
+                    val targetName = targetModule?.getPropertyValue(BuiltinLanguages.jetbrains_mps_lang_core.INamedConcept.name.toReference())
+                    val targetId = (
+                        targetModule?.getPropertyValue(BuiltinLanguages.MPSRepositoryConcepts.Module.id.toReference())
+                            ?: mpsTargetModuleRef.moduleId
+                        ).let { ModuleId.fromString(it) }
                     val ref = PersistenceFacade.getInstance().createModuleReference(targetId, targetName)
                     val resolvedModule = checkNotNull(ref.resolve(element.getRepository())) { "Module not found: $ref" }
                     element.addModule(resolvedModule)

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

@@ -9,6 +9,7 @@ import org.jetbrains.mps.openapi.module.SModuleId
 import org.jetbrains.mps.openapi.module.SModuleReference
 import org.jetbrains.mps.openapi.persistence.PersistenceFacade
 import org.modelix.model.api.INodeReference
+import org.modelix.model.api.NodeReference
 import org.modelix.mps.multiplatform.model.MPSModelReference
 import org.modelix.mps.multiplatform.model.MPSModuleReference
 import org.modelix.mps.multiplatform.model.MPSNodeReference
@@ -142,7 +143,22 @@ data class MPSProjectModuleReference(val moduleRef: SModuleReference, val projec
 
     companion object {
         internal const val PREFIX = "mps-project-module"
+        internal const val PREFIX_COLON = "$PREFIX:"
         internal const val SEPARATOR = "#IN#"
+
+        fun tryConvert(ref: INodeReference): MPSProjectModuleReference? {
+            if (ref is MPSProjectModuleReference) return ref
+            val serialized = ref.serialize()
+            if (!serialized.startsWith(PREFIX_COLON)) return null
+            val moduleRef = serialized
+                .substringAfter(PREFIX_COLON)
+                .substringBefore(SEPARATOR)
+                .let { MPSReferenceParser.parseSModuleReference(it) }
+            val projectRef = NodeReference(serialized.substringAfter(SEPARATOR))
+                .let { MPSProjectReference.tryConvert(it) }
+                .let { requireNotNull(it) { "Invalid project reference: $it" } }
+            return MPSProjectModuleReference(moduleRef, projectRef)
+        }
     }
 
     override fun serialize(): String {