Bug fixes: Memory leak/off by one on UIntSet (#1616)

* #include an absolute path didn't work - because paths were taken to always be relative.

* Fix memory leak on ScopedAllocation.
Fix off by one bug on UIntSet

3 files changed, 49 insertions, 1 deletions

diff --git a/source/core/slang-blob.h b/source/core/slang-blob.h
index 8bf02512d..d326f9c9c 100644
--- a/source/core/slang-blob.h
+++ b/source/core/slang-blob.h
@@ -109,17 +109,41 @@ public:
         m_sizeInBytes = size;
     }
 
+    void* set(const void* data, size_t size)
+    {
+        void* dst = allocate(size);
+        if (dst)
+        {
+            memcpy(dst, data, size);
+        }
+        return dst;
+    }
+
     /// Get the allocated data. Returns nullptr if there is no allocated data
     void* getData() const { return m_data; }
     /// Get the size of the allocated data.
     size_t getSizeInBytes() const { return m_sizeInBytes; }
 
+    void swap(ThisType& rhs)
+    {
+        void*const data = m_data;
+        const size_t sizeInBytes = m_sizeInBytes;
+
+        m_data = rhs.m_data;
+        m_sizeInBytes = rhs.m_sizeInBytes;
+
+        rhs.m_data = data;
+        rhs.m_sizeInBytes = sizeInBytes;
+    }
+
     ScopedAllocation() :
         m_data(nullptr),
         m_sizeInBytes(0)
     {
     }
 
+    ~ScopedAllocation() { deallocate(); }
+
 private:
     // disable
     ScopedAllocation(const ThisType& rhs) = delete;
@@ -153,6 +177,12 @@ public:
         blob->m_data.attach(data, dataCount);
         return blob;
     }
+    static RefPtr<RawBlob> moveCreate(ScopedAllocation& alloc)
+    {
+        RawBlob* blob = new RawBlob;
+        blob->m_data.swap(alloc);
+        return blob;
+    }
 
 protected:
     RawBlob() = default;
diff --git a/source/core/slang-uint-set.cpp b/source/core/slang-uint-set.cpp
index 3ac1c530a..02e142706 100644
--- a/source/core/slang-uint-set.cpp
+++ b/source/core/slang-uint-set.cpp
@@ -64,6 +64,21 @@ void UIntSet::clear()
     ::memset(m_buffer.getBuffer(), 0, m_buffer.getCount() * sizeof(Element));
 }
 
+bool UIntSet::isEmpty() const
+{
+    const Element*const src = m_buffer.getBuffer();
+    const Index count = m_buffer.getCount();
+
+    for (Index i = 0; i < count; ++i)
+    {
+        if (src[i])
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
 void UIntSet::clearAndDeallocate()
 {
     m_buffer.clearAndDeallocate();
diff --git a/source/core/slang-uint-set.h b/source/core/slang-uint-set.h
index 7833ffa25..f89f37df2 100644
--- a/source/core/slang-uint-set.h
+++ b/source/core/slang-uint-set.h
@@ -61,6 +61,9 @@ public:
         /// Store the intersection between this and set in this
     void intersectWith(const UIntSet& set);
 
+        /// 
+    bool isEmpty() const;
+
         /// Store the union of set1 and set2 in outRs
     static void calcUnion(UIntSet& outRs, const UIntSet& set1, const UIntSet& set2);
         /// Store the intersection of set1 and set2 in outRs
@@ -99,7 +102,7 @@ inline void UIntSet::remove(UInt val)
 inline bool UIntSet::contains(UInt val) const
 {
     const Index idx = Index(val >> kElementShift);
-    return idx <= m_buffer.getCount() &&
+    return idx < m_buffer.getCount() &&
         ((m_buffer[idx] & (Element(1) << (val & kElementMask))) != 0);
 }