refactor(language): invalid multiplicity trace

Also simplifies attributes and flags for now, as we don't translate them to
abstractions.

4 files changed, 3 insertions, 251 deletions

diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java
index c7952369..96e7cf9c 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java
@@ -31,7 +31,6 @@ class ProblemParsingTest {
                                 class Person {
                                         Person[0..*] children opposite parent
                                         Person[0..1] parent opposite children
-                                        int age
                                         TaxStatus taxStatus
                                 }
 
@@ -51,8 +50,6 @@ class ProblemParsingTest {
                                 children(anne, ciri).
                                 ?children(bob, ciri).
                                 taxStatus(anne, ADULT).
-                                age(bob): 21..35.
-                                age(ciri): 10.
                                 """);
                 assertThat(problem.errors(), empty());
         }
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java
index 1180d131..ed193e90 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java
@@ -29,9 +29,7 @@ class TransitiveClosureParserTest {
         @Test
         void binaryAddOperatorTest() {
                 var problem = parseHelper.parse("""
-                                        fn int a().
-                                        fn int b().
-                                        pred foo() <-> a() + (b()) > 10.
+                                        pred foo(a, b) <-> a + (b) > 10.
                                 """);
                 assertThat(problem.errors(), empty());
                 var literal = problem.pred("foo").conj(0).lit(0).get();
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java
index 3f3a081f..9f4f2bbf 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java
@@ -178,7 +178,7 @@ class ProblemSerializerTest {
                 var variable = ProblemFactory.eINSTANCE.createImplicitVariable();
                 variable.setName("q");
                 conjunction.getImplicitVariables().add(variable);
-                var equals = nodeType.feature("equals");
+                var equals = builtin.pred("equals").get();
                 conjunction.getLiterals().add(createAtom(equals, parameter1, variable));
                 conjunction.getLiterals().add(createAtom(equals, variable, parameter2));
                 pred.getBodies().add(conjunction);
@@ -212,7 +212,7 @@ class ProblemSerializerTest {
                 pred.getParameters().add(parameter);
                 var conjunction = ProblemFactory.eINSTANCE.createConjunction();
                 var atom = ProblemFactory.eINSTANCE.createAtom();
-                var equals = nodeType.feature("equals");
+                var equals = builtin.pred("equals").get();
                 atom.setRelation(equals);
                 var arg1 = ProblemFactory.eINSTANCE.createVariableOrNodeExpr();
                 arg1.setVariableOrNode(parameter);
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/utils/SymbolCollectorTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/utils/SymbolCollectorTest.java
deleted file mode 100644
index d200eeff..00000000
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/utils/SymbolCollectorTest.java
+++ /dev/null
@@ -1,243 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.language.tests.utils;
-
-import com.google.inject.Inject;
-import org.eclipse.xtext.testing.InjectWith;
-import org.eclipse.xtext.testing.extensions.InjectionExtension;
-import org.hamcrest.Matcher;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import tools.refinery.language.model.problem.*;
-import tools.refinery.language.model.tests.utils.ProblemParseHelper;
-import tools.refinery.language.tests.ProblemInjectorProvider;
-import tools.refinery.language.utils.ContainmentRole;
-import tools.refinery.language.utils.ProblemDesugarer;
-
-import java.util.stream.Stream;
-
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.*;
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
-
-@ExtendWith(InjectionExtension.class)
-@InjectWith(ProblemInjectorProvider.class)
-class SymbolCollectorTest {
-        @Inject
-        private ProblemParseHelper parseHelper;
-
-        @Inject
-        private ProblemDesugarer desugarer;
-
-        @Test
-        void implicitNodeTest() {
-                var problem = parseHelper.parse("""
-                                exists(a).
-                                """);
-                var collectedSymbols = desugarer.collectSymbols(problem.get());
-                var node = problem.node("a");
-                assertThat(collectedSymbols.nodes(), hasKey(node));
-                assertThat(collectedSymbols.nodes().get(node).individual(), is(false));
-        }
-
-        @Test
-        void individualNodeTest() {
-                var problem = parseHelper.parse("""
-                                indiv a.
-                                """);
-                var collectedSymbols = desugarer.collectSymbols(problem.get());
-                var node = problem.individualNode("a");
-                assertThat(collectedSymbols.nodes(), hasKey(node));
-                assertThat(collectedSymbols.nodes().get(node).individual(), is(true));
-        }
-
-        @Test
-        void classTest() {
-                var problem = parseHelper.parse("""
-                                class Foo.
-                                """);
-                var collectedSymbols = desugarer.collectSymbols(problem.get());
-                var classDeclaration = problem.findClass("Foo").get();
-                assertThat(collectedSymbols.relations(), hasKey(classDeclaration));
-                var classInfo = collectedSymbols.relations().get(classDeclaration);
-                assertThat(classInfo.parameters(), hasSize(1));
-                assertThat(classInfo.containmentRole(), is(ContainmentRole.CONTAINED));
-                assertThat(classInfo.hasDefinition(), is(false));
-                var newNode = classDeclaration.getNewNode();
-                assertThat(collectedSymbols.nodes(), hasKey(newNode));
-                assertThat(collectedSymbols.nodes().get(newNode).individual(), is(false));
-                assertThat(classInfo.assertions(), assertsNode(newNode, LogicValue.TRUE));
-                assertThat(collectedSymbols.relations().get(problem.builtinSymbols().exists()).assertions(),
-                                assertsNode(newNode, LogicValue.UNKNOWN));
-                assertThat(collectedSymbols.relations().get(problem.builtinSymbols().equals()).assertions(),
-                                assertsNode(newNode, LogicValue.UNKNOWN));
-        }
-
-        @Test
-        void abstractClassTest() {
-                var problem = parseHelper.parse("""
-                                abstract class Foo.
-                                """);
-                var collectedSymbols = desugarer.collectSymbols(problem.get());
-                assertThat(collectedSymbols.relations().get(problem.findClass("Foo").get()).assertions(), hasSize(0));
-        }
-
-        @Test
-        void referenceTest() {
-                var problem = parseHelper.parse("""
-                                class Foo {
-                                        refers Foo[] bar opposite quux
-                                        refers Foo quux opposite bar
-                                }
-                                """);
-                var collectedSymbols = desugarer.collectSymbols(problem.get());
-                var fooClass = problem.findClass("Foo");
-                var barReference = fooClass.feature("bar");
-                var barInfo = collectedSymbols.relations().get(barReference);
-                var quuxReference = fooClass.feature("quux");
-                var quuxInfo = collectedSymbols.relations().get(quuxReference);
-                assertThat(barInfo.containmentRole(), is(ContainmentRole.NONE));
-                assertThat(barInfo.opposite(), is(quuxReference));
-                assertThat(barInfo.multiplicity(), is(instanceOf(UnboundedMultiplicity.class)));
-                assertThat(barInfo.hasDefinition(), is(false));
-                assertThat(quuxInfo.containmentRole(), is(ContainmentRole.NONE));
-                assertThat(quuxInfo.opposite(), is(barReference));
-                assertThat(quuxInfo.multiplicity(), is(instanceOf(ExactMultiplicity.class)));
-                assertThat(quuxInfo.multiplicity(), hasProperty("exactValue", is(1)));
-                assertThat(quuxInfo.hasDefinition(), is(false));
-        }
-
-        @Test
-        void containmentReferenceTest() {
-                var problem = parseHelper.parse("""
-                                class Foo {
-                                        contains Foo[] bar
-                                }
-                                """);
-                var collectedSymbols = desugarer.collectSymbols(problem.get());
-                assertThat(collectedSymbols.relations().get(problem.findClass("Foo").feature("bar")).containmentRole(),
-                                is(ContainmentRole.CONTAINMENT));
-        }
-
-        @Disabled("TODO: Rework numerical references")
-        @Test
-        void dataReferenceTest() {
-                var problem = parseHelper.parse("""
-                                class Foo {
-                                        int bar
-                                }
-                                """);
-                var collectedSymbols = desugarer.collectSymbols(problem.get());
-                assertThat(collectedSymbols.relations().get(problem.findClass("Foo").feature("bar")).containmentRole(),
-                                is(ContainmentRole.CONTAINMENT));
-        }
-
-        @Test
-        void enumTest() {
-                var problem = parseHelper.parse("""
-                                enum Foo {
-                                        bar, quux
-                                }
-                                """);
-                var collectedSymbols = desugarer.collectSymbols(problem.get());
-                var enumDeclaration = problem.findEnum("Foo");
-                var enumInfo = collectedSymbols.relations().get(enumDeclaration.get());
-                assertThat(enumInfo.containmentRole(), is(ContainmentRole.NONE));
-                assertThat(enumInfo.assertions(), assertsNode(enumDeclaration.literal("bar"), LogicValue.TRUE));
-                assertThat(enumInfo.assertions(), assertsNode(enumDeclaration.literal("quux"), LogicValue.TRUE));
-        }
-
-        @ParameterizedTest
-        @MethodSource
-        void predicateTest(String keyword, ContainmentRole containmentRole) {
-                var problem = parseHelper.parse(keyword + " foo(node x) <-> domain(x); data(x).");
-                var collectedSymbols = desugarer.collectSymbols(problem.get());
-                var predicateInfo = collectedSymbols.relations().get(problem.pred("foo").get());
-                assertThat(predicateInfo.containmentRole(), is(containmentRole));
-                assertThat(predicateInfo.parameters(), hasSize(1));
-                assertThat(predicateInfo.bodies(), hasSize(2));
-                assertThat(predicateInfo.hasDefinition(), is(true));
-        }
-
-        static Stream<Arguments> predicateTest() {
-                return Stream.of(Arguments.of("pred", ContainmentRole.NONE), Arguments.of("error", ContainmentRole.NONE),
-                                Arguments.of("contained pred", ContainmentRole.CONTAINED), Arguments.of("containment pred",
-                                                ContainmentRole.CONTAINMENT));
-        }
-
-        @ParameterizedTest
-        @MethodSource("logicValues")
-        void assertionTest(String keyword, LogicValue value) {
-                var problem = parseHelper.parse("""
-                                pred foo(node x).
-                                foo(a): %s.
-                                """.formatted(keyword));
-                var collectedSymbols = desugarer.collectSymbols(problem.get());
-                assertThat(collectedSymbols.relations().get(problem.pred("foo").get()).assertions(),
-                                assertsNode(problem.node("a"), value));
-        }
-
-        @ParameterizedTest
-        @MethodSource("logicValues")
-        void defaultAssertionTest(String keyword, LogicValue value) {
-                var problem = parseHelper.parse("""
-                                pred foo(node x).
-                                default foo(a): %s.
-                                """.formatted(keyword));
-                var collectedSymbols = desugarer.collectSymbols(problem.get());
-                assertThat(collectedSymbols.relations().get(problem.pred("foo").get()).assertions(),
-                                assertsNode(problem.node("a"), value));
-        }
-
-        static Stream<Arguments> logicValues() {
-                return Stream.of(Arguments.of("true", LogicValue.TRUE), Arguments.of("false", LogicValue.FALSE),
-                                Arguments.of("unknown", LogicValue.UNKNOWN), Arguments.of("error", LogicValue.ERROR));
-        }
-
-        @Test
-        void invalidAssertionArityTest() {
-                var problem = parseHelper.parse("""
-                                pred foo(node x).
-                                foo(a, b).
-                                """);
-                var collectedSymbols = desugarer.collectSymbols(problem.get());
-                assertThat(collectedSymbols.relations().get(problem.pred("foo").get()).assertions(), hasSize(0));
-        }
-
-        @Test
-        void invalidProblemTest() {
-                var problem = parseHelper.parse("""
-                                class Foo {
-                                        bar[] opposite quux
-                                        Foo quux opposite bar
-                                }
-                                """).get();
-                assertDoesNotThrow(() -> desugarer.collectSymbols(problem));
-        }
-
-        @Test
-        void errorAssertionTest() {
-                var problem = parseHelper.parse("""
-                                error foo(node a, node b) <-> equals(a, b).
-                                """);
-                var collectedSymbols = desugarer.collectSymbols(problem.get());
-                var fooInfo = collectedSymbols.relations().get(problem.pred("foo").get());
-                assertThat(fooInfo.assertions(), hasSize(1));
-                var assertion = fooInfo.assertions().stream().findFirst().orElseThrow();
-                assertThat(assertion.getValue(), hasProperty("logicValue", is(LogicValue.FALSE)));
-                assertThat(assertion.getArguments(), hasSize(2));
-                assertThat(assertion.getArguments(), everyItem(instanceOf(WildcardAssertionArgument.class)));
-        }
-
-        private static Matcher<Iterable<? super Assertion>> assertsNode(Node node, LogicValue value) {
-                return hasItem(allOf(hasProperty("arguments", hasItem(hasProperty("node", is(node)))), hasProperty("value",
-                                hasProperty("logicValue", is(value)))));
-        }
-}