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.

Author: paxcut

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.

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; }
@@ -537,15 +543,15 @@ namespace pl::ptrn {
             this->m_initialized = initialized;
         }
 
-        [[nodiscard]] const Pattern* getParent() const {
-            return m_parent;
+        [[nodiscard]] const std::shared_ptr<Pattern> getParent() const {
+            return m_parent.lock();
         }
 
-        [[nodiscard]] Pattern* getParent() {
-            return m_parent;
+        [[nodiscard]] std::shared_ptr<Pattern> getParent() {
+            return m_parent.lock();
         }
 
-        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;

lib/include/pl/patterns/pattern_array_dynamic.hpp

@@ -8,19 +8,18 @@ namespace pl::ptrn {
                                 public IInlinable,
                                 public IIndexable {
     public:
-        PatternArrayDynamic(core::Evaluator *evaluator, u64 offset, size_t size, u32 line)
-            : Pattern(evaluator, offset, size, line) { }
+        PatternArrayDynamic(core::Evaluator *evaluator, u64 offset, size_t size, u32 line) : Pattern(evaluator, offset, size, line) { }
 
-        PatternArrayDynamic(const PatternArrayDynamic &other) : Pattern(other) {
-            std::vector<std::shared_ptr<Pattern>> entries;
-            for (const auto &entry : other.m_entries)
-                entries.push_back(entry->clone());
-
-            this->setEntries(entries);
-        }
+        PatternArrayDynamic(const PatternArrayDynamic &other) : Pattern(other) {}
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternArrayDynamic(*this));
+            auto other = std::make_shared<PatternArrayDynamic>(*this);
+            std::vector<std::shared_ptr<Pattern>> entries;
+            for (const auto &entry : this->m_entries) {
+                entries.push_back(entry->clone());
+            }
+            other->setEntries(entries);
+            return other;
         }
 
         void setColor(u32 color) override {
@@ -133,7 +132,7 @@ namespace pl::ptrn {
 
             if (!entry->hasOverriddenColor())
                 entry->setBaseColor(this->getColor());
-            entry->setParent(this);
+            entry->setParent(reference());
 
             this->m_entries.emplace_back(entry);
         }

lib/include/pl/patterns/pattern_array_static.hpp

@@ -11,12 +11,12 @@ namespace pl::ptrn {
         PatternArrayStatic(core::Evaluator *evaluator, u64 offset, size_t size, u32 line)
             : Pattern(evaluator, offset, size, line) { }
 
-        PatternArrayStatic(const PatternArrayStatic &other) : Pattern(other) {
-            this->setEntries(other.getTemplate()->clone(), other.getEntryCount());
-        }
+        PatternArrayStatic(const PatternArrayStatic &other) : Pattern(other) {}
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternArrayStatic(*this));
+            auto other = std::make_shared<PatternArrayStatic>(*this);
+            other->setEntries(this->m_template->clone(), this->m_entryCount);
+            return other;
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> getEntry(size_t index) const override {
@@ -153,7 +153,7 @@ 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_template->setParent(reference());
             this->m_highlightTemplates.push_back(this->m_template->clone());
             this->m_entryCount        = count;
 

lib/include/pl/patterns/pattern_bitfield.hpp

@@ -12,7 +12,7 @@ namespace pl::ptrn {
         [[nodiscard]] const PatternBitfieldMember& getTopmostBitfield() const {
             const PatternBitfieldMember* topBitfield = this;
             while (auto parent = topBitfield->getParent()) {
-                auto parentBitfield = dynamic_cast<const PatternBitfieldMember*>(parent);
+                auto parentBitfield = dynamic_cast<const PatternBitfieldMember*>(parent.get());
                 if (parentBitfield == nullptr)
                     break;
 
@@ -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) {
@@ -65,7 +66,7 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternBitfieldField(*this));
+            return std::make_shared<PatternBitfieldField>(*this);
         }
 
         [[nodiscard]] u128 readValue() const {
@@ -162,7 +163,7 @@ namespace pl::ptrn {
         using PatternBitfieldField::PatternBitfieldField;
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternBitfieldFieldSigned(*this));
+            return std::make_shared<PatternBitfieldFieldSigned>(*this);
         }
 
         [[nodiscard]] core::Token::Literal getValue() const override {
@@ -186,7 +187,7 @@ namespace pl::ptrn {
         using PatternBitfieldField::PatternBitfieldField;
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternBitfieldFieldBoolean(*this));
+            return std::make_shared<PatternBitfieldFieldBoolean>(*this);
         }
 
         [[nodiscard]] core::Token::Literal getValue() const override {
@@ -245,7 +246,7 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternBitfieldFieldEnum(*this));
+            return std::make_shared<PatternBitfieldFieldEnum>(*this);
         }
 
         std::string formatDisplayValue() override {
@@ -282,7 +283,7 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternBitfieldArray(*this));
+            return std::make_shared<PatternBitfieldArray>(*this);
         }
 
         [[nodiscard]] u8 getBitOffset() const override {
@@ -422,7 +423,7 @@ namespace pl::ptrn {
                 if (!entry->hasOverriddenColor())
                     entry->setBaseColor(this->getColor());
 
-                entry->setParent(this);
+                entry->setParent(reference());
 
                 this->m_sortedEntries.push_back(entry.get());
             }
@@ -554,7 +555,7 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternBitfield(*this));
+            return std::make_shared<PatternBitfield>(*this);
         }
 
         [[nodiscard]] u8 getBitOffset() const override {
@@ -643,7 +644,7 @@ namespace pl::ptrn {
                 this->setBaseColor(this->m_fields.front()->getColor());
 
             for (const auto &field : this->m_fields) {
-                field->setParent(this);
+                field->setParent(reference());
                 this->m_sortedFields.push_back(field.get());
             }
         }

lib/include/pl/patterns/pattern_boolean.hpp

@@ -10,7 +10,7 @@ namespace pl::ptrn {
             : Pattern(evaluator, offset, 1, line) { }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternBoolean(*this));
+            return std::make_shared<PatternBoolean>(*this);
         }
 
         [[nodiscard]] core::Token::Literal getValue() const override {

lib/include/pl/patterns/pattern_character.hpp

@@ -10,7 +10,7 @@ namespace pl::ptrn {
             : Pattern(evaluator, offset, 1, line) { }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::make_unique<PatternCharacter>(*this);
+            return std::make_shared<PatternCharacter>(*this);
         }
 
         [[nodiscard]] core::Token::Literal getValue() const override {

lib/include/pl/patterns/pattern_enum.hpp

@@ -18,7 +18,7 @@ namespace pl::ptrn {
             : Pattern(evaluator, offset, size, line) { }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternEnum(*this));
+            return std::make_shared<PatternEnum>(*this);
         }
 
         [[nodiscard]] core::Token::Literal getValue() const override {

lib/include/pl/patterns/pattern_error.hpp

@@ -10,7 +10,7 @@ namespace pl::ptrn {
             : Pattern(evaluator, offset, size, line), m_errorMessage(std::move(errorMessage)) { }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternError(*this));
+            return std::make_shared<PatternError>(*this);
         }
 
         [[nodiscard]] std::string getFormattedName() const override {

lib/include/pl/patterns/pattern_float.hpp

@@ -10,7 +10,7 @@ namespace pl::ptrn {
             : Pattern(evaluator, offset, size, line) { }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternFloat(*this));
+            return std::make_shared<PatternFloat>(*this);
         }
 
         [[nodiscard]] core::Token::Literal getValue() const override {