Issue 2282: PatternLanuage changes: [Bug] Crash when hovering on a static array

lib/include/pl/patterns/pattern.hpp

@@ -282,9 +282,7 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] virtual core::Token::Literal getValue() const {
-            auto clone = this->clone();
-
-            return this->transformValue(std::move(clone));
+            return this->transformValue(const_cast<Pattern*>(this)->reference());
         }
 
         [[nodiscard]] virtual std::vector<std::pair<u64, Pattern*>> getChildren() {
@@ -537,15 +535,15 @@ namespace pl::ptrn {
             this->m_initialized = initialized;
         }
 
-        [[nodiscard]] const Pattern* getParent() const {
+        [[nodiscard]] std::shared_ptr<const Pattern> getParent() const {
             return m_parent;
         }
 
-        [[nodiscard]] Pattern* getParent() {
+        [[nodiscard]] std::shared_ptr<Pattern> getParent() {
             return m_parent;
         }
 
-        void setParent(Pattern *parent) {
+       void setParent(std::shared_ptr<Pattern> parent) {
             m_parent = parent;
         }
 
@@ -623,7 +621,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::shared_ptr<Pattern> m_parent;
         u32 m_line = 0;
 
         std::set<std::string>::const_iterator m_variableName;

lib/include/pl/patterns/pattern_array_dynamic.hpp

@@ -14,13 +14,13 @@ namespace pl::ptrn {
         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());
+                entries.push_back(entry);
 
             this->setEntries(entries);
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternArrayDynamic(*this));
+            return std::shared_ptr<Pattern>(new PatternArrayDynamic(*this));
         }
 
         void setColor(u32 color) override {
@@ -133,7 +133,7 @@ namespace pl::ptrn {
 
             if (!entry->hasOverriddenColor())
                 entry->setBaseColor(this->getColor());
-            entry->setParent(this);
+            entry->setParent(this->reference());
 
             this->m_entries.emplace_back(entry);
         }

lib/include/pl/patterns/pattern_array_static.hpp

@@ -16,7 +16,7 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternArrayStatic(*this));
+            return std::shared_ptr<Pattern>(new PatternArrayStatic(*this));
         }
 
         [[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(this->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;
 
@@ -53,7 +53,7 @@ namespace pl::ptrn {
 
     class PatternBitfieldField : public PatternBitfieldMember {
     public:
-        PatternBitfieldField(core::Evaluator *evaluator, u64 offset, u8 bitOffset, u8 bitSize, u32 line, PatternBitfieldMember *parentBitfield = nullptr)
+        PatternBitfieldField(core::Evaluator *evaluator, u64 offset, u8 bitOffset, u8 bitSize, u32 line, std::shared_ptr<PatternBitfieldMember> parentBitfield = nullptr)
                 : PatternBitfieldMember(evaluator, offset, (bitOffset + bitSize + 7) / 8, line), m_bitOffset(bitOffset % 8), m_bitSize(bitSize) {
             this->setParent(parentBitfield);
         }
@@ -65,7 +65,7 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternBitfieldField(*this));
+            return std::shared_ptr<Pattern>(new PatternBitfieldField(*this));
         }
 
         [[nodiscard]] u128 readValue() const {
@@ -162,7 +162,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::shared_ptr<Pattern>(new PatternBitfieldFieldSigned(*this));
         }
 
         [[nodiscard]] core::Token::Literal getValue() const override {
@@ -186,7 +186,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::shared_ptr<Pattern>(new PatternBitfieldFieldBoolean(*this));
         }
 
         [[nodiscard]] core::Token::Literal getValue() const override {
@@ -245,7 +245,7 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternBitfieldFieldEnum(*this));
+            return std::shared_ptr<Pattern>(new PatternBitfieldFieldEnum(*this));
         }
 
         std::string formatDisplayValue() override {
@@ -282,7 +282,7 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternBitfieldArray(*this));
+            return std::shared_ptr<Pattern>(new PatternBitfieldArray(*this));
         }
 
         [[nodiscard]] u8 getBitOffset() const override {
@@ -422,7 +422,7 @@ namespace pl::ptrn {
                 if (!entry->hasOverriddenColor())
                     entry->setBaseColor(this->getColor());
 
-                entry->setParent(this);
+                entry->setParent(this->reference());
 
                 this->m_sortedEntries.push_back(entry.get());
             }
@@ -554,7 +554,7 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternBitfield(*this));
+            return std::shared_ptr<Pattern>(new PatternBitfield(*this));
         }
 
         [[nodiscard]] u8 getBitOffset() const override {
@@ -643,7 +643,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());
             }
         }

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::shared_ptr<Pattern>(new PatternBoolean(*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::shared_ptr<Pattern>(new 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::shared_ptr<Pattern>(new 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::shared_ptr<Pattern>(new PatternFloat(*this));
         }
 
         [[nodiscard]] core::Token::Literal getValue() const override {

lib/include/pl/patterns/pattern_padding.hpp

@@ -9,7 +9,7 @@ namespace pl::ptrn {
         PatternPadding(core::Evaluator *evaluator, u64 offset, size_t size, u32 line) : Pattern(evaluator, offset, size, line) { }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternPadding(*this));
+            return std::shared_ptr<Pattern>(new PatternPadding(*this));
         }
 
         [[nodiscard]] std::string getFormattedName() const override {

lib/include/pl/patterns/pattern_pointer.hpp

@@ -21,7 +21,7 @@ namespace pl::ptrn {
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternPointer(*this));
+            return std::shared_ptr<Pattern>(new PatternPointer(*this));
         }
 
         [[nodiscard]] core::Token::Literal getValue() const override {

lib/include/pl/patterns/pattern_signed.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 PatternSigned(*this));
+            return std::shared_ptr<Pattern>(new PatternSigned(*this));
         }
 
         [[nodiscard]] core::Token::Literal getValue() const override {

lib/include/pl/patterns/pattern_string.hpp

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

lib/include/pl/patterns/pattern_struct.hpp

@@ -15,14 +15,14 @@ namespace pl::ptrn {
             for (const auto &member : other.m_members) {
                 auto copy = member->clone();
 
-                copy->setParent(this);
+                copy->setParent(this->reference());
                 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));
+            return std::shared_ptr<Pattern>(new PatternStruct(*this));
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> getEntry(size_t index) const override {
@@ -36,7 +36,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);
         }

lib/include/pl/patterns/pattern_union.hpp

@@ -13,15 +13,15 @@ namespace pl::ptrn {
 
         PatternUnion(const PatternUnion &other) : Pattern(other) {
             for (const auto &member : other.m_members) {
-                auto copy = member->clone();
+                //auto copy = member->clone();
 
-                this->m_sortedMembers.push_back(copy.get());
-                this->m_members.push_back(std::move(copy));
+                this->m_sortedMembers.push_back(member.get());
+                this->m_members.push_back(member);
             }
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
-            return std::unique_ptr<Pattern>(new PatternUnion(*this));
+            return std::shared_ptr<Pattern>(new PatternUnion(*this));
         }
 
         [[nodiscard]] std::shared_ptr<Pattern> getEntry(size_t index) const override {
@@ -35,7 +35,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);
         }

lib/include/pl/patterns/pattern_unsigned.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 PatternUnsigned(*this));
+            return std::shared_ptr<Pattern>(new PatternUnsigned(*this));
         }
 
         [[nodiscard]] core::Token::Literal getValue() const override {

lib/include/pl/patterns/pattern_wide_character.hpp

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

lib/include/pl/patterns/pattern_wide_string.hpp

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

lib/source/pl/core/ast/ast_node_array_variable_decl.cpp

@@ -217,14 +217,14 @@ namespace pl::core::ast {
             }
         }
 
-        if (dynamic_cast<ptrn::PatternPadding *>(templatePattern.get())) {
-            outputPattern = std::make_unique<ptrn::PatternPadding>(evaluator, startOffset, 0, getLocation().line);
-        } else if (dynamic_cast<ptrn::PatternCharacter *>(templatePattern.get())) {
-            outputPattern = std::make_unique<ptrn::PatternString>(evaluator, startOffset, 0, getLocation().line);
-        } else if (dynamic_cast<ptrn::PatternWideCharacter *>(templatePattern.get())) {
-            outputPattern = std::make_unique<ptrn::PatternWideString>(evaluator, startOffset, 0, getLocation().line);
+        if (std::dynamic_pointer_cast<ptrn::PatternPadding>(templatePattern)) {
+            outputPattern = std::make_shared<ptrn::PatternPadding>(evaluator, startOffset, 0, getLocation().line);
+        } else if (std::dynamic_pointer_cast<ptrn::PatternCharacter>(templatePattern)) {
+            outputPattern = std::make_shared<ptrn::PatternString>(evaluator, startOffset, 0, getLocation().line);
+        } else if (std::dynamic_pointer_cast<ptrn::PatternWideCharacter>(templatePattern)) {
+            outputPattern = std::make_shared<ptrn::PatternWideString>(evaluator, startOffset, 0, getLocation().line);
         } else {
-            auto arrayPattern = std::make_unique<ptrn::PatternArrayStatic>(evaluator, startOffset, 0, getLocation().line);
+            auto arrayPattern = std::make_shared<ptrn::PatternArrayStatic>(evaluator, startOffset, 0, getLocation().line);
             arrayPattern->setEntries(templatePattern->clone(), size_t(entryCount));
             arrayPattern->setSection(templatePattern->getSection());
             outputPattern = std::move(arrayPattern);
@@ -256,7 +256,7 @@ namespace pl::core::ast {
         };
 
         evaluator->alignToByte();
-        auto arrayPattern = std::make_unique<ptrn::PatternArrayDynamic>(evaluator, evaluator->getReadOffset(), 0, getLocation().line);
+        auto arrayPattern = std::make_shared<ptrn::PatternArrayDynamic>(evaluator, evaluator->getReadOffset(), 0, getLocation().line);
         arrayPattern->setVariableName(this->m_name);
         arrayPattern->setSection(evaluator->getSectionId());
 

lib/source/pl/core/ast/ast_node_bitfield.cpp

@@ -138,8 +138,8 @@ namespace pl::core::ast {
         }
 
         for (auto &pattern : potentialPatterns) {
-            if (auto bitfieldMember = dynamic_cast<ptrn::PatternBitfieldMember*>(pattern.get()); bitfieldMember != nullptr) {
-                bitfieldMember->setParent(bitfieldPattern.get());
+            if (auto bitfieldMember = std::dynamic_pointer_cast<ptrn::PatternBitfieldMember>(pattern); bitfieldMember != nullptr) {
+                bitfieldMember->setParent(bitfieldPattern);
                 if (!bitfieldMember->isPadding())
                     fields.push_back(pattern);
             } else {

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());
@@ -132,8 +132,8 @@ namespace pl::core::ast {
             }
 
             for (auto &pattern : entries) {
-                if (auto bitfieldMember = dynamic_cast<ptrn::PatternBitfieldMember*>(pattern.get()); bitfieldMember != nullptr)
-                    bitfieldMember->setParent(arrayPattern.get());
+                if (auto bitfieldMember = std::dynamic_pointer_cast<ptrn::PatternBitfieldMember>(pattern); bitfieldMember != nullptr)
+                    bitfieldMember->setParent(arrayPattern);
             }
 
             arrayPattern->setEntries(entries);

lib/source/pl/core/ast/ast_node_bitfield_field.cpp

@@ -79,7 +79,7 @@ namespace pl::core::ast {
     evaluator->setBitwiseReadOffset(originalPosition);
 
     if (auto *patternEnum = dynamic_cast<ptrn::PatternEnum *>(pattern.get()); patternEnum != nullptr) {
-        auto bitfieldEnum = std::make_unique<ptrn::PatternBitfieldFieldEnum>(evaluator, byteOffset, bitOffset, bitSize, getLocation().line);
+        auto bitfieldEnum = std::make_shared<ptrn::PatternBitfieldFieldEnum>(evaluator, byteOffset, bitOffset, bitSize, getLocation().line);
         bitfieldEnum->setTypeName(patternEnum->getTypeName());
         bitfieldEnum->setEnumValues(patternEnum->getEnumValues());
         result = std::move(bitfieldEnum);