refactor(language): no fully qualified self import

Make sure it is impossible to create clashing fully qualified names when
renaming a module by forbidding modules from referring to their own elements
with fully qualified names. Therefore, serializing a solution will not create
clashing fully qualified names (which would prevent serialization from
succeeding).

6 files changed, 202 insertions, 131 deletions

diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SemanticsUtils.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SemanticsUtils.java
index 110295b2..9c40e6df 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SemanticsUtils.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SemanticsUtils.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -8,11 +8,14 @@ package tools.refinery.language.semantics;
 import com.google.inject.Inject;
 import com.google.inject.Singleton;
 import com.google.inject.name.Named;
+import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.xtext.naming.IQualifiedNameConverter;
 import org.eclipse.xtext.naming.IQualifiedNameProvider;
 import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.resource.IEObjectDescription;
+import org.eclipse.xtext.resource.IResourceDescriptionsProvider;
 import org.eclipse.xtext.scoping.IScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -33,6 +36,9 @@ public class SemanticsUtils {
         @Inject
         private IQualifiedNameConverter qualifiedNameConverter;
 
+        @Inject
+        private IResourceDescriptionsProvider resourceDescriptionsProvider;
+
         public Optional<String> getNameWithoutRootPrefix(EObject eObject) {
                 var qualifiedName = delegateQualifiedNameProvider.getFullyQualifiedName(eObject);
                 if (qualifiedName == null) {
@@ -42,11 +48,31 @@ public class SemanticsUtils {
         }
 
         @Nullable
+        public <T> T maybeGetLocalElement(Problem problem, QualifiedName qualifiedName, Class<T> type, EClass eClass) {
+                var resource = problem.eResource();
+                var resourceSet = resource.getResourceSet();
+                var resourceDescriptions = resourceDescriptionsProvider.getResourceDescriptions(resourceSet);
+                var resourceDescription = resourceDescriptions.getResourceDescription(resource.getURI());
+                if (resourceDescription == null) {
+                        return null;
+                }
+                var eObjectDescriptions = resourceDescription.getExportedObjects(eClass, qualifiedName, false);
+                return maybeGet(problem, eObjectDescriptions, qualifiedName, type);
+        }
+
+        @Nullable
         public <T> T maybeGetElement(Problem problem, IScope scope, QualifiedName qualifiedName, Class<T> type) {
                 if (qualifiedName == null) {
                         throw new IllegalArgumentException("Element name must not be null");
                 }
-                var iterator = scope.getElements(qualifiedName).iterator();
+                var eObjectDescriptions = scope.getElements(qualifiedName);
+                return maybeGet(problem, eObjectDescriptions, qualifiedName, type);
+        }
+
+        @Nullable
+        private <T> T maybeGet(Problem problem, Iterable<IEObjectDescription> eObjectDescriptions,
+                                                   QualifiedName qualifiedName, Class<T> type) {
+                var iterator = eObjectDescriptions.iterator();
                 if (!iterator.hasNext()) {
                         return null;
                 }
@@ -66,8 +92,19 @@ public class SemanticsUtils {
         }
 
         @NotNull
+        public <T> T getLocalElement(Problem problem, QualifiedName qualifiedName, Class<T> type, EClass eClass) {
+                var element = maybeGetLocalElement(problem, qualifiedName, type, eClass);
+                return getOrThrow(element, qualifiedName, type);
+        }
+
+        @NotNull
         public <T> T getElement(Problem problem, IScope scope, QualifiedName qualifiedName, Class<T> type) {
                 var element = maybeGetElement(problem, scope, qualifiedName, type);
+                return getOrThrow(element, qualifiedName, type);
+        }
+
+        @NotNull
+        private <T> T getOrThrow(@Nullable T element, QualifiedName qualifiedName, Class<T> type) {
                 if (element == null) {
                         var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
                         throw new IllegalArgumentException("No such %s: %s"
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SolutionSerializer.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SolutionSerializer.java
index 2fb0a49d..377a66f3 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SolutionSerializer.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SolutionSerializer.java
@@ -10,6 +10,8 @@ import com.google.inject.Provider;
 import org.eclipse.collections.api.factory.primitive.IntObjectMaps;
 import org.eclipse.collections.api.map.primitive.MutableIntObjectMap;
 import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.xtext.naming.IQualifiedNameProvider;
 import org.eclipse.xtext.naming.QualifiedName;
@@ -18,7 +20,7 @@ import org.eclipse.xtext.resource.XtextResource;
 import org.eclipse.xtext.resource.XtextResourceSet;
 import org.eclipse.xtext.scoping.IScopeProvider;
 import tools.refinery.language.model.problem.*;
-import tools.refinery.language.scoping.imports.ImportAdapter;
+import tools.refinery.language.naming.NamingUtil;
 import tools.refinery.language.utils.ProblemDesugarer;
 import tools.refinery.language.utils.ProblemUtil;
 import tools.refinery.store.model.Model;
@@ -34,9 +36,7 @@ import tools.refinery.store.tuple.Tuple;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
-import java.util.Map;
-import java.util.TreeMap;
-import java.util.TreeSet;
+import java.util.*;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
@@ -66,13 +66,17 @@ public class SolutionSerializer {
         private Model model;
         private ReasoningAdapter reasoningAdapter;
         private PartialInterpretation<TruthValue, Boolean> existsInterpretation;
+        private Resource originalResource;
         private Problem originalProblem;
+        private QualifiedName originalProblemName;
         private Problem problem;
+        private QualifiedName newProblemName;
         private NodeDeclaration nodeDeclaration;
         private final MutableIntObjectMap<Node> nodes = IntObjectMaps.mutable.empty();
 
         public Problem serializeSolution(ProblemTrace trace, Model model) {
-                var uri = URI.createURI("__synthetic." + ProblemUtil.MODULE_EXTENSION);
+                var uri = URI.createURI("__solution_%s.%s".formatted(UUID.randomUUID().toString().replace('-', '_'),
+                                ProblemUtil.MODULE_EXTENSION));
                 return serializeSolution(trace, model, uri);
         }
 
@@ -83,10 +87,14 @@ public class SolutionSerializer {
                 existsInterpretation = reasoningAdapter.getPartialInterpretation(Concreteness.CANDIDATE,
                                 ReasoningAdapter.EXISTS_SYMBOL);
                 originalProblem = trace.getProblem();
+                originalProblemName = qualifiedNameProvider.getFullyQualifiedName(originalProblem);
                 problem = copyProblem(originalProblem, uri);
-                problem.setKind(ModuleKind.MODULE);
+                problem.setKind(ProblemUtil.getDefaultModuleKind(uri));
+                problem.setExplicitKind(false);
+                problem.setName(null);
+                newProblemName = qualifiedNameProvider.getFullyQualifiedName(originalProblem);
                 problem.getStatements().removeIf(SolutionSerializer::shouldRemoveStatement);
-                problem.getNodes().removeIf(this::shouldRemoveNode);
+                removeNonExistentImplicitNodes();
                 nodeDeclaration = ProblemFactory.eINSTANCE.createNodeDeclaration();
                 nodeDeclaration.setKind(NodeKind.NODE);
                 nodeDeclaration.getNodes().addAll(problem.getNodes());
@@ -105,15 +113,28 @@ public class SolutionSerializer {
                 return statement instanceof Assertion || statement instanceof ScopeDeclaration;
         }
 
-        private boolean shouldRemoveNode(Node newNode) {
-                var qualifiedName = qualifiedNameProvider.getFullyQualifiedName(newNode);
-                var scope = scopeProvider.getScope(originalProblem, ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE);
-                var originalNode = semanticsUtils.maybeGetElement(originalProblem, scope, qualifiedName, Node.class);
-                if (originalNode == null) {
-                        return false;
+        private void removeNonExistentImplicitNodes() {
+                var originalImplicitNodes = originalProblem.getNodes();
+                var newImplicitNodes = problem.getNodes();
+                if (newImplicitNodes.size() != originalImplicitNodes.size()) {
+                        throw new IllegalStateException("Expected %d implicit nodes in problem, but got %d after copying"
+                                        .formatted(originalImplicitNodes.size(), newImplicitNodes.size()));
+                }
+                var iterator = newImplicitNodes.iterator();
+                for (var originalNode : originalImplicitNodes) {
+                        if (!iterator.hasNext()) {
+                                throw new AssertionError("Unexpected end of copied implicit node list");
+                        }
+                        var newNode = iterator.next();
+                        if (!Objects.equals(originalNode.getName(), newNode.getName())) {
+                                throw new IllegalStateException("Expected copy of '%s' to have the same name, got '%s' instead"
+                                                .formatted(originalNode.getName(), newNode.getName()));
+                        }
+                        int nodeId = trace.getNodeId(originalNode);
+                        if (!isExistingNode(nodeId)) {
+                                iterator.remove();
+                        }
                 }
-                int nodeId = trace.getNodeId(originalNode);
-                return !isExistingNode(nodeId);
         }
 
         private boolean isExistingNode(int nodeId) {
@@ -125,14 +146,10 @@ public class SolutionSerializer {
         }
 
         private Problem copyProblem(Problem originalProblem, URI uri) {
-                var newResourceSet = resourceSetProvider.get();
-                ImportAdapter.copySettings(originalProblem, newResourceSet);
-                if (!ProblemUtil.MODULE_EXTENSION.equals(uri.fileExtension())) {
-                        uri = uri.appendFileExtension(ProblemUtil.MODULE_EXTENSION);
-                }
+                originalResource = originalProblem.eResource();
+                var resourceSet = originalResource.getResourceSet();
                 var newResource = resourceFactory.createResource(uri);
-                newResourceSet.getResources().add(newResource);
-                var originalResource = originalProblem.eResource();
+                resourceSet.getResources().add(newResource);
                 if (originalResource instanceof XtextResource) {
                         byte[] bytes;
                         try {
@@ -147,7 +164,7 @@ public class SolutionSerializer {
                                 throw new IllegalStateException("Failed to copy problem", e);
                         }
                         var contents = newResource.getContents();
-                        EcoreUtil.resolveAll(newResourceSet);
+                        EcoreUtil.resolveAll(newResource);
                         if (!contents.isEmpty() && contents.getFirst() instanceof Problem newProblem) {
                                 return newProblem;
                         }
@@ -159,10 +176,24 @@ public class SolutionSerializer {
                 }
         }
 
+        private QualifiedName getConvertedName(EObject original) {
+                var qualifiedName = qualifiedNameProvider.getFullyQualifiedName(original);
+                if (originalProblemName != null && qualifiedName.startsWith(originalProblemName)) {
+                        qualifiedName = qualifiedName.skipFirst(originalProblemName.getSegmentCount());
+                }
+                if (newProblemName != null) {
+                        qualifiedName = newProblemName.append(qualifiedName);
+                }
+                return NamingUtil.addRootPrefix(qualifiedName);
+        }
+
         private Relation findRelation(Relation originalRelation) {
-                var qualifiedName = qualifiedNameProvider.getFullyQualifiedName(originalRelation);
-                var scope = scopeProvider.getScope(problem, ProblemPackage.Literals.ASSERTION__RELATION);
-                return semanticsUtils.getElement(problem, scope, qualifiedName, Relation.class);
+                if (originalRelation.eResource() != originalResource) {
+                        return originalRelation;
+                }
+                var qualifiedName = getConvertedName(originalRelation);
+                return semanticsUtils.getLocalElement(problem, qualifiedName, Relation.class,
+                                ProblemPackage.Literals.RELATION);
         }
 
         private Relation findPartialRelation(PartialRelation partialRelation) {
@@ -170,13 +201,11 @@ public class SolutionSerializer {
         }
 
         private Node findNode(Node originalNode) {
-                var qualifiedName = qualifiedNameProvider.getFullyQualifiedName(originalNode);
-                return findNode(qualifiedName);
-        }
-
-        private Node findNode(QualifiedName qualifiedName) {
-                var scope = scopeProvider.getScope(problem, ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE);
-                return semanticsUtils.maybeGetElement(problem, scope, qualifiedName, Node.class);
+                if (originalNode.eResource() != originalResource) {
+                        return originalNode;
+                }
+                var qualifiedName = getConvertedName(originalNode);
+                return semanticsUtils.maybeGetLocalElement(problem, qualifiedName, Node.class, ProblemPackage.Literals.NODE);
         }
 
         private void addAssertion(Relation relation, LogicValue value, Node... arguments) {
@@ -194,8 +223,8 @@ public class SolutionSerializer {
         }
 
         private void addExistsAssertions() {
-                var builtinSymbols = desugarer.getBuiltinSymbols(problem)
-                                .orElseThrow(() -> new IllegalStateException("No builtin library in copied problem"));
+                var builtinSymbols = desugarer.getBuiltinSymbols(problem).orElseThrow(() -> new IllegalStateException("No " +
+                                "builtin library in copied problem"));
                 // Make sure to output exists assertions in a deterministic order.
                 var sortedNewNodes = new TreeMap<Integer, Node>();
                 for (var pair : trace.getNodeTrace().keyValuesView()) {
@@ -204,8 +233,7 @@ public class SolutionSerializer {
                         var newNode = findNode(originalNode);
                         // Since all implicit nodes that do not exist has already been removed in serializeSolution,
                         // we only need to add !exists assertions to ::new nodes and explicitly declared nodes that do not exist.
-                        if (ProblemUtil.isMultiNode(originalNode) ||
-                                        (ProblemUtil.isDeclaredNode(originalNode) && !isExistingNode(nodeId))) {
+                        if (ProblemUtil.isMultiNode(originalNode) || (ProblemUtil.isDeclaredNode(originalNode) && !isExistingNode(nodeId))) {
                                 sortedNewNodes.put(nodeId, newNode);
                         } else {
                                 nodes.put(nodeId, newNode);
@@ -218,8 +246,8 @@ public class SolutionSerializer {
         }
 
         private void addClassAssertions() {
-                var types = trace.getMetamodel().typeHierarchy().getPreservedTypes().keySet().stream()
-                                .collect(Collectors.toMap(Function.identity(), this::findPartialRelation));
+                var types =
+                                trace.getMetamodel().typeHierarchy().getPreservedTypes().keySet().stream().collect(Collectors.toMap(Function.identity(), this::findPartialRelation));
                 var cursor = model.getInterpretation(TypeHierarchyTranslator.TYPE_SYMBOL).getAll();
                 while (cursor.move()) {
                         var key = cursor.getKey();
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/NoFullyQualifiedNamesSelectable.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/NoFullyQualifiedNamesSelectable.java
new file mode 100644
index 00000000..f9405fc1
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/NoFullyQualifiedNamesSelectable.java
@@ -0,0 +1,62 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.scoping;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.Iterables;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.resource.IEObjectDescription;
+import org.eclipse.xtext.resource.ISelectable;
+import tools.refinery.language.naming.NamingUtil;
+
+import java.util.List;
+
+public class NoFullyQualifiedNamesSelectable implements ISelectable {
+        private final ISelectable delegateSelectable;
+
+        // {@link com.google.common.base.Predicate} required by Xtext API.
+        @SuppressWarnings("squid:S4738")
+        private final Predicate<IEObjectDescription> filter =
+                        eObjectDescription -> !NamingUtil.isFullyQualified(eObjectDescription.getName());
+
+    public NoFullyQualifiedNamesSelectable(ISelectable delegateSelectable) {
+        this.delegateSelectable = delegateSelectable;
+    }
+
+    @Override
+        public boolean isEmpty() {
+                return delegateSelectable.isEmpty();
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjects() {
+                return filter(delegateSelectable.getExportedObjects());
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjects(EClass type, QualifiedName name, boolean ignoreCase) {
+                if (NamingUtil.isFullyQualified(name)) {
+                        return List.of();
+                }
+                return delegateSelectable.getExportedObjects(type, name, ignoreCase);
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjectsByType(EClass type) {
+                return filter(delegateSelectable.getExportedObjectsByType(type));
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjectsByObject(EObject object) {
+                return filter(delegateSelectable.getExportedObjectsByObject(object));
+        }
+
+        private Iterable<IEObjectDescription> filter(Iterable<IEObjectDescription> eObjectDescriptions) {
+                return Iterables.filter(eObjectDescriptions, filter);
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemLocalScopeProvider.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemLocalScopeProvider.java
index 1c0c1d86..0067bf94 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemLocalScopeProvider.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemLocalScopeProvider.java
@@ -12,7 +12,6 @@ import org.eclipse.emf.ecore.EReference;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.xtext.naming.IQualifiedNameProvider;
 import org.eclipse.xtext.naming.QualifiedName;
-import org.eclipse.xtext.resource.IResourceDescription;
 import org.eclipse.xtext.resource.IResourceDescriptionsProvider;
 import org.eclipse.xtext.resource.ISelectable;
 import org.eclipse.xtext.scoping.IScope;
@@ -39,41 +38,31 @@ public class ProblemLocalScopeProvider extends AbstractGlobalScopeDelegatingScop
                 if (resource == null) {
                         return IScope.NULLSCOPE;
                 }
+                var globalScope = getGlobalScope(resource, reference);
                 var localImports = cache.get(CACHE_KEY, resource, () -> computeLocalImports(resource));
-                if (localImports.resourceDescription() == null) {
-                        return IScope.NULLSCOPE;
+                if (localImports == null) {
+                        return globalScope;
                 }
-                var globalScope = getGlobalScope(resource, reference);
                 var type = reference.getEReferenceType();
                 boolean ignoreCase = isIgnoreCase(reference);
-                var scope = ShadowingKeyAwareSelectableBasedScope.createScope(globalScope, localImports.resourceDescription(),
-                                type, ignoreCase);
-                if (localImports.normalizedSelectable() == null) {
-                        return scope;
-                }
-                return ShadowingKeyAwareSelectableBasedScope.createScope(scope, localImports.normalizedSelectable(), type,
-                                ignoreCase);
+                return ShadowingKeyAwareSelectableBasedScope.createScope(globalScope, localImports, type, ignoreCase);
         }
 
-        protected LocalImports computeLocalImports(Resource resource) {
+        protected ISelectable computeLocalImports(Resource resource) {
                 // Force the use of ProblemResourceDescriptionStrategy to include all QualifiedNames of objects.
                 var resourceDescriptions = resourceDescriptionsProvider.getResourceDescriptions(resource.getResourceSet());
                 var resourceDescription = resourceDescriptions.getResourceDescription(resource.getURI());
                 if (resourceDescription == null) {
-                        return new LocalImports(null, null);
+                        return null;
                 }
                 var rootElement = resource.getContents().getFirst();
                 if (rootElement == null) {
-                        return new LocalImports(resourceDescription, null);
+                        return new NoFullyQualifiedNamesSelectable(resourceDescription);
                 }
                 var rootName = delegateQualifiedNameProvider.getFullyQualifiedName(rootElement);
                 if (rootName == null) {
-                        return new LocalImports(resourceDescription, null);
+                        return new NoFullyQualifiedNamesSelectable(resourceDescription);
                 }
-                var normalizedSelectable = new NormalizedSelectable(resourceDescription, rootName, QualifiedName.EMPTY);
-                return new LocalImports(resourceDescription, normalizedSelectable);
-        }
-
-        protected record LocalImports(IResourceDescription resourceDescription, ISelectable normalizedSelectable) {
+                return new NormalizedSelectable(resourceDescription, rootName, QualifiedName.EMPTY);
         }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportAdapter.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportAdapter.java
index 5a8f7fd7..d7a5304f 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportAdapter.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportAdapter.java
@@ -12,7 +12,6 @@ import org.apache.log4j.Logger;
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.impl.AdapterImpl;
 import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.emf.ecore.util.EcoreUtil;
@@ -203,28 +202,4 @@ public class ImportAdapter extends AdapterImpl {
         private static ImportAdapter getAdapter(ResourceSet resourceSet) {
         return (ImportAdapter) EcoreUtil.getAdapter(resourceSet.eAdapters(), ImportAdapter.class);
         }
-
-        public static void copySettings(EObject context, ResourceSet newResourceSet) {
-                var resource = context.eResource();
-                if (resource == null) {
-                        return;
-                }
-                var originalResourceSet = resource.getResourceSet();
-                if (originalResourceSet == null) {
-                        return;
-                }
-                copySettings(originalResourceSet, newResourceSet);
-        }
-
-        public static void copySettings(ResourceSet originalResourceSet, ResourceSet newResourceSet) {
-                var originalAdapter = getAdapter(originalResourceSet);
-                if (originalAdapter == null) {
-                        return;
-                }
-                var newAdapter = getOrInstall(newResourceSet);
-                newAdapter.libraries.clear();
-                newAdapter.libraries.addAll(originalAdapter.libraries);
-                newAdapter.libraryPaths.clear();
-                newAdapter.libraryPaths.addAll(originalAdapter.libraryPaths);
-        }
 }
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java
index bc0320a6..0704e026 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -68,15 +68,14 @@ class NodeScopingTest {
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.node("b")));
         }
 
-        @ParameterizedTest
-        @MethodSource("atomNodeReferenceSource")
-        void atomNodeInAssertionTest(String qualifiedNamePrefix, boolean namedProblem) {
+        @Test
+        void atomNodeInAssertionTest() {
                 var problem = parse("""
                                 atom a, b.
                                 pred predicate(node x, node y) <-> node(x).
-                                predicate({PARAM}a, {PARAM}a).
-                                ?predicate({PARAM}a, {PARAM}b).
-                                """, qualifiedNamePrefix, namedProblem);
+                                predicate(a, a).
+                                ?predicate(a, b).
+                                """);
                 assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.atomNode("a")));
@@ -85,22 +84,17 @@ class NodeScopingTest {
                 assertThat(problem.assertion(1).arg(1).node(), equalTo(problem.atomNode("b")));
         }
 
-        @ParameterizedTest
-        @MethodSource("atomNodeReferenceSource")
-        void atomNodeInPredicateTest(String qualifiedNamePrefix, boolean namedProblem) {
+        @Test
+        void atomNodeInPredicateTest() {
                 var problem = parse("""
                                 atom b.
-                                pred predicate(node a) <-> node({PARAM}b).
-                                """, qualifiedNamePrefix, namedProblem);
+                                pred predicate(node a) <-> node(b).
+                                """);
                 assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(), equalTo(problem.atomNode("b")));
         }
 
-        static Stream<Arguments> atomNodeReferenceSource() {
-                return Stream.of(Arguments.of("", false), Arguments.of("", true), Arguments.of("test::", true));
-        }
-
         @Disabled("No nodes are present in builtin.problem currently")
         @ParameterizedTest
         @MethodSource("builtInNodeReferencesSource")
@@ -131,37 +125,30 @@ class NodeScopingTest {
                 return Stream.of(Arguments.of("int::new"), Arguments.of("builtin::int::new"));
         }
 
-        @ParameterizedTest
-        @MethodSource("classNewNodeReferencesSource")
-        void classNewNodeTest(String qualifiedName, boolean namedProblem) {
+        @Test
+        void classNewNodeTest() {
                 var problem = parse("""
                                 class Foo.
                                 pred predicate(node x) <-> node(x).
-                                predicate({PARAM}).
-                                """, qualifiedName, namedProblem);
+                                predicate(Foo::new).
+                                """);
                 assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.findClass("Foo").get().getNewNode()));
         }
 
-        @ParameterizedTest
-        @MethodSource("classNewNodeReferencesSource")
-        void classNewNodeInPredicateTest(String qualifiedName, boolean namedProblem) {
+        @Test
+        void classNewNodeInPredicateTest() {
                 var problem = parse("""
                                 class Foo.
-                                pred predicate(node x) <-> node({PARAM}).
-                                """, qualifiedName, namedProblem);
+                                pred predicate(node x) <-> node(Foo::new).
+                                """);
                 assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(),
                                 equalTo(problem.findClass("Foo").get().getNewNode()));
         }
 
-        static Stream<Arguments> classNewNodeReferencesSource() {
-                return Stream.of(Arguments.of("Foo::new", false), Arguments.of("Foo::new", true),
-                                Arguments.of("test::Foo::new", true));
-        }
-
         @Test
         void newNodeIsNotSpecial() {
                 var problem = parse("""
@@ -176,12 +163,12 @@ class NodeScopingTest {
 
         @ParameterizedTest
         @MethodSource("enumLiteralReferencesSource")
-        void enumLiteralTest(String qualifiedName, boolean namedProblem) {
+        void enumLiteralTest(String qualifiedName) {
                 var problem = parse("""
                                 enum Foo { alpha, beta }
                                 pred predicate(Foo a) <-> node(a).
                                 predicate({PARAM}).
-                                """, qualifiedName, namedProblem);
+                                """, qualifiedName);
                 assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.findEnum("Foo").literal("alpha")));
@@ -189,11 +176,11 @@ class NodeScopingTest {
 
         @ParameterizedTest
         @MethodSource("enumLiteralReferencesSource")
-        void enumLiteralInPredicateTest(String qualifiedName, boolean namedProblem) {
+        void enumLiteralInPredicateTest(String qualifiedName) {
                 var problem = parse("""
                                 enum Foo { alpha, beta }
                                 pred predicate(Foo a) <-> node({PARAM}).
-                                """, qualifiedName, namedProblem);
+                                """, qualifiedName);
                 assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(),
@@ -201,9 +188,7 @@ class NodeScopingTest {
         }
 
         static Stream<Arguments> enumLiteralReferencesSource() {
-                return 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));
+                return Stream.of(Arguments.of("alpha"), Arguments.of("Foo::alpha"));
         }
 
         @Disabled("No enum literals are present in builtin.problem currently")
@@ -222,7 +207,7 @@ class NodeScopingTest {
         @Disabled("No enum literals are present in builtin.problem currently")
         @ParameterizedTest
         @MethodSource("builtInEnumLiteralReferencesSource")
-        void bultInEnumLiteralInPredicateTest(String qualifiedName) {
+        void builtInEnumLiteralInPredicateTest(String qualifiedName) {
                 var problem = parse("""
                                 pred predicate() <-> node({PARAM}).
                                 """, qualifiedName);
@@ -237,13 +222,8 @@ class NodeScopingTest {
                                 Arguments.of("builtin::bool::true"));
         }
 
-        private WrappedProblem parse(String text, String parameter, boolean namedProblem) {
-                var problemName = namedProblem ? "problem test.\n" : "";
-                return parseHelper.parse(problemName + text.replace("{PARAM}", parameter));
-        }
-
         private WrappedProblem parse(String text, String parameter) {
-                return parse(text, parameter, false);
+                return parseHelper.parse(text.replace("{PARAM}", parameter));
         }
 
         private WrappedProblem parse(String text) {