1 files changed, 23 insertions, 12 deletions

diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/QueryWrapperFactory.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/QueryWrapperFactory.java
index 0d046455..2b7280f2 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/QueryWrapperFactory.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/QueryWrapperFactory.java
@@ -14,12 +14,13 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeCo
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery;
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
 import tools.refinery.store.query.Constraint;
 import tools.refinery.store.query.dnf.Dnf;
-import tools.refinery.store.query.dnf.DnfClause;
 import tools.refinery.store.query.dnf.DnfUtils;
 import tools.refinery.store.query.literal.AbstractCallLiteral;
+import tools.refinery.store.query.term.ParameterDirection;
 import tools.refinery.store.query.term.Variable;
 import tools.refinery.store.query.view.AnySymbolView;
 import tools.refinery.store.query.view.SymbolView;
@@ -45,21 +46,17 @@ class QueryWrapperFactory {
                 }
                 return maybeWrapConstraint(symbolView, identity);
         }
-        public WrappedCall maybeWrapConstraint(AbstractCallLiteral callLiteral, DnfClause clause) {
+
+        public WrappedCall maybeWrapConstraint(AbstractCallLiteral callLiteral) {
                 var arguments = callLiteral.getArguments();
                 int arity = arguments.size();
                 var remappedParameters = new int[arity];
-                var boundVariables = clause.boundVariables();
                 var unboundVariableIndices = new HashMap<Variable, Integer>();
                 var appendVariable = new VariableAppender();
                 for (int i = 0; i < arity; i++) {
                         var variable = arguments.get(i);
-                        if (boundVariables.contains(variable)) {
-                                // Do not join bound variable to make sure that the embedded pattern stays as general as possible.
-                                remappedParameters[i] = appendVariable.applyAsInt(variable);
-                        } else {
-                                remappedParameters[i] = unboundVariableIndices.computeIfAbsent(variable, appendVariable::applyAsInt);
-                        }
+                        // Unify all variables to avoid VIATRA bugs, even if they're bound in the containing clause.
+                        remappedParameters[i] = unboundVariableIndices.computeIfAbsent(variable, appendVariable::applyAsInt);
                 }
                 var pattern = maybeWrapConstraint(callLiteral.getTarget(), remappedParameters);
                 return new WrappedCall(pattern, appendVariable.getRemappedArguments());
@@ -89,6 +86,8 @@ class QueryWrapperFactory {
                 var constraint = remappedConstraint.constraint();
                 var remappedParameters = remappedConstraint.remappedParameters();
 
+                checkNoInputParameters(constraint);
+
                 var embeddedPQuery = new RawPQuery(DnfUtils.generateUniqueName(constraint.name()), PVisibility.EMBEDDED);
                 var body = new PBody(embeddedPQuery);
                 int arity = Arrays.stream(remappedParameters).max().orElse(-1) + 1;
@@ -112,6 +111,21 @@ class QueryWrapperFactory {
                 }
                 var argumentTuple = Tuples.flatTupleOf(arguments);
 
+                addPositiveConstraint(constraint, body, argumentTuple);
+                embeddedPQuery.addBody(body);
+                return embeddedPQuery;
+        }
+
+        private static void checkNoInputParameters(Constraint constraint) {
+                for (var constraintParameter : constraint.getParameters()) {
+                        if (constraintParameter.getDirection() == ParameterDirection.IN) {
+                                throw new IllegalArgumentException("Input parameter %s of %s is not supported"
+                                                .formatted(constraintParameter, constraint));
+                        }
+                }
+        }
+
+        private void addPositiveConstraint(Constraint constraint, PBody body, Tuple argumentTuple) {
                 if (constraint instanceof SymbolView<?> view) {
                         new TypeConstraint(body, argumentTuple, getInputKey(view));
                 } else if (constraint instanceof Dnf dnf) {
@@ -120,9 +134,6 @@ class QueryWrapperFactory {
                 } else {
                         throw new IllegalArgumentException("Unknown Constraint: " + constraint);
                 }
-
-                embeddedPQuery.addBody(body);
-                return embeddedPQuery;
         }
 
         public IInputKey getInputKey(AnySymbolView symbolView) {