feat(mps-sync-plugin): synchronizing read-only modules and models (#154)

* feat(mps-sync-plugin): transform read-only model imports

* feat(mps-sync-plugin): transform read-only module dependencies

* feat(mps-sync-plugin): disable the sync and unbind actions on read-only models and modules

* feat(mps-sync-plugin): transform read-only node references

* fix(mps-sync-plugin-lib): serialize MPSModelImportReference by hand

to avoid a serializer not found exception at runtime

* fix(mps-sync-plugin-lib): move creating read-only model import to a separate method

because we have to do some more checks and steps than just simply creating the MPSModelImportReference

* fix(mps-sync-plugin-lib): encapsulate the MPSNodeReference in a NodeReference

otherwise the reference cannot be serialized

* fix(mps-sync-plugin-lib): setting a reference for a read-only node

* fix(mps-sync-plugin-lib): fix cahing read-only model import during modelix traversal

* fix(mps-sync-plugin-lib): model imports can be added and resolved at any time

Track if the ResolvableModelImport has been resolved (i.e. synced to the cloud) and if so then remove it from the pending this. This way, we can sync model imports directly after they were added to the model.

* refactor(mps-sync-plugin-lib): do not use SNode, SModel, SModule in the cache

Because they may change behind-the-scenes without any warning. As a consequence, they will not be found in the cache as keys, even though they did not change. (MODELIX-787)

* feat(mps-sync-plugin-lib): add SRepository as a new field to the ServiceLocator

so the MPS Repository is always directly accessible and we do not have to go to the MPS Project first

* fix(mps-sync-plugin-lib): create mapping link for the read-only model imports

* fix(mps-sync-plugin-lib): remove outgoing model and module dependency mappings

from the cache, when the corresponding ModelImport, ModuleDependency, LanguageDependency, DevKitDependency is removed

* refactor(mps-sync-plugin-lib): reclassify missed node removal error to warning

* fix(mps-sync-plugin-lib): add null-checks where returned object may be null

* refactor(mps-sync-plugin-lib): inline a variable that is used only once

Author: benedekh

mps-sync-plugin-lib/src/main/kotlin/org/modelix/mps/sync/SyncServiceImpl.kt

@@ -55,7 +55,7 @@ class SyncServiceImpl : ISyncService, InjectableService {
         get() = serviceLocator.branchRegistry
 
     private val mpsRepository: SRepository
-        get() = serviceLocator.mpsProject.repository
+        get() = serviceLocator.mpsRepository
 
     private val languageRepository: MPSLanguageRepository
         get() = serviceLocator.languageRepository

mps-sync-plugin-lib/src/main/kotlin/org/modelix/mps/sync/modelix/branch/BranchRegistry.kt

@@ -16,9 +16,9 @@
 
 package org.modelix.mps.sync.modelix.branch
 
-import jetbrains.mps.project.MPSProject
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.runBlocking
+import org.jetbrains.mps.openapi.module.SRepository
 import org.modelix.kotlin.utils.UnstableModelixFeature
 import org.modelix.model.api.IBranch
 import org.modelix.model.client2.ModelClientV2
@@ -38,8 +38,8 @@ class BranchRegistry : InjectableService {
 
     private lateinit var serviceLocator: ServiceLocator
 
-    private val mpsProject: MPSProject
-        get() = serviceLocator.mpsProject
+    private val mpsRepository: SRepository
+        get() = serviceLocator.mpsRepository
 
     var model: ReplicatedModel? = null
         private set
@@ -91,7 +91,7 @@ class BranchRegistry : InjectableService {
         this.client = client
 
         val repositoryChangeListener = RepositoryChangeListener(branch, serviceLocator)
-        mpsProject.repository.addRepositoryListener(repositoryChangeListener)
+        mpsRepository.addRepositoryListener(repositoryChangeListener)
         repoChangeListener = repositoryChangeListener
 
         return model!!
@@ -100,7 +100,7 @@ class BranchRegistry : InjectableService {
     override fun dispose() {
         val branch = getBranch() ?: return
         branch.removeListener(branchListener)
-        mpsProject.repository.removeRepositoryListener(repoChangeListener)
+        mpsRepository.removeRepositoryListener(repoChangeListener)
 
         model?.dispose()
 

mps-sync-plugin-lib/src/main/kotlin/org/modelix/mps/sync/modelix/util/ModuleDependencyConstants.kt

@@ -0,0 +1,7 @@
+package org.modelix.mps.sync.modelix.util
+
+import org.modelix.model.api.PropertyFromName
+
+object ModuleDependencyConstants {
+    val MODULE_DEPENDENCY_IS_READ_ONLY_PROPERTY = PropertyFromName("isReadOnly")
+}

mps-sync-plugin-lib/src/main/kotlin/org/modelix/mps/sync/mps/factories/SNodeFactory.kt

@@ -28,8 +28,11 @@ import org.modelix.kotlin.utils.UnstableModelixFeature
 import org.modelix.model.api.BuiltinLanguages
 import org.modelix.model.api.IBranch
 import org.modelix.model.api.INode
+import org.modelix.model.api.PNodeReference
 import org.modelix.model.api.getNode
+import org.modelix.model.mpsadapters.MPSArea
 import org.modelix.model.mpsadapters.MPSLanguageRepository
+import org.modelix.model.mpsadapters.MPSNode
 import org.modelix.model.mpsadapters.MPSProperty
 import org.modelix.model.mpsadapters.MPSReferenceLink
 import org.modelix.mps.sync.modelix.util.getMpsNodeId
@@ -53,6 +56,7 @@ class SNodeFactory(
     private val nodeMap = serviceLocator.nodeMap
     private val syncQueue = serviceLocator.syncQueue
     private val futuresWaitQueue = serviceLocator.futuresWaitQueue
+    private val mpsRepository = serviceLocator.mpsRepository
 
     private val resolvableReferences = mutableListOf<ResolvableReference>()
 
@@ -125,17 +129,32 @@ class SNodeFactory(
     }
 
     private fun prepareLinkReferences(iNode: INode) {
-        iNode.getAllReferenceTargets().forEach {
-            val sourceNodeId = iNode.nodeIdAsLong()
-            val source = nodeMap.getNode(sourceNodeId)!!
+        val sourceNodeId = iNode.nodeIdAsLong()
+        val source = nodeMap.getNode(sourceNodeId)!!
 
+        iNode.getAllReferenceTargetRefs().forEach {
             val reference = when (val referenceLink = it.first) {
                 is MPSReferenceLink -> referenceLink.link
                 else -> source.concept.referenceLinks.first { refLink -> refLink.name == referenceLink.getSimpleName() }
             }
 
-            val targetNodeId = it.second.nodeIdAsLong()
-            resolvableReferences.add(ResolvableReference(source, reference, targetNodeId))
+            val targetNodeReference = it.second
+            val serializedRef = targetNodeReference.serialize()
+            val targetIsAnINode = PNodeReference.tryDeserialize(serializedRef) != null
+
+            if (targetIsAnINode) {
+                // delay the reference resolution, because the target node might not have been transformed yet
+                val targetNode = iNode.getReferenceTarget(it.first)
+                    ?: throw IllegalArgumentException("PNodeReference exists, but PNode cannot be resolved: '$serializedRef'")
+                val targetNodeId = targetNode.nodeIdAsLong()
+                resolvableReferences.add(ResolvableReference(source, reference, targetNodeId))
+            } else {
+                // target node is an existing SNode
+                val area = MPSArea(mpsRepository)
+                val mpsNode = area.resolveNode(targetNodeReference) as MPSNode?
+                requireNotNull(mpsNode) { "SNode identified by Node $sourceNodeId is not found." }
+                source.setReferenceTarget(reference, mpsNode.node)
+            }
         }
     }
 

mps-sync-plugin-lib/src/main/kotlin/org/modelix/mps/sync/mps/services/ServiceLocator.kt

@@ -4,6 +4,7 @@ import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.components.Service
 import com.intellij.openapi.project.Project
+import org.jetbrains.mps.openapi.module.SRepository
 import org.modelix.kotlin.utils.UnstableModelixFeature
 import org.modelix.mps.sync.SyncServiceImpl
 import org.modelix.mps.sync.bindings.BindingsRegistry
@@ -40,6 +41,8 @@ class ServiceLocator(val project: Project) : Disposable {
     val futuresWaitQueue = FuturesWaitQueue()
 
     val mpsProject = project.toMpsProject()
+    val mpsRepository: SRepository
+        get() = mpsProject.repository
 
     val languageRepository = ApplicationManager.getApplication()
         .getService(MPSLanguageRepositoryProvider::class.java).mpsLanguageRepository