fix(lang): mark transient references

Xtext fails to serialize non-transient references that have no
corresponding assignment in the grammar. Therefore, we mark

* Problem.nodes
* ClassDeclaration.newNode
* ExistentialQualifier.implicitVariables
* VariableOrNodeArgument.singletonVariable

as transient.

This will allow serializing Problem instances using the textual concrete
syntax for display.

5 files changed, 208 insertions, 8 deletions

diff --git a/language-model/META-INF/MANIFEST.MF b/language-model/META-INF/MANIFEST.MF
index 88725730..96617f85 100644
--- a/language-model/META-INF/MANIFEST.MF
+++ b/language-model/META-INF/MANIFEST.MF
@@ -12,5 +12,6 @@ Export-Package: tools.refinery.language.model.problem,
  tools.refinery.language.model.problem.impl,
  tools.refinery.language.model.problem.util
 Require-Bundle: org.eclipse.emf.ecore;visibility:=reexport,
+ org.eclipse.emf.ecore.xmi;visibility:=reexport,
  org.eclipse.core.runtime
 Bundle-ActivationPolicy: lazy
diff --git a/language-model/src/main/java/tools/refinery/language/model/GenerateProblemModel.mwe2 b/language-model/src/main/java/tools/refinery/language/model/GenerateProblemModel.mwe2
index 7f998448..c1518b4d 100644
--- a/language-model/src/main/java/tools/refinery/language/model/GenerateProblemModel.mwe2
+++ b/language-model/src/main/java/tools/refinery/language/model/GenerateProblemModel.mwe2
@@ -3,7 +3,7 @@ module tools.refinery.language.model.GenerateProblemModel
 Workflow {
         bean = org.eclipse.emf.mwe.utils.StandaloneSetup {
                 projectMapping = {
-                        projectName = "language-model"
+                        projectName = "refinery-language-model"
                         path = "."
                 }
         }
@@ -14,7 +14,7 @@ Workflow {
 
         component = org.eclipse.emf.mwe2.ecore.EcoreGenerator {
                 generateCustomClasses = false
-                genModel = "platform:/resource/language-model/src/main/resources/model/problem.genmodel"
-                srcPath = "platform:/resource/language-model/src/main/emf-gen"
+                genModel = "platform:/resource/refinery-language-model/src/main/resources/model/problem.genmodel"
+                srcPath = "platform:/resource/refinery-language-model/src/main/emf-gen"
         }
 }
diff --git a/language-model/src/main/resources/model/problem.ecore b/language-model/src/main/resources/model/problem.ecore
index 77211b66..582f67c8 100644
--- a/language-model/src/main/resources/model/problem.ecore
+++ b/language-model/src/main/resources/model/problem.ecore
@@ -3,7 +3,7 @@
     xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="problem" nsURI="https://refinery.tools/emf/2021/Problem" nsPrefix="problem">
   <eClassifiers xsi:type="ecore:EClass" name="Problem" eSuperTypes="#//NamedElement">
     <eStructuralFeatures xsi:type="ecore:EReference" name="nodes" upperBound="-1"
-        eType="#//Node" containment="true"/>
+        eType="#//Node" transient="true" containment="true"/>
     <eStructuralFeatures xsi:type="ecore:EReference" name="statements" upperBound="-1"
         eType="#//Statement" containment="true"/>
   </eClassifiers>
@@ -15,7 +15,7 @@
     <eStructuralFeatures xsi:type="ecore:EReference" name="referenceDeclarations"
         upperBound="-1" eType="#//ReferenceDeclaration" containment="true"/>
     <eStructuralFeatures xsi:type="ecore:EReference" name="newNode" eType="#//Node"
-        containment="true"/>
+        transient="true" containment="true"/>
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EClass" name="ReferenceDeclaration" eSuperTypes="#//Relation">
     <eStructuralFeatures xsi:type="ecore:EReference" name="referenceType" eType="#//Relation"/>
@@ -52,7 +52,7 @@
   <eClassifiers xsi:type="ecore:EClass" name="ExistentialQuantifier" abstract="true"
       interface="true">
     <eStructuralFeatures xsi:type="ecore:EReference" name="implicitVariables" upperBound="-1"
-        eType="#//ImplicitVariable" containment="true"/>
+        eType="#//ImplicitVariable" transient="true" containment="true"/>
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EClass" name="Assertion" eSuperTypes="#//Statement">
     <eStructuralFeatures xsi:type="ecore:EReference" name="relation" eType="#//Relation"/>
@@ -95,7 +95,7 @@
   <eClassifiers xsi:type="ecore:EClass" name="VariableOrNodeArgument" eSuperTypes="#//Argument">
     <eStructuralFeatures xsi:type="ecore:EReference" name="variableOrNode" eType="#//VariableOrNode"/>
     <eStructuralFeatures xsi:type="ecore:EReference" name="singletonVariable" eType="#//ImplicitVariable"
-        containment="true"/>
+        transient="true" containment="true"/>
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EClass" name="EnumDeclaration" eSuperTypes="#//Relation #//Statement">
     <eStructuralFeatures xsi:type="ecore:EReference" name="literals" upperBound="-1"
diff --git a/language-model/src/main/resources/model/problem.genmodel b/language-model/src/main/resources/model/problem.genmodel
index 094533e7..3e0ee35e 100644
--- a/language-model/src/main/resources/model/problem.genmodel
+++ b/language-model/src/main/resources/model/problem.genmodel
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel"
-    modelDirectory="/language-model/src/main/emf-gen" creationIcons="false"
+    modelDirectory="/refinery-language-model/src/main/emf-gen" creationIcons="false"
     editDirectory="/language-edit/src/main/emf-gen" editorDirectory="/org.eclipse.viatra.solver.language.model.editor/src-gen"
     modelPluginID="language-model" modelName="Problem" rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container"
     codeFormatting="true" importerID="org.eclipse.emf.importer.ecore" complianceLevel="5.0"
diff --git a/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java b/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java
new file mode 100644
index 00000000..34c1d14b
--- /dev/null
+++ b/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java
@@ -0,0 +1,199 @@
+package tools.refinery.language.tests.serializer;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Map;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import com.google.inject.Inject;
+
+import tools.refinery.language.model.ProblemUtil;
+import tools.refinery.language.model.problem.Atom;
+import tools.refinery.language.model.problem.LogicValue;
+import tools.refinery.language.model.problem.Node;
+import tools.refinery.language.model.problem.PredicateDefinition;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.model.problem.ProblemFactory;
+import tools.refinery.language.model.problem.Relation;
+import tools.refinery.language.model.problem.VariableOrNode;
+import tools.refinery.language.model.tests.ProblemTestUtil;
+import tools.refinery.language.tests.ProblemInjectorProvider;
+
+@ExtendWith(InjectionExtension.class)
+@InjectWith(ProblemInjectorProvider.class)
+public class ProblemSerializerTest {
+        @Inject
+        ResourceSet resourceSet;
+
+        @Inject
+        ProblemTestUtil testUtil;
+
+        Resource resource;
+
+        Problem problem;
+
+        Problem builtin;
+
+        @BeforeEach
+        void beforeEach() {
+                problem = ProblemFactory.eINSTANCE.createProblem();
+                resource = resourceSet.createResource(URI.createFileURI("test.problem"));
+                resource.getContents().add(problem);
+                builtin = ProblemUtil.getBuiltInLibrary(problem).get();
+        }
+
+        @Test
+        void implicitNodeTest() {
+                var pred = createPred();
+                var node = ProblemFactory.eINSTANCE.createNode();
+                node.setName("a");
+                problem.getNodes().add(node);
+                createAssertion(pred, node);
+
+                assertSerializedResult("pred foo ( node p ) . foo ( a ) : true .");
+        }
+
+        @Test
+        void individualNodeTest() {
+                var pred = createPred();
+                var node = ProblemFactory.eINSTANCE.createNode();
+                node.setName("a");
+                var individualDeclaration = ProblemFactory.eINSTANCE.createIndividualDeclaration();
+                individualDeclaration.getNodes().add(node);
+                problem.getStatements().add(individualDeclaration);
+                createAssertion(pred, node);
+
+                assertSerializedResult("pred foo ( node p ) . individual a . foo ( a ) : true .");
+        }
+
+        private PredicateDefinition createPred() {
+                var pred = ProblemFactory.eINSTANCE.createPredicateDefinition();
+                pred.setName("foo");
+                var parameter = ProblemFactory.eINSTANCE.createParameter();
+                var nodeType = testUtil.findClass(builtin, "node");
+                parameter.setParameterType(nodeType);
+                parameter.setName("p");
+                pred.getParameters().add(parameter);
+                problem.getStatements().add(pred);
+                return pred;
+        }
+        
+        @Test
+        void newNodeTest() {
+                var classDeclaration = ProblemFactory.eINSTANCE.createClassDeclaration();
+                classDeclaration.setName("Foo");
+                var newNode = ProblemFactory.eINSTANCE.createNode();
+                newNode.setName("new");
+                classDeclaration.setNewNode(newNode);
+                problem.getStatements().add(classDeclaration);
+                createAssertion(classDeclaration, newNode);
+
+                assertSerializedResult("class Foo . Foo ( Foo::new ) : true .");
+        }
+        
+        private void createAssertion(Relation relation, Node node) {
+                var assertion = ProblemFactory.eINSTANCE.createAssertion();
+                assertion.setRelation(relation);
+                var argument = ProblemFactory.eINSTANCE.createNodeAssertionArgument();
+                argument.setNode(node);
+                assertion.getArguments().add(argument);
+                assertion.setValue(LogicValue.TRUE);
+                problem.getStatements().add(assertion);
+        }
+
+        @Test
+        void implicitVariableTest() {
+                var pred = ProblemFactory.eINSTANCE.createPredicateDefinition();
+                pred.setName("foo");
+                var nodeType = testUtil.findClass(builtin, "node");
+                var parameter1 = ProblemFactory.eINSTANCE.createParameter();
+                parameter1.setParameterType(nodeType);
+                parameter1.setName("p1");
+                pred.getParameters().add(parameter1);
+                var parameter2 = ProblemFactory.eINSTANCE.createParameter();
+                parameter2.setParameterType(nodeType);
+                parameter2.setName("p2");
+                pred.getParameters().add(parameter2);
+                var conjunction = ProblemFactory.eINSTANCE.createConjunction();
+                var variable = ProblemFactory.eINSTANCE.createImplicitVariable();
+                variable.setName("q");
+                conjunction.getImplicitVariables().add(variable);
+                var equals = testUtil.reference(nodeType, "equals");
+                conjunction.getLiterals().add(createAtom(equals, parameter1, variable));
+                conjunction.getLiterals().add(createAtom(equals, variable, parameter2));
+                pred.getBodies().add(conjunction);
+                problem.getStatements().add(pred);
+
+                assertSerializedResult("pred foo ( node p1 , node p2 ) <-> equals ( p1 , q ) , equals ( q , p2 ) .");
+        }
+
+        private Atom createAtom(Relation relation, VariableOrNode variable1, VariableOrNode variable2) {
+                var atom = ProblemFactory.eINSTANCE.createAtom();
+                atom.setRelation(relation);
+                var arg1 = ProblemFactory.eINSTANCE.createVariableOrNodeArgument();
+                arg1.setVariableOrNode(variable1);
+                atom.getArguments().add(arg1);
+                var arg2 = ProblemFactory.eINSTANCE.createVariableOrNodeArgument();
+                arg2.setVariableOrNode(variable2);
+                atom.getArguments().add(arg2);
+                return atom;
+        }
+        
+        @Test
+        void singletonVariableTest() {
+                var pred = ProblemFactory.eINSTANCE.createPredicateDefinition();
+                pred.setName("foo");
+                var nodeType = testUtil.findClass(builtin, "node");
+                var parameter = ProblemFactory.eINSTANCE.createParameter();
+                parameter.setParameterType(nodeType);
+                parameter.setName("p");
+                pred.getParameters().add(parameter);
+                var conjunction = ProblemFactory.eINSTANCE.createConjunction();
+                var atom = ProblemFactory.eINSTANCE.createAtom();
+                var equals = testUtil.reference(nodeType, "equals");
+                atom.setRelation(equals);
+                var arg1 = ProblemFactory.eINSTANCE.createVariableOrNodeArgument();
+                arg1.setVariableOrNode(parameter);
+                atom.getArguments().add(arg1);
+                var arg2 = ProblemFactory.eINSTANCE.createVariableOrNodeArgument();
+                var variable = ProblemFactory.eINSTANCE.createImplicitVariable();
+                variable.setName("_q");
+                arg2.setSingletonVariable(variable);
+                arg2.setVariableOrNode(variable);
+                atom.getArguments().add(arg2);
+                conjunction.getLiterals().add(atom);
+                pred.getBodies().add(conjunction);
+                problem.getStatements().add(pred);
+                
+                assertSerializedResult("pred foo ( node p ) <-> equals ( p , _q ) .");
+        }
+
+        private void assertSerializedResult(String expected) {
+                var outputStream = new ByteArrayOutputStream();
+                try {
+                        resource.save(outputStream, Map.of());
+                } catch (IOException e) {
+                        throw new AssertionError("Failed to serialize problem", e);
+                } finally {
+                        try {
+                                outputStream.close();
+                        } catch (IOException e) {
+                                // Nothing to handle in a test.
+                        }
+                }
+                var problemString = outputStream.toString();
+
+                assertThat(problemString, equalTo(expected));
+        }
+}