feat(mps-model-adapters): add references and their serialization logic

Author: mhuster23

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

@@ -40,7 +40,11 @@ data class MPSDevKitDependencyAsNode(
     }
 
     override val reference: INodeReference
-        get() = MPSModuleReference(moduleReference)
+        get() = MPSDevKitDependencyReference(
+            moduleReference.moduleId,
+            userModule = moduleImporter?.moduleReference,
+            userModel = modelImporter?.reference,
+        )
     override val concept: IConcept
         get() = BuiltinLanguages.MPSRepositoryConcepts.DevkitDependency
     override val parent: INode

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

@@ -34,7 +34,10 @@ data class MPSJavaModuleFacetAsNode(val facet: JavaModuleFacet) : IDefaultNodeAd
     }
 
     override val reference: INodeReference
-        get() = TODO("Not yet implemented")
+        get() {
+            val module = checkNotNull(facet.module) { "Module of facet $facet not found" }
+            return MPSJavaModuleFacetReference(module.moduleReference)
+        }
     override val concept: IConcept
         get() = BuiltinLanguages.MPSRepositoryConcepts.JavaModuleFacet
     override val parent: INode?

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

@@ -23,7 +23,6 @@ import org.modelix.model.api.IConcept
 import org.modelix.model.api.INode
 import org.modelix.model.api.INodeReference
 import org.modelix.model.api.IProperty
-import org.modelix.model.api.NodeReference
 import org.modelix.model.api.NullChildLink
 import org.modelix.model.area.IArea
 
@@ -34,7 +33,7 @@ data class MPSModelAsNode(val model: SModel) : IDefaultNodeAdapter {
     }
 
     override val reference: INodeReference
-        get() = NodeReference("mps-model:" + model.reference.toString())
+        get() = MPSModelReference(model.reference)
     override val concept: IConcept
         get() = BuiltinLanguages.MPSRepositoryConcepts.Model
     override val parent: INode

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

@@ -31,7 +31,10 @@ class MPSModelImportAsNode(val importedModel: SModel, val importingModel: SModel
         MPSArea(importingModel.repository)
 
     override val reference: INodeReference
-        get() = TODO("Not yet implemented")
+        get() = MPSModelImportReference(
+            importedModel = importedModel.reference,
+            importingModel = importingModel.reference,
+        )
     override val concept: IConcept
         get() = BuiltinLanguages.MPSRepositoryConcepts.ModelReference
     override val parent: INode

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

@@ -46,7 +46,10 @@ data class MPSModuleDependencyAsNode(
     }
 
     override val reference: INodeReference
-        get() = TODO("Not yet implemented")
+        get() = MPSModuleDependencyReference(
+            usedModuleId = moduleReference.moduleId,
+            userModuleReference = importer.moduleReference,
+        )
     override val concept: IConcept
         get() = BuiltinLanguages.MPSRepositoryConcepts.ModuleDependency
     override val parent: INode

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

@@ -29,7 +29,7 @@ import org.modelix.model.area.IArea
 data class MPSProjectAsNode(val project: ProjectBase) : IDefaultNodeAdapter {
 
     override val reference: INodeReference
-        get() = TODO("Not yet implemented")
+        get() = MPSProjectReference(project.name)
     override val concept: IConcept
         get() = BuiltinLanguages.MPSRepositoryConcepts.Project
     override val parent: INode

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

@@ -30,7 +30,10 @@ import org.modelix.model.area.IArea
 data class MPSProjectModuleAsNode(val project: ProjectBase, val module: SModule) : IDefaultNodeAdapter {
 
     override val reference: INodeReference
-        get() = TODO("Not yet implemented")
+        get() = MPSProjectModuleReference(
+            projectRef = parent.reference as MPSProjectReference,
+            moduleRef = module.moduleReference,
+        )
     override val concept: IConcept
         get() = BuiltinLanguages.MPSRepositoryConcepts.ProjectModule
     override val parent: INode

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

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2023.
+ *
+ * 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 jetbrains.mps.smodel.SNodePointer
+import org.jetbrains.mps.openapi.model.SModelReference
+import org.jetbrains.mps.openapi.model.SNodeReference
+import org.jetbrains.mps.openapi.module.SModuleId
+import org.jetbrains.mps.openapi.module.SModuleReference
+import org.modelix.model.api.INodeReference
+
+data class MPSModuleReference(val moduleReference: SModuleReference) : INodeReference {
+    override fun serialize(): String {
+        return "mps-module:$moduleReference"
+    }
+}
+
+data class MPSModelReference(val modelReference: SModelReference) : INodeReference {
+    override fun serialize(): String {
+        return "mps-model:$modelReference"
+    }
+}
+
+data class MPSNodeReference(val ref: SNodeReference) : INodeReference {
+    companion object {
+        @Deprecated("INodeResolutionScope.resolveNode(INodeReference) is now responsible for deserializing supported references")
+        fun tryConvert(ref: INodeReference): MPSNodeReference? {
+            if (ref is MPSNodeReference) return ref
+            val serialized = ref.serialize()
+            val serializedMPSRef = when {
+                serialized.startsWith("mps-node:") -> serialized.substringAfter("mps-node:")
+                serialized.startsWith("mps:") -> serialized.substringAfter("mps:")
+                else -> return null
+            }
+            return MPSNodeReference(SNodePointer.deserialize(serializedMPSRef))
+        }
+    }
+
+    override fun serialize(): String {
+        return "mps:$ref"
+    }
+}
+
+data class MPSDevKitDependencyReference(
+    val usedModuleId: SModuleId,
+    val userModule: SModuleReference? = null,
+    val userModel: SModelReference? = null,
+) : INodeReference {
+    override fun serialize(): String {
+        val importer = userModule?.let { "mps-module:$it" }
+            ?: userModel?.let { "mps-model:$it" }
+            ?: throw IllegalStateException("importer not found")
+
+        return "mps-devkit:$usedModuleId#IN#$importer"
+    }
+}
+
+data class MPSJavaModuleFacetReference(val moduleReference: SModuleReference) : INodeReference {
+    override fun serialize(): String {
+        return "mps-java-facet:$moduleReference"
+    }
+}
+
+data class MPSModelImportReference(
+    val importedModel: SModelReference,
+    val importingModel: SModelReference,
+) : INodeReference {
+    override fun serialize(): String {
+        return "mps-model-import:$importedModel#IN#$importingModel"
+    }
+}
+
+data class MPSModuleDependencyReference(
+    val usedModuleId: SModuleId,
+    val userModuleReference: SModuleReference,
+) : INodeReference {
+    override fun serialize(): String {
+        return "mps-module-dependency:$usedModuleId#IN#$userModuleReference"
+    }
+}
+
+data class MPSProjectReference(val projectName: String) : INodeReference {
+    override fun serialize(): String {
+        return "mps-project:$projectName"
+    }
+}
+
+data class MPSProjectModuleReference(val moduleRef: SModuleReference, val projectRef: MPSProjectReference) : INodeReference {
+    override fun serialize(): String {
+        return "mps-project-module:$moduleRef#IN#${projectRef.serialize()}"
+    }
+}
+
+data class MPSSingleLanguageDependencyReference(
+    val usedModuleId: SModuleId,
+    val userModule: SModuleReference? = null,
+    val userModel: SModelReference? = null,
+) : INodeReference {
+    override fun serialize(): String {
+        val importer = userModule?.let { "mps-module:$it" }
+            ?: userModel?.let { "mps-model:$it" }
+            ?: throw IllegalStateException("importer not found")
+
+        return "mps-lang:$usedModuleId#IN#$importer"
+    }
+}