2 files changed, 120 insertions, 13 deletions

diff --git a/subprojects/language-ide/src/main/java/tools/refinery/language/ide/syntaxcoloring/ProblemSemanticHighlightingCalculator.java b/subprojects/language-ide/src/main/java/tools/refinery/language/ide/syntaxcoloring/ProblemSemanticHighlightingCalculator.java
index ae8c70e0..f64d4066 100644
--- a/subprojects/language-ide/src/main/java/tools/refinery/language/ide/syntaxcoloring/ProblemSemanticHighlightingCalculator.java
+++ b/subprojects/language-ide/src/main/java/tools/refinery/language/ide/syntaxcoloring/ProblemSemanticHighlightingCalculator.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -38,9 +38,12 @@ public class ProblemSemanticHighlightingCalculator extends DefaultSemanticHighli
         @Inject
         private ProblemDesugarer desugarer;
 
+        @Inject
+        private TypeHashProvider typeHashProvider;
+
         @Override
         protected boolean highlightElement(EObject object, IHighlightedPositionAcceptor acceptor,
-                        CancelIndicator cancelIndicator) {
+                                                                           CancelIndicator cancelIndicator) {
                 highlightName(object, acceptor);
                 highlightCrossReferences(object, acceptor, cancelIndicator);
                 return false;
@@ -57,7 +60,7 @@ public class ProblemSemanticHighlightingCalculator extends DefaultSemanticHighli
         }
 
         protected void highlightCrossReferences(EObject object, IHighlightedPositionAcceptor acceptor,
-                        CancelIndicator cancelIndicator) {
+                                                                                        CancelIndicator cancelIndicator) {
                 for (EReference reference : object.eClass().getEAllReferences()) {
                         if (reference.isContainment()) {
                                 continue;
@@ -98,7 +101,7 @@ public class ProblemSemanticHighlightingCalculator extends DefaultSemanticHighli
                 boolean isError = ProblemUtil.isError(eObject);
                 if (ProblemUtil.isBuiltIn(eObject)) {
                         var className = isError ? ERROR_CLASS : BUILTIN_CLASS;
-                        return new String[] { className };
+                        return new String[]{className};
                 }
                 return getUserDefinedElementHighlightClass(eObject, reference, isError);
         }
@@ -113,21 +116,32 @@ public class ProblemSemanticHighlightingCalculator extends DefaultSemanticHighli
                                 && desugarer.isContainmentReference(referenceDeclaration)) {
                         classesBuilder.add(CONTAINMENT_CLASS);
                 }
-                if (isError) {
+                if (isError && reference != null) {
+                        // References to error patterns should be highlighted as errors, but error pattern definitions shouldn't.
                         classesBuilder.add(ERROR_CLASS);
                 }
                 if (eObject instanceof Node node) {
-                        if (reference == ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__VARIABLE_OR_NODE) {
-                                classesBuilder.add(NODE_CLASS);
-                        }
-                        if (ProblemUtil.isIndividualNode(node)) {
-                                classesBuilder.add(INDIVIDUAL_NODE_CLASS);
-                        }
-                        if (ProblemUtil.isNewNode(node)) {
-                                classesBuilder.add(NEW_NODE_CLASS);
+                        highlightNode(node, reference, classesBuilder);
+                }
+                if (eObject instanceof Relation relation) {
+                        var typeHash = typeHashProvider.getTypeHash(relation);
+                        if (typeHash != null) {
+                                classesBuilder.add("typeHash-" + typeHash);
                         }
                 }
                 List<String> classes = classesBuilder.build();
                 return classes.toArray(new String[0]);
         }
+
+        private static void highlightNode(Node node, EReference reference, ImmutableList.Builder<String> classesBuilder) {
+                if (reference == ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__VARIABLE_OR_NODE) {
+                        classesBuilder.add(NODE_CLASS);
+                }
+                if (ProblemUtil.isIndividualNode(node)) {
+                        classesBuilder.add(INDIVIDUAL_NODE_CLASS);
+                }
+                if (ProblemUtil.isNewNode(node)) {
+                        classesBuilder.add(NEW_NODE_CLASS);
+                }
+        }
 }
diff --git a/subprojects/language-ide/src/main/java/tools/refinery/language/ide/syntaxcoloring/TypeHashProvider.java b/subprojects/language-ide/src/main/java/tools/refinery/language/ide/syntaxcoloring/TypeHashProvider.java
new file mode 100644
index 00000000..f75ecdb2
--- /dev/null
+++ b/subprojects/language-ide/src/main/java/tools/refinery/language/ide/syntaxcoloring/TypeHashProvider.java
@@ -0,0 +1,93 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.ide.syntaxcoloring;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import org.eclipse.xtext.EcoreUtil2;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.IQualifiedNameProvider;
+import org.eclipse.xtext.scoping.IScopeProvider;
+import org.eclipse.xtext.util.IResourceScopeCache;
+import tools.refinery.language.model.problem.*;
+import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
+import tools.refinery.language.utils.ProblemUtil;
+
+import java.util.*;
+
+@Singleton
+public class TypeHashProvider {
+        private static final String CACHE_KEY = "tools.refinery.language.ide.syntaxcoloring.TypeHashProvider";
+        private static final int COLOR_COUNT = 10;
+
+        @Inject
+        private IResourceScopeCache resourceScopeCache;
+
+        @Inject
+        private IScopeProvider scopeProvider;
+
+        @Inject
+        private IQualifiedNameProvider qualifiedNameProvider;
+
+        @Inject
+        private IQualifiedNameConverter qualifiedNameConverter;
+
+        public String getTypeHash(Relation relation) {
+                if (!(relation instanceof ClassDeclaration || relation instanceof EnumDeclaration) ||
+                                ProblemUtil.isBuiltIn(relation)) {
+                        return null;
+                }
+                var qualifiedName = qualifiedNameProvider.getFullyQualifiedName(relation);
+                if (qualifiedName == null) {
+                        return null;
+                }
+                var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
+                var problem = EcoreUtil2.getContainerOfType(relation, Problem.class);
+                if (problem == null) {
+                        return null;
+                }
+                var cache = resourceScopeCache.get(CACHE_KEY, problem.eResource(), () -> computeHashes(problem));
+                return cache.get(qualifiedNameString);
+        }
+
+        private Map<String, String> computeHashes(Problem problem) {
+                var qualifiedNameStrings = new TreeSet<String>();
+                var scope = scopeProvider.getScope(problem, ProblemPackage.Literals.ASSERTION__RELATION);
+                for (var description : scope.getAllElements()) {
+                        if (ProblemResourceDescriptionStrategy.COLOR_RELATION_TRUE.equals(
+                                        description.getUserData(ProblemResourceDescriptionStrategy.COLOR_RELATION))) {
+                                var qualifiedNameString = qualifiedNameConverter.toString(description.getQualifiedName());
+                                qualifiedNameStrings.add(qualifiedNameString);
+                        }
+                }
+                var stringList = new ArrayList<>(qualifiedNameStrings);
+                int size = stringList.size();
+                if (size == 0) {
+                        return Map.of();
+                }
+                // The use of a non-cryptographic random generator is safe here, because we only use it to shuffle the color
+                // IDs in a pseudo-random way. The shuffle depends on the size of the list of identifiers before padding to
+                // make sure that adding a new class randomizes all color IDs.
+                @SuppressWarnings("squid:S2245")
+                var random = new Random(size);
+                int padding = COLOR_COUNT - (size % COLOR_COUNT);
+                for (int i = 0; i < padding; i++) {
+                        stringList.add(null);
+                }
+                size += padding;
+                Collections.shuffle(stringList, random);
+                var mapBuilder = ImmutableMap.<String, String>builder();
+                for (int i = 0; i < size; i++) {
+                        var key = stringList.get(i);
+                        if (key != null) {
+                                int colorId = i % COLOR_COUNT;
+                                mapBuilder.put(key, Integer.toString(colorId));
+                        }
+                }
+                return mapBuilder.build();
+        }
+}