1 files changed, 160 insertions, 0 deletions

diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportCollector.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportCollector.java
new file mode 100644
index 00000000..ac5a92ba
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportCollector.java
@@ -0,0 +1,160 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.scoping.imports;
+
+import com.google.common.base.Splitter;
+import com.google.common.base.Strings;
+import com.google.inject.Inject;
+import com.google.inject.Provider;
+import com.google.inject.Singleton;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtext.linking.impl.LinkingHelper;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.nodemodel.util.NodeModelUtils;
+import org.eclipse.xtext.resource.IEObjectDescription;
+import org.eclipse.xtext.util.IResourceScopeCache;
+import tools.refinery.language.model.problem.ImportStatement;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.model.problem.ProblemPackage;
+import tools.refinery.language.naming.NamingUtil;
+import tools.refinery.language.resource.LoadOnDemandResourceDescriptionProvider;
+import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
+
+import java.util.*;
+
+@Singleton
+public class ImportCollector {
+        private static final String PREFIX = "tools.refinery.language.imports.";
+        private static final String DIRECT_IMPORTS_KEY = PREFIX + "DIRECT_IMPORTS";
+        private static final String ALL_IMPORTS_KEY = PREFIX + "ALL_IMPORTS";
+
+        @Inject
+        private IResourceScopeCache cache;
+
+        @Inject
+        private LinkingHelper linkingHelper;
+
+        @Inject
+        private IQualifiedNameConverter qualifiedNameConverter;
+
+        @Inject
+        private Provider<LoadOnDemandResourceDescriptionProvider> loadOnDemandProvider;
+
+        public ImportCollection getDirectImports(Resource resource) {
+                return cache.get(DIRECT_IMPORTS_KEY, resource, () -> this.computeDirectImports(resource));
+        }
+
+        protected ImportCollection computeDirectImports(Resource resource) {
+                if (resource.getContents().isEmpty() || !(resource.getContents().getFirst() instanceof Problem problem)) {
+                        return ImportCollection.EMPTY;
+                }
+                var resourceSet = resource.getResourceSet();
+                if (resourceSet == null) {
+                        return ImportCollection.EMPTY;
+                }
+                var adapter = ImportAdapter.getOrInstall(resourceSet);
+                var collection = new ImportCollection();
+                collectAutomaticImports(collection, adapter);
+                collectExplicitImports(problem, collection, adapter);
+                collection.remove(resource.getURI());
+                return collection;
+        }
+
+        private void collectAutomaticImports(ImportCollection importCollection, ImportAdapter adapter) {
+                for (var library : adapter.getLibraries()) {
+                        for (var qualifiedName : library.getAutomaticImports()) {
+                                var uri = adapter.resolveQualifiedName(qualifiedName);
+                                if (uri != null) {
+                                        importCollection.add(NamedImport.implicit(uri, qualifiedName));
+                                }
+                        }
+                }
+        }
+
+        private void collectExplicitImports(Problem problem, ImportCollection collection, ImportAdapter adapter) {
+                for (var statement : problem.getStatements()) {
+                        if (statement instanceof ImportStatement importStatement) {
+                                collectImportStatement(importStatement, collection, adapter);
+                        }
+                }
+        }
+
+        private void collectImportStatement(ImportStatement importStatement, ImportCollection collection,
+                                                                                ImportAdapter adapter) {
+                var nodes = NodeModelUtils.findNodesForFeature(importStatement,
+                                ProblemPackage.Literals.IMPORT_STATEMENT__IMPORTED_MODULE);
+                var aliasString = importStatement.getAlias();
+                var alias = Strings.isNullOrEmpty(aliasString) ? QualifiedName.EMPTY :
+                                NamingUtil.stripRootPrefix(qualifiedNameConverter.toQualifiedName(aliasString));
+                var referredProblem = (EObject) importStatement.eGet(ProblemPackage.Literals.IMPORT_STATEMENT__IMPORTED_MODULE,
+                                false);
+                URI referencedUri = null;
+                if (referredProblem != null && !referredProblem.eIsProxy()) {
+                        var resource = referredProblem.eResource();
+                        if (resource != null) {
+                                referencedUri = resource.getURI();
+                        }
+                }
+                for (var node : nodes) {
+                        var qualifiedNameString = linkingHelper.getCrossRefNodeAsString(node, true);
+                        if (Strings.isNullOrEmpty(qualifiedNameString)) {
+                                continue;
+                        }
+                        var qualifiedName = NamingUtil.stripRootPrefix(
+                                        qualifiedNameConverter.toQualifiedName(qualifiedNameString));
+                        var uri = referencedUri == null ? adapter.resolveQualifiedName(qualifiedName) : referencedUri;
+                        if (uri != null) {
+                                collection.add(NamedImport.explicit(uri, qualifiedName, List.of(alias)));
+                        }
+                }
+        }
+
+        public ImportCollection getAllImports(Resource resource) {
+                return cache.get(ALL_IMPORTS_KEY, resource, () -> this.computeAllImports(resource));
+        }
+
+        protected ImportCollection computeAllImports(Resource resource) {
+                var collection = new ImportCollection();
+                collection.addAll(getDirectImports(resource).toList());
+                var loadOnDemand = loadOnDemandProvider.get();
+                loadOnDemand.setContext(resource);
+                var seen = new HashSet<URI>();
+                seen.add(resource.getURI());
+                var queue = new ArrayDeque<>(collection.toUriSet());
+                while (!queue.isEmpty()) {
+                        var uri = queue.removeFirst();
+                        seen.add(uri);
+                        collection.add(new TransitiveImport(uri));
+                        var resourceDescription = loadOnDemand.getResourceDescription(uri);
+                        if (resourceDescription == null) {
+                                continue;
+                        }
+                        var problemDescriptions = resourceDescription.getExportedObjectsByType(ProblemPackage.Literals.PROBLEM);
+                        for (var eObjectDescription : problemDescriptions) {
+                                for (var importedUri : getImports(eObjectDescription)) {
+                                        if (!seen.contains(importedUri)) {
+                                                queue.addLast(importedUri);
+                                        }
+                                }
+                        }
+                }
+                collection.remove(resource.getURI());
+                return collection;
+        }
+
+        protected List<URI> getImports(IEObjectDescription eObjectDescription) {
+                var importString = eObjectDescription.getUserData(ProblemResourceDescriptionStrategy.IMPORTS);
+                if (importString == null || importString.isEmpty()) {
+                        return List.of();
+                }
+                return Splitter.on(ProblemResourceDescriptionStrategy.IMPORTS_SEPARATOR).splitToStream(importString)
+                                .map(URI::createURI)
+                                .toList();
+        }
+}