1 files changed, 40 insertions, 21 deletions

diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java
index 28ba7625..7343f709 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java
@@ -5,16 +5,44 @@
  */
 package tools.refinery.store.query.literal;
 
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.equality.LiteralHashCodeHelper;
 import tools.refinery.store.query.substitution.Substitution;
-import tools.refinery.store.query.term.NodeVariable;
 import tools.refinery.store.query.term.Variable;
 
 import java.util.Objects;
 import java.util.Set;
 
-public record EquivalenceLiteral(boolean positive, NodeVariable left, NodeVariable right)
-                implements CanNegate<EquivalenceLiteral> {
+// {@link Object#equals(Object)} is implemented by {@link AbstractLiteral}.
+@SuppressWarnings("squid:S2160")
+public final class EquivalenceLiteral extends AbstractLiteral implements CanNegate<EquivalenceLiteral> {
+        private final boolean positive;
+        private final Variable left;
+        private final Variable right;
+
+        public EquivalenceLiteral(boolean positive, Variable left, Variable right) {
+                if (!left.tryGetType().equals(right.tryGetType())) {
+                        throw new InvalidQueryException("Variables %s and %s of different type cannot be equivalent"
+                                        .formatted(left, right));
+                }
+                this.positive = positive;
+                this.left = left;
+                this.right = right;
+        }
+
+        public boolean isPositive() {
+                return positive;
+        }
+
+        public Variable getLeft() {
+                return left;
+        }
+
+        public Variable getRight() {
+                return right;
+        }
+
         @Override
         public Set<Variable> getOutputVariables() {
                 return Set.of(left);
@@ -37,8 +65,8 @@ public record EquivalenceLiteral(boolean positive, NodeVariable left, NodeVariab
 
         @Override
         public EquivalenceLiteral substitute(Substitution substitution) {
-                return new EquivalenceLiteral(positive, substitution.getTypeSafeSubstitute(left),
-                                substitution.getTypeSafeSubstitute(right));
+                return new EquivalenceLiteral(positive, substitution.getSubstitute(left),
+                                substitution.getSubstitute(right));
         }
 
         @Override
@@ -55,27 +83,18 @@ public record EquivalenceLiteral(boolean positive, NodeVariable left, NodeVariab
                         return false;
                 }
                 var otherEquivalenceLiteral = (EquivalenceLiteral) other;
-                return helper.variableEqual(left, otherEquivalenceLiteral.left) && helper.variableEqual(right,
-                                otherEquivalenceLiteral.right);
-        }
-
-        @Override
-        public String toString() {
-                return "%s %s %s".formatted(left, positive ? "===" : "!==", right);
+                return helper.variableEqual(left, otherEquivalenceLiteral.left) &&
+                                helper.variableEqual(right, otherEquivalenceLiteral.right);
         }
 
         @Override
-        public boolean equals(Object obj) {
-                if (obj == this) return true;
-                if (obj == null || obj.getClass() != this.getClass()) return false;
-                var that = (EquivalenceLiteral) obj;
-                return this.positive == that.positive &&
-                                Objects.equals(this.left, that.left) &&
-                                Objects.equals(this.right, that.right);
+        public int hashCodeWithSubstitution(LiteralHashCodeHelper helper) {
+                return Objects.hash(super.hashCodeWithSubstitution(helper), helper.getVariableHashCode(left),
+                                helper.getVariableHashCode(right));
         }
 
         @Override
-        public int hashCode() {
-                return Objects.hash(getClass(), positive, left, right);
+        public String toString() {
+                return "%s %s %s".formatted(left, positive ? "===" : "!==", right);
         }
 }