fix(import solver, error): the error message about non existing files while importing didn't show the correct path to the file

Author: SuperFola

include/Ark/Compiler/Package/ImportSolver.hpp

@@ -48,11 +48,17 @@ namespace Ark::internal
         [[nodiscard]] const Node& ast() const noexcept override;
 
     private:
+        struct ImportWithSource
+        {
+            std::filesystem::path file;
+            Import import;
+        };
+
         unsigned m_debug_level;
         std::vector<std::filesystem::path> m_libenv;
         std::filesystem::path m_root;  ///< Folder were the entry file is
         Node m_ast;
-        std::stack<Import> m_imports;
+        std::stack<ImportWithSource> m_imports;
         std::unordered_map<std::string, Package> m_packages;  ///< Package name to package AST & data mapping
         std::vector<std::string> m_imported;                  ///< List of imports, in the order they were found and parsed
 
@@ -67,11 +73,11 @@ namespace Ark::internal
          * @brief Parse a given file and returns a list of its imports.
          *        The AST is parsed and stored in m_modules[import.prefix]
          *
-         * @param base_path path to the file containing the import
+         * @param source path to the file containing the import
          * @param import current import directive
-         * @return std::vector<Import> imports found in the processed file
+         * @return std::vector<ImportWithSource> imports found in the processed file
          */
-        std::vector<Import> parseImport(const std::filesystem::path& base_path, const Import& import);
+        std::vector<ImportWithSource> parseImport(const std::filesystem::path& source, const Import& import);
 
         /**
          * @brief Search for an import file, using the root file path

src/arkreactor/Compiler/Package/ImportSolver.cpp

@@ -16,13 +16,10 @@ namespace Ark::internal
 
     ImportSolver& ImportSolver::setup(const std::filesystem::path& root, const std::vector<Import>& origin_imports)
     {
-        if (is_directory(root))
-            m_root = root;
-        else
-            m_root = root.parent_path();
+        m_root = root.parent_path();
 
         for (const auto& origin_import : std::ranges::reverse_view(origin_imports))
-            m_imports.push(origin_import);
+            m_imports.push({ root, origin_import });
 
         return *this;
     }
@@ -33,27 +30,27 @@ namespace Ark::internal
 
         while (!m_imports.empty())
         {
-            Import import = m_imports.top();
-            m_logger.debug("Importing {}", import.toPackageString());
+            ImportWithSource source = m_imports.top();
+            m_logger.debug("Importing {}", source.import.toPackageString());
 
             // Remove the top element to process the other imports
             // It needs to be removed first because we might be adding
             // other imports later and don't want to pop THEM
             m_imports.pop();
-            const auto package = import.toPackageString();
+            const auto package = source.import.toPackageString();
 
             if (m_packages.contains(package))
             {
                 // merge the definition, so that we can generate valid Full Qualified Names in the name & scope resolver
-                m_packages[package].import.with_prefix |= import.with_prefix;
-                m_packages[package].import.is_glob |= import.is_glob;
-                for (auto&& symbol : import.symbols)
+                m_packages[package].import.with_prefix |= source.import.with_prefix;
+                m_packages[package].import.is_glob |= source.import.is_glob;
+                for (auto&& symbol : source.import.symbols)
                     m_packages[package].import.symbols.push_back(symbol);
             }
             else
             {
                 // NOTE: since the "file" (=root) argument doesn't change between all calls, we could get rid of it
-                std::vector<Import> temp = parseImport(m_root, import);
+                std::vector<ImportWithSource> temp = parseImport(source.file, source.import);
                 for (auto& additional_import : std::ranges::reverse_view(temp))
                     m_imports.push(additional_import);
             }
@@ -138,11 +135,11 @@ namespace Ark::internal
         return m_ast;
     }
 
-    std::vector<Import> ImportSolver::parseImport(const std::filesystem::path& base_path, const Import& import)
+    std::vector<ImportSolver::ImportWithSource> ImportSolver::parseImport(const std::filesystem::path& source, const Import& import)
     {
-        m_logger.traceStart(fmt::format("parseImport {}", base_path.string()));
+        m_logger.traceStart(fmt::format("parseImport {}", source.string()));
 
-        const auto path = findFile(base_path, import);
+        const auto path = findFile(source, import);
         if (path.extension() == ".arkm")  // Nothing to import in case of modules
         {
             // Creating an import node that will stay there when visiting the AST and
@@ -151,9 +148,11 @@ namespace Ark::internal
             module_node.push_back(Node(Keyword::Import));
 
             auto package_node = Node(NodeType::List);
-            std::ranges::transform(import.package, std::back_inserter(package_node.list()), [](const std::string& stem) {
-                return Node(NodeType::String, stem);
-            });
+            std::ranges::transform(
+                import.package,
+                std::back_inserter(package_node.list()), [](const std::string& stem) {
+                    return Node(NodeType::String, stem);
+                });
             module_node.push_back(package_node);
             // empty symbols list
             module_node.push_back(Node(NodeType::List));
@@ -177,7 +176,15 @@ namespace Ark::internal
         };
 
         m_logger.traceEnd();
-        return parser.imports();
+
+        auto imports = parser.imports();
+        std::vector<ImportWithSource> output;
+        std::ranges::transform(
+            imports,
+            std::back_inserter(output), [&path](const Import& i) {
+                return ImportWithSource { path, i };
+            });
+        return output;
     }
 
     std::optional<std::filesystem::path> testExtensions(const std::filesystem::path& folder, const std::string& package_path)
@@ -205,7 +212,7 @@ namespace Ark::internal
         // fallback, we couldn't find the file
         throw CodeError(
             fmt::format("While processing file {}, couldn't import {}: file not found",
-                        file.generic_string(), import.toPackageString()),
+                        file.filename().string(), import.toPackageString()),
             CodeErrorContext(
                 file.generic_string(),
                 import.line,

tests/unittests/resources/DiagnosticsSuite/compileTime/import_not_found.ark

@@ -0,0 +1,3 @@
+(import error__this_file_will_never_exist)
+
+(print 1)

tests/unittests/resources/DiagnosticsSuite/compileTime/import_not_found.expected

@@ -0,0 +1,6 @@
+At (import error__this_file_will_never_exist) @ 1:42
+    1 | (import error__this_file_will_never_exist)
+      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    2 |
+    3 | (print 1)
+        While processing file import_not_found.ark, couldn't import error__this_file_will_never_exist: file not found