fix(language): unambigous reference serialization

4 files changed, 246 insertions, 6 deletions

diff --git a/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java b/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
index 0a5cb3c2..00dd3de3 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
@@ -20,6 +20,7 @@ import org.eclipse.xtext.scoping.IGlobalScopeProvider;
 import org.eclipse.xtext.scoping.IScopeProvider;
 import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
 import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
+import org.eclipse.xtext.serializer.tokens.ICrossReferenceSerializer;
 import org.eclipse.xtext.validation.IDiagnosticConverter;
 import org.eclipse.xtext.validation.IResourceValidator;
 import org.eclipse.xtext.xbase.annotations.validation.DerivedStateAwareResourceValidator;
@@ -34,12 +35,15 @@ import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
 import tools.refinery.language.scoping.ProblemGlobalScopeProvider;
 import tools.refinery.language.scoping.ProblemLocalScopeProvider;
 import tools.refinery.language.serializer.PreferShortAssertionsProblemSemanticSequencer;
+import tools.refinery.language.serializer.ProblemCrossReferenceSerializer;
 import tools.refinery.language.validation.ProblemDiagnosticConverter;
 
 /**
  * Use this class to register components to be used at runtime / without the
  * Equinox extension registry.
  */
+// Unused methods in this class are called by reflection to configure the Xtext Injector.
+@SuppressWarnings("unused")
 public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
         @Override
         public Class<? extends IParser> bindIParser() {
@@ -104,6 +108,10 @@ public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
                 return PreferShortAssertionsProblemSemanticSequencer.class;
         }
 
+        public Class<? extends ICrossReferenceSerializer> bindICrossReferenceSerializer() {
+                return ProblemCrossReferenceSerializer.class;
+        }
+
         public Class<? extends IDiagnosticConverter> bindIDiagnosticConverter() {
                 return ProblemDiagnosticConverter.class;
         }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java b/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java
index 770a1a19..0f3bd3ee 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java
@@ -69,6 +69,7 @@ public class ProblemFormatter extends AbstractJavaFormatter {
                 doc.prepend(region.keyword("{"), this::oneSpace);
                 doc.append(region.keyword("{"), it -> it.setNewLines(1, 1, 2));
                 doc.prepend(region.keyword("}"), it -> it.setNewLines(1, 1, 2));
+                doc.interior(region.keyword("{"), region.keyword("}"), IHiddenRegionFormatter::indent);
                 doc.prepend(region.keyword("."), this::noSpace);
                 for (var featureDeclaration : classDeclaration.getFeatureDeclarations()) {
                         doc.format(featureDeclaration);
@@ -82,6 +83,7 @@ public class ProblemFormatter extends AbstractJavaFormatter {
                 doc.prepend(region.keyword("{"), this::oneSpace);
                 doc.append(region.keyword("{"), it -> it.setNewLines(1, 1, 2));
                 doc.prepend(region.keyword("}"), it -> it.setNewLines(1, 1, 2));
+                doc.interior(region.keyword("{"), region.keyword("}"), IHiddenRegionFormatter::indent);
                 doc.prepend(region.keyword("."), this::noSpace);
         }
 
diff --git a/subprojects/language/src/main/java/tools/refinery/language/serializer/ProblemCrossReferenceSerializer.java b/subprojects/language/src/main/java/tools/refinery/language/serializer/ProblemCrossReferenceSerializer.java
new file mode 100644
index 00000000..42950e61
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/serializer/ProblemCrossReferenceSerializer.java
@@ -0,0 +1,167 @@
+/*******************************************************************************
+ * Copyright (c) 2008, 2018 itemis AG (http://www.itemis.eu) and others.
+ * Copyright (c) 2023 The Refinery Authors <https://refinery.tools/>
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.language.serializer;
+
+import com.google.common.collect.Lists;
+import com.google.inject.Inject;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.xtext.CrossReference;
+import org.eclipse.xtext.EcoreUtil2;
+import org.eclipse.xtext.GrammarUtil;
+import org.eclipse.xtext.IGrammarAccess;
+import org.eclipse.xtext.conversion.IValueConverterService;
+import org.eclipse.xtext.conversion.ValueConverterException;
+import org.eclipse.xtext.linking.impl.LinkingHelper;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.scoping.IScope;
+import org.eclipse.xtext.scoping.IScopeProvider;
+import org.eclipse.xtext.serializer.diagnostic.ISerializationDiagnostic;
+import org.eclipse.xtext.serializer.diagnostic.SerializationDiagnostic;
+import org.eclipse.xtext.serializer.tokens.CrossReferenceSerializer;
+import org.eclipse.xtext.serializer.tokens.SerializerScopeProviderBinding;
+import org.eclipse.xtext.util.EmfFormatter;
+
+import java.util.List;
+
+public class ProblemCrossReferenceSerializer extends CrossReferenceSerializer {
+        public static final String AMBIGUOUS_REFERENCE_DIAGNOSTIC = "tools.refinery.language.serializer" +
+                        ".ProblemCrossReferenceSerializer.AMBIGUOUS_REFERENCE";
+
+        @Inject
+        private LinkingHelper linkingHelper;
+
+        @Inject
+        private IQualifiedNameConverter qualifiedNameConverter;
+
+        @Inject
+        @SerializerScopeProviderBinding
+        private IScopeProvider scopeProvider;
+
+        @Inject
+        private IValueConverterService valueConverter;
+
+        @Inject
+        private IGrammarAccess grammarAccess;
+
+        @Override
+        public String serializeCrossRef(EObject semanticObject, CrossReference crossref, EObject target, INode node,
+                                                                        ISerializationDiagnostic.Acceptor errors) {
+                if ((target == null || target.eIsProxy()) && node != null) {
+                        return tokenUtil.serializeNode(node);
+                }
+
+                final EReference ref = GrammarUtil.getReference(crossref, semanticObject.eClass());
+                final IScope scope = scopeProvider.getScope(semanticObject, ref);
+                if (scope == null) {
+                        if (errors != null) {
+                                errors.accept(diagnostics.getNoScopeFoundDiagnostic(semanticObject, crossref, target));
+                        }
+                        return null;
+                }
+
+                if (target != null && target.eIsProxy()) {
+                        target = handleProxy(target, semanticObject, ref);
+                }
+
+                if (target != null && node != null) {
+                        String text = linkingHelper.getCrossRefNodeAsString(node, true);
+                        QualifiedName qualifiedName = qualifiedNameConverter.toQualifiedName(text);
+                        URI targetUri = EcoreUtil2.getPlatformResourceOrNormalizedURI(target);
+                        if (isUniqueInScope(scope, qualifiedName, targetUri)) {
+                                return tokenUtil.serializeNode(node);
+                        }
+                }
+
+                return getCrossReferenceNameFromScope(semanticObject, crossref, target, scope, errors);
+        }
+
+        private boolean isUniqueInScope(IScope scope, QualifiedName qualifiedName, URI targetUri) {
+                var iterator = scope.getElements(qualifiedName).iterator();
+                if (!iterator.hasNext()) {
+                        return false;
+                }
+                var description = iterator.next();
+                return targetUri.equals(description.getEObjectURI()) && !iterator.hasNext();
+        }
+
+        @Override
+        protected String getCrossReferenceNameFromScope(EObject semanticObject, CrossReference crossref, EObject target,
+                                                                                                        IScope scope, ISerializationDiagnostic.Acceptor errors) {
+                var ruleName = linkingHelper.getRuleNameFrom(crossref);
+                var targetUri = EcoreUtil2.getPlatformResourceOrNormalizedURI(target);
+                FoundName foundName = FoundName.NONE;
+                int shortestNameLength = Integer.MAX_VALUE;
+                String shortestName = null;
+                List<ISerializationDiagnostic> recordedErrors = null;
+                for (var description : scope.getElements(target)) {
+                        var qualifiedName = description.getName();
+                        var segmentCount = qualifiedName.getSegmentCount();
+                        if (shortestName != null && segmentCount >= shortestNameLength) {
+                                continue;
+                        }
+                        if (isUniqueInScope(scope, qualifiedName, targetUri)) {
+                                var unconverted = qualifiedNameConverter.toString(qualifiedName);
+                                try {
+                                        shortestName = valueConverter.toString(unconverted, ruleName);
+                                        shortestNameLength = segmentCount;
+                                        foundName = FoundName.VALID;
+                                } catch (ValueConverterException e) {
+                                        if (recordedErrors == null) {
+                                                recordedErrors = Lists.newArrayList();
+                                        }
+                                        recordedErrors.add(diagnostics.getValueConversionExceptionDiagnostic(semanticObject, crossref,
+                                                        unconverted, e));
+                                }
+                        } else if (foundName == FoundName.NONE) {
+                                foundName = FoundName.AMBIGUOUS;
+                        }
+                }
+                handleErrors(semanticObject, crossref, target, scope, errors, recordedErrors, foundName);
+                return shortestName;
+        }
+
+        private void handleErrors(
+                        EObject semanticObject, CrossReference crossref, EObject target, IScope scope,
+                        ISerializationDiagnostic.Acceptor errors, List<ISerializationDiagnostic> recordedErrors,
+                        FoundName foundName) {
+                if (errors == null) {
+                        return;
+                }
+                if (recordedErrors != null) {
+                        recordedErrors.forEach(errors::accept);
+                }
+                if (foundName == FoundName.NONE) {
+                        errors.accept(diagnostics.getNoEObjectDescriptionFoundDiagnostic(semanticObject, crossref, target,
+                                        scope));
+                } else if (foundName == FoundName.AMBIGUOUS) {
+                        // Computation of reference name copied from
+                        // {@link org.eclipse.xtext.serializer.diagnostic.TokenDiagnosticProvider#getFullReferenceName}.
+                        var ref = GrammarUtil.getReference(crossref);
+                        var clazz = semanticObject.eClass().getName();
+                        if (ref.getEContainingClass() != semanticObject.eClass()) {
+                clazz = ref.getEContainingClass().getName() + "(" + clazz + ")";
+            }
+                        var message = "No unambiguous name could be found in scope %s.%s for %s"
+                                        .formatted(clazz, ref.getName(), EmfFormatter.objPath(target));
+                        var diagnostic = new SerializationDiagnostic(AMBIGUOUS_REFERENCE_DIAGNOSTIC, semanticObject, crossref,
+                                        grammarAccess.getGrammar(), message);
+                        errors.accept(diagnostic);
+                }
+        }
+
+        private enum FoundName {
+                NONE,
+                AMBIGUOUS,
+                VALID
+        }
+}
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java
index 4a3a9ac2..65675b6b 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java
@@ -156,6 +156,7 @@ class ProblemSerializerTest {
                 problem.getStatements().add(assertion);
         }
 
+
         @Test
         void implicitVariableTest() {
                 var pred = ProblemFactory.eINSTANCE.createPredicateDefinition();
@@ -227,15 +228,77 @@ class ProblemSerializerTest {
                                 """);
         }
 
+        @Test
+        void unambiguousNameTest() {
+                createClassAndAssertion("Foo", "foo");
+
+                assertSerializedResult("""
+                                class Foo {
+                                        Foo ref
+                                }
+
+                                ref(foo, foo).
+                                """);
+        }
+
+        @Test
+        void ambiguousNameTest() {
+                createClassAndAssertion("Foo", "foo");
+                createClassAndAssertion("Bar", "bar");
+
+                assertSerializedResult("""
+                                class Foo {
+                                        Foo ref
+                                }
+
+                                Foo::ref(foo, foo).
+
+                                class Bar {
+                                        Bar ref
+                                }
+
+                                Bar::ref(bar, bar).
+                                """);
+        }
+
+        private void createClassAndAssertion(String className, String nodeName) {
+                var classDeclaration = ProblemFactory.eINSTANCE.createClassDeclaration();
+                classDeclaration.setName(className);
+                var referenceDeclaration = ProblemFactory.eINSTANCE.createReferenceDeclaration();
+                referenceDeclaration.setReferenceType(classDeclaration);
+                referenceDeclaration.setName("ref");
+                classDeclaration.getFeatureDeclarations().add(referenceDeclaration);
+                problem.getStatements().add(classDeclaration);
+                var node = ProblemFactory.eINSTANCE.createNode();
+                node.setName(nodeName);
+                problem.getNodes().add(node);
+                createBinaryAssertion(referenceDeclaration, node, node);
+        }
+
+        private void createBinaryAssertion(Relation relation, Node from, Node to) {
+                var assertion = ProblemFactory.eINSTANCE.createAssertion();
+                assertion.setRelation(relation);
+                var fromArgument = ProblemFactory.eINSTANCE.createNodeAssertionArgument();
+                fromArgument.setNode(from);
+                assertion.getArguments().add(fromArgument);
+                var toArgument = ProblemFactory.eINSTANCE.createNodeAssertionArgument();
+                toArgument.setNode(to);
+                assertion.getArguments().add(toArgument);
+                var value = ProblemFactory.eINSTANCE.createLogicConstant();
+                value.setLogicValue(LogicValue.TRUE);
+                assertion.setValue(value);
+                problem.getStatements().add(assertion);
+        }
+
         private void assertSerializedResult(String expected) {
                 String problemString;
-        try (var outputStream = new ByteArrayOutputStream()) {
-            resource.save(outputStream, Map.of());
+                try (var outputStream = new ByteArrayOutputStream()) {
+                        resource.save(outputStream, Map.of());
                         problemString = outputStream.toString();
-        } catch (IOException e) {
-            throw new AssertionError("Failed to serialize problem", e);
-        }
-        // Nothing to handle in a test.
+                } catch (IOException e) {
+                        throw new AssertionError("Failed to serialize problem", e);
+                }
+                // Nothing to handle in a test.
 
                 assertThat(problemString.replace("\r\n", "\n"), equalTo(expected.replace("\r\n", "\n")));
         }