api: fix reference counting for self-assigned expressions

julelang · Oct 2, 2024 · 452130c · 452130c
1 parent 33c6945
commit 452130c
Show file tree

Hide file tree

Showing 5 changed files with 38 additions and 10 deletions.
diff --git a/api/any.hpp b/api/any.hpp
@@ -53,7 +53,8 @@ namespace jule
         template <typename T>
         Any(const jule::Ptr<T> &ref, jule::Any::Type *type) noexcept
         {
-            if (ref == nullptr) {
+            if (ref == nullptr)
+            {
                 // Pointer is nil, so can't able to use as base allocation.
                 // Make a nil any.
                 return;
@@ -177,6 +178,10 @@ namespace jule
 
         inline jule::Any &operator=(const jule::Any &src) noexcept
         {
+            // Assignment to itself.
+            if (this->data == src.data)
+                return *this;
+
             this->dealloc();
             this->data = src.data;
             this->type = src.type;

diff --git a/api/ptr.hpp b/api/ptr.hpp
@@ -66,7 +66,7 @@ namespace jule
             buffer.alloc = new (std::nothrow) T;
             if (!buffer.alloc)
                 __jule_panic_s(__JULE_ERROR__MEMORY_ALLOCATION_FAILED
-                            "\nruntime: memory allocation failed for heap of smart pointer");
+                               "\nruntime: memory allocation failed for heap of smart pointer");
 
             *buffer.alloc = instance;
             buffer.ref = ref;
@@ -262,8 +262,9 @@ namespace jule
         jule::Ptr<T> &operator=(const jule::Ptr<T> &src) noexcept
         {
             // Assignment to itself.
-            if (this->alloc != nullptr && this->alloc == src.alloc)
+            if (this->alloc == src.alloc)
                 return *this;
+
             this->dealloc();
             this->__get_copy(src);
             return *this;

diff --git a/api/slice.hpp b/api/slice.hpp
@@ -165,7 +165,7 @@ namespace jule
             Item *alloc = new (std::nothrow) Item[cap];
             if (!alloc)
                 __jule_panic_s(__JULE_ERROR__MEMORY_ALLOCATION_FAILED
-                            "\nruntime: heap allocation failed of slice");
+                               "\nruntime: heap allocation failed of slice");
 
 #ifdef __JULE_DISABLE__REFERENCE_COUNTING
             this->data = jule::Ptr<Item>::make(alloc, nullptr);
@@ -438,6 +438,14 @@ namespace jule
 
         jule::Slice<Item> &operator=(const jule::Slice<Item> &src) noexcept
         {
+            // Assignment to itself.
+            if (this->data.alloc == src.data.alloc)
+            {
+                this->_len = src._len;
+                this->_cap = src._cap;
+                this->_slice = src._slice;
+                return *this;
+            }
             this->dealloc();
             this->__get_copy(src);
             return *this;

diff --git a/api/str.hpp b/api/str.hpp
@@ -35,7 +35,7 @@ namespace jule
             auto buf = new (std::nothrow) jule::U8[len];
             if (!buf)
                 __jule_panic_s(__JULE_ERROR__MEMORY_ALLOCATION_FAILED
-                            "\nruntime: memory allocation failed for string");
+                               "\nruntime: memory allocation failed for string");
             std::memset(buf, 0, len);
             return buf;
         }
@@ -395,6 +395,14 @@ namespace jule
 
         jule::Str &operator=(const jule::Str &str)
         {
+            // Assignment to itself.
+            if (this->buffer.alloc == str.buffer.alloc)
+            {
+                this->_len = str._len;
+                this->_slice = str._slice;
+                return *this;
+            }
+            this->dealloc();
             this->buffer = str.buffer;
             this->_slice = str._slice;
             this->_len = str._len;
@@ -403,6 +411,7 @@ namespace jule
 
         jule::Str &operator=(jule::Str &&str)
         {
+            this->dealloc();
             this->buffer = std::move(str.buffer);
             this->_slice = str._slice;
             this->_len = str._len;
@@ -425,22 +434,22 @@ namespace jule
 
         jule::Bool operator<(const jule::Str &str) const noexcept
         {
-            return __jule_compareStr((jule::Str*)this, (jule::Str*)&str) == -1;
+            return __jule_compareStr((jule::Str *)this, (jule::Str *)&str) == -1;
         }
 
         inline jule::Bool operator<=(const jule::Str &str) const noexcept
         {
-            return __jule_compareStr((jule::Str*)this, (jule::Str*)&str) <= 0;
+            return __jule_compareStr((jule::Str *)this, (jule::Str *)&str) <= 0;
         }
 
         jule::Bool operator>(const jule::Str &str) const noexcept
         {
-            return __jule_compareStr((jule::Str*)this, (jule::Str*)&str) == +1;
+            return __jule_compareStr((jule::Str *)this, (jule::Str *)&str) == +1;
         }
 
         inline jule::Bool operator>=(const jule::Str &str) const noexcept
         {
-            return __jule_compareStr((jule::Str*)this, (jule::Str*)&str) >= 0;
+            return __jule_compareStr((jule::Str *)this, (jule::Str *)&str) >= 0;
         }
     };
 } // namespace jule

diff --git a/api/trait.hpp b/api/trait.hpp
@@ -81,7 +81,8 @@ namespace jule
         template <typename T>
         Trait(const jule::Ptr<T> &ref, jule::Trait::Type *type) noexcept
         {
-            if (ref == nullptr) {
+            if (ref == nullptr)
+            {
                 // Pointer is nil, so can't able to use as base allocation.
                 // Make a nil trait.
                 return;
@@ -227,6 +228,10 @@ namespace jule
 
         inline jule::Trait &operator=(const jule::Trait &src) noexcept
         {
+            // Assignment to itself.
+            if (this->data.alloc == src.data.alloc)
+                return *this;
+
             this->dealloc();
             this->__get_copy(src);
             return *this;