Add scoping tests and simplify implicit nodes

* Do not export implicit nodes to the global scope
* Enum literals must not be quoted
* Plan for the future: unify quoted nodes from the global scope in
  post-processing

3 files changed, 259 insertions, 1 deletions

diff --git a/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemParsingTest.xtend b/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemParsingTest.xtend
index b007cf8b..9b1bb698 100644
--- a/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemParsingTest.xtend
+++ b/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemParsingTest.xtend
@@ -1,5 +1,5 @@
 /*
- * generated by Xtext 2.25.0
+ * generated by Xtext 2.26.0.M1
  */
 package org.eclipse.viatra.solver.language.tests
 
diff --git a/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemScopingTest.xtend b/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemScopingTest.xtend
new file mode 100644
index 00000000..7872b0f7
--- /dev/null
+++ b/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemScopingTest.xtend
@@ -0,0 +1,148 @@
+/*
+ * generated by Xtext 2.25.0
+ */
+package org.eclipse.viatra.solver.language.tests
+
+import com.google.inject.Inject
+import org.eclipse.viatra.solver.language.model.problem.Problem
+import org.eclipse.xtext.testing.InjectWith
+import org.eclipse.xtext.testing.extensions.InjectionExtension
+import org.eclipse.xtext.testing.util.ParseHelper
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.^extension.ExtendWith
+
+import static org.hamcrest.MatcherAssert.assertThat
+import static org.hamcrest.Matchers.*
+
+@ExtendWith(InjectionExtension)
+@InjectWith(ProblemInjectorProvider)
+class ProblemScopingTest {
+        @Inject
+        ParseHelper<Problem> parseHelper
+
+        @Inject
+        extension ProblemTestUtil
+
+        @Test
+        def void builtInArgumentTypeTest() {
+                val it = parseHelper.parse('''
+                        pred predicate(node a, data b, int c).
+                ''').assertNoErrors
+                assertThat(pred('predicate').param(0).parameterType, equalTo(builtin.findClass('node')))
+                assertThat(pred('predicate').param(1).parameterType, equalTo(builtin.findClass('data')))
+                assertThat(pred('predicate').param(2).parameterType, equalTo(builtin.findClass('int')))
+        }
+
+        @Test
+        def void builtiQualifiedArgumentTypeTest() {
+                val it = parseHelper.parse('''
+                        pred predicate(builtin::node a, builtin::data b, builtin::int c).
+                ''').assertNoErrors
+                assertThat(pred('predicate').param(0).parameterType, equalTo(builtin.findClass('node')))
+                assertThat(pred('predicate').param(1).parameterType, equalTo(builtin.findClass('data')))
+                assertThat(pred('predicate').param(2).parameterType, equalTo(builtin.findClass('int')))
+        }
+
+        @Test
+        def void implicitNodeInAssertionTest() {
+                val it = parseHelper.parse('''
+                        pred predicate(node a, node b).
+                        predicate(a, a).
+                        ?predicate(a, b).
+                ''').assertNoErrors
+                assertThat(nodeNames, hasItems('a', 'b'))
+                assertThat(assertion(0).arg(0).node, equalTo(node('a')))
+                assertThat(assertion(0).arg(1).node, equalTo(node('a')))
+                assertThat(assertion(1).arg(0).node, equalTo(node('a')))
+                assertThat(assertion(1).arg(1).node, equalTo(node('b')))
+        }
+
+        @Test
+        def void quotedNodeInAssertionTest() {
+                val it = parseHelper.parse('''
+                        pred predicate(node a, node b).
+                        predicate('a', 'a').
+                        ?predicate('a', 'b').
+                ''').assertNoErrors
+                assertThat(nodeNames, hasItems("'a'", "'b'"))
+                assertThat(assertion(0).arg(0).node, equalTo(node("'a'")))
+                assertThat(assertion(0).arg(1).node, equalTo(node("'a'")))
+                assertThat(assertion(1).arg(0).node, equalTo(node("'a'")))
+                assertThat(assertion(1).arg(1).node, equalTo(node("'b'")))
+        }
+
+        @Test
+        def void builtInNodeInAssertionTest() {
+                val it = parseHelper.parse('''
+                        pred predicate(node a).
+                        predicate(int::new).
+                ''').assertNoErrors
+                assertThat(nodes, empty)
+                assertThat(assertion(0).arg(0).node, equalTo(builtin.findClass('int').newNode))
+        }
+        
+        @Test
+        def void qualifiedBuiltInNodeInAssertionTest() {
+                val it = parseHelper.parse('''
+                        pred predicate(node a).
+                        predicate(builtin::int::new).
+                ''').assertNoErrors
+                assertThat(nodes, empty)
+                assertThat(assertion(0).arg(0).node, equalTo(builtin.findClass('int').newNode))
+        }
+
+        @Test
+        def void classNewNodeTest() {
+                val it = parseHelper.parse('''
+                        class Foo.
+                        pred predicate(node a).
+                        predicate(Foo::new).
+                ''').assertNoErrors
+                assertThat(nodes, empty)
+                assertThat(assertion(0).arg(0).node, equalTo(findClass('Foo').newNode))
+        }
+        
+        
+        @Test
+        def void qualifiedClassNewNodeTest() {
+                val it = parseHelper.parse('''
+                        problem test.
+                        class Foo.
+                        pred predicate(node a).
+                        predicate(test::Foo::new).
+                ''').assertNoErrors
+                assertThat(nodes, empty)
+                assertThat(assertion(0).arg(0).node, equalTo(findClass('Foo').newNode))
+        }
+        
+        @Test
+        def void newNodeIsNotSpecial() {
+                val it = parseHelper.parse('''
+                        class Foo.
+                        pred predicate(node a).
+                        predicate(new).
+                ''').assertNoErrors
+                assertThat(nodeNames, hasItem('new'))
+                assertThat(assertion(0).arg(0).node, not(equalTo(findClass('Foo').newNode)))
+        }
+        
+        @Test
+        def void implicitNodeInPredicateTest() {
+                val it = parseHelper.parse('''
+                        pred predicate(node a) :- node(b).
+                        predicate(b).
+                ''').assertNoErrors
+                assertThat(nodeNames, hasItem("b"))
+                assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(node("b")))
+                assertThat(assertion(0).arg(0).node, equalTo(node("b")))
+        }
+        
+        @Test
+        def void quotedNodeInPredicateTest() {
+                val it = parseHelper.parse('''
+                        pred predicate(node a) :- node('b').
+                ''').assertNoErrors
+                assertThat(nodeNames, hasItem("'b'"))
+                assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(node("'b'")))
+        }
+}
diff --git a/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemTestUtil.xtend b/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemTestUtil.xtend
new file mode 100644
index 00000000..98b53675
--- /dev/null
+++ b/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemTestUtil.xtend
@@ -0,0 +1,110 @@
+package org.eclipse.viatra.solver.language.tests
+
+import org.eclipse.emf.ecore.util.EcoreUtil
+import org.eclipse.viatra.solver.language.ProblemUtil
+import org.eclipse.viatra.solver.language.model.problem.Argument
+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.ClassDeclaration
+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.PredicateDefinition
+import org.eclipse.viatra.solver.language.model.problem.Problem
+import org.eclipse.viatra.solver.language.model.problem.Variable
+import org.eclipse.viatra.solver.language.model.problem.VariableOrNodeArgument
+import org.junit.jupiter.api.Assertions
+
+class ProblemTestUtil {
+        def builtin(Problem it) {
+                ProblemUtil.getBuiltInLibrary(it).get
+        }
+        
+        def assertNoErrors(Problem it) {
+                Assertions.assertNotNull(it)
+                EcoreUtil.resolveAll(it)
+                val errors = eResource.errors
+                Assertions.assertTrue(errors.isEmpty, '''Unexpected errors: «errors.join(", ")»''')
+                it
+        }
+        
+        def nodeNames(Problem it) {
+                nodes.map[name]
+        }
+        
+        def pred(Problem it, String name) {
+                statements.filter(PredicateDefinition).findFirst[it.name == name]
+        }
+        
+        def param(PredicateDefinition it, int i) {
+                parameters.get(i)
+        } 
+
+        def conj(PredicateDefinition it, int i) {
+                bodies.get(i)
+        }
+
+        def lit(Conjunction it, int i) {
+                literals.get(i)
+        }
+
+        def negated(Literal it) {
+                (it as NegativeLiteral).atom
+        }
+
+        def relation(Literal it) {
+                (it as Atom).relation
+        }
+
+        def arg(Atom it, int i) {
+                it.arguments.get(i)
+        }
+
+        def arg(Literal it, int i) {
+                (it as Atom).arg(i)
+        }
+
+        def variable(Argument it) {
+                (it as VariableOrNodeArgument).variableOrNode as Variable
+        }
+
+        def node(Argument it) {
+                (it as VariableOrNodeArgument).variableOrNode as Node
+        }
+        
+        def assertion(Problem it, int i) {
+                statements.filter(Assertion).get(i)
+        }
+        
+        def arg(Assertion it, int i) {
+                arguments.get(i)
+        }
+        
+        def node(AssertionArgument it) {
+                (it as NodeAssertionArgument).node
+        }
+        
+        def node(Problem it, String name) {
+                nodes.findFirst[it.name == name]
+        }
+        
+        def findClass(Problem it, String name) {
+                statements.filter(ClassDeclaration).findFirst[it.name == name]
+        }
+        
+        def reference(ClassDeclaration it, String name) {
+                it.referenceDeclarations.findFirst[it.name == name]
+        }
+        
+        def findEnum(Problem it, String name) {
+                statements.filter(EnumDeclaration).findFirst[it.name == name]
+        }
+        
+        def literal(EnumDeclaration it, String name) {
+                literals.findFirst[it.name == name]
+        }
+}