Fix enum literal scopes

2 files changed, 51 insertions, 27 deletions

diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/resource/NodeNameCollector.java b/language/src/main/java/org/eclipse/viatra/solver/language/resource/NodeNameCollector.java
index 4dee5434..79d7ffbb 100644
--- a/language/src/main/java/org/eclipse/viatra/solver/language/resource/NodeNameCollector.java
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/resource/NodeNameCollector.java
@@ -12,10 +12,8 @@ import org.eclipse.viatra.solver.language.model.problem.Assertion;
 import org.eclipse.viatra.solver.language.model.problem.AssertionArgument;
 import org.eclipse.viatra.solver.language.model.problem.Atom;
 import org.eclipse.viatra.solver.language.model.problem.Conjunction;
-import org.eclipse.viatra.solver.language.model.problem.EnumDeclaration;
 import org.eclipse.viatra.solver.language.model.problem.Literal;
 import org.eclipse.viatra.solver.language.model.problem.NegativeLiteral;
-import org.eclipse.viatra.solver.language.model.problem.Node;
 import org.eclipse.viatra.solver.language.model.problem.NodeAssertionArgument;
 import org.eclipse.viatra.solver.language.model.problem.NodeValueAssertion;
 import org.eclipse.viatra.solver.language.model.problem.PredicateDefinition;
@@ -47,7 +45,6 @@ public class NodeNameCollector {
         private IScopeProvider scopeProvider;
 
         private final Set<String> nodeNames = new HashSet<>();
-        private final Set<String> existingNodeNames = new HashSet<>();
 
         private IScope nodeScope;
 
@@ -56,27 +53,12 @@ public class NodeNameCollector {
         }
 
         public void collectNodeNames(Problem problem) {
-                nodeScope = scopeProvider.getScope(problem, ProblemPackage.Literals.ASSERTION__ARGUMENTS);
-                collectEnumLiteralNames(problem);
+                nodeScope = scopeProvider.getScope(problem, ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE);
                 for (Statement statement : problem.getStatements()) {
                         collectStatementNodeNames(statement);
                 }
         }
 
-        protected void collectEnumLiteralNames(Problem problem) {
-                for (Statement statement : problem.getStatements()) {
-                        if (statement instanceof EnumDeclaration) {
-                                EnumDeclaration enumDeclaration = (EnumDeclaration) statement;
-                                for (Node literal : enumDeclaration.getLiterals()) {
-                                        String name = literal.getName();
-                                        if (ProblemDerivedStateComputer.validId(name)) {
-                                                existingNodeNames.add(name);
-                                        }
-                                }
-                        }
-                }
-        }
-
         protected void collectStatementNodeNames(Statement statement) {
                 if (statement instanceof Assertion) {
                         collectAssertionNodeNames((Assertion) statement);
@@ -90,14 +72,14 @@ public class NodeNameCollector {
         protected void collectAssertionNodeNames(Assertion assertion) {
                 for (AssertionArgument argument : assertion.getArguments()) {
                         if (argument instanceof NodeAssertionArgument) {
-                                addNodeNames(argument, ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE,
+                                collectNodeNames(argument, ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE,
                                                 ProblemDerivedStateComputer::validNodeName);
                         }
                 }
         }
 
         protected void collectNodeValueAssertionNodeNames(NodeValueAssertion nodeValueAssertion) {
-                addNodeNames(nodeValueAssertion, ProblemPackage.Literals.NODE_VALUE_ASSERTION__NODE,
+                collectNodeNames(nodeValueAssertion, ProblemPackage.Literals.NODE_VALUE_ASSERTION__NODE,
                                 ProblemDerivedStateComputer::validNodeName);
         }
 
@@ -116,7 +98,7 @@ public class NodeNameCollector {
                                 }
                                 for (Argument argument : atom.getArguments()) {
                                         if (argument instanceof VariableOrNodeArgument) {
-                                                addNodeNames(argument, ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE,
+                                                collectNodeNames(argument, ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE,
                                                                 ProblemDerivedStateComputer::validQuotedId);
                                         }
                                 }
@@ -124,7 +106,7 @@ public class NodeNameCollector {
                 }
         }
 
-        private void addNodeNames(EObject eObject, EStructuralFeature feature, Predicate<String> condition) {
+        private void collectNodeNames(EObject eObject, EStructuralFeature feature, Predicate<String> condition) {
                 List<INode> nodes = NodeModelUtils.findNodesForFeature(eObject, feature);
                 for (INode node : nodes) {
                         String nodeName = linkingHelper.getCrossRefNodeAsString(node, true);
@@ -132,7 +114,7 @@ public class NodeNameCollector {
                                 continue;
                         }
                         QualifiedName qualifiedName = qualifiedNameConverter.toQualifiedName(nodeName);
-                        if (!existingNodeNames.contains(nodeName) && nodeScope.getSingleElement(qualifiedName) == null) {
+                        if (nodeScope.getSingleElement(qualifiedName) == null) {
                                 nodeNames.add(nodeName);
                         }
                 }
diff --git a/language/src/test/java/org/eclipse/viatra/solver/language/tests/scoping/NodeScopingTest.xtend b/language/src/test/java/org/eclipse/viatra/solver/language/tests/scoping/NodeScopingTest.xtend
index c92ad4c2..91a9e8a4 100644
--- a/language/src/test/java/org/eclipse/viatra/solver/language/tests/scoping/NodeScopingTest.xtend
+++ b/language/src/test/java/org/eclipse/viatra/solver/language/tests/scoping/NodeScopingTest.xtend
@@ -219,7 +219,7 @@ class NodeScopingTest {
                         predicate(«qualifiedName»).
                 ''')
                 assertThat(errors, empty)
-                assertThat(nodeNames, empty)
+                assertThat(nodes, empty)
                 assertThat(assertion(0).arg(0).node, equalTo(findEnum("Foo").literal("alpha")))
         }
 
@@ -232,7 +232,7 @@ class NodeScopingTest {
                         «qualifiedName»: 16.
                 ''')
                 assertThat(errors, empty)
-                assertThat(nodeNames, empty)
+                assertThat(nodes, empty)
                 assertThat(nodeValueAssertion(0).node, equalTo(findEnum("Foo").literal("alpha")))
         }
 
@@ -245,7 +245,7 @@ class NodeScopingTest {
                         pred predicate(Foo a) :- node(«qualifiedName»).
                 ''')
                 assertThat(errors, empty)
-                assertThat(nodeNames, empty)
+                assertThat(nodes, empty)
                 assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(findEnum("Foo").literal("alpha")))
         }
 
@@ -259,4 +259,46 @@ class NodeScopingTest {
                         Arguments.of("test::Foo::alpha", true)
                 )
         }
+
+        @ParameterizedTest
+        @MethodSource("builtInEnumLiteralReferencesSource")
+        def void builtInEnumLiteralTest(String qualifiedName) {
+                val it = parseHelper.parse('''
+                        pred predicate(node a) :- node(a).
+                        predicate(«qualifiedName»).
+                ''')
+                assertThat(errors, empty)
+                assertThat(nodes, empty)
+                assertThat(assertion(0).arg(0).node, equalTo(builtin.findEnum("bool").literal("true")))
+        }
+
+        @ParameterizedTest
+        @MethodSource("builtInEnumLiteralReferencesSource")
+        def void builtInEnumLiteralInNodeValueAssertionTest(String qualifiedName) {
+                val it = parseHelper.parse('''
+                        «qualifiedName»: 16.
+                ''')
+                assertThat(errors, empty)
+                assertThat(nodes, empty)
+                assertThat(nodeValueAssertion(0).node, equalTo(builtin.findEnum("bool").literal("true")))
+        }
+
+        @ParameterizedTest
+        @MethodSource("builtInEnumLiteralReferencesSource")
+        def void bultInEnumLiteralInPredicateTest(String qualifiedName) {
+                val it = parseHelper.parse('''
+                        pred predicate() :- node(«qualifiedName»).
+                ''')
+                assertThat(errors, empty)
+                assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(builtin.findEnum("bool").literal("true")))
+        }
+
+        static def builtInEnumLiteralReferencesSource() {
+                Stream.of(
+                        Arguments.of("true"),
+                        Arguments.of("bool::true"),
+                        Arguments.of("builtin::true"),
+                        Arguments.of("builtin::bool::true")
+                )
+        }
 }