compiles

Author: takev

src/ast/module_declaration_node.hpp

@@ -7,6 +7,7 @@
 #include "utility/semantic_version.hpp"
 #include "utility/enum_variant.hpp"
 #include <string>
+#include <filesystem>
 
 namespace hk::ast {
 
@@ -25,7 +26,7 @@ class module_declaration_node : public node {
      * 
      * This is the path to the file that contains the module declaration.
      */
-    path_id path = {};
+    std::filesystem::path path = {};
 
     /** The type of module declaration.
      * 

src/prologue/prologue_scan.cpp

@@ -1,6 +1,9 @@
 
 #include "prologue_scan.hpp"
 #include "utility/vector_set.hpp"
+#include "utility/file_cursor.hpp"
+#include "error/error_list.hpp"
+#include "parser/parsers.hpp"
 
 namespace hk {
 
@@ -39,11 +42,12 @@ namespace hk {
             continue;
         }
 
+        auto errors = error_list{};
         auto cursor = file_cursor(entry.path());
         if (auto node = parse_module(cursor, errors, true)) {
 
-            r.push_back(std::move(node()).value());
-        } else if (node.is_error()) {
+            r.push_back(std::move(node).value());
+        } else if (node.error()) {
 
 
         } else {

src/tokenizer/tokenizer_tests.cpp

@@ -17,8 +17,8 @@ TEST_SUITE(tokenizer_suite)
 
     static std::vector<hk::token> parse_tokens(std::string_view text)
     {
-        auto path_id = hk::make_file_buffer(text);
-        auto cursor = hk::file_cursor{path_id, path_id};
+        auto path = hk::make_file_buffer(text);
+        auto cursor = hk::file_cursor{path};
         auto delegate = delegate_type{};
 
         hk::tokenize(cursor, delegate);

src/utility/file.cpp

@@ -8,38 +8,18 @@
 
 namespace hk {
 
-file::file(hk::path_id path_id)
-    : _path_id(path_id)
-{
-}
-
 
-inline static std::mutex file_mutex;
-inline static std::map<path_id, std::unique_ptr<file>> file_by_path_id;
-
-[[nodiscard]] file& get_file(hk::path_id path_id)
+[[nodiscard]] std::unique_ptr<file> make_file(std::filesystem::path path)
 {
-    auto const _ = std::scoped_lock(file_mutex);
-
-    auto it = file_by_path_id.lower_bound(path_id);
-    if (it != file_by_path_id.end() and it->first == path_id) {
-        return *(it->second);
-    }
-
-    auto file_ptr = std::unique_ptr<file>{};
-
-    auto rel_path = path_id->relative_path();
+    assert(not path.empty());
+    auto rel_path = path.relative_path();
     auto rel_path_str = rel_path.generic_string();
 
     if (rel_path_str.starts_with("tmp/hic-buffer-") and rel_path_str.ends_with(".bin")) {
-        file_ptr = std::make_unique<file_buffer>(path_id);
+        return std::make_unique<file_buffer>(std::move(path));
     } else {
-        file_ptr = std::make_unique<file_ifstream>(path_id);
+        return std::make_unique<file_ifstream>(std::move(path));
     }
-    assert(file_ptr != nullptr);
-
-    it = file_by_path_id.emplace_hint(it, path_id, std::move(file_ptr));
-    return *(it->second);
 }   
 
 } // namespace hk

src/utility/file.hpp

@@ -13,18 +13,12 @@ namespace hk {
  * This class provides methods to read the content of a file, open and close it,
  * and manage its path identifier.
  * 
- * This class is thread-safe, meaning that multiple threads can access it
- * concurrently.
  */
 class file {
 public:
     virtual ~file() = default;
 
-    /** Create a file object with the given path.
-     *
-     * @param path The absolute normalized path to the file.
-     */
-    explicit file(hk::path_id path_id);
+    file() = default;
 
     /** Read the file content into a buffer.
      *
@@ -61,31 +55,12 @@ class file {
      * If the file is not open, this will do nothing.
      */
     virtual void close() noexcept {};
-
-protected:
-    /** This class is thread-safe, so we need a mutex to protect access to the file stream.
-     */
-    std::mutex _mutex;
-
-    /** The absolute normalized path to the file.
-     */
-    path_id _path_id = {};
 };
 
-/** Get a file object pointing the the given path identifier.
- * 
- * @param path_id The path identifier to get the file for.
- * @return A file object pointing to the file, or an error code if the file could not be opened.
- */
-[[nodiscard]] file &get_file(hk::path_id path_id);
-
-/** Remove the file object from memory.
- * 
- * This will close the file and remove it from the internal cache.
- * This is used when the file no longer exists during incremental compilation.
+/** Make a file object from a path.
  * 
- * @param path_id The path identifier of the file object to remove.
+ * @param path The path to open.
  */
-void free_file(hk::path_id path_id) noexcept;
+[[nodiscard]] std::unique_ptr<file> make_file(std::filesystem::path path);
 
 } // namespace hk

src/utility/file_buffer.cpp

@@ -3,11 +3,16 @@
 #include "file.hpp"
 #include <cassert>
 #include <format>
+#include <mutex>
+#include <map>
 
 namespace hk {
 
-file_buffer::file_buffer(hk::path_id path_id)
-    : file(path_id)
+std::mutex file_buffer::_mutex;
+std::map<std::filesystem::path, std::vector<char>> file_buffer::_content_by_path;
+
+file_buffer::file_buffer(std::filesystem::path path)
+    : file(), _path(std::move(path))
 {
 }
 
@@ -18,13 +23,18 @@ file_buffer::file_buffer(hk::path_id path_id)
     }
 
     auto const _ = std::scoped_lock(_mutex);
+    auto it = _content_by_path.lower_bound(_path);
+    if (it == _content_by_path.end() or it->first != _path) {
+        it = _content_by_path.emplace_hint(it, _path, std::vector<char>{});
+    }
+    auto const &content = it->second;
 
-    if (position >= _content.size()) {
+    if (position >= content.size()) {
         return 0; // Position is beyond the end of the content
     }
 
-    auto bytes_read = std::min(buffer.size(), _content.size() - position);
-    std::copy_n(_content.data() + position, bytes_read, buffer.data());
+    auto bytes_read = std::min(buffer.size(), content.size() - position);
+    std::copy_n(content.data() + position, bytes_read, buffer.data());
 
     if (bytes_read < buffer.size()) {
         // If we read less than the buffer size, fill the rest with null characters.
@@ -36,10 +46,17 @@ file_buffer::file_buffer(hk::path_id path_id)
 
 std::size_t file_buffer::write(std::size_t position, std::span<char const> buffer)
 {
-    if (position >= _content.size()) {
-        _content.resize(position + buffer.size(), '\0');
+    auto const _ = std::scoped_lock(_mutex);
+    auto it = _content_by_path.lower_bound(_path);
+    if (it == _content_by_path.end() or it->first != _path) {
+        it = _content_by_path.emplace_hint(it, _path, std::vector<char>{});
+    }
+    auto &content = it->second;
+
+    if (position >= content.size()) {
+        content.resize(position + buffer.size(), '\0');
     }
-    std::copy(buffer.begin(), buffer.end(), _content.begin() + position);
+    std::copy(buffer.begin(), buffer.end(), content.begin() + position);
     return buffer.size();
 }
 
@@ -49,20 +66,19 @@ std::size_t file_buffer::write(std::size_t position, std::span<char const> buffe
 
     // Generate a unique path for the file buffer.
     // This could be a temporary file or a specific directory for file buffers.
-    return std::format("/tmp/hic-buffer-{}.bin", ++counter);
+    return std::filesystem::path{std::format("/tmp/hic-buffer-{}.bin", ++counter)};
 }
 
-[[nodiscard]] path_id make_file_buffer(std::span<char const> content)
+[[nodiscard]] std::filesystem::path make_file_buffer(std::span<char const> content)
 {
-    auto path = path_id{make_file_buffer_path()};
-    auto& file = get_file(path);
-    assert(dynamic_cast<file_buffer*>(&file) != nullptr);
+    auto path = make_file_buffer_path();
+    auto file = file_buffer{path};
 
     file.write(0, content);
     return path;
 }
 
-[[nodiscard]] path_id make_file_buffer(std::string_view content)
+[[nodiscard]] std::filesystem::path make_file_buffer(std::string_view content)
 {
     return make_file_buffer(std::span<char const>{content.data(), content.size()});
 }

src/utility/file_buffer.hpp

@@ -3,6 +3,7 @@
 
 #include "file.hpp"
 #include <vector>
+#include <map>
 
 namespace hk {
 
@@ -14,7 +15,7 @@ class file_buffer : public file {
      *
      * @param path The absolute normalized path to the file.
      */
-    explicit file_buffer(hk::path_id path_id);
+    explicit file_buffer(std::filesystem::path path);
 
     /** Read the file content into a buffer.
      *
@@ -27,26 +28,30 @@ class file_buffer : public file {
     std::size_t write(std::size_t position, std::span<char const> buffer) override;
 
 private:
+    static std::mutex _mutex;
+
     /** The file content stored in a vector.
      *
      * This is used to read the file content from memory instead of from disk.
      * It is initialized when the file is opened.
      */
-    std::vector<char> _content = {};
+    static std::map<std::filesystem::path, std::vector<char>> _content_by_path;
+
+    std::filesystem::path _path;
 };
 
 /** Create a file buffer with the given content.
  * 
  * @param content The content to write to the file buffer.
  * @return A unique identifier for the file buffer.
  */
-[[nodiscard]] path_id make_file_buffer(std::span<char const> content);
+[[nodiscard]] std::filesystem::path make_file_buffer(std::span<char const> content);
 
 /** Create a file buffer with the given content.
  * 
  * @param content The content to write to the file buffer.
  * @return A unique identifier for the file buffer.
  */
-[[nodiscard]] path_id make_file_buffer(std::string_view content);
+[[nodiscard]] std::filesystem::path make_file_buffer(std::string_view content);
 
 }

src/utility/file_cursor.cpp

@@ -6,8 +6,9 @@
 
 namespace hk {
 
-file_cursor::file_cursor(hk::path_id base_path_id, hk::path_id path_id) noexcept : _location(base_path_id, path_id)
+file_cursor::file_cursor(std::filesystem::path path) : _file(make_file(path))
 {
+    _upstream_paths.push_back(std::move(path));
     _buffer.resize(max_buffer_size);
     fill_lookahead();
 }
@@ -54,10 +55,8 @@ void file_cursor::advance()
 
 void file_cursor::fill_buffer()
 {
-    auto &file = hk::get_file(_location.path_id);
-
     assert(_buffer.size() == max_buffer_size);
-    _buffer_size = file.read(_offset, std::span<char>(_buffer));
+    _buffer_size = _file->read(_offset, std::span<char>(_buffer));
     if (_buffer_size < max_buffer_size) {
         // Fill the rest of the buffer with zeros, so that the lookahead
         // can safely read beyond the end of the file.

src/utility/file_cursor.hpp

@@ -3,6 +3,7 @@
 
 #include "path.hpp"
 #include "file_location.hpp"
+#include "file.hpp"
 #include <cstddef>
 #include <bit>
 #include <vector>
@@ -25,16 +26,11 @@ namespace hk {
  */
 class file_cursor {
 public:
-    /** Create a file_cursor that is not associated with any file.
-     */
-    constexpr file_cursor() noexcept = default;
-
     /** Create a file_cursor that points to the given file.
      * 
-     * @param base_path_id The path where compilation started.
-     * @param path_id The file being compiled.
+     * @param path The path of the file being read.
      */
-    file_cursor(hk::path_id base_path_id, hk::path_id path_id) noexcept;
+    file_cursor(std::filesystem::path path);
 
     /** Get the file location where this file_cursor is currently pointint to.
      * 
@@ -165,6 +161,10 @@ class file_cursor {
 
     constexpr static std::size_t buffer_mask = max_buffer_size - 1;
 
+    /** The file object to read from.
+     */
+    std::unique_ptr<file> _file;
+
     /** The buffer used to read the file.
      * 
      * This buffer is used to read the file in chunks, so that we can efficiently