1 files changed, 38 insertions, 32 deletions

diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java
index b511a5c7..ec880435 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java
@@ -19,11 +19,13 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.Consta
 import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
 import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
 import tools.refinery.store.query.dnf.Dnf;
 import tools.refinery.store.query.dnf.DnfClause;
+import tools.refinery.store.query.dnf.SymbolicParameter;
 import tools.refinery.store.query.literal.*;
 import tools.refinery.store.query.term.ConstantTerm;
 import tools.refinery.store.query.term.StatefulAggregator;
@@ -82,15 +84,20 @@ public class Dnf2PQuery {
                 var pQuery = new RawPQuery(dnfQuery.getUniqueName());
                 pQuery.setEvaluationHints(consumeHint(dnfQuery));
 
-                Map<Variable, PParameter> parameters = new HashMap<>();
-                for (Variable variable : dnfQuery.getParameters()) {
-                        parameters.put(variable, new PParameter(variable.getUniqueName()));
-                }
-
+                Map<SymbolicParameter, PParameter> parameters = new HashMap<>();
                 List<PParameter> parameterList = new ArrayList<>();
-                for (var param : dnfQuery.getParameters()) {
-                        parameterList.add(parameters.get(param));
+                for (var parameter : dnfQuery.getSymbolicParameters()) {
+                        var direction = switch (parameter.getDirection()) {
+                                case IN_OUT -> PParameterDirection.INOUT;
+                                case OUT -> PParameterDirection.OUT;
+                                case IN -> throw new IllegalArgumentException("Query %s with input parameter %s is not supported"
+                                                .formatted(dnfQuery, parameter.getVariable()));
+                        };
+                        var pParameter = new PParameter(parameter.getVariable().getUniqueName(), null, null, direction);
+                        parameters.put(parameter, pParameter);
+                        parameterList.add(pParameter);
                 }
+
                 pQuery.setParameters(parameterList);
 
                 for (var functionalDependency : dnfQuery.getFunctionalDependencies()) {
@@ -110,15 +117,15 @@ public class Dnf2PQuery {
                 synchronized (P_CONSTRAINT_LOCK) {
                         for (DnfClause clause : dnfQuery.getClauses()) {
                                 PBody body = new PBody(pQuery);
-                                List<ExportedParameter> symbolicParameters = new ArrayList<>();
-                                for (var param : dnfQuery.getParameters()) {
-                                        PVariable pVar = body.getOrCreateVariableByName(param.getUniqueName());
-                                        symbolicParameters.add(new ExportedParameter(body, pVar, parameters.get(param)));
+                                List<ExportedParameter> parameterExports = new ArrayList<>();
+                                for (var parameter : dnfQuery.getSymbolicParameters()) {
+                                        PVariable pVar = body.getOrCreateVariableByName(parameter.getVariable().getUniqueName());
+                                        parameterExports.add(new ExportedParameter(body, pVar, parameters.get(parameter)));
                                 }
-                                body.setSymbolicParameters(symbolicParameters);
+                                body.setSymbolicParameters(parameterExports);
                                 pQuery.addBody(body);
                                 for (Literal literal : clause.literals()) {
-                                        translateLiteral(literal, clause, body);
+                                        translateLiteral(literal, body);
                                 }
                         }
                 }
@@ -126,11 +133,11 @@ public class Dnf2PQuery {
                 return pQuery;
         }
 
-        private void translateLiteral(Literal literal, DnfClause clause, PBody body) {
+        private void translateLiteral(Literal literal, PBody body) {
                 if (literal instanceof EquivalenceLiteral equivalenceLiteral) {
                         translateEquivalenceLiteral(equivalenceLiteral, body);
                 } else if (literal instanceof CallLiteral callLiteral) {
-                        translateCallLiteral(callLiteral, clause, body);
+                        translateCallLiteral(callLiteral, body);
                 } else if (literal instanceof ConstantLiteral constantLiteral) {
                         translateConstantLiteral(constantLiteral, body);
                 } else if (literal instanceof AssignLiteral<?> assignLiteral) {
@@ -138,25 +145,25 @@ public class Dnf2PQuery {
                 } else if (literal instanceof AssumeLiteral assumeLiteral) {
                         translateAssumeLiteral(assumeLiteral, body);
                 } else if (literal instanceof CountLiteral countLiteral) {
-                        translateCountLiteral(countLiteral, clause, body);
+                        translateCountLiteral(countLiteral, body);
                 } else if (literal instanceof AggregationLiteral<?, ?> aggregationLiteral) {
-                        translateAggregationLiteral(aggregationLiteral, clause, body);
+                        translateAggregationLiteral(aggregationLiteral, body);
                 } else {
                         throw new IllegalArgumentException("Unknown literal: " + literal.toString());
                 }
         }
 
         private void translateEquivalenceLiteral(EquivalenceLiteral equivalenceLiteral, PBody body) {
-                PVariable varSource = body.getOrCreateVariableByName(equivalenceLiteral.left().getUniqueName());
-                PVariable varTarget = body.getOrCreateVariableByName(equivalenceLiteral.right().getUniqueName());
-                if (equivalenceLiteral.positive()) {
+                PVariable varSource = body.getOrCreateVariableByName(equivalenceLiteral.getLeft().getUniqueName());
+                PVariable varTarget = body.getOrCreateVariableByName(equivalenceLiteral.getRight().getUniqueName());
+                if (equivalenceLiteral.isPositive()) {
                         new Equality(body, varSource, varTarget);
                 } else {
                         new Inequality(body, varSource, varTarget);
                 }
         }
 
-        private void translateCallLiteral(CallLiteral callLiteral, DnfClause clause, PBody body) {
+        private void translateCallLiteral(CallLiteral callLiteral, PBody body) {
                 var polarity = callLiteral.getPolarity();
                 switch (polarity) {
                 case POSITIVE -> {
@@ -186,7 +193,7 @@ public class Dnf2PQuery {
                         new BinaryTransitiveClosure(body, substitution, pattern);
                 }
                 case NEGATIVE -> {
-                        var wrappedCall = wrapperFactory.maybeWrapConstraint(callLiteral, clause);
+                        var wrappedCall = wrapperFactory.maybeWrapConstraint(callLiteral);
                         var substitution = translateSubstitution(wrappedCall.remappedArguments(), body);
                         var pattern = wrappedCall.pattern();
                         new NegativePatternCall(body, substitution, pattern);
@@ -206,13 +213,13 @@ public class Dnf2PQuery {
         }
 
         private void translateConstantLiteral(ConstantLiteral constantLiteral, PBody body) {
-                var variable = body.getOrCreateVariableByName(constantLiteral.variable().getUniqueName());
-                new ConstantValue(body, variable, constantLiteral.nodeId());
+                var variable = body.getOrCreateVariableByName(constantLiteral.getVariable().getUniqueName());
+                new ConstantValue(body, variable, constantLiteral.getNodeId());
         }
 
         private <T> void translateAssignLiteral(AssignLiteral<T> assignLiteral, PBody body) {
-                var variable = body.getOrCreateVariableByName(assignLiteral.variable().getUniqueName());
-                var term = assignLiteral.term();
+                var variable = body.getOrCreateVariableByName(assignLiteral.getTargetVariable().getUniqueName());
+                var term = assignLiteral.getTerm();
                 if (term instanceof ConstantTerm<T> constantTerm) {
                         new ConstantValue(body, variable, constantTerm.getValue());
                 } else {
@@ -222,19 +229,18 @@ public class Dnf2PQuery {
         }
 
         private void translateAssumeLiteral(AssumeLiteral assumeLiteral, PBody body) {
-                var evaluator = new AssumptionEvaluator(assumeLiteral.term());
+                var evaluator = new AssumptionEvaluator(assumeLiteral.getTerm());
                 new ExpressionEvaluation(body, evaluator, null);
         }
 
-        private void translateCountLiteral(CountLiteral countLiteral, DnfClause clause, PBody body) {
-                var wrappedCall = wrapperFactory.maybeWrapConstraint(countLiteral, clause);
+        private void translateCountLiteral(CountLiteral countLiteral, PBody body) {
+                var wrappedCall = wrapperFactory.maybeWrapConstraint(countLiteral);
                 var substitution = translateSubstitution(wrappedCall.remappedArguments(), body);
                 var resultVariable = body.getOrCreateVariableByName(countLiteral.getResultVariable().getUniqueName());
                 new PatternMatchCounter(body, substitution, wrappedCall.pattern(), resultVariable);
         }
 
-        private <R, T> void translateAggregationLiteral(AggregationLiteral<R, T> aggregationLiteral, DnfClause clause,
-                                                                                                        PBody body) {
+        private <R, T> void translateAggregationLiteral(AggregationLiteral<R, T> aggregationLiteral, PBody body) {
                 var aggregator = aggregationLiteral.getAggregator();
                 IMultisetAggregationOperator<T, ?, R> aggregationOperator;
                 if (aggregator instanceof StatelessAggregator<R, T> statelessAggregator) {
@@ -244,7 +250,7 @@ public class Dnf2PQuery {
                 } else {
                         throw new IllegalArgumentException("Unknown aggregator: " + aggregator);
                 }
-                var wrappedCall = wrapperFactory.maybeWrapConstraint(aggregationLiteral, clause);
+                var wrappedCall = wrapperFactory.maybeWrapConstraint(aggregationLiteral);
                 var substitution = translateSubstitution(wrappedCall.remappedArguments(), body);
                 var inputVariable = body.getOrCreateVariableByName(aggregationLiteral.getInputVariable().getUniqueName());
                 var aggregatedColumn = substitution.invertIndex().get(inputVariable);