recursive scan work

Author: takev

src/ast/module_node.cpp

@@ -4,11 +4,11 @@
 
 namespace hk::ast {
 
-[[nodiscard]] generator<repository_url> module_node::remote_repositories() const
+[[nodiscard]] generator<module_node::remote_repository_result> module_node::remote_repositories() const
 {
     for (auto const& import : imports) {
         if (auto repository_import_ptr = dynamic_cast<import_repository_declaration_node const*>(import.get())) {
-            co_yield repository_import_ptr->url;
+            co_yield remote_repository_result{repository_import_ptr->url, fxxxxxxxst, this};
         }
     }
 }

src/ast/module_node.hpp

@@ -49,7 +49,13 @@ class module_node : public node {
     std::vector<import_declaration_node_ptr> imports;
     std::vector<node_ptr> body;
 
-    [[nodiscard]] generator<repository_url> remote_repositories() const;
+    struct remote_repository_result {
+        repository_url url;
+        file_location first;
+        file_location last;
+        module_node *node;
+    };
+    [[nodiscard]] generator<remote_repository_result> remote_repositories() const;
 
 };
 

src/error/error_item.hpp

@@ -33,6 +33,13 @@ class error_item {
         assert(_code.has_value());
     }
 
+    template<typename... Args>
+    error_item(error_code code, std::format_string<Args...> fmt, Args&&... args)
+        : _first(), _last(), _code(code), _message(std::format(std::move(fmt), std::forward<Args>(args)...))
+    {
+        assert(_code.has_value());
+    }
+
     template<typename... Args>
     void add_cause(file_location first, file_location last, std::format_string<Args...> fmt, Args&&... args)
     {

src/error/error_list.hpp

@@ -16,10 +16,9 @@ class error_list : public std::vector<error_item> {
 
     /** Add an error to the list. 
      * 
+     *  @tparam ErrorCode The error being raised, including the format string.
      *  @param first The first file location where the error occurred.
      *  @param last The last file location where the error occurred.
-     *  @param code The error code.
-     *  @param fmt The format string for the error message.
      *  @param args The arguments to format the error message.
      *  @return A unexpected error containing the error code.
      */
@@ -31,6 +30,20 @@ class error_list : public std::vector<error_item> {
         return std::unexpected{ErrorType::code};
     }
 
+    /** Add an error to the list. 
+     * 
+     *  @tparam ErrorCode The error being raised, including the format string.
+     *  @param args The arguments to format the error message.
+     *  @return A unexpected error containing the error code.
+     */
+    template<typename ErrorType, typename... Args>
+    std::unexpected<error_code> add(Args&&... args)
+    {
+        auto e = error_item{ErrorType::code, ErrorType::fmt, std::forward<Args>(args)...};
+        this->push_back(std::move(e));
+        return std::unexpected{ErrorType::code};
+    }
+
 private:
 };
 

src/repository/repository.cpp

@@ -3,6 +3,7 @@
 #include "utility/path.hpp"
 #include "utility/vector_set.hpp"
 #include "utility/file_cursor.hpp"
+#include "utility/git.hpp"
 #include "parser/parse_module.hpp"
 #include <cassert>
 #include <algorithm>
@@ -14,7 +15,7 @@ repository::repository(std::filesystem::path path) : _path(std::move(path))
     assert(std::filesystem::canonical(_path) == _path);
 }
 
-void repository::scan_prologues(bool force)
+void repository::scan_prologues(repository_flags flags)
 {
     untouch(false);
 
@@ -53,7 +54,7 @@ void repository::scan_prologues(bool force)
         auto& m = get_module(module_path);
         m.touched = true;
 
-        if (m.ast and m.time == entry.last_write_time() and not force) {
+        if (m.ast and m.time == entry.last_write_time() and not to_bool(flags & repository_flags::force_scan)) {
             // The prologue for this module has already been scanned.
             continue;
         }
@@ -68,10 +69,37 @@ void repository::scan_prologues(bool force)
     untouch(true);
 }
 
-void repository::recursive_scan_prologues(bool force)
+void repository::recursive_scan_prologues(repository_flags flags)
 {
+    auto todo = std::set<repository_url>{};
+    auto done = std::set<repository_url>{};
 
-    
+    scan_prologues(flags);
+    for (auto child_repo_url : remote_repositories()) {
+        todo.insert(std::move(child_repo_url));
+    }
+
+    auto hkdeps = _path / "_hkdeps";
+    while (not todo.empty()) {
+        auto child_repo_url_node = todo.extract(todo.begin());
+        auto [it, inserted, _] = done.insert(std::move(child_repo_url_node));
+        if (not inserted) {
+            continue;
+        }
+
+        assert(it != done.end());
+        auto child_repo_path = hkdeps / it->directory();
+        auto &child_repo = get_child_repository(*it);
+        if (not child_repo.repository) {
+            if (auto r = git_checkout_or_clone(*it, child_repo_path, flags); r != git_error::ok) {
+
+            }
+
+            child_repo.repository = std::make_unique<repository>(child_repo_path);
+        }
+    }
+
+    // Remove internal repositories not in done.
 }
 
 void repository::untouch(bool remove)

src/repository/repository.hpp

@@ -4,6 +4,7 @@
 #include "ast/module_node.hpp"
 #include "error/error_list.hpp"
 #include "utility/repository_url.hpp"
+#include "utility/repository_flags.hpp"
 #include "utility/generator.hpp"
 #include <filesystem>
 #include <memory>
@@ -20,13 +21,13 @@ class repository {
      * 
      * @param force Force scanning even on files that were already parsed.
      */
-    void scan_prologues(bool force);
+    void scan_prologues(repository_flags flags);
 
     /** Recusively clone and scan repositories.
      * 
      * @param force Force scanning even on files that were already parsed.
      */
-    void recursive_scan_prologues(bool force);
+    void recursive_scan_prologues(repository_flags flags);
 
     [[nodiscard]] generator<repository_url> remote_repositories() const;
 

src/utility/git.cpp

@@ -456,7 +456,7 @@ repository_fetch(::git_repository* repository, std::string const& remote_name =
 }
 
 [[nodiscard]] git_error
-git_fetch_and_update(std::string const& url, std::string const& rev, std::filesystem::path path, git_checkout_flags flags)
+git_fetch_and_update(std::string const& url, std::string const& rev, std::filesystem::path path, repository_flags flags)
 {
     auto const& _ = git_lib_initialize();
 
@@ -478,17 +478,17 @@ git_fetch_and_update(std::string const& url, std::string const& rev, std::filesy
         return remote_url_o.error();
     }
 
-    auto fetch = to_bool(flags & git_checkout_flags::force_fetch);
+    auto fetch = to_bool(flags & repository_flags::force_fetch);
     if (auto result = repository_matches_rev(repository, rev)) {
         switch (*result) {
         case rev_match::rev_not_found:
-            if (to_bool(flags & git_checkout_flags::fresh_clone)) {
+            if (to_bool(flags & repository_flags::fresh_clone)) {
                 return git_error::rev_not_found;
             }
             [[fallthrough]];
         case rev_match::not_checked_out:
         case rev_match::checked_out_branch:
-            fetch |= not to_bool(flags & git_checkout_flags::fresh_clone);
+            fetch |= not to_bool(flags & repository_flags::fresh_clone);
             break;
         case rev_match::checked_out:
             // Revisions that are tags or commits will not cause a fetch.
@@ -522,9 +522,9 @@ git_fetch_and_update(std::string const& url, std::string const& rev, std::filesy
     }
 
     auto clean = checkout;
-    clean |= to_bool(flags & git_checkout_flags::force_clean);
+    clean |= to_bool(flags & repository_flags::force_clean);
     // A fresh clone does not need to be cleaned.
-    clean &= not to_bool(flags & git_checkout_flags::fresh_clone);
+    clean &= not to_bool(flags & repository_flags::fresh_clone);
 
     if (clean) {
         if (auto result = repository_clean(repository); result != git_error::ok) {
@@ -584,7 +584,7 @@ git_fetch_and_update(std::string const& url, std::string const& rev, std::filesy
 }
 
 [[nodiscard]] git_error git_checkout_or_clone(
-    std::string const& url, std::string const& rev, std::filesystem::path path, git_checkout_flags flags)
+    std::string const& url, std::string const& rev, std::filesystem::path path, repository_flags flags)
 {
     // First try and just update the repository.
     switch(git_fetch_and_update(url, rev, path, flags)) {
@@ -614,7 +614,7 @@ git_fetch_and_update(std::string const& url, std::string const& rev, std::filesy
     }
 
     // In case rev is a tag or commit, checkout/update the repository.
-    flags |= git_checkout_flags::fresh_clone;
+    flags |= repository_flags::fresh_clone;
     return git_fetch_and_update(url, rev, path, flags);
 }
 

src/utility/git.hpp

@@ -2,6 +2,7 @@
 #pragma once
 
 #include "repository_url.hpp"
+#include "repository_flags.hpp"
 #include <expected>
 #include <system_error>
 #include <memory>
@@ -76,49 +77,7 @@ enum class git_error {
     could_not_connect_with_remote,
 };
 
-enum class git_checkout_flags {
-    /** The repository was freshly cloned, not need for a fetch.
-     */
-    fresh_clone = 0x1,
-
-    /** Fetch, even when the rev points to a tag or commit.
-     */
-    force_fetch = 0x2,
-
-    /** Force the repository to be cleaned, even if no checkout is performed.
-     */
-    force_clean = 0x4
-};
-
-[[nodiscard]] constexpr git_checkout_flags operator|(git_checkout_flags lhs, git_checkout_flags rhs) noexcept
-{
-    return static_cast<git_checkout_flags>(std::to_underlying(lhs) | std::to_underlying(rhs));
-}
-
-[[nodiscard]] constexpr git_checkout_flags operator&(git_checkout_flags lhs, git_checkout_flags rhs) noexcept
-{
-    return static_cast<git_checkout_flags>(std::to_underlying(lhs) & std::to_underlying(rhs));
-}
 
-[[nodiscard]] constexpr git_checkout_flags operator~(git_checkout_flags rhs) noexcept
-{
-    return static_cast<git_checkout_flags>(~std::to_underlying(rhs));
-}
-
-constexpr git_checkout_flags& operator|=(git_checkout_flags& lhs, git_checkout_flags rhs) noexcept
-{
-    return lhs = lhs | rhs;
-}
-
-constexpr git_checkout_flags& operator&=(git_checkout_flags& lhs, git_checkout_flags rhs) noexcept
-{
-    return lhs = lhs & rhs;
-}
-
-[[nodiscard]] constexpr bool to_bool(git_checkout_flags rhs) noexcept
-{
-    return static_cast<bool>(std::to_underlying(rhs));
-}
 
 struct git_reference {
     std::string name = {};
@@ -200,7 +159,7 @@ class git_references : public std::vector<git_reference> {
     std::string const& url,
     std::string const& rev,
     std::filesystem::path path,
-    git_checkout_flags flags = git_checkout_flags{});
+    repository_flags flags = repository_flags{});
 
 /** Checkout or clone the repository.
  *
@@ -215,14 +174,14 @@ class git_references : public std::vector<git_reference> {
     std::string const& url,
     std::string const& rev,
     std::filesystem::path path,
-    git_checkout_flags flags = git_checkout_flags{});
+    repository_flags flags = repository_flags{});
 
 /** Checkout or clone the repository.
  *
  * @see git_checkout_or_clone
  */
 [[nodiscard]] inline git_error
-git_checkout_or_clone(repository_url const& url, std::filesystem::path path, git_checkout_flags flags = git_checkout_flags{})
+git_checkout_or_clone(repository_url const& url, std::filesystem::path path, repository_flags flags = repository_flags{})
 {
     assert(url.kind() == repository_type::git);
     return git_checkout_or_clone(url.url(), url.rev(), path, flags);

src/utility/git_tests.cpp

@@ -51,7 +51,7 @@ TEST_CASE(git_clone_fail_wrong_rev_name)
     auto const r = hk::git_clone(git_url, git_rev, tmp_dir.path());
     REQUIRE(r == hk::git_error::ok);
 
-    auto const r2 = hk::git_fetch_and_update(git_url, git_rev, tmp_dir.path(), hk::git_checkout_flags::fresh_clone);
+    auto const r2 = hk::git_fetch_and_update(git_url, git_rev, tmp_dir.path(), hk::repository_flags::fresh_clone);
     REQUIRE(r2 == hk::git_error::rev_not_found);
 }
 
@@ -66,7 +66,7 @@ TEST_CASE(git_clone_fail_wrong_rev_oid)
     auto const r = hk::git_clone(git_url, git_rev, tmp_dir.path());
     REQUIRE(r == hk::git_error::ok);
 
-    auto const r2 = hk::git_fetch_and_update(git_url, git_rev, tmp_dir.path(), hk::git_checkout_flags::fresh_clone);
+    auto const r2 = hk::git_fetch_and_update(git_url, git_rev, tmp_dir.path(), hk::repository_flags::fresh_clone);
     REQUIRE(r2 == hk::git_error::rev_not_found);
 }
 
@@ -83,7 +83,7 @@ TEST_CASE(git_fetch_and_update_tag)
     auto const r1 = hk::git_clone(git_url, git_rev, tmp_dir.path());
     REQUIRE(r1 == hk::git_error::ok);
 
-    auto const r2 = hk::git_fetch_and_update(git_url, git_rev, tmp_dir.path(), hk::git_checkout_flags::fresh_clone);
+    auto const r2 = hk::git_fetch_and_update(git_url, git_rev, tmp_dir.path(), hk::repository_flags::fresh_clone);
     REQUIRE(r2 == hk::git_error::ok);
 }
 
@@ -100,7 +100,7 @@ TEST_CASE(git_fetch_and_update_commit)
     auto const r1 = hk::git_clone(git_url, git_rev, tmp_dir.path());
     REQUIRE(r1 == hk::git_error::ok);
 
-    auto const r2 = hk::git_fetch_and_update(git_url, git_rev, tmp_dir.path(), hk::git_checkout_flags::fresh_clone);
+    auto const r2 = hk::git_fetch_and_update(git_url, git_rev, tmp_dir.path(), hk::repository_flags::fresh_clone);
     REQUIRE(r2 == hk::git_error::ok);
 }