Node scoping fixes

6 files changed, 417 insertions, 221 deletions

diff --git a/language/build.gradle b/language/build.gradle
index 5b0ab20f..7e079f27 100644
--- a/language/build.gradle
+++ b/language/build.gradle
@@ -7,6 +7,7 @@ configurations {
 dependencies {
         testCompile "org.junit.jupiter:junit-jupiter-api:${junitVersion}"
         testRuntime "org.junit.jupiter:junit-jupiter-engine:${junitVersion}"
+        testCompile "org.junit.jupiter:junit-jupiter-params:${junitVersion}"
         testCompile "org.eclipse.xtext:org.eclipse.xtext.testing:${xtextVersion}"
         testCompile "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:${xtextVersion}"
         testCompile "org.hamcrest:hamcrest:${hamcrestVersion}"
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
new file mode 100644
index 00000000..4dee5434
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/resource/NodeNameCollector.java
@@ -0,0 +1,140 @@
+package org.eclipse.viatra.solver.language.resource;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Predicate;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+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.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;
+import org.eclipse.viatra.solver.language.model.problem.Problem;
+import org.eclipse.viatra.solver.language.model.problem.ProblemPackage;
+import org.eclipse.viatra.solver.language.model.problem.Statement;
+import org.eclipse.viatra.solver.language.model.problem.VariableOrNodeArgument;
+import org.eclipse.xtext.linking.impl.LinkingHelper;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.nodemodel.util.NodeModelUtils;
+import org.eclipse.xtext.scoping.IScope;
+import org.eclipse.xtext.scoping.IScopeProvider;
+import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
+
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
+
+public class NodeNameCollector {
+        @Inject
+        private LinkingHelper linkingHelper;
+
+        @Inject
+        private IQualifiedNameConverter qualifiedNameConverter;
+
+        @Inject
+        @Named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)
+        private IScopeProvider scopeProvider;
+
+        private final Set<String> nodeNames = new HashSet<>();
+        private final Set<String> existingNodeNames = new HashSet<>();
+
+        private IScope nodeScope;
+
+        public Set<String> getNodeNames() {
+                return nodeNames;
+        }
+
+        public void collectNodeNames(Problem problem) {
+                nodeScope = scopeProvider.getScope(problem, ProblemPackage.Literals.ASSERTION__ARGUMENTS);
+                collectEnumLiteralNames(problem);
+                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);
+                } else if (statement instanceof NodeValueAssertion) {
+                        collectNodeValueAssertionNodeNames((NodeValueAssertion) statement);
+                } else if (statement instanceof PredicateDefinition) {
+                        collectPredicateDefinitionNodeNames((PredicateDefinition) statement);
+                }
+        }
+
+        protected void collectAssertionNodeNames(Assertion assertion) {
+                for (AssertionArgument argument : assertion.getArguments()) {
+                        if (argument instanceof NodeAssertionArgument) {
+                                addNodeNames(argument, ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE,
+                                                ProblemDerivedStateComputer::validNodeName);
+                        }
+                }
+        }
+
+        protected void collectNodeValueAssertionNodeNames(NodeValueAssertion nodeValueAssertion) {
+                addNodeNames(nodeValueAssertion, ProblemPackage.Literals.NODE_VALUE_ASSERTION__NODE,
+                                ProblemDerivedStateComputer::validNodeName);
+        }
+
+        protected void collectPredicateDefinitionNodeNames(PredicateDefinition predicateDefinition) {
+                for (Conjunction body : predicateDefinition.getBodies()) {
+                        for (Literal literal : body.getLiterals()) {
+                                Atom atom = null;
+                                if (literal instanceof Atom) {
+                                        atom = (Atom) literal;
+                                } else if (literal instanceof NegativeLiteral) {
+                                        NegativeLiteral negativeLiteral = (NegativeLiteral) literal;
+                                        atom = negativeLiteral.getAtom();
+                                }
+                                if (atom == null) {
+                                        continue;
+                                }
+                                for (Argument argument : atom.getArguments()) {
+                                        if (argument instanceof VariableOrNodeArgument) {
+                                                addNodeNames(argument, ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE,
+                                                                ProblemDerivedStateComputer::validQuotedId);
+                                        }
+                                }
+                        }
+                }
+        }
+
+        private void addNodeNames(EObject eObject, EStructuralFeature feature, Predicate<String> condition) {
+                List<INode> nodes = NodeModelUtils.findNodesForFeature(eObject, feature);
+                for (INode node : nodes) {
+                        String nodeName = linkingHelper.getCrossRefNodeAsString(node, true);
+                        if (!condition.test(nodeName)) {
+                                continue;
+                        }
+                        QualifiedName qualifiedName = qualifiedNameConverter.toQualifiedName(nodeName);
+                        if (!existingNodeNames.contains(nodeName) && nodeScope.getSingleElement(qualifiedName) == null) {
+                                nodeNames.add(nodeName);
+                        }
+                }
+        }
+}
\ No newline at end of file
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemDerivedStateComputer.java b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemDerivedStateComputer.java
index 42e53534..81236afd 100644
--- a/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemDerivedStateComputer.java
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemDerivedStateComputer.java
@@ -5,18 +5,14 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.function.Predicate;
 import java.util.regex.Pattern;
 
 import org.eclipse.emf.common.notify.impl.AdapterImpl;
 import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.emf.ecore.resource.Resource;
 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;
@@ -25,8 +21,6 @@ import org.eclipse.viatra.solver.language.model.problem.ImplicitVariable;
 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.Parameter;
 import org.eclipse.viatra.solver.language.model.problem.PredicateDefinition;
 import org.eclipse.viatra.solver.language.model.problem.Problem;
@@ -48,6 +42,7 @@ import org.eclipse.xtext.scoping.IScopeProvider;
 import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
 
 import com.google.inject.Inject;
+import com.google.inject.Provider;
 import com.google.inject.Singleton;
 import com.google.inject.name.Named;
 
@@ -73,6 +68,9 @@ public class ProblemDerivedStateComputer implements IDerivedStateComputer {
         @Named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)
         private IScopeProvider scopeProvider;
 
+        @Inject
+        private Provider<NodeNameCollector> nodeNameCollectorProvider;
+        
         @Override
         public void installDerivedState(DerivedStateAwareResource resource, boolean preLinkingPhase) {
                 Problem problem = getProblem(resource);
@@ -121,46 +119,9 @@ public class ProblemDerivedStateComputer implements IDerivedStateComputer {
         }
 
         protected Set<String> installDerivedNodes(Problem problem) {
-                IScope nodeScope = scopeProvider.getScope(problem, ProblemPackage.Literals.ASSERTION__ARGUMENTS);
-                Set<String> nodeNames = new HashSet<>();
-                for (Statement statement : problem.getStatements()) {
-                        if (statement instanceof Assertion) {
-                                Assertion assertion = (Assertion) statement;
-                                for (AssertionArgument argument : assertion.getArguments()) {
-                                        if (argument instanceof NodeAssertionArgument) {
-                                                addNodeNames(nodeNames, nodeScope, argument,
-                                                                ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE,
-                                                                ProblemDerivedStateComputer::validNodeName);
-                                        }
-                                }
-                        } else if (statement instanceof NodeValueAssertion) {
-                                addNodeNames(nodeNames, nodeScope, statement, ProblemPackage.Literals.NODE_VALUE_ASSERTION__NODE,
-                                                ProblemDerivedStateComputer::validNodeName);
-                        } else if (statement instanceof PredicateDefinition) {
-                                PredicateDefinition predicateDefinition = (PredicateDefinition) statement;
-                                for (Conjunction body : predicateDefinition.getBodies()) {
-                                        for (Literal literal : body.getLiterals()) {
-                                                Atom atom = null;
-                                                if (literal instanceof Atom) {
-                                                        atom = (Atom) literal;
-                                                } else if (literal instanceof NegativeLiteral) {
-                                                        NegativeLiteral negativeLiteral = (NegativeLiteral) literal;
-                                                        atom = negativeLiteral.getAtom();
-                                                }
-                                                if (atom == null) {
-                                                        continue;
-                                                }
-                                                for (Argument argument : atom.getArguments()) {
-                                                        if (argument instanceof VariableOrNodeArgument) {
-                                                                addNodeNames(nodeNames, nodeScope, argument,
-                                                                                ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE,
-                                                                                ProblemDerivedStateComputer::validQuotedId);
-                                                        }
-                                                }
-                                        }
-                                }
-                        }
-                }
+                NodeNameCollector collector = nodeNameCollectorProvider.get();
+                collector.collectNodeNames(problem);
+                Set<String> nodeNames = collector.getNodeNames();
                 List<Node> grapNodes = problem.getNodes();
                 for (String nodeName : nodeNames) {
                         Node graphNode = createNode(nodeName);
@@ -169,21 +130,6 @@ public class ProblemDerivedStateComputer implements IDerivedStateComputer {
                 return nodeNames;
         }
 
-        private void addNodeNames(Set<String> nodeNames, IScope nodeScope, EObject eObject, EStructuralFeature feature,
-                        Predicate<String> condition) {
-                List<INode> nodes = NodeModelUtils.findNodesForFeature(eObject, feature);
-                for (INode node : nodes) {
-                        String nodeName = linkingHelper.getCrossRefNodeAsString(node, true);
-                        if (!condition.test(nodeName)) {
-                                continue;
-                        }
-                        QualifiedName qualifiedName = qualifiedNameConverter.toQualifiedName(nodeName);
-                        if (!nodeNames.contains(nodeName) && nodeScope.getSingleElement(qualifiedName) == null) {
-                                nodeNames.add(nodeName);
-                        }
-                }
-        }
-
         protected Node createNode(String name) {
                 Node node = ProblemFactory.eINSTANCE.createNode();
                 node.setName(name);
@@ -347,7 +293,7 @@ public class ProblemDerivedStateComputer implements IDerivedStateComputer {
                 return validId(name) || validQuotedId(name);
         }
 
-        public Adapter getOrInstallAdapter(Resource resource) {
+        protected Adapter getOrInstallAdapter(Resource resource) {
                 if (!(resource instanceof XtextResource)) {
                         return new Adapter();
                 }
@@ -363,7 +309,7 @@ public class ProblemDerivedStateComputer implements IDerivedStateComputer {
                 return adapter;
         }
 
-        private static class Adapter extends AdapterImpl {
+        protected static class Adapter extends AdapterImpl {
                 public Map<ClassDeclaration, Node> newNodes = new HashMap<>();
 
                 @Override
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
deleted file mode 100644
index 7fc1c44d..00000000
--- a/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemScopingTest.xtend
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * 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).
-                ''')
-                assertThat(errors, empty)
-                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).
-                ''')
-                assertThat(errors, empty)
-                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).
-                ''')
-                assertThat(errors, empty)
-                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').
-                ''')
-                assertThat(errors, empty)
-                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).
-                ''')
-                assertThat(errors, empty)
-                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).
-                ''')
-                assertThat(errors, empty)
-                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).
-                ''')
-                assertThat(errors, empty)
-                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).
-                ''')
-                assertThat(errors, empty)
-                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).
-                ''')
-                assertThat(errors, empty)
-                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).
-                ''')
-                assertThat(errors, empty)
-                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').
-                ''')
-                assertThat(errors, empty)
-                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
index b16de2b5..f2aedfd5 100644
--- 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
@@ -12,6 +12,7 @@ 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
 import org.eclipse.viatra.solver.language.model.problem.Problem
 import org.eclipse.viatra.solver.language.model.problem.Variable
@@ -74,6 +75,10 @@ class ProblemTestUtil {
                 statements.filter(Assertion).get(i)
         }
         
+        def nodeValueAssertion(Problem it, int i) {
+                statements.filter(NodeValueAssertion).get(i)
+        }
+        
         def arg(Assertion it, int i) {
                 arguments.get(i)
         }
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
new file mode 100644
index 00000000..c92ad4c2
--- /dev/null
+++ b/language/src/test/java/org/eclipse/viatra/solver/language/tests/scoping/NodeScopingTest.xtend
@@ -0,0 +1,262 @@
+package org.eclipse.viatra.solver.language.tests.scoping
+
+import com.google.inject.Inject
+import java.util.stream.Stream
+import org.eclipse.viatra.solver.language.model.problem.Problem
+import org.eclipse.viatra.solver.language.tests.ProblemInjectorProvider
+import org.eclipse.viatra.solver.language.tests.ProblemTestUtil
+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 org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.MethodSource
+import org.junit.jupiter.params.provider.ValueSource
+
+import static org.hamcrest.MatcherAssert.assertThat
+import static org.hamcrest.Matchers.*
+
+@ExtendWith(InjectionExtension)
+@InjectWith(ProblemInjectorProvider)
+class NodeScopingTest {
+        @Inject
+        ParseHelper<Problem> parseHelper
+
+        @Inject
+        extension ProblemTestUtil
+
+        @ParameterizedTest
+        @ValueSource(strings=#["", "builtin::"])
+        def void builtInArgumentTypeTest(String prefix) {
+                val it = parseHelper.parse('''
+                        pred predicate(«prefix»node a, «prefix»data b, «prefix»int c).
+                ''')
+                assertThat(errors, empty)
+                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 x, node y) :- node(x).
+                        predicate(a, a).
+                        ?predicate(a, b).
+                ''')
+                assertThat(errors, empty)
+                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 implicitNodeInNodeValueAssertionTest() {
+                val it = parseHelper.parse('''
+                        a: 16.
+                ''')
+                assertThat(errors, empty)
+                assertThat(nodeNames, hasItems('a'))
+                assertThat(nodeValueAssertion(0).node, equalTo(node('a')))
+        }
+
+        def void implicitNodeInPredicateTest() {
+                val it = parseHelper.parse('''
+                        pred predicate(node a) :- node(b).
+                        predicate(b).
+                ''')
+                assertThat(errors, empty)
+                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 quotedNodeInAssertionTest() {
+                val it = parseHelper.parse('''
+                        pred predicate(node x, node y) :- node(x).
+                        predicate('a', 'a').
+                        ?predicate('a', 'b').
+                ''')
+                assertThat(errors, empty)
+                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 quotedNodeInNodeValueAssertionTest() {
+                val it = parseHelper.parse('''
+                        'a': 16.
+                ''')
+                assertThat(errors, empty)
+                assertThat(nodeNames, hasItems("'a'"))
+                assertThat(nodeValueAssertion(0).node, equalTo(node("'a'")))
+        }
+
+        @Test
+        def void quotedNodeInPredicateTest() {
+                val it = parseHelper.parse('''
+                        pred predicate(node a) :- node('b').
+                ''')
+                assertThat(errors, empty)
+                assertThat(nodeNames, hasItem("'b'"))
+                assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(node("'b'")))
+        }
+
+        @ParameterizedTest
+        @MethodSource("builtInNodeReferencesSource")
+        def void builtInNodeTest(String qualifiedName) {
+                val it = parseHelper.parse('''
+                        pred predicate(node x) :- node(x).
+                        predicate(«qualifiedName»).
+                ''')
+                assertThat(errors, empty)
+                assertThat(nodes, empty)
+                assertThat(assertion(0).arg(0).node, equalTo(builtin.findClass('int').newNode))
+        }
+
+        @ParameterizedTest
+        @MethodSource("builtInNodeReferencesSource")
+        def void builtInNodeInNodeValueAssertionTest(String qualifiedName) {
+                val it = parseHelper.parse('''
+                        «qualifiedName»: 16.
+                ''')
+                assertThat(errors, empty)
+                assertThat(nodes, empty)
+                assertThat(nodeValueAssertion(0).node, equalTo(builtin.findClass('int').newNode))
+        }
+
+        @ParameterizedTest
+        @MethodSource("builtInNodeReferencesSource")
+        def void builtInNodeInPredicateTest(String qualifiedName) {
+                val it = parseHelper.parse('''
+                        pred predicate(node x) :- node(«qualifiedName»).
+                ''')
+                assertThat(errors, empty)
+                assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(builtin.findClass('int').newNode))
+        }
+
+        static def builtInNodeReferencesSource() {
+                Stream.of(
+                        Arguments.of("int::new"),
+                        Arguments.of("builtin::int::new")
+                )
+        }
+
+        @ParameterizedTest(name="{0}, namedProblem={1}")
+        @MethodSource("classNewNodeReferencesSource")
+        def void classNewNodeTest(String qualifiedName, boolean namedProblem) {
+                val it = parseHelper.parse('''
+                        «IF namedProblem»problem test.«ENDIF»
+                        class Foo.
+                        pred predicate(node x) :- node(x).
+                        predicate(«qualifiedName»).
+                ''')
+                assertThat(errors, empty)
+                assertThat(nodes, empty)
+                assertThat(assertion(0).arg(0).node, equalTo(findClass('Foo').newNode))
+        }
+
+        @ParameterizedTest(name="{0}, namedProblem={1}")
+        @MethodSource("classNewNodeReferencesSource")
+        def void classNewNodeInNodeValueAssertionTest(String qualifiedName, boolean namedProblem) {
+                val it = parseHelper.parse('''
+                        «IF namedProblem»problem test.«ENDIF»
+                        class Foo.
+                        «qualifiedName»: 16.
+                ''')
+                assertThat(errors, empty)
+                assertThat(nodes, empty)
+                assertThat(nodeValueAssertion(0).node, equalTo(findClass('Foo').newNode))
+        }
+
+        @ParameterizedTest(name="{0}, namedProblem={1}")
+        @MethodSource("classNewNodeReferencesSource")
+        def void classNewNodeInPredicateTest(String qualifiedName, boolean namedProblem) {
+                val it = parseHelper.parse('''
+                        «IF namedProblem»problem test.«ENDIF»
+                        class Foo.
+                        pred predicate(node x) :- node(«qualifiedName»).
+                ''')
+                assertThat(errors, empty)
+                assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(findClass('Foo').newNode))
+        }
+
+        static def classNewNodeReferencesSource() {
+                Stream.of(
+                        Arguments.of("Foo::new", false),
+                        Arguments.of("Foo::new", true),
+                        Arguments.of("test::Foo::new", true)
+                )
+        }
+
+        @Test
+        def void newNodeIsNotSpecial() {
+                val it = parseHelper.parse('''
+                        class Foo.
+                        pred predicate(node x) :- node(x).
+                        predicate(new).
+                ''')
+                assertThat(errors, empty)
+                assertThat(nodeNames, hasItem('new'))
+                assertThat(assertion(0).arg(0).node, not(equalTo(findClass('Foo').newNode)))
+        }
+
+        @ParameterizedTest(name="{0}, namedProblem={1}")
+        @MethodSource("enumLiteralReferencesSource")
+        def void enumLiteralTest(String qualifiedName, boolean namedProblem) {
+                val it = parseHelper.parse('''
+                        «IF namedProblem»problem test.«ENDIF»
+                        enum Foo { alpha, beta }
+                        pred predicate(Foo a) :- node(a).
+                        predicate(«qualifiedName»).
+                ''')
+                assertThat(errors, empty)
+                assertThat(nodeNames, empty)
+                assertThat(assertion(0).arg(0).node, equalTo(findEnum("Foo").literal("alpha")))
+        }
+
+        @ParameterizedTest(name="{0}, namedProblem={1}")
+        @MethodSource("enumLiteralReferencesSource")
+        def void enumLiteralInNodeValueAssertionTest(String qualifiedName, boolean namedProblem) {
+                val it = parseHelper.parse('''
+                        «IF namedProblem»problem test.«ENDIF»
+                        enum Foo { alpha, beta }
+                        «qualifiedName»: 16.
+                ''')
+                assertThat(errors, empty)
+                assertThat(nodeNames, empty)
+                assertThat(nodeValueAssertion(0).node, equalTo(findEnum("Foo").literal("alpha")))
+        }
+
+        @ParameterizedTest(name="{0}, namedProblem={1}")
+        @MethodSource("enumLiteralReferencesSource")
+        def void enumLiteralInPredicateTest(String qualifiedName, boolean namedProblem) {
+                val it = parseHelper.parse('''
+                        «IF namedProblem»problem test.«ENDIF»
+                        enum Foo { alpha, beta }
+                        pred predicate(Foo a) :- node(«qualifiedName»).
+                ''')
+                assertThat(errors, empty)
+                assertThat(nodeNames, empty)
+                assertThat(pred("predicate").conj(0).lit(0).arg(0).node, equalTo(findEnum("Foo").literal("alpha")))
+        }
+
+        static def enumLiteralReferencesSource() {
+                Stream.of(
+                        Arguments.of("alpha", false),
+                        Arguments.of("alpha", true),
+                        Arguments.of("Foo::alpha", false),
+                        Arguments.of("Foo::alpha", true),
+                        Arguments.of("test::alpha", true),
+                        Arguments.of("test::Foo::alpha", true)
+                )
+        }
+}