1 files changed, 167 insertions, 0 deletions

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
+        }
+}