feat: add HIR infra, add sema infra, add some more parsing stuff

Author: w4z3d

.clang-format

@@ -2,6 +2,6 @@ BasedOnStyle: Google
 IndentWidth: 2
 ColumnLimit: 100
 BreakBeforeBraces: Attach
-AllowShortIfStatementsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: true
 PointerAlignment: Left

.clang-tidy

@@ -8,3 +8,4 @@ Checks: >
 WarningsAsErrors: ""
 HeaderFilterRegex: "src/|include/"
 FormatStyle: file
+Add: [-std=c++20]

include/cinder/alloc/arena.hpp

@@ -28,9 +28,7 @@ class Arena {
       data = static_cast<std::byte*>(::operator new(size, std::align_val_t{alignment}));
     }
 
-    ~Block() {
-      ::operator delete(data, std::align_val_t{alignment});
-    }
+    ~Block() { ::operator delete(data, std::align_val_t{alignment}); }
 
     Block(const Block&) = delete;
     Block& operator=(const Block&) = delete;
@@ -173,9 +171,7 @@ class Arena {
     return total;
   }
 
-  ~Arena() {
-    run_destructors();
-  }
+  ~Arena() { run_destructors(); }
 
   Arena(const Arena&) = delete;
   Arena& operator=(const Arena&) = delete;

include/cinder/alloc/arena_list.hpp

@@ -1,68 +1,139 @@
 #pragma once
 
+#include <cassert>
+#include <iterator>
+#include <type_traits>
+
 namespace cinder::arena {
 
 template <typename T>
 class ArenaList;
 
 template <typename T>
 struct ListHook {
-  T* previous;
-  T* next;
+  T* previous = nullptr;
+  T* next = nullptr;
 
   template <typename>
   friend class ArenaList;
 };
 
 template <typename T>
 class ArenaList {
+  static_assert(std::is_base_of_v<ListHook<T>, T>, "T must inherit from ListHook<T>");
+
  public:
   class iterator {
    public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = T;
+    using difference_type = std::ptrdiff_t;
+    using pointer = T*;
+    using reference = T&;
+
     explicit iterator(T* node) : node_(node) {}
 
-    T& operator*() const {
-      return *node_;
-    }
-    T* operator->() const {
-      return node_;
-    }
+    T& operator*() const { return *node_; }
+    T* operator->() const { return node_; }
 
     iterator& operator++() {
-      node_ = node_->next;
+      node_ = hook(node_).next;
       return *this;
     }
 
-    bool operator==(const iterator& other) const {
-      return node_ == other.node_;
-    }
-    bool operator!=(const iterator& other) const {
-      return node_ != other.node_;
+    iterator operator++(int) {
+      iterator old = *this;
+      ++(*this);
+      return old;
     }
 
+    bool operator==(const iterator& other) const { return node_ == other.node_; }
+
+    bool operator!=(const iterator& other) const { return node_ != other.node_; }
+
    private:
     T* node_ = nullptr;
   };
 
-  iterator begin() {
-    return iterator(head_);
-  }
-  iterator end() {
-    return iterator(nullptr);
-  }
+  ArenaList() = default;
+
+  ArenaList(const ArenaList&) = delete;
+  ArenaList& operator=(const ArenaList&) = delete;
+
+  iterator begin() { return iterator(head_); }
+  iterator end() { return iterator(nullptr); }
+
+  [[nodiscard]] bool empty() const { return head_ == nullptr; }
+
+  [[nodiscard]] T* front() const { return head_; }
+  [[nodiscard]] T* back() const { return tail_; }
+
+  void push_back(T* node) {
+    assert(node != nullptr);
+
+    auto& node_hook = hook(node);
+
+    node_hook.previous = tail_;
+    node_hook.next = nullptr;
+
+    if (tail_) {
+      hook(tail_).next = node;
+    } else {
+      head_ = node;
+    }
 
-  [[nodiscard]] bool empty() const {
-    return head_ == nullptr;
+    tail_ = node;
   }
-  T* front() const {
-    return head_;
+
+  void push_front(T* node) {
+    assert(node != nullptr);
+
+    auto& node_hook = hook(node);
+
+    node_hook.previous = nullptr;
+    node_hook.next = head_;
+
+    if (head_) {
+      hook(head_).previous = node;
+    } else {
+      tail_ = node;
+    }
+
+    head_ = node;
   }
-  T* back() const {
-    return tail_;
+
+  void remove(T* node) {
+    assert(node != nullptr);
+
+    auto& node_hook = hook(node);
+
+    T* previous = node_hook.previous;
+    T* next = node_hook.next;
+
+    if (previous) {
+      hook(previous).next = next;
+    } else {
+      head_ = next;
+    }
+
+    if (next) {
+      hook(next).previous = previous;
+    } else {
+      tail_ = previous;
+    }
+
+    node_hook.previous = nullptr;
+    node_hook.next = nullptr;
   }
 
+ private:
+  static ListHook<T>& hook(T* node) { return static_cast<ListHook<T>&>(*node); }
+
+  static const ListHook<T>& hook(const T* node) { return static_cast<const ListHook<T>&>(*node); }
+
  private:
   T* head_ = nullptr;
   T* tail_ = nullptr;
 };
+
 }  // namespace cinder::arena

include/cinder/alloc/array_ref.hpp

@@ -39,29 +39,17 @@ class ArrayRef {
     }
       : data_(ref.data()), length_(static_cast<size_type>(ref.size())) {}
 
-  [[nodiscard]] constexpr const T* data() const noexcept {
-    return data_;
-  }
+  [[nodiscard]] constexpr const T* data() const noexcept { return data_; }
 
-  [[nodiscard]] constexpr size_type size() const noexcept {
-    return length_;
-  }
+  [[nodiscard]] constexpr size_type size() const noexcept { return length_; }
 
-  [[nodiscard]] constexpr bool empty() const noexcept {
-    return length_ == 0;
-  }
+  [[nodiscard]] constexpr bool empty() const noexcept { return length_ == 0; }
 
-  [[nodiscard]] constexpr const_reference operator[](size_type index) const {
-    return data_[index];
-  }
+  [[nodiscard]] constexpr const_reference operator[](size_type index) const { return data_[index]; }
 
-  [[nodiscard]] constexpr const_iterator begin() const noexcept {
-    return data_;
-  }
+  [[nodiscard]] constexpr const_iterator begin() const noexcept { return data_; }
 
-  [[nodiscard]] constexpr const_iterator end() const noexcept {
-    return data_ + length_;
-  }
+  [[nodiscard]] constexpr const_iterator end() const noexcept { return data_ + length_; }
 
   [[nodiscard]] constexpr const_reverse_iterator rbegin() const noexcept {
     return const_reverse_iterator(end());
@@ -70,13 +58,9 @@ class ArrayRef {
   [[nodiscard]] constexpr const_reverse_iterator rend() const noexcept {
     return const_reverse_iterator(begin());
   }
-  [[nodiscard]] constexpr const_reference front() const {
-    return data_[0];
-  }
+  [[nodiscard]] constexpr const_reference front() const { return data_[0]; }
 
-  [[nodiscard]] constexpr const_reference back() const {
-    return data_[length_ - 1];
-  }
+  [[nodiscard]] constexpr const_reference back() const { return data_[length_ - 1]; }
 
  private:
   const T* data_;