fix: fixes for various errors related to shared_from_this. (WerWolv#171)

paxcut · web-flow · commit 55b67dea24d3 · 2025-06-15T09:52:29.000-07:00
* fix: fixes for various errors related to shared_from_this.

A while back there were some changes to the pattern language library that changed the way shared_pointers are created using shared_from_this(). Unfortunatelly the changes were not complete and various bugs were created among them 2234, json type not working, unable to export files, static arrays of bitfields,... The cause of the errors was that in class Pattern the member m_parent was left as a raw pointer and it needs to be handled by shared pointers. Also there were some cases in which share pointers were needed but unique pointers were used instead. Both cause crashes when shared_from_this is used on pointers that are not managed by shared_ptr. Another source of errors were infinite loops of clone and reference that caused stack overflow.
The fixes include making m_parent a weak pointer, turning unique pointers into shared pointers and moving codefrom the copy constructors into clone to break the infinite loops.These changes are the bare minimum needed to bring the pattern language back to the full functionality that it had before shared_from_this was introduced or at least thats the hope.

* build: unit tests

* I got tired of not knowing what was broken, so I went back to master and looked at the various bugs under the debugger and found two types of problems that made ImHex crash. The bug reported in the issue is created because enable_shared_from_this seems to affect the dynamic cast convertion. I was able to patch both places where the error occurs (one for data window and other for the imhex tooltip)

For the other type of problems I turned reference() into a detection tool for invalid uses of shared_from_this and ran about a dozen of patterns  and found that there is only one line on each constructor that causes crashes. The constructor can call shared_from_this on any object except the ones that detect and store the parent reference on each of the children. typically they are member-&gt;setParent(reference()) or something similar to that.

Only about a dozen or so changes to 6 files in 1 repository are needed to fix all the bugs created by the introduction of shared_from_this in the code. Pinpointing the source of the errors allows us also to avoid moving code out of the constructors that doesn't need to be moved which in turn makes it safe to call constructors with the understanding that references to the childrens parent
will not be created automatically and needs to be done after construction (most likely in clone()).

We obtain the same level of safety and prevent adding bugs in the future with only a fraction of the changes which increases code stability and also reduces the risk of adding new bugs that always comes with massive changes to the code base.

* build: unit tests

* Needed to set m_parent to weak_ptr in order to fix problems with dynamic cast. Also json types needed to be set to shared_ptrs instead of unique.

* build: unit tests

* build: unit tests

* build: unit tests

* unique ptr that should have been shared.

* undoing unneeded changes

* build: unit tests
diff --git a/lib/include/pl/api.hpp b/lib/include/pl/api.hpp
@@ -126,7 +126,7 @@ namespace pl::api {
     /**
      * @brief A function callback called when a custom built-in type is being instantiated
      */
-    using TypeCallback = std::function<std::unique_ptr<ptrn::Pattern>(core::Evaluator *, const std::vector<core::Token::Literal> &)>;
+    using TypeCallback = std::function<std::shared_ptr<ptrn::Pattern>(core::Evaluator *, const std::vector<core::Token::Literal> &)>;
 
     /**
      * @brief A type representing a function.
diff --git a/lib/include/pl/patterns/pattern.hpp b/lib/include/pl/patterns/pattern.hpp
@@ -116,7 +116,13 @@ namespace pl::ptrn {
         }
 
         virtual std::shared_ptr<Pattern> clone() const = 0;
-        std::shared_ptr<Pattern> reference() { return shared_from_this(); }
+        std::shared_ptr<Pattern> reference() {
+            auto weakPtr = weak_from_this();
+            if (weakPtr.expired()) {
+                core::err::E0001.throwError("Cannot call shared_from_this if this is not shared.");
+            }
+            return shared_from_this();
+        }
 
         [[nodiscard]] u64 getOffset() const { return this->m_offset; }
         [[nodiscard]] virtual u128 getOffsetForSorting() const { return this->getOffset() << 3; }
@@ -538,14 +544,14 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] const Pattern* getParent() const {
-            return m_parent;
+            return m_parent.lock().get();
         }
 
         [[nodiscard]] Pattern* getParent() {
-            return m_parent;
+            return m_parent.lock().get();
         }
 
-        void setParent(Pattern *parent) {
+        void setParent(std::shared_ptr<Pattern> parent) {
             m_parent = parent;
         }
 
@@ -623,7 +629,7 @@ namespace pl::ptrn {
         core::Evaluator *m_evaluator;
 
         std::unique_ptr<std::map<std::string, std::vector<core::Token::Literal>>> m_attributes;
-        Pattern *m_parent = nullptr;
+        std::weak_ptr<Pattern> m_parent;
         u32 m_line = 0;
 
         std::set<std::string>::const_iterator m_variableName;
diff --git a/lib/include/pl/patterns/pattern_array_dynamic.hpp b/lib/include/pl/patterns/pattern_array_dynamic.hpp
@@ -20,7 +20,11 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternArrayDynamic(*this));
+            auto other = std::make_shared<PatternArrayDynamic>(*this);
+            for (const auto &entry : other->m_entries)
+                entry->setParent(other->reference());
+
+            return other;
         }
 
         void setColor(u32 color) override {
@@ -133,7 +137,6 @@ namespace pl::ptrn {
 
             if (!entry->hasOverriddenColor())
                 entry->setBaseColor(this->getColor());
-            entry->setParent(this);
 
             this->m_entries.emplace_back(entry);
         }
diff --git a/lib/include/pl/patterns/pattern_array_static.hpp b/lib/include/pl/patterns/pattern_array_static.hpp
@@ -16,7 +16,9 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternArrayStatic(*this));
+            auto other = std::make_shared<PatternArrayStatic>(*this);
+            other->m_template->setParent(other->reference());
+            return other;
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> getEntry(size_t index) const override {
@@ -153,7 +155,6 @@ namespace pl::ptrn {
 
         void setEntries(std::shared_ptr<Pattern> &&templatePattern, size_t count) {
             this->m_template          = std::move(templatePattern);
-            this->m_template->setParent(this);
             this->m_highlightTemplates.push_back(this->m_template->clone());
             this->m_entryCount        = count;
 
diff --git a/lib/include/pl/patterns/pattern_bitfield.hpp b/lib/include/pl/patterns/pattern_bitfield.hpp
@@ -55,7 +55,8 @@ namespace pl::ptrn {
     public:
         PatternBitfieldField(core::Evaluator *evaluator, u64 offset, u8 bitOffset, u8 bitSize, u32 line, PatternBitfieldMember *parentBitfield = nullptr)
                 : PatternBitfieldMember(evaluator, offset, (bitOffset + bitSize + 7) / 8, line), m_bitOffset(bitOffset % 8), m_bitSize(bitSize) {
-            this->setParent(parentBitfield);
+            if (parentBitfield != nullptr)
+                this->setParent(parentBitfield->reference());
         }
 
         PatternBitfieldField(const PatternBitfieldField &other) : PatternBitfieldMember(other) {
@@ -282,7 +283,10 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternBitfieldArray(*this));
+            auto other =  std::make_shared<PatternBitfieldArray>(*this);
+            for (const auto &entry : other->m_entries)
+                entry->setParent(other->reference());
+            return other;
         }
 
         [[nodiscard]] u8 getBitOffset() const override {
@@ -422,8 +426,6 @@ namespace pl::ptrn {
                 if (!entry->hasOverriddenColor())
                     entry->setBaseColor(this->getColor());
 
-                entry->setParent(this);
-
                 this->m_sortedEntries.push_back(entry.get());
             }
 
@@ -643,7 +645,7 @@ namespace pl::ptrn {
                 this->setBaseColor(this->m_fields.front()->getColor());
 
             for (const auto &field : this->m_fields) {
-                field->setParent(this);
+                field->setParent(this->reference());
                 this->m_sortedFields.push_back(field.get());
             }
         }
diff --git a/lib/include/pl/patterns/pattern_struct.hpp b/lib/include/pl/patterns/pattern_struct.hpp
@@ -15,14 +15,17 @@ namespace pl::ptrn {
             for (const auto &member : other.m_members) {
                 auto copy = member->clone();
 
-                copy->setParent(this);
                 this->m_sortedMembers.push_back(copy.get());
                 this->m_members.push_back(std::move(copy));
             }
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternStruct(*this));
+            auto other = std::make_shared<PatternStruct>(*this);
+            for (const auto &member : other->m_members)
+                member->setParent(other->reference());
+
+            return other;
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> getEntry(size_t index) const override {
@@ -36,7 +39,7 @@ namespace pl::ptrn {
         void addEntry(const std::shared_ptr<Pattern> &entry) override {
             if (entry == nullptr) return;
 
-            entry->setParent(this);
+            entry->setParent(this->reference());
             this->m_sortedMembers.push_back(entry.get());
             this->m_members.push_back(entry);
         }
diff --git a/lib/include/pl/patterns/pattern_union.hpp b/lib/include/pl/patterns/pattern_union.hpp
@@ -21,7 +21,11 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternUnion(*this));
+            auto other = std::make_shared<PatternUnion>(*this);
+            for (const auto &member : other->m_members)
+                member->setParent(other->reference());
+
+            return other;
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> getEntry(size_t index) const override {
@@ -35,7 +39,6 @@ namespace pl::ptrn {
         void addEntry(const std::shared_ptr<Pattern> &entry) override {
             if (entry == nullptr) return;
 
-            entry->setParent(this);
             this->m_sortedMembers.push_back(entry.get());
             this->m_members.push_back(entry);
         }
diff --git a/lib/source/pl/core/ast/ast_node_bitfield.cpp b/lib/source/pl/core/ast/ast_node_bitfield.cpp
@@ -139,7 +139,7 @@ namespace pl::core::ast {
 
         for (auto &pattern : potentialPatterns) {
             if (auto bitfieldMember = dynamic_cast<ptrn::PatternBitfieldMember*>(pattern.get()); bitfieldMember != nullptr) {
-                bitfieldMember->setParent(bitfieldPattern.get());
+                bitfieldMember->setParent(bitfieldPattern->reference());
                 if (!bitfieldMember->isPadding())
                     fields.push_back(pattern);
             } else {
diff --git a/lib/source/pl/core/ast/ast_node_bitfield_array_variable_decl.cpp b/lib/source/pl/core/ast/ast_node_bitfield_array_variable_decl.cpp
@@ -53,7 +53,7 @@ namespace pl::core::ast {
         };
 
         auto position = evaluator->getBitwiseReadOffset();
-        auto arrayPattern = std::make_unique<ptrn::PatternBitfieldArray>(evaluator, position.byteOffset, position.bitOffset, 0, getLocation().line);
+        auto arrayPattern = std::make_shared<ptrn::PatternBitfieldArray>(evaluator, position.byteOffset, position.bitOffset, 0, getLocation().line);
         arrayPattern->setVariableName(this->m_name);
         arrayPattern->setSection(evaluator->getSectionId());
         arrayPattern->setReversed(evaluator->isReadOrderReversed());
@@ -133,7 +133,7 @@ namespace pl::core::ast {
 
             for (auto &pattern : entries) {
                 if (auto bitfieldMember = dynamic_cast<ptrn::PatternBitfieldMember*>(pattern.get()); bitfieldMember != nullptr)
-                    bitfieldMember->setParent(arrayPattern.get());
+                    bitfieldMember->setParent(arrayPattern->reference());
             }
 
             arrayPattern->setEntries(entries);
diff --git a/lib/source/pl/core/ast/ast_node_builtin_type.cpp b/lib/source/pl/core/ast/ast_node_builtin_type.cpp
@@ -23,23 +23,23 @@ namespace pl::core::ast {
         auto size   = Token::getTypeSize(this->m_type);
         auto offset = evaluator->getReadOffsetAndIncrement(size);
 
-        std::unique_ptr<ptrn::Pattern> pattern;
+        std::shared_ptr<ptrn::Pattern> pattern;
         if (Token::isUnsigned(this->m_type))
-            pattern = std::make_unique<ptrn::PatternUnsigned>(evaluator, offset, size, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternUnsigned>(evaluator, offset, size, getLocation().line);
         else if (Token::isSigned(this->m_type))
-            pattern = std::make_unique<ptrn::PatternSigned>(evaluator, offset, size, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternSigned>(evaluator, offset, size, getLocation().line);
         else if (Token::isFloatingPoint(this->m_type))
-            pattern = std::make_unique<ptrn::PatternFloat>(evaluator, offset, size, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternFloat>(evaluator, offset, size, getLocation().line);
         else if (this->m_type == Token::ValueType::Boolean)
-            pattern = std::make_unique<ptrn::PatternBoolean>(evaluator, offset, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternBoolean>(evaluator, offset, getLocation().line);
         else if (this->m_type == Token::ValueType::Character)
-            pattern = std::make_unique<ptrn::PatternCharacter>(evaluator, offset, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternCharacter>(evaluator, offset, getLocation().line);
         else if (this->m_type == Token::ValueType::Character16)
-            pattern = std::make_unique<ptrn::PatternWideCharacter>(evaluator, offset, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternWideCharacter>(evaluator, offset, getLocation().line);
         else if (this->m_type == Token::ValueType::Padding)
-            pattern = std::make_unique<ptrn::PatternPadding>(evaluator, offset, 1, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternPadding>(evaluator, offset, 1, getLocation().line);
         else if (this->m_type == Token::ValueType::String)
-            pattern = std::make_unique<ptrn::PatternString>(evaluator, offset, 0, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternString>(evaluator, offset, 0, getLocation().line);
         else if (this->m_type == Token::ValueType::CustomType) {
             std::vector<Token::Literal> params;
 
diff --git a/tests/include/test_patterns/test_pattern.hpp b/tests/include/test_patterns/test_pattern.hpp
@@ -30,18 +30,18 @@ namespace pl::test {
         virtual ~TestPattern() = default;
 
         template<typename T>
-        std::unique_ptr<T> create(const std::string &typeName, const std::string &varName, auto... args) {
-            auto pattern = std::make_unique<T>(m_evaluator, args...);
+        std::shared_ptr<T> create(const std::string &typeName, const std::string &varName, auto... args) {
+            auto pattern = std::make_shared<T>(m_evaluator, args...);
             pattern->setTypeName(typeName);
             pattern->setVariableName(varName);
 
-            return std::move(pattern);
+            return pattern;
         }
 
         [[nodiscard]] virtual std::string getSourceCode() const = 0;
 
-        [[nodiscard]] virtual const std::vector<std::unique_ptr<ptrn::Pattern>> &getPatterns() const final { return this->m_patterns; }
-        virtual void addPattern(std::unique_ptr<ptrn::Pattern> &&pattern) final {
+        [[nodiscard]] virtual const std::vector<std::shared_ptr<ptrn::Pattern>> &getPatterns() const final { return this->m_patterns; }
+        virtual void addPattern(std::shared_ptr<ptrn::Pattern> &&pattern) final {
             this->m_patterns.push_back(std::move(pattern));
         }
 
@@ -60,7 +60,7 @@ namespace pl::test {
         }
 
     private:
-        std::vector<std::unique_ptr<ptrn::Pattern>> m_patterns;
+        std::vector<std::shared_ptr<ptrn::Pattern>> m_patterns;
         core::Evaluator *m_evaluator;
         Mode m_mode;
 
diff --git a/tests/include/test_patterns/test_pattern_bitfields.hpp b/tests/include/test_patterns/test_pattern_bitfields.hpp
@@ -22,7 +22,7 @@ namespace pl::test {
                     nestedFields.push_back(create<PatternBitfieldField>("", "nestedA", 0x25, 5, 4, 0, testBitfield.get()));
                     nestedFields.push_back(create<PatternBitfieldField>("", "nestedB", 0x26, 1, 4, 0, testBitfield.get()));
                 }
-                nestedBitfield->setParent(testBitfield.get());
+                nestedBitfield->setParent(testBitfield->reference());
                 nestedBitfield->setFields(std::move(nestedFields));
                 nestedBitfield->setEndian(std::endian::big);
                 bitfieldFields.push_back(std::move(nestedBitfield));
@@ -39,7 +39,7 @@ namespace pl::test {
                         array0Fields.push_back(create<PatternBitfieldField>("", "nestedA", 0x27, 5, 4, 0, array0Bitfield.get()));
                         array0Fields.push_back(create<PatternBitfieldField>("", "nestedB", 0x28, 1, 4, 0, array0Bitfield.get()));
                     }
-                    array0Bitfield->setParent(array.get());
+                    array0Bitfield->setParent(array->reference());
                     array0Bitfield->setFields(std::move(array0Fields));
                     array0Bitfield->setEndian(std::endian::big);
                     arrayEntries.push_back(std::move(array0Bitfield));
@@ -50,12 +50,12 @@ namespace pl::test {
                         array1Fields.push_back(create<PatternBitfieldField>("", "nestedA", 0x28, 5, 4, 0, array1Bitfield.get()));
                         array1Fields.push_back(create<PatternBitfieldField>("", "nestedB", 0x29, 1, 4, 0, array1Bitfield.get()));
                     }
-                    array1Bitfield->setParent(array.get());
+                    array1Bitfield->setParent(array->reference());
                     array1Bitfield->setFields(std::move(array1Fields));
                     array1Bitfield->setEndian(std::endian::big);
                     arrayEntries.push_back(std::move(array1Bitfield));
                 }
-                array->setParent(testBitfield.get());
+                array->setParent(testBitfield->reference());
                 array->setEntries(arrayEntries);
                 array->setEndian(std::endian::big);
                 bitfieldFields.push_back(std::move(array));

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,11 @@ namespace pl::ptrn {`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`[[nodiscard]] std::shared_ptr<Pattern> clone() const override {`
`23`		`- return std::unique_ptr<Pattern>(new PatternArrayDynamic(*this));`
	`23`	`+ auto other = std::make_shared<PatternArrayDynamic>(*this);`
	`24`	`+ for (const auto &entry : other->m_entries)`
	`25`	`+ entry->setParent(other->reference());`
	`26`	`+`
	`27`	`+ return other;`
`24`	`28`	`}`
`25`	`29`
`26`	`30`	`void setColor(u32 color) override {`
`@@ -133,7 +137,6 @@ namespace pl::ptrn {`
`133`	`137`
`134`	`138`	`if (!entry->hasOverriddenColor())`
`135`	`139`	`entry->setBaseColor(this->getColor());`
`136`		`- entry->setParent(this);`
`137`	`140`
`138`	`141`	`this->m_entries.emplace_back(entry);`
`139`	`142`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,9 @@ namespace pl::ptrn {`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`[[nodiscard]] std::shared_ptr<Pattern> clone() const override {`
`19`		`- return std::unique_ptr<Pattern>(new PatternArrayStatic(*this));`
	`19`	`+ auto other = std::make_shared<PatternArrayStatic>(*this);`
	`20`	`+ other->m_template->setParent(other->reference());`
	`21`	`+ return other;`
`20`	`22`	`}`
`21`	`23`
`22`	`24`	`[[nodiscard]] std::shared_ptr<Pattern> getEntry(size_t index) const override {`
`@@ -153,7 +155,6 @@ namespace pl::ptrn {`
`153`	`155`
`154`	`156`	`void setEntries(std::shared_ptr<Pattern> &&templatePattern, size_t count) {`
`155`	`157`	`this->m_template = std::move(templatePattern);`
`156`		`- this->m_template->setParent(this);`
`157`	`158`	`this->m_highlightTemplates.push_back(this->m_template->clone());`
`158`	`159`	`this->m_entryCount = count;`
`159`	`160`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,8 @@ namespace pl::ptrn {`
`55`	`55`	`public:`
`56`	`56`	`PatternBitfieldField(core::Evaluator evaluator, u64 offset, u8 bitOffset, u8 bitSize, u32 line, PatternBitfieldMember parentBitfield = nullptr)`
`57`	`57`	`: PatternBitfieldMember(evaluator, offset, (bitOffset + bitSize + 7) / 8, line), m_bitOffset(bitOffset % 8), m_bitSize(bitSize) {`
`58`		`- this->setParent(parentBitfield);`
	`58`	`+ if (parentBitfield != nullptr)`
	`59`	`+ this->setParent(parentBitfield->reference());`
`59`	`60`	`}`
`60`	`61`
`61`	`62`	`PatternBitfieldField(const PatternBitfieldField &other) : PatternBitfieldMember(other) {`
`@@ -282,7 +283,10 @@ namespace pl::ptrn {`
`282`	`283`	`}`
`283`	`284`
`284`	`285`	`[[nodiscard]] std::shared_ptr<Pattern> clone() const override {`
`285`		`- return std::unique_ptr<Pattern>(new PatternBitfieldArray(*this));`
	`286`	`+ auto other = std::make_shared<PatternBitfieldArray>(*this);`
	`287`	`+ for (const auto &entry : other->m_entries)`
	`288`	`+ entry->setParent(other->reference());`
	`289`	`+ return other;`
`286`	`290`	`}`
`287`	`291`
`288`	`292`	`[[nodiscard]] u8 getBitOffset() const override {`
`@@ -422,8 +426,6 @@ namespace pl::ptrn {`
`422`	`426`	`if (!entry->hasOverriddenColor())`
`423`	`427`	`entry->setBaseColor(this->getColor());`
`424`	`428`
`425`		`- entry->setParent(this);`
`426`		`-`
`427`	`429`	`this->m_sortedEntries.push_back(entry.get());`
`428`	`430`	`}`
`429`	`431`
`@@ -643,7 +645,7 @@ namespace pl::ptrn {`
`643`	`645`	`this->setBaseColor(this->m_fields.front()->getColor());`
`644`	`646`
`645`	`647`	`for (const auto &field : this->m_fields) {`
`646`		`- field->setParent(this);`
	`648`	`+ field->setParent(this->reference());`
`647`	`649`	`this->m_sortedFields.push_back(field.get());`
`648`	`650`	`}`
`649`	`651`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,14 +15,17 @@ namespace pl::ptrn {`
`15`	`15`	`for (const auto &member : other.m_members) {`
`16`	`16`	`auto copy = member->clone();`
`17`	`17`
`18`		`- copy->setParent(this);`
`19`	`18`	`this->m_sortedMembers.push_back(copy.get());`
`20`	`19`	`this->m_members.push_back(std::move(copy));`
`21`	`20`	`}`
`22`	`21`	`}`
`23`	`22`
`24`	`23`	`[[nodiscard]] std::shared_ptr<Pattern> clone() const override {`
`25`		`- return std::unique_ptr<Pattern>(new PatternStruct(*this));`
	`24`	`+ auto other = std::make_shared<PatternStruct>(*this);`
	`25`	`+ for (const auto &member : other->m_members)`
	`26`	`+ member->setParent(other->reference());`
	`27`	`+`
	`28`	`+ return other;`
`26`	`29`	`}`
`27`	`30`
`28`	`31`	`[[nodiscard]] std::shared_ptr<Pattern> getEntry(size_t index) const override {`
`@@ -36,7 +39,7 @@ namespace pl::ptrn {`
`36`	`39`	`void addEntry(const std::shared_ptr<Pattern> &entry) override {`
`37`	`40`	`if (entry == nullptr) return;`
`38`	`41`
`39`		`- entry->setParent(this);`
	`42`	`+ entry->setParent(this->reference());`
`40`	`43`	`this->m_sortedMembers.push_back(entry.get());`
`41`	`44`	`this->m_members.push_back(entry);`
`42`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,11 @@ namespace pl::ptrn {`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`[[nodiscard]] std::shared_ptr<Pattern> clone() const override {`
`24`		`- return std::unique_ptr<Pattern>(new PatternUnion(*this));`
	`24`	`+ auto other = std::make_shared<PatternUnion>(*this);`
	`25`	`+ for (const auto &member : other->m_members)`
	`26`	`+ member->setParent(other->reference());`
	`27`	`+`
	`28`	`+ return other;`
`25`	`29`	`}`
`26`	`30`
`27`	`31`	`[[nodiscard]] std::shared_ptr<Pattern> getEntry(size_t index) const override {`
`@@ -35,7 +39,6 @@ namespace pl::ptrn {`
`35`	`39`	`void addEntry(const std::shared_ptr<Pattern> &entry) override {`
`36`	`40`	`if (entry == nullptr) return;`
`37`	`41`
`38`		`- entry->setParent(this);`
`39`	`42`	`this->m_sortedMembers.push_back(entry.get());`
`40`	`43`	`this->m_members.push_back(entry);`
`41`	`44`	`}`