refactor: enable data variable unification

This is needed for demand set transformation of DNFs with input data parameters,
where the result of the transformation has an out data parameter that has to be
unified with the variable in the parent clause.

1 files changed, 1 insertions, 178 deletions

diff --git a/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/VariableDirectionTest.java b/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/VariableDirectionTest.java
index c509da4d..bfeaa447 100644
--- a/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/VariableDirectionTest.java
+++ b/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/VariableDirectionTest.java
@@ -28,9 +28,8 @@ import static org.hamcrest.Matchers.hasItem;
 import static org.hamcrest.Matchers.not;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static tools.refinery.store.query.literal.Literals.check;
 import static tools.refinery.store.query.literal.Literals.not;
-import static tools.refinery.store.query.term.int_.IntTerms.*;
+import static tools.refinery.store.query.term.int_.IntTerms.INT_SUM;
 
 class VariableDirectionTest {
         private static final Symbol<Boolean> person = Symbol.of("Person", 1);
@@ -246,182 +245,6 @@ class VariableDirectionTest {
                 );
         }
 
-        @ParameterizedTest
-        @MethodSource("clausesWithDataVariableInput")
-        void unboundOutDataVariableTest(List<? extends Literal> clause) {
-                var builder = Dnf.builder().parameter(x, ParameterDirection.OUT).clause(clause);
-                assertThrows(IllegalArgumentException.class, builder::build);
-        }
-
-        @ParameterizedTest
-        @MethodSource("clausesWithDataVariableInput")
-        void unboundInDataVariableTest(List<? extends Literal> clause) {
-                var builder = Dnf.builder().parameter(x, ParameterDirection.IN).clause(clause);
-                var dnf = assertDoesNotThrow(builder::build);
-                var clauses = dnf.getClauses();
-                if (clauses.size() > 0) {
-                        assertThat(clauses.get(0).positiveVariables(), hasItem(x));
-                }
-        }
-
-        @ParameterizedTest
-        @MethodSource("clausesWithDataVariableInput")
-        void boundPrivateDataVariableTest(List<? extends Literal> clause) {
-                var clauseWithBinding = new ArrayList<Literal>(clause);
-                clauseWithBinding.add(x.assign(constant(27)));
-                var builder = Dnf.builder().clause(clauseWithBinding);
-                var dnf = assertDoesNotThrow(builder::build);
-                var clauses = dnf.getClauses();
-                if (clauses.size() > 0) {
-                        assertThat(clauses.get(0).positiveVariables(), hasItem(x));
-                }
-        }
-
-        static Stream<Arguments> clausesWithDataVariableInput() {
-                return Stream.concat(
-                                clausesNotBindingDataVariable(),
-                                literalToClauseArgumentStream(literalsWithRequiredDataVariableInput())
-                );
-        }
-
-        @ParameterizedTest
-        @MethodSource("clausesNotBindingDataVariable")
-        void unboundPrivateDataVariableTest(List<? extends Literal> clause) {
-                var builder = Dnf.builder().clause(clause);
-                var dnf = assertDoesNotThrow(builder::build);
-                var clauses = dnf.getClauses();
-                if (clauses.size() > 0) {
-                        assertThat(clauses.get(0).positiveVariables(), not(hasItem(x)));
-                }
-        }
-
-        static Stream<Arguments> clausesNotBindingDataVariable() {
-                return Stream.concat(
-                                Stream.of(
-                                                Arguments.of(List.of()),
-                                                Arguments.of(List.of(BooleanLiteral.TRUE)),
-                                                Arguments.of(List.of(BooleanLiteral.FALSE))
-                                ),
-                                literalToClauseArgumentStream(literalsWithPrivateDataVariable())
-                );
-        }
-
-        @ParameterizedTest
-        @MethodSource("literalsWithPrivateDataVariable")
-        void unboundTwicePrivateDataVariableTest(Literal literal) {
-                var builder = Dnf.builder().clause(not(ageView.call(p, x)), literal);
-                assertThrows(IllegalArgumentException.class, builder::build);
-        }
-
-        static Stream<Arguments> literalsWithPrivateDataVariable() {
-                var dnfWithOutput = Dnf.builder("WithDataOutput")
-                                .parameter(y, ParameterDirection.OUT)
-                                .parameter(q, ParameterDirection.OUT)
-                                .clause(ageView.call(q, y))
-                                .build();
-
-                return Stream.of(
-                                Arguments.of(not(ageView.call(q, x))),
-                                Arguments.of(y.assign(ageView.count(q, x))),
-                                Arguments.of(not(dnfWithOutput.call(x, q)))
-                );
-        }
-
-        @ParameterizedTest
-        @MethodSource("literalsWithRequiredDataVariableInput")
-        void unboundPrivateDataVariableTest(Literal literal) {
-                var builder = Dnf.builder().clause(literal);
-                assertThrows(IllegalArgumentException.class, builder::build);
-        }
-
-        static Stream<Arguments> literalsWithRequiredDataVariableInput() {
-                var dnfWithInput = Dnf.builder("WithDataInput")
-                                .parameter(y, ParameterDirection.IN)
-                                .parameter(q, ParameterDirection.OUT)
-                                .clause(ageView.call(q, x))
-                                .build();
-                // We are passing {@code y} to the parameter named {@code right} of {@code greaterEq}.
-                @SuppressWarnings("SuspiciousNameCombination")
-                var dnfWithInputToAggregate = Dnf.builder("WithDataInputToAggregate")
-                                .parameter(y, ParameterDirection.IN)
-                                .parameter(q, ParameterDirection.OUT)
-                                .parameter(x, ParameterDirection.OUT)
-                                .clause(
-                                                friendView.call(p, q),
-                                                ageView.call(q, x),
-                                                check(greaterEq(x, y))
-                                )
-                                .build();
-
-                return Stream.of(
-                                Arguments.of(dnfWithInput.call(x, q)),
-                                Arguments.of(not(dnfWithInput.call(x, q))),
-                                Arguments.of(y.assign(dnfWithInput.count(x, q))),
-                                Arguments.of(y.assign(dnfWithInputToAggregate.aggregateBy(z, INT_SUM, x, q, z)))
-                );
-        }
-
-        @ParameterizedTest
-        @MethodSource("literalsWithDataVariableOutput")
-        void boundDataParameterTest(Literal literal) {
-                var builder = Dnf.builder().parameter(x, ParameterDirection.OUT).clause(literal);
-                var dnf = assertDoesNotThrow(builder::build);
-                assertThat(dnf.getClauses().get(0).positiveVariables(), hasItem(x));
-        }
-
-        @ParameterizedTest
-        @MethodSource("literalsWithDataVariableOutput")
-        void boundTwiceDataParameterTest(Literal literal) {
-                var builder = Dnf.builder().parameter(x, ParameterDirection.IN).clause(literal);
-                assertThrows(IllegalArgumentException.class, builder::build);
-        }
-
-        @ParameterizedTest
-        @MethodSource("literalsWithDataVariableOutput")
-        void boundPrivateDataVariableOutputTest(Literal literal) {
-                var dnfWithInput = Dnf.builder("WithInput")
-                                .parameter(x, ParameterDirection.IN)
-                                .clause(check(greaterEq(x, constant(24))))
-                                .build();
-                var builder = Dnf.builder().clause(dnfWithInput.call(x), literal);
-                var dnf = assertDoesNotThrow(builder::build);
-                assertThat(dnf.getClauses().get(0).positiveVariables(), hasItem(x));
-        }
-
-        @ParameterizedTest
-        @MethodSource("literalsWithDataVariableOutput")
-        void boundTwicePrivateDataVariableOutputTest(Literal literal) {
-                var builder = Dnf.builder().clause(x.assign(constant(27)), literal);
-                assertThrows(IllegalArgumentException.class, builder::build);
-        }
-
-        static Stream<Arguments> literalsWithDataVariableOutput() {
-                var dnfWithOutput = Dnf.builder("WithOutput")
-                                .parameter(q, ParameterDirection.OUT)
-                                .clause(personView.call(q))
-                                .build();
-                var dnfWithDataOutput = Dnf.builder("WithDataOutput")
-                                .parameter(y, ParameterDirection.OUT)
-                                .parameter(q, ParameterDirection.OUT)
-                                .clause(ageView.call(q, y))
-                                .build();
-                var dnfWithOutputToAggregate = Dnf.builder("WithDataOutputToAggregate")
-                                .parameter(q, ParameterDirection.OUT)
-                                .parameter(y, ParameterDirection.OUT)
-                                .clause(ageView.call(q, y))
-                                .build();
-
-                return Stream.of(
-                                Arguments.of(x.assign(constant(24))),
-                                Arguments.of(ageView.call(q, x)),
-                                Arguments.of(x.assign(personView.count(q))),
-                                Arguments.of(x.assign(ageView.aggregate(INT_SUM, q))),
-                                Arguments.of(dnfWithDataOutput.call(x, q)),
-                                Arguments.of(x.assign(dnfWithOutput.count(q))),
-                                Arguments.of(x.assign(dnfWithOutputToAggregate.aggregateBy(z, INT_SUM, q, z)))
-                );
-        }
-
         private static Stream<Arguments> literalToClauseArgumentStream(Stream<Arguments> literalArgumentsStream) {
                 return literalArgumentsStream.map(arguments -> Arguments.of(List.of(arguments.get()[0])));
         }