refactor(language): name disambiguation

* Use fully qualified names starting with :: (as in C++) to unambiguously refer
  to an element.
* Name shadowing within modules.

14 files changed, 488 insertions, 87 deletions

diff --git a/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext b/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
index 4ce3fae1..f0d6c38c 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
+++ b/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
@@ -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
  */
@@ -16,10 +16,13 @@ enum ModuleKind:
         PROBLEM="problem" | MODULE="module";
 
 Statement:
-        Assertion | ClassDeclaration | EnumDeclaration |
+        ImportStatement | Assertion | ClassDeclaration | EnumDeclaration |
         PredicateDefinition | /* FunctionDefinition | RuleDefinition | */
         ScopeDeclaration | NodeDeclaration;
 
+ImportStatement:
+        "import" importedModule=[Problem|QualifiedName] ("as" alias=ID)? ".";
+
 ClassDeclaration:
         abstract?="abstract"? "class"
         name=Identifier
@@ -266,10 +269,10 @@ UpperBound returns ecore::EInt:
         INT | "*";
 
 QualifiedName hidden():
-        Identifier ("::" Identifier)*;
+        "::"? Identifier (QUALIFIED_NAME_SEPARATOR Identifier)*;
 
 NonContainmentQualifiedName hidden():
-        NonContainmentIdentifier ("::" Identifier)*;
+        (NonContainmentIdentifier | "::" Identifier) (QUALIFIED_NAME_SEPARATOR Identifier)*;
 
 Identifier:
         NonContainmentIdentifier | "contains" | "container";
@@ -284,6 +287,9 @@ Real returns ecore::EDouble:
 terminal TRANSITIVE_CLOSURE:
         "synthetic:TRANSITIVE_CLOSURE";
 
+terminal QUALIFIED_NAME_SEPARATOR:
+        "synthetic::QUALIFIED_NAME_SEPARATOR";
+
 @Override
 terminal ID:
         ('a'..'z' | 'A'..'Z' | '_') ('a'..'z' | 'A'..'Z' | '_' | '0'..'9')*;
diff --git a/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java b/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
index 00dd3de3..19816da4 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.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
  */
@@ -14,6 +14,7 @@ import com.google.inject.name.Names;
 import org.eclipse.xtext.conversion.IValueConverterService;
 import org.eclipse.xtext.linking.ILinkingService;
 import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.IQualifiedNameProvider;
 import org.eclipse.xtext.parser.IParser;
 import org.eclipse.xtext.resource.*;
 import org.eclipse.xtext.scoping.IGlobalScopeProvider;
@@ -26,12 +27,11 @@ import org.eclipse.xtext.validation.IResourceValidator;
 import org.eclipse.xtext.xbase.annotations.validation.DerivedStateAwareResourceValidator;
 import tools.refinery.language.conversion.ProblemValueConverterService;
 import tools.refinery.language.linking.ProblemLinkingService;
+import tools.refinery.language.naming.ProblemDelegateQualifiedNameProvider;
 import tools.refinery.language.naming.ProblemQualifiedNameConverter;
+import tools.refinery.language.naming.ProblemQualifiedNameProvider;
 import tools.refinery.language.parser.antlr.TokenSourceInjectingProblemParser;
-import tools.refinery.language.resource.ProblemDerivedStateComputer;
-import tools.refinery.language.resource.ProblemLocationInFileProvider;
-import tools.refinery.language.resource.ProblemResource;
-import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
+import tools.refinery.language.resource.*;
 import tools.refinery.language.scoping.ProblemGlobalScopeProvider;
 import tools.refinery.language.scoping.ProblemLocalScopeProvider;
 import tools.refinery.language.serializer.PreferShortAssertionsProblemSemanticSequencer;
@@ -54,6 +54,17 @@ public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
                 return ProblemQualifiedNameConverter.class;
         }
 
+        public void configureIQualifiedNameProviderDelegate(Binder binder) {
+                binder.bind(IQualifiedNameProvider.class)
+                                .annotatedWith(Names.named(ProblemQualifiedNameProvider.NAMED_DELEGATE))
+                                .to(ProblemDelegateQualifiedNameProvider.class);
+        }
+
+        @Override
+        public Class<? extends IQualifiedNameProvider> bindIQualifiedNameProvider() {
+                return ProblemQualifiedNameProvider.class;
+        }
+
         public Class<? extends IDefaultResourceDescriptionStrategy> bindIDefaultResourceDescriptionStrategy() {
                 return ProblemResourceDescriptionStrategy.class;
         }
@@ -87,7 +98,7 @@ public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
         // Method name follows Xtext convention.
         @SuppressWarnings("squid:S100")
         public Class<? extends IResourceDescription.Manager> bindIResourceDescription$Manager() {
-                return DerivedStateAwareResourceDescriptionManager.class;
+                return ProblemResourceDescriptionManager.class;
         }
 
         public Class<? extends IResourceValidator> bindIResourceValidator() {
diff --git a/subprojects/language/src/main/java/tools/refinery/language/naming/NamingUtil.java b/subprojects/language/src/main/java/tools/refinery/language/naming/NamingUtil.java
index 1647d4e7..feae5ebb 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/naming/NamingUtil.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/naming/NamingUtil.java
@@ -1,21 +1,24 @@
 /*
- * 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
  */
 package tools.refinery.language.naming;
 
+import org.eclipse.xtext.naming.QualifiedName;
+
 import java.util.regex.Pattern;
 
 public final class NamingUtil {
         private static final String SINGLETON_VARIABLE_PREFIX = "_";
-        
-        private static final Pattern ID_REGEX = Pattern.compile("[_a-zA-Z][_0-9a-zA-Z]*");
+        public static final QualifiedName ROOT_NAME = QualifiedName.create("");
+
+        private static final Pattern ID_REGEX = Pattern.compile("[_a-zA-Z]\\w*");
 
         private NamingUtil() {
                 throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
         }
-        
+
         public static boolean isNullOrEmpty(String name) {
                 return name == null || name.isEmpty();
         }
@@ -23,8 +26,28 @@ public final class NamingUtil {
         public static boolean isSingletonVariableName(String name) {
                 return name != null && name.startsWith(SINGLETON_VARIABLE_PREFIX);
         }
-        
+
+        // This method name only makes sense if it checks for the positive case.
+        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
         public static boolean isValidId(String name) {
                 return name != null && ID_REGEX.matcher(name).matches();
         }
+
+        public static boolean isFullyQualified(QualifiedName name) {
+                return name.startsWith(ROOT_NAME);
+        }
+
+        public static QualifiedName stripRootPrefix(QualifiedName name) {
+                if (name == null) {
+                        return null;
+                }
+                return isFullyQualified(name) ? name.skipFirst(ROOT_NAME.getSegmentCount()) : name;
+        }
+
+        public static QualifiedName addRootPrefix(QualifiedName name) {
+                if (name == null) {
+                        return null;
+                }
+                return isFullyQualified(name) ? name : ROOT_NAME.append(name);
+        }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemDelegateQualifiedNameProvider.java b/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemDelegateQualifiedNameProvider.java
new file mode 100644
index 00000000..1e78cee1
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemDelegateQualifiedNameProvider.java
@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.naming;
+
+import org.eclipse.xtext.naming.DefaultDeclarativeQualifiedNameProvider;
+import org.eclipse.xtext.naming.QualifiedName;
+import tools.refinery.language.model.problem.Problem;
+
+public class ProblemDelegateQualifiedNameProvider extends DefaultDeclarativeQualifiedNameProvider {
+        protected QualifiedName qualifiedName(Problem ele) {
+                var qualifiedName = computeFullyQualifiedNameFromNameAttribute(ele);
+                // Strip the root prefix even if explicitly provided.
+                return NamingUtil.stripRootPrefix(qualifiedName);
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemQualifiedNameConverter.java b/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemQualifiedNameConverter.java
index 74b4e208..88a0fe9a 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemQualifiedNameConverter.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemQualifiedNameConverter.java
@@ -12,7 +12,7 @@ import com.google.inject.Singleton;
 @Singleton
 public class ProblemQualifiedNameConverter extends IQualifiedNameConverter.DefaultImpl {
         public static final String DELIMITER = "::";
-        
+
         @Override
         public String getDelimiter() {
                 return DELIMITER;
diff --git a/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemQualifiedNameProvider.java b/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemQualifiedNameProvider.java
new file mode 100644
index 00000000..5b682058
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemQualifiedNameProvider.java
@@ -0,0 +1,41 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.naming;
+
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.naming.IQualifiedNameProvider;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.util.IResourceScopeCache;
+import org.eclipse.xtext.util.Tuples;
+import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
+
+public class ProblemQualifiedNameProvider extends IQualifiedNameProvider.AbstractImpl {
+        private static final String PREFIX = "tools.refinery.language.naming.ProblemQualifiedNameProvider.";
+        public static final String NAMED_DELEGATE = PREFIX + "NAMED_DELEGATE";
+        public static final String CACHE_KEY = PREFIX + "CACHE_KEY";
+
+        @Inject
+        @Named(NAMED_DELEGATE)
+        private IQualifiedNameProvider delegate;
+
+        @Inject
+        private IResourceScopeCache cache = IResourceScopeCache.NullImpl.INSTANCE;
+
+        @Override
+        public QualifiedName getFullyQualifiedName(EObject obj) {
+                return cache.get(Tuples.pair(obj, CACHE_KEY), obj.eResource(), () -> computeFullyQualifiedName(obj));
+        }
+
+        public QualifiedName computeFullyQualifiedName(EObject obj) {
+                var qualifiedName = delegate.getFullyQualifiedName(obj);
+                if (qualifiedName != null && ProblemResourceDescriptionStrategy.shouldExport(obj)) {
+                        return NamingUtil.addRootPrefix(qualifiedName);
+                }
+                return qualifiedName;
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/IdentifierTokenProvider.java b/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/IdentifierTokenProvider.java
index 306a86fc..0e19357f 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/IdentifierTokenProvider.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/IdentifierTokenProvider.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
  */
@@ -59,7 +59,7 @@ public class IdentifierTokenProvider {
 
                 private void createValueToTokenIdMap() {
                         var tokenIdToValueMap = tokenDefProvider.getTokenDefMap();
-                        valueToTokenIdMap = new HashMap<>(tokenIdToValueMap.size());
+                        valueToTokenIdMap = HashMap.newHashMap(tokenIdToValueMap.size());
                         for (var entry : tokenIdToValueMap.entrySet()) {
                                 valueToTokenIdMap.put(entry.getValue(), entry.getKey());
                         }
@@ -74,17 +74,16 @@ public class IdentifierTokenProvider {
                 }
 
                 private void collectIdentifierTokensFromElement(AbstractElement element) {
-                        if (element instanceof Alternatives alternatives) {
-                                for (var alternative : alternatives.getElements()) {
-                                        collectIdentifierTokensFromElement(alternative);
-                                }
-                        } else if (element instanceof RuleCall ruleCall) {
-                                collectIdentifierTokensFromRule(ruleCall.getRule());
-                        } else if (element instanceof Keyword keyword) {
-                                collectToken("'" + keyword.getValue() + "'");
-                        } else {
-                                throw new IllegalArgumentException("Unknown Xtext grammar element: " + element);
-                        }
+            switch (element) {
+                case Alternatives alternatives -> {
+                    for (var alternative : alternatives.getElements()) {
+                        collectIdentifierTokensFromElement(alternative);
+                    }
+                }
+                case RuleCall ruleCall -> collectIdentifierTokensFromRule(ruleCall.getRule());
+                case Keyword keyword -> collectToken("'" + keyword.getValue() + "'");
+                default -> throw new IllegalArgumentException("Unknown Xtext grammar element: " + element);
+            }
                 }
 
                 private void collectToken(String value) {
diff --git a/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/ProblemTokenSource.java b/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/ProblemTokenSource.java
index 5b91a6cc..487e4ceb 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/ProblemTokenSource.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/ProblemTokenSource.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
  */
@@ -28,6 +28,8 @@ public class ProblemTokenSource implements TokenSource {
 
         private boolean seenId;
 
+        private boolean lastVisible;
+
         public ProblemTokenSource(TokenSource delegate) {
                 this.delegate = delegate;
         }
@@ -47,18 +49,18 @@ public class ProblemTokenSource implements TokenSource {
 
         @Override
         public Token nextToken() {
-                if (!buffer.isEmpty()) {
-                        return buffer.removeFirst();
-                }
-                var token = delegate.nextToken();
-                if (isIdentifier(token)) {
-                        seenId = true;
-                } else if (seenId && isPlusOrTransitiveClosure(token)) {
-                        if (peekForTransitiveClosure()) {
+                boolean fromStream = buffer.isEmpty();
+                var token = fromStream ? delegate.nextToken() : buffer.removeFirst();
+                if (seenId) {
+                        if (fromStream && isPlusOrTransitiveClosure(token) && peekForTransitiveClosure()) {
                                 token.setType(InternalProblemParser.RULE_TRANSITIVE_CLOSURE);
+                        } else if (lastVisible && isQualifiedNameSeparator(token)) {
+                                token.setType(InternalProblemParser.RULE_QUALIFIED_NAME_SEPARATOR);
                         }
-                } else if (isVisibleToken(token)) {
-                        seenId = false;
+                }
+                lastVisible = isVisibleToken(token);
+                if (lastVisible) {
+                        seenId = isIdentifier(token);
                 }
                 return token;
         }
@@ -76,6 +78,10 @@ public class ProblemTokenSource implements TokenSource {
                 return token.getType() == InternalProblemParser.PlusSign;
         }
 
+        protected boolean isQualifiedNameSeparator(Token token) {
+                return token.getType() == InternalProblemParser.ColonColon;
+        }
+
         protected boolean isVisibleToken(Token token) {
                 int tokenId = token.getType();
                 return tokenId != InternalProblemParser.RULE_WS && tokenId != InternalProblemParser.RULE_SL_COMMENT &&
@@ -87,11 +93,16 @@ public class ProblemTokenSource implements TokenSource {
                 if (token.getType() != InternalProblemParser.LeftParenthesis) {
                         return false;
                 }
+                boolean allowFullyQualifiedName = true;
                 while (true) {
                         token = peekWithSkipWhitespace();
+                        if (allowFullyQualifiedName && token.getType() == InternalProblemParser.ColonColon) {
+                                token = peekWithSkipWhitespace();
+                        }
                         if (!isIdentifier(token)) {
                                 return false;
                         }
+                        allowFullyQualifiedName = false;
                         token = peekWithSkipWhitespace();
                         switch (token.getType()) {
                         case InternalProblemParser.Comma:
@@ -112,11 +123,6 @@ public class ProblemTokenSource implements TokenSource {
 
         protected Token peekToken() {
                 var token = delegate.nextToken();
-                if (isIdentifier(token)) {
-                        seenId = true;
-                } else if (isVisibleToken(token)) {
-                        seenId = false;
-                }
                 buffer.addLast(token);
                 return token;
         }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescription.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescription.java
new file mode 100644
index 00000000..498a7c57
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescription.java
@@ -0,0 +1,106 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2011 itemis AG (http://www.itemis.eu) and others.
+ * Copyright (c) 2024 The Refinery Authors <https://refinery.tools/>
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.language.resource;
+
+import org.apache.log4j.Logger;
+import org.eclipse.emf.common.util.TreeIterator;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.xtext.resource.IDefaultResourceDescriptionStrategy;
+import org.eclipse.xtext.resource.IEObjectDescription;
+import org.eclipse.xtext.resource.impl.DefaultResourceDescription;
+import org.eclipse.xtext.resource.impl.EObjectDescriptionLookUp;
+import org.eclipse.xtext.util.IAcceptor;
+import tools.refinery.language.naming.NamingUtil;
+
+import java.io.IOException;
+import java.util.*;
+
+/**
+ * A resource description that takes {@link ProblemResourceDescriptionStrategy#SHADOWING_KEY} into account when
+ * describing EObjects.
+ * <p>
+ * Based on {@link DefaultResourceDescription}.
+ */
+public class ProblemResourceDescription extends DefaultResourceDescription {
+        private static final Logger log = Logger.getLogger(ProblemResourceDescription.class);
+
+        private final IDefaultResourceDescriptionStrategy strategy;
+
+        public ProblemResourceDescription(Resource resource, IDefaultResourceDescriptionStrategy strategy) {
+                super(resource, strategy);
+                this.strategy = strategy;
+        }
+
+        /**
+         * Based on {@link DefaultResourceDescription#computeExportedObjects()}.
+         *
+         * @return The computed exported objects, taking shadowing into account.
+         */
+        @Override
+        protected List<IEObjectDescription> computeExportedObjects() {
+                if (!getResource().isLoaded()) {
+                        try {
+                                getResource().load(null);
+                        } catch (IOException e) {
+                                log.error(e.getMessage(), e);
+                                return Collections.emptyList();
+                        }
+                }
+                final Map<ProblemResourceDescriptionStrategy.ShadowingKey, List<IEObjectDescription>> nameToDescriptionsMap =
+                                new LinkedHashMap<>();
+                IAcceptor<IEObjectDescription> acceptor = eObjectDescription -> {
+                        var key = ProblemResourceDescriptionStrategy.getShadowingKey(eObjectDescription);
+                        var descriptions = nameToDescriptionsMap.computeIfAbsent(key, ignored -> new ArrayList<>());
+                        descriptions.add(eObjectDescription);
+                };
+                TreeIterator<EObject> allProperContents = EcoreUtil.getAllProperContents(getResource(), false);
+                while (allProperContents.hasNext()) {
+                        EObject content = allProperContents.next();
+                        if (!strategy.createEObjectDescriptions(content, acceptor)) {
+                                allProperContents.prune();
+                        }
+                }
+                return omitShadowedNames(nameToDescriptionsMap);
+        }
+
+        private static List<IEObjectDescription> omitShadowedNames(
+                        Map<ProblemResourceDescriptionStrategy.ShadowingKey, List<IEObjectDescription>> nameToDescriptionsMap) {
+                final List<IEObjectDescription> exportedEObjects = new ArrayList<>();
+                for (var entry : nameToDescriptionsMap.entrySet()) {
+                        var descriptions = entry.getValue();
+                        if (NamingUtil.isFullyQualified(entry.getKey().name())) {
+                                exportedEObjects.addAll(descriptions);
+                        } else {
+                                boolean foundPreferred = false;
+                                for (var description : descriptions) {
+                                        if (ProblemResourceDescriptionStrategy.PREFERRED_NAME_TRUE.equals(
+                                                        description.getUserData(ProblemResourceDescriptionStrategy.PREFERRED_NAME))) {
+                                                exportedEObjects.add(description);
+                                                foundPreferred = true;
+                                        }
+                                }
+                                if (!foundPreferred) {
+                                        exportedEObjects.addAll(descriptions);
+                                }
+                        }
+                }
+                return exportedEObjects;
+        }
+
+        // Based on {@code DerivedStateAwareResourceDescriptionManager#createResourceDescription}.
+        @Override
+        protected EObjectDescriptionLookUp getLookUp() {
+                if (lookup == null) {
+                        lookup = new EObjectDescriptionLookUp(computeExportedObjects());
+                }
+                return lookup;
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionManager.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionManager.java
new file mode 100644
index 00000000..23ca139a
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionManager.java
@@ -0,0 +1,19 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.resource;
+
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtext.resource.DerivedStateAwareResourceDescriptionManager;
+import org.eclipse.xtext.resource.IDefaultResourceDescriptionStrategy;
+import org.eclipse.xtext.resource.IResourceDescription;
+
+public class ProblemResourceDescriptionManager extends DerivedStateAwareResourceDescriptionManager {
+        @Override
+        protected IResourceDescription createResourceDescription(Resource resource,
+                                                                                                                         IDefaultResourceDescriptionStrategy strategy) {
+                return new ProblemResourceDescription(resource, strategy);
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
index 79dad6e7..76fd5852 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
@@ -25,9 +25,16 @@ import java.util.Map;
 @Singleton
 public class ProblemResourceDescriptionStrategy extends DefaultResourceDescriptionStrategy {
         private static final String DATA_PREFIX = "tools.refinery.language.resource.ProblemResourceDescriptionStrategy.";
+
         public static final String ARITY = DATA_PREFIX + "ARITY";
         public static final String ERROR_PREDICATE = DATA_PREFIX + "ERROR_PREDICATE";
         public static final String ERROR_PREDICATE_TRUE = "true";
+        public static final String SHADOWING_KEY = DATA_PREFIX + "SHADOWING_KEY";
+        public static final String SHADOWING_KEY_PROBLEM = "problem";
+        public static final String SHADOWING_KEY_NODE = "node";
+        public static final String SHADOWING_KEY_RELATION = "relation";
+        public static final String PREFERRED_NAME = DATA_PREFIX + "PREFERRED_NAME";
+        public static final String PREFERRED_NAME_TRUE = "true";
         public static final String COLOR_RELATION = DATA_PREFIX + "COLOR_RELATION";
         public static final String COLOR_RELATION_TRUE = "true";
 
@@ -44,8 +51,12 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
                         return true;
                 }
                 var problem = EcoreUtil2.getContainerOfType(eObject, Problem.class);
-                var problemQualifiedName = getNameAsQualifiedName(problem);
                 var userData = getUserData(eObject);
+                if (eObject.equals(problem)) {
+                        acceptEObjectDescription(eObject, qualifiedName, QualifiedName.EMPTY, userData, true, acceptor);
+                        return true;
+                }
+                var problemQualifiedName = getNameAsQualifiedName(problem);
                 QualifiedName lastQualifiedNameToExport = null;
                 if (shouldExportSimpleName(eObject)) {
                         lastQualifiedNameToExport = qualifiedName;
@@ -82,10 +93,14 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
                 if (NamingUtil.isNullOrEmpty(name)) {
                         return null;
                 }
-                return qualifiedNameConverter.toQualifiedName(name);
+                var qualifiedName = qualifiedNameConverter.toQualifiedName(name);
+                if (eObject instanceof Problem) {
+                        return NamingUtil.stripRootPrefix(qualifiedName);
+                }
+                return qualifiedName;
         }
 
-        protected boolean shouldExport(EObject eObject) {
+        public static boolean shouldExport(EObject eObject) {
                 if (eObject instanceof Variable) {
                         // Variables are always private to the containing predicate definition.
                         return false;
@@ -98,7 +113,12 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
 
         protected Map<String, String> getUserData(EObject eObject) {
                 var builder = ImmutableMap.<String, String>builder();
-                if (eObject instanceof Relation relation) {
+                if (eObject instanceof Problem) {
+                        builder.put(SHADOWING_KEY, SHADOWING_KEY_PROBLEM);
+                } else if (eObject instanceof Node) {
+                        builder.put(SHADOWING_KEY, SHADOWING_KEY_NODE);
+                } else if (eObject instanceof Relation relation) {
+                        builder.put(SHADOWING_KEY, SHADOWING_KEY_RELATION);
                         int arity = ProblemUtil.getArity(relation);
                         builder.put(ARITY, Integer.toString(arity));
                 }
@@ -124,20 +144,31 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
         }
 
         private void acceptEObjectDescription(EObject eObject, QualifiedName prefix, QualifiedName qualifiedName,
-                                                                                  Map<String, String> userData, boolean fullyQualified,
+                                                                                  Map<String, String> userData, boolean preferredName,
                                                                                   IAcceptor<IEObjectDescription> acceptor) {
                 var qualifiedNameWithPrefix = prefix == null ? qualifiedName : prefix.append(qualifiedName);
-                Map<String, String> userDataWithFullyQualified;
-                if (fullyQualified && shouldColorRelation(eObject)) {
-                        userDataWithFullyQualified = ImmutableMap.<String, String>builder()
+                var userDataWithPreference = userData;
+                if (preferredName) {
+                        userDataWithPreference = ImmutableMap.<String, String>builder()
                                         .putAll(userData)
-                                        .put(COLOR_RELATION, COLOR_RELATION_TRUE)
+                                        .put(PREFERRED_NAME, PREFERRED_NAME_TRUE)
                                         .build();
-                } else {
-                        userDataWithFullyQualified = userData;
                 }
-                var description = EObjectDescription.create(qualifiedNameWithPrefix, eObject, userDataWithFullyQualified);
+                var description = EObjectDescription.create(qualifiedNameWithPrefix, eObject, userDataWithPreference);
                 acceptor.accept(description);
+                if (!preferredName) {
+                        return;
+                }
+                var userDataWithFullyQualified = userDataWithPreference;
+                if (shouldColorRelation(eObject)) {
+                        userDataWithFullyQualified = ImmutableMap.<String, String>builder()
+                                        .putAll(userDataWithPreference)
+                                        .put(COLOR_RELATION, COLOR_RELATION_TRUE)
+                                        .build();
+                }
+                var rootQualifiedName = NamingUtil.addRootPrefix(qualifiedNameWithPrefix);
+                var rootDescription = EObjectDescription.create(rootQualifiedName, eObject, userDataWithFullyQualified);
+                acceptor.accept(rootDescription);
         }
 
         private boolean shouldColorRelation(EObject eObject) {
@@ -146,4 +177,11 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
                 }
                 return eObject instanceof ClassDeclaration || eObject instanceof EnumDeclaration;
         }
+
+        public static ShadowingKey getShadowingKey(IEObjectDescription description) {
+                return new ShadowingKey(description.getName(), description.getUserData(SHADOWING_KEY));
+        }
+
+        public record ShadowingKey(QualifiedName name, String shadowingKey) {
+        }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/NormalizedSelectable.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/NormalizedSelectable.java
new file mode 100644
index 00000000..0c7828d8
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/NormalizedSelectable.java
@@ -0,0 +1,122 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.scoping;
+
+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 org.eclipse.xtext.resource.impl.AliasedEObjectDescription;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+public class NormalizedSelectable implements ISelectable {
+        private final ISelectable delegateSelectable;
+        private final QualifiedName originalPrefix;
+        private final QualifiedName normalizedPrefix;
+
+        private NormalizedSelectable(ISelectable delegateSelectable, QualifiedName originalPrefix,
+                                                                 QualifiedName normalizedPrefix) {
+                this.delegateSelectable = delegateSelectable;
+                this.originalPrefix = originalPrefix;
+                this.normalizedPrefix = normalizedPrefix;
+        }
+
+        @Override
+        public boolean isEmpty() {
+                return delegateSelectable.isEmpty();
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjects() {
+                var delegateIterable = delegateSelectable.getExportedObjects();
+                var aliasedIterable = getAliasedElements(delegateIterable);
+                return Iterables.concat(delegateIterable, aliasedIterable);
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjects(EClass type, QualifiedName name, boolean ignoreCase) {
+                var delegateIterable = delegateSelectable.getExportedObjects(type, name, ignoreCase);
+                boolean startsWith = ignoreCase ? name.startsWithIgnoreCase(normalizedPrefix) :
+                                name.startsWith(normalizedPrefix);
+                if (startsWith && name.getSegmentCount() > normalizedPrefix.getSegmentCount()) {
+                        var originalName = originalPrefix.append(name.skipFirst(normalizedPrefix.getSegmentCount()));
+                        var originalIterable = Iterables.transform(
+                                        delegateSelectable.getExportedObjects(type, originalName, ignoreCase),
+                                        description -> {
+                                                var normalizedName = normalizedPrefix.append(
+                                                                description.getName().skipFirst(originalPrefix.getSegmentCount()));
+                                                return new AliasedEObjectDescription(normalizedName, description);
+                                        });
+                        return Iterables.concat(originalIterable, delegateIterable);
+                }
+                return delegateIterable;
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjectsByType(EClass type) {
+                var delegateIterable = delegateSelectable.getExportedObjectsByType(type);
+                var aliasedIterable = getAliasedElements(delegateIterable);
+                return Iterables.concat(delegateIterable, aliasedIterable);
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjectsByObject(EObject object) {
+                var delegateIterable = delegateSelectable.getExportedObjectsByObject(object);
+                var aliasedIterable = getAliasedElements(delegateIterable);
+                return Iterables.concat(delegateIterable, aliasedIterable);
+        }
+
+        private Iterable<IEObjectDescription> getAliasedElements(Iterable<IEObjectDescription> delegateIterable) {
+                return () -> new Iterator<>() {
+                        private final Iterator<IEObjectDescription> delegateIterator = delegateIterable.iterator();
+                        private IEObjectDescription next = computeNext();
+
+                        @Override
+                        public boolean hasNext() {
+                                return next != null;
+                        }
+
+                        @Override
+                        public IEObjectDescription next() {
+                                if (!hasNext()) {
+                                        throw new NoSuchElementException();
+                                }
+                                var current = next;
+                                next = computeNext();
+                                return current;
+                        }
+
+                        private IEObjectDescription computeNext() {
+                                while (delegateIterator.hasNext()) {
+                                        var description = delegateIterator.next();
+                                        var qualifiedName = description.getName();
+                                        if (qualifiedName.startsWith(originalPrefix) &&
+                                                        qualifiedName.getSegmentCount() > originalPrefix.getSegmentCount()) {
+                                                var alias = normalizedPrefix.append(qualifiedName.skipFirst(originalPrefix.getSegmentCount()));
+                                                return new AliasedEObjectDescription(alias, description);
+                                        }
+                                }
+                                return null;
+                        }
+                };
+        }
+
+        public static ISelectable of(@NotNull ISelectable delegateSelectable, @NotNull QualifiedName originalPrefix,
+                                                                 @NotNull QualifiedName normalizedPrefix) {
+                if (originalPrefix.equals(normalizedPrefix)) {
+                        return delegateSelectable;
+                }
+                if (originalPrefix.equals(QualifiedName.EMPTY)) {
+                        throw new IllegalArgumentException("Cannot normalize empty qualified name prefix");
+                }
+                return new NormalizedSelectable(delegateSelectable, originalPrefix, normalizedPrefix);
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemGlobalScopeProvider.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemGlobalScopeProvider.java
index 4d2dd772..37a67c0c 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemGlobalScopeProvider.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemGlobalScopeProvider.java
@@ -5,14 +5,21 @@
  */
 package tools.refinery.language.scoping;
 
-import java.util.LinkedHashSet;
-
+import com.google.common.base.Predicate;
 import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.resource.IEObjectDescription;
+import org.eclipse.xtext.resource.IResourceDescriptions;
+import org.eclipse.xtext.resource.ISelectable;
+import org.eclipse.xtext.scoping.IScope;
 import org.eclipse.xtext.scoping.impl.ImportUriGlobalScopeProvider;
-
+import org.eclipse.xtext.scoping.impl.SelectableBasedScope;
 import tools.refinery.language.utils.ProblemUtil;
 
+import java.util.LinkedHashSet;
+
 public class ProblemGlobalScopeProvider extends ImportUriGlobalScopeProvider {
         @Override
         protected LinkedHashSet<URI> getImportedUris(Resource resource) {
@@ -20,4 +27,14 @@ public class ProblemGlobalScopeProvider extends ImportUriGlobalScopeProvider {
                 importedUris.add(ProblemUtil.BUILTIN_LIBRARY_URI);
                 return importedUris;
         }
+
+        @Override
+        protected IScope createLazyResourceScope(IScope parent, URI uri, IResourceDescriptions descriptions, EClass type,
+                                                                                         Predicate<IEObjectDescription> filter, boolean ignoreCase) {
+                ISelectable description = descriptions.getResourceDescription(uri);
+                if (description != null && ProblemUtil.BUILTIN_LIBRARY_URI.equals(uri)) {
+                        description = NormalizedSelectable.of(description, QualifiedName.create("builtin"), QualifiedName.EMPTY);
+                }
+                return SelectableBasedScope.createScope(parent, description, filter, type, ignoreCase);
+        }
 }
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 229960a0..9be32636 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
@@ -1,47 +1,42 @@
 /*
- * 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
  */
 package tools.refinery.language.scoping;
 
-import java.util.List;
-
-import org.eclipse.emf.ecore.EObject;
+import com.google.inject.Inject;
 import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtext.naming.IQualifiedNameProvider;
 import org.eclipse.xtext.naming.QualifiedName;
-import org.eclipse.xtext.resource.IResourceDescriptions;
 import org.eclipse.xtext.resource.IResourceDescriptionsProvider;
 import org.eclipse.xtext.resource.ISelectable;
-import org.eclipse.xtext.scoping.impl.ImportNormalizer;
-import org.eclipse.xtext.scoping.impl.ImportedNamespaceAwareLocalScopeProvider;
-
-import com.google.inject.Inject;
-
-import tools.refinery.language.utils.ProblemUtil;
+import org.eclipse.xtext.scoping.impl.SimpleLocalScopeProvider;
+import tools.refinery.language.naming.NamingUtil;
 
-public class ProblemLocalScopeProvider extends ImportedNamespaceAwareLocalScopeProvider {
-        private static final QualifiedName BUILTIN_LIBRARY_QUALIFIED_NAME = QualifiedName
-                        .create(ProblemUtil.BUILTIN_LIBRARY_NAME);
+public class ProblemLocalScopeProvider extends SimpleLocalScopeProvider {
+        @Inject
+        private IQualifiedNameProvider qualifiedNameProvider;
 
         @Inject
         private IResourceDescriptionsProvider resourceDescriptionsProvider;
 
         @Override
-        protected List<ImportNormalizer> getImplicitImports(boolean ignoreCase) {
-                return List.of(doCreateImportNormalizer(BUILTIN_LIBRARY_QUALIFIED_NAME, true, ignoreCase));
-        }
-
-        @Override
-        protected List<ImportNormalizer> getImportedNamespaceResolvers(EObject context, boolean ignoreCase) {
-                return List.of();
-        }
-
-        @Override
-        protected ISelectable internalGetAllDescriptions(Resource resource) {
+        protected ISelectable getAllDescriptions(Resource resource) {
                 // Force the use of ProblemResourceDescriptionStrategy to include all QualifiedNames of objects.
-                IResourceDescriptions resourceDescriptions = resourceDescriptionsProvider
+                var resourceDescriptions = resourceDescriptionsProvider
                                 .getResourceDescriptions(resource.getResourceSet());
-                return resourceDescriptions.getResourceDescription(resource.getURI());
+                var resourceDescription = resourceDescriptions.getResourceDescription(resource.getURI());
+                if (resourceDescription != null && !resource.getContents().isEmpty()) {
+                        var rootElement = resource.getContents().getFirst();
+                        if (rootElement != null) {
+                                var rootName = NamingUtil.stripRootPrefix(qualifiedNameProvider.getFullyQualifiedName(rootElement));
+                                if (rootName == null) {
+                                        return resourceDescription;
+                                }
+                                return NormalizedSelectable.of(resourceDescription, rootName, QualifiedName.EMPTY);
+                        }
+                }
+                return resourceDescription;
         }
 }