koffi 2.1.0-beta.3 → 2.1.0

package/vendor/libcc/libcc.hh

@@ -109,9 +109,14 @@ extern "C" const char *FelixCompiler;
     #error Machine architecture not supported
 #endif
 
-#if !defined(_MSC_VER) && __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
-    #error This code base is not designed to support big-endian platforms
+#if defined(_MSC_VER) || __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    // Sane platform
+#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+    #define RG_BIG_ENDIAN
+#else
+    #error This code base is not designed to support platforms with crazy endianness
 #endif
+
 #if UINT_MAX != 0xFFFFFFFFu
     #error This code base is not designed to support non-32-bits int types
 #endif
@@ -302,11 +307,17 @@ static inline constexpr int32_t ReverseBytes(int32_t i)
 static inline constexpr int64_t ReverseBytes(int64_t i)
     { return (int64_t)ReverseBytes((uint64_t)i); }
 
-// Sensitive to endianness
+#ifdef RG_BIG_ENDIAN
+template <typename T>
+constexpr T LittleEndian(T v) { return ReverseBytes(v); }
+template <typename T>
+constexpr T BigEndian(T v) { return v; }
+#else
 template <typename T>
 constexpr T LittleEndian(T v) { return v; }
 template <typename T>
 constexpr T BigEndian(T v) { return ReverseBytes(v); }
+#endif
 
 #if defined(__GNUC__)
     static inline int CountLeadingZeros(uint32_t u)
@@ -445,6 +456,26 @@ constexpr T BigEndian(T v) { return ReverseBytes(v); }
     #error No implementation of CountLeadingZeros(), CountTrailingZeros() and PopCount() for this compiler / toolchain
 #endif
 
+static inline Size AlignLen(Size len, Size align)
+{
+    Size aligned = (len + align - 1) / align * align;
+    return aligned;
+}
+
+template <typename T>
+static inline T *AlignUp(T *ptr, Size align)
+{
+    uint8_t *aligned = (uint8_t *)(((uintptr_t)ptr + align - 1) / align * align);
+    return (T *)aligned;
+}
+
+template <typename T>
+static inline T *AlignDown(T *ptr, Size align)
+{
+    uint8_t *aligned = (uint8_t *)((uintptr_t)ptr / align * align);
+    return (T *)aligned;
+}
+
 // Calling memcpy (and friends) with a NULL source pointer is undefined behavior
 // even if length is 0. This is dumb, work around this.
 static inline void *memcpy_safe(void *dest, const void *src, size_t len)
@@ -619,10 +650,179 @@ struct Vec3 {
 // Memory / Allocator
 // ------------------------------------------------------------------------
 
-class Allocator;
+// I'd love to make Span default to { nullptr, 0 } but unfortunately that makes
+// it a non-POD and prevents putting it in a union.
+template <typename T>
+struct Span {
+    T *ptr;
+    Size len;
 
-Allocator *GetDefaultAllocator();
-Allocator *GetNullAllocator();
+    Span() = default;
+    constexpr Span(T &value) : ptr(&value), len(1) {}
+    constexpr Span(std::initializer_list<T> l) : ptr(l.begin()), len((Size)l.size()) {}
+    constexpr Span(T *ptr_, Size len_) : ptr(ptr_), len(len_) {}
+    template <Size N>
+    constexpr Span(T (&arr)[N]) : ptr(arr), len(N) {}
+
+    void Reset()
+    {
+        ptr = nullptr;
+        len = 0;
+    }
+
+    T *begin() { return ptr; }
+    const T *begin() const { return ptr; }
+    T *end() { return ptr + len; }
+    const T *end() const { return ptr + len; }
+
+    bool IsValid() const { return ptr; }
+
+    T &operator[](Size idx)
+    {
+        RG_ASSERT(idx >= 0 && idx < len);
+        return ptr[idx];
+    }
+    const T &operator[](Size idx) const
+    {
+        RG_ASSERT(idx >= 0 && idx < len);
+        return ptr[idx];
+    }
+
+    operator Span<const T>() const { return Span<const T>(ptr, len); }
+
+    bool operator==(const Span &other) const
+    {
+        if (len != other.len)
+            return false;
+
+        for (Size i = 0; i < len; i++) {
+            if (ptr[i] != other.ptr[i])
+                return false;
+        }
+
+        return true;
+    }
+    bool operator!=(const Span &other) const { return !(*this == other); }
+
+    Span Take(Size offset, Size sub_len) const
+    {
+        RG_ASSERT(sub_len >= 0 && sub_len <= len);
+        RG_ASSERT(offset >= 0 && offset <= len - sub_len);
+
+        Span<T> sub;
+        sub.ptr = ptr + offset;
+        sub.len = sub_len;
+        return sub;
+    }
+
+    template <typename U>
+    Span<U> As() const { return Span<U>((U *)ptr, len); }
+};
+
+// Use strlen() to build Span<const char> instead of the template-based
+// array constructor.
+template <>
+struct Span<const char> {
+    const char *ptr;
+    Size len;
+
+    Span() = default;
+    constexpr Span(const char &ch) : ptr(&ch), len(1) {}
+    constexpr Span(const char *ptr_, Size len_) : ptr(ptr_), len(len_) {}
+#ifdef __clang__
+    constexpr Span(const char *const &str) : ptr(str), len(str ? (Size)__builtin_strlen(str) : 0) {}
+#else
+    constexpr Span(const char *const &str) : ptr(str), len(str ? (Size)strlen(str) : 0) {}
+#endif
+
+    void Reset()
+    {
+        ptr = nullptr;
+        len = 0;
+    }
+
+    const char *begin() const { return ptr; }
+    const char *end() const { return ptr + len; }
+
+    bool IsValid() const { return ptr; }
+
+    char operator[](Size idx) const
+    {
+        RG_ASSERT(idx >= 0 && idx < len);
+        return ptr[idx];
+    }
+
+    // The implementation comes later, after TestStr() is available
+    bool operator==(Span<const char> other) const;
+    bool operator==(const char *other) const;
+    bool operator!=(Span<const char> other) const { return !(*this == other); }
+    bool operator!=(const char *other) const { return !(*this == other); }
+
+    Span Take(Size offset, Size sub_len) const
+    {
+        RG_ASSERT(sub_len >= 0 && sub_len <= len);
+        RG_ASSERT(offset >= 0 && offset <= len - sub_len);
+
+        Span<const char> sub;
+        sub.ptr = ptr + offset;
+        sub.len = sub_len;
+        return sub;
+    }
+
+    template <typename U>
+    Span<U> As() const { return Span<U>((U *)ptr, len); }
+};
+
+template <typename T>
+static inline constexpr Span<T> MakeSpan(T *ptr, Size len)
+{
+    return Span<T>(ptr, len);
+}
+template <typename T>
+static inline constexpr Span<T> MakeSpan(T *ptr, T *end)
+{
+    return Span<T>(ptr, end - ptr);
+}
+template <typename T, Size N>
+static inline constexpr Span<T> MakeSpan(T (&arr)[N])
+{
+    return Span<T>(arr, N);
+}
+
+template <typename T>
+class Strider {
+public:
+    void *ptr = nullptr;
+    Size stride;
+
+    Strider() = default;
+    constexpr Strider(T *ptr_) : ptr(ptr_), stride(RG_SIZE(T)) {}
+    constexpr Strider(T *ptr_, Size stride_) : ptr(ptr_), stride(stride_) {}
+
+    bool IsValid() const { return ptr; }
+
+    T &operator[](Size idx) const
+    {
+        RG_ASSERT(idx >= 0);
+        return *(T *)((uint8_t *)ptr + (idx * stride));
+    }
+};
+
+template <typename T>
+static inline constexpr Strider<T> MakeStrider(T *ptr)
+{
+    return Strider<T>(ptr, RG_SIZE(T));
+}
+template <typename T>
+static inline constexpr Strider<T> MakeStrider(T *ptr, Size stride)
+{
+    return Strider<T>(ptr, stride);
+}
+template <typename T, Size N>
+static inline constexpr Strider<T> MakeStrider(T (&arr)[N])
+{
+    return Strider<T>(arr, RG_SIZE(T));
+}
 
 class Allocator {
     RG_DELETE_COPY(Allocator)
@@ -636,40 +836,60 @@ public:
     Allocator() = default;
     virtual ~Allocator() = default;
 
-    static void *Allocate(Allocator *alloc, Size size, unsigned int flags = 0)
-    {
-        RG_ASSERT(size >= 0);
+    virtual void *Allocate(Size size, unsigned int flags = 0) = 0;
+    virtual void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags = 0) = 0;
+    virtual void Release(void *ptr, Size size) = 0;
+};
 
-        if (!alloc) {
-            alloc = GetDefaultAllocator();
-        }
-        return alloc->Allocate(size, flags);
+Allocator *GetDefaultAllocator();
+Allocator *GetNullAllocator();
+
+template <typename T>
+Span<T> AllocateMemory(Allocator *alloc, Size size, unsigned int flags = 0)
+{
+    RG_ASSERT(size >= 0);
+
+    if (!alloc) {
+        alloc = GetDefaultAllocator();
     }
 
-    static void Resize(Allocator *alloc, void **ptr, Size old_size, Size new_size,
-                       unsigned int flags = 0)
-    {
-        RG_ASSERT(new_size >= 0);
+    T *ptr = (T *)alloc->Allocate(size, flags);
+    return MakeSpan(ptr, size);
+}
 
-        if (!alloc) {
-            alloc = GetDefaultAllocator();
-        }
-        alloc->Resize(ptr, old_size, new_size, flags);
+template <typename T>
+Span<T> ResizeMemory(Allocator *alloc, T *ptr, Size old_size, Size new_size,
+                         unsigned int flags = 0)
+{
+    RG_ASSERT(new_size >= 0);
+
+    if (!alloc) {
+        alloc = GetDefaultAllocator();
     }
 
-    static void Release(Allocator *alloc, void *ptr, Size size)
-    {
-        if (!alloc) {
-            alloc = GetDefaultAllocator();
-        }
-        alloc->Release(ptr, size);
+    alloc->Resize((void **)&ptr, old_size, new_size, flags);
+    return MakeSpan(ptr, new_size);
+}
+
+template<typename T>
+void ReleaseMemory(Allocator *alloc, Span<T> mem)
+{
+    if (!alloc) {
+        alloc = GetDefaultAllocator();
     }
 
-protected:
-    virtual void *Allocate(Size size, unsigned int flags = 0) = 0;
-    virtual void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags = 0) = 0;
-    virtual void Release(void *ptr, Size size) = 0;
-};
+    alloc->Release((void *)mem.ptr, mem.len);
+}
+
+template<typename T>
+void ReleaseMemory(Allocator *alloc, T *ptr, Size size)
+{
+    if (!alloc) {
+        alloc = GetDefaultAllocator();
+    }
+
+    alloc->Release((void *)ptr, size);
+}
 
 class LinkedAllocator final: public Allocator {
     struct Node {
@@ -679,7 +899,7 @@ class LinkedAllocator final: public Allocator {
     struct Bucket {
          // Keep head first or stuff will break
         Node head;
-        alignas(16) uint8_t data[];
+        uint8_t data[8]; // Extra size is used to align pointer
     };
 
     Allocator *allocator;
@@ -696,9 +916,8 @@ public:
 
     void ReleaseAll();
 
-protected:
-    void *Allocate(Size size, unsigned int flags) override;
-    void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags) override;
+    void *Allocate(Size size, unsigned int flags = 0) override;
+    void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags = 0) override;
     void Release(void *ptr, Size size) override;
 
 private:
@@ -709,7 +928,7 @@ private:
 class BlockAllocatorBase: public Allocator {
     struct Bucket {
         Size used;
-        alignas(8) uint8_t data[];
+        uint8_t data[8]; // Extra size is used to align pointer
     };
 
     Size block_size;
@@ -724,11 +943,11 @@ public:
         RG_ASSERT(block_size > 0);
     }
 
-protected:
-    void *Allocate(Size size, unsigned int flags) override;
-    void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags) override;
+    void *Allocate(Size size, unsigned int flags = 0) override;
+    void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags = 0) override;
     void Release(void *ptr, Size size) override;
 
+protected:
     void CopyFrom(BlockAllocatorBase *other);
     void ForgetCurrentBlock();
 
@@ -736,9 +955,6 @@ protected:
 
 private:
     bool AllocateSeparately(Size aligned_size) const { return aligned_size >= block_size / 2; }
-
-    static Size AlignSizeValue(Size size)
-        { return (RG_SIZE(Bucket) + size + 7) / 8 * 8 - RG_SIZE(Bucket); }
 };
 
 class BlockAllocator final: public BlockAllocatorBase {
@@ -873,180 +1089,6 @@ public:
 // Collections
 // ------------------------------------------------------------------------
 
-// I'd love to make Span default to { nullptr, 0 } but unfortunately that makes
-// it a non-POD and prevents putting it in a union.
-template <typename T>
-struct Span {
-    T *ptr;
-    Size len;
-
-    Span() = default;
-    constexpr Span(T &value) : ptr(&value), len(1) {}
-    constexpr Span(std::initializer_list<T> l) : ptr(l.begin()), len((Size)l.size()) {}
-    constexpr Span(T *ptr_, Size len_) : ptr(ptr_), len(len_) {}
-    template <Size N>
-    constexpr Span(T (&arr)[N]) : ptr(arr), len(N) {}
-
-    void Reset()
-    {
-        ptr = nullptr;
-        len = 0;
-    }
-
-    T *begin() { return ptr; }
-    const T *begin() const { return ptr; }
-    T *end() { return ptr + len; }
-    const T *end() const { return ptr + len; }
-
-    bool IsValid() const { return ptr; }
-
-    T &operator[](Size idx)
-    {
-        RG_ASSERT(idx >= 0 && idx < len);
-        return ptr[idx];
-    }
-    const T &operator[](Size idx) const
-    {
-        RG_ASSERT(idx >= 0 && idx < len);
-        return ptr[idx];
-    }
-
-    operator Span<const T>() const { return Span<const T>(ptr, len); }
-
-    bool operator==(const Span &other) const
-    {
-        if (len != other.len)
-            return false;
-
-        for (Size i = 0; i < len; i++) {
-            if (ptr[i] != other.ptr[i])
-                return false;
-        }
-
-        return true;
-    }
-    bool operator!=(const Span &other) const { return !(*this == other); }
-
-    Span Take(Size offset, Size sub_len) const
-    {
-        RG_ASSERT(sub_len >= 0 && sub_len <= len);
-        RG_ASSERT(offset >= 0 && offset <= len - sub_len);
-
-        Span<T> sub;
-        sub.ptr = ptr + offset;
-        sub.len = sub_len;
-        return sub;
-    }
-
-    template <typename U>
-    Span<U> As() const { return Span<U>((U *)ptr, len); }
-};
-
-// Use strlen() to build Span<const char> instead of the template-based
-// array constructor.
-template <>
-struct Span<const char> {
-    const char *ptr;
-    Size len;
-
-    Span() = default;
-    constexpr Span(const char &ch) : ptr(&ch), len(1) {}
-    constexpr Span(const char *ptr_, Size len_) : ptr(ptr_), len(len_) {}
-#ifdef __clang__
-    constexpr Span(const char *const &str) : ptr(str), len(str ? (Size)__builtin_strlen(str) : 0) {}
-#else
-    constexpr Span(const char *const &str) : ptr(str), len(str ? (Size)strlen(str) : 0) {}
-#endif
-
-    void Reset()
-    {
-        ptr = nullptr;
-        len = 0;
-    }
-
-    const char *begin() const { return ptr; }
-    const char *end() const { return ptr + len; }
-
-    bool IsValid() const { return ptr; }
-
-    char operator[](Size idx) const
-    {
-        RG_ASSERT(idx >= 0 && idx < len);
-        return ptr[idx];
-    }
-
-    // The implementation comes later, after TestStr() is available
-    bool operator==(Span<const char> other) const;
-    bool operator==(const char *other) const;
-    bool operator!=(Span<const char> other) const { return !(*this == other); }
-    bool operator!=(const char *other) const { return !(*this == other); }
-
-    Span Take(Size offset, Size sub_len) const
-    {
-        RG_ASSERT(sub_len >= 0 && sub_len <= len);
-        RG_ASSERT(offset >= 0 && offset <= len - sub_len);
-
-        Span<const char> sub;
-        sub.ptr = ptr + offset;
-        sub.len = sub_len;
-        return sub;
-    }
-
-    template <typename U>
-    Span<U> As() const { return Span<U>((U *)ptr, len); }
-};
-
-template <typename T>
-static inline constexpr Span<T> MakeSpan(T *ptr, Size len)
-{
-    return Span<T>(ptr, len);
-}
-template <typename T>
-static inline constexpr Span<T> MakeSpan(T *ptr, T *end)
-{
-    return Span<T>(ptr, end - ptr);
-}
-template <typename T, Size N>
-static inline constexpr Span<T> MakeSpan(T (&arr)[N])
-{
-    return Span<T>(arr, N);
-}
-
-template <typename T>
-class Strider {
-public:
-    void *ptr = nullptr;
-    Size stride;
-
-    Strider() = default;
-    constexpr Strider(T *ptr_) : ptr(ptr_), stride(RG_SIZE(T)) {}
-    constexpr Strider(T *ptr_, Size stride_) : ptr(ptr_), stride(stride_) {}
-
-    bool IsValid() const { return ptr; }
-
-    T &operator[](Size idx) const
-    {
-        RG_ASSERT(idx >= 0);
-        return *(T *)((uint8_t *)ptr + (idx * stride));
-    }
-};
-
-template <typename T>
-static inline constexpr Strider<T> MakeStrider(T *ptr)
-{
-    return Strider<T>(ptr, RG_SIZE(T));
-}
-template <typename T>
-static inline constexpr Strider<T> MakeStrider(T *ptr, Size stride)
-{
-    return Strider<T>(ptr, stride);
-}
-template <typename T, Size N>
-static inline constexpr Strider<T> MakeStrider(T (&arr)[N])
-{
-    return Strider<T>(arr, RG_SIZE(T));
-}
-
 template <typename T, Size N, Size AlignAs = alignof(T)>
 class LocalArray {
 public:
@@ -1273,8 +1315,7 @@ public:
                 len = new_capacity;
             }
 
-            Allocator::Resize(allocator, (void **)&ptr,
-                              capacity * RG_SIZE(T), new_capacity * RG_SIZE(T));
+            ptr = ResizeMemory(allocator, ptr, capacity * RG_SIZE(T), new_capacity * RG_SIZE(T)).ptr;
             capacity = new_capacity;
         }
     }
@@ -1571,9 +1612,9 @@ public:
         Size bucket_offset = (offset + len) % BucketSize;
 
         if (bucket_idx >= buckets.len) {
-            Bucket *new_bucket = (Bucket *)Allocator::Allocate(buckets.allocator, RG_SIZE(Bucket));
+            Bucket *new_bucket = AllocateMemory<Bucket>(buckets.allocator, RG_SIZE(Bucket)).ptr;
             new (&new_bucket->allocator) AllocatorType();
-            new_bucket->values = (T *)Allocator::Allocate(&new_bucket->allocator, BucketSize * RG_SIZE(T));
+            new_bucket->values = AllocateMemory<T>(&new_bucket->allocator, BucketSize * RG_SIZE(T)).ptr;
 
             buckets.Append(new_bucket);
         }
@@ -1690,7 +1731,7 @@ private:
     void DeleteBucket(Bucket *bucket)
     {
         bucket->allocator.~AllocatorType();
-        Allocator::Release(buckets.allocator, bucket, RG_SIZE(Bucket));
+        ReleaseMemory(buckets.allocator, bucket, RG_SIZE(Bucket));
     }
 };
 
@@ -2203,10 +2244,10 @@ private:
         Size old_capacity = capacity;
 
         if (new_capacity) {
-            used = (size_t *)Allocator::Allocate(allocator,
+            used = AllocateMemory<size_t>(allocator,
                                                  (new_capacity + (RG_SIZE(size_t) * 8) - 1) / RG_SIZE(size_t),
-                                                 (int)Allocator::Flag::Zero);
-            data = (ValueType *)Allocator::Allocate(allocator, new_capacity * RG_SIZE(ValueType));
+                                                 (int)Allocator::Flag::Zero).ptr;
+            data = AllocateMemory<ValueType>(allocator, new_capacity * RG_SIZE(ValueType)).ptr;
             for (Size i = 0; i < new_capacity; i++) {
                 new (&data[i]) ValueType();
             }
@@ -2228,9 +2269,9 @@ private:
             capacity = 0;
         }
 
-        Allocator::Release(allocator, old_used,
+        ReleaseMemory(allocator, old_used,
                            (old_capacity + (RG_SIZE(size_t) * 8) - 1) / RG_SIZE(size_t));
-        Allocator::Release(allocator, old_data, old_capacity * RG_SIZE(ValueType));
+        ReleaseMemory(allocator, old_data, old_capacity * RG_SIZE(ValueType));
     }
 
     void MarkUsed(Size idx)
@@ -2554,18 +2595,28 @@ public:
 // Date
 // ------------------------------------------------------------------------
 
-union Date {
+union LocalDate {
     int32_t value;
     struct {
-        // Sensitive to endianness
+#ifdef RG_BIG_ENDIAN
+        int16_t year;
+        int8_t month;
+        int8_t day;
+#else
         int8_t day;
         int8_t month;
         int16_t year;
+#endif
     } st;
 
-    Date() = default;
-    Date(int16_t year, int8_t month, int8_t day)
-        : st({day, month, year}) { RG_ASSERT(IsValid()); } // Sensitive to endianness
+    LocalDate() = default;
+#ifdef RG_BIG_ENDIAN
+    LocalDate(int16_t year, int8_t month, int8_t day)
+        : st({year, month, day}) { RG_ASSERT(IsValid()); }
+#else
+    LocalDate(int16_t year, int8_t month, int8_t day)
+        : st({day, month, year}) { RG_ASSERT(IsValid()); }
+#endif
 
     static inline bool IsLeapYear(int16_t year)
     {
@@ -2577,10 +2628,10 @@ union Date {
         return (int8_t)(DaysPerMonth[month - 1] + (month == 2 && IsLeapYear(year)));
     }
 
-    static Date Parse(Span<const char> date_str, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
-                      Span<const char> *out_remaining = nullptr);
-    static Date FromJulianDays(int days);
-    static Date FromCalendarDate(int days) { return Date::FromJulianDays(days + 2440588); }
+    static LocalDate Parse(Span<const char> date_str, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
+                           Span<const char> *out_remaining = nullptr);
+    static LocalDate FromJulianDays(int days);
+    static LocalDate FromCalendarDate(int days) { return LocalDate::FromJulianDays(days + 2440588); }
 
     bool IsValid() const
     {
@@ -2594,25 +2645,25 @@ union Date {
         return true;
     }
 
-    bool operator==(Date other) const { return value == other.value; }
-    bool operator!=(Date other) const { return value != other.value; }
-    bool operator>(Date other) const { return value > other.value; }
-    bool operator>=(Date other) const { return value >= other.value; }
-    bool operator<(Date other) const { return value < other.value; }
-    bool operator<=(Date other) const { return value <= other.value; }
+    bool operator==(LocalDate other) const { return value == other.value; }
+    bool operator!=(LocalDate other) const { return value != other.value; }
+    bool operator>(LocalDate other) const { return value > other.value; }
+    bool operator>=(LocalDate other) const { return value >= other.value; }
+    bool operator<(LocalDate other) const { return value < other.value; }
+    bool operator<=(LocalDate other) const { return value <= other.value; }
 
     int ToJulianDays() const;
     int ToCalendarDate() const { return ToJulianDays() - 2440588; }
 
     int GetWeekDay() const;
 
-    int operator-(Date other) const
+    int operator-(LocalDate other) const
         { return ToJulianDays() - other.ToJulianDays(); }
 
-    Date operator+(int days) const
+    LocalDate operator+(int days) const
     {
         if (days < 5 && days > -5) {
-            Date date = *this;
+            LocalDate date = *this;
             if (days > 0) {
                 while (days--) {
                     ++date;
@@ -2624,19 +2675,19 @@ union Date {
             }
             return date;
         } else {
-            return Date::FromJulianDays(ToJulianDays() + days);
+            return LocalDate::FromJulianDays(ToJulianDays() + days);
         }
     }
     // That'll fail with INT_MAX days but that's far more days than can
     // be represented as a date anyway
-    Date operator-(int days) const { return *this + (-days); }
+    LocalDate operator-(int days) const { return *this + (-days); }
 
-    Date &operator+=(int days) { *this = *this + days; return *this; }
-    Date &operator-=(int days) { *this = *this - days; return *this; }
-    Date &operator++();
-    Date operator++(int) { Date date = *this; ++(*this); return date; }
-    Date &operator--();
-    Date operator--(int) { Date date = *this; --(*this); return date; }
+    LocalDate &operator+=(int days) { *this = *this + days; return *this; }
+    LocalDate &operator-=(int days) { *this = *this - days; return *this; }
+    LocalDate &operator++();
+    LocalDate operator++(int) { LocalDate date = *this; ++(*this); return date; }
+    LocalDate &operator--();
+    LocalDate operator--(int) { LocalDate date = *this; --(*this); return date; }
 
     uint64_t Hash() const { return HashTraits<int32_t>::Hash(value); }
 };
@@ -3067,7 +3118,7 @@ public:
             int max_prec;
         } d;
         const void *ptr;
-        Date date;
+        LocalDate date;
         TimeSpec time;
         Size random_len;
         struct {
@@ -3110,7 +3161,7 @@ public:
     FmtArg(float f) : type(FmtType::Float) { u.f = { f, 0, INT_MAX }; }
     FmtArg(double d) : type(FmtType::Double) { u.d = { d, 0, INT_MAX }; }
     FmtArg(const void *ptr) : type(FmtType::Hexadecimal) { u.u = (uint64_t)ptr; }
-    FmtArg(const Date &date) : type(FmtType::Date) { u.date = date; }
+    FmtArg(const LocalDate &date) : type(FmtType::Date) { u.date = date; }
 
     FmtArg &Repeat(int new_repeat) { repeat = new_repeat; return *this; }
     FmtArg &Pad(int len, char c = ' ') { pad_char = c; pad_len = len; return *this; }