Retain custom build types as they are global and have lifetimes beyond a single evaluation.

Author: AkiSakurai

lib/include/pl/core/parser_manager.hpp

@@ -38,7 +38,15 @@ namespace pl::core {
             this->m_onceIncluded.clear();
             for(const auto &[_, types] : this->m_parsedTypes) {
                 for(const auto &[_, type] : types) {
-                    type->setType(nullptr);
+                    if(type != nullptr && type->isValid()) {
+                        if(auto builtinType = dynamic_cast<ast::ASTNodeBuiltinType*>(type->getType().get()); builtinType != nullptr) {
+                            if(builtinType->getType() != Token::ValueType::CustomType) {
+                                type->setType(nullptr);
+                            }
+                        }
+                    } else {
+                        type->setType(nullptr);
+                    }
                 }
             }
             this->m_parsedTypes.clear();

lib/source/pl/core/parser.cpp

@@ -2814,8 +2814,14 @@ namespace pl::core {
 
     void Parser::reset() {
         for(const auto &[_, type] : this->m_types) {
-            if(type != nullptr) {
-                type->setType(nullptr);
+            if(type != nullptr && type->isValid()) {
+                if(auto builtinType = dynamic_cast<ast::ASTNodeBuiltinType*>(type->getType().get()); builtinType != nullptr) {
+                    if(builtinType->getType() != Token::ValueType::CustomType) {
+                        type->setType(nullptr);
+                    }
+                } else {
+                    type->setType(nullptr);
+                }
             }
         }
         this->m_types.clear();

tests/CMakeLists.txt

@@ -34,6 +34,7 @@ set(AVAILABLE_TESTS
         RValuesAssignmentInStruct
         TemplateParametersScope
         TypeNameOf
+        CustomBuiltInType
 )
 
 

tests/include/test_patterns/test_pattern.hpp

@@ -59,6 +59,10 @@ namespace pl::test {
             return true;
         }
 
+        [[nodiscard]] virtual size_t repeatTimes() const {
+            return 1;
+        }
+
     private:
         std::vector<std::shared_ptr<ptrn::Pattern>> m_patterns;
         core::Evaluator *m_evaluator;

tests/include/test_patterns/test_pattern_custom_builtin_type.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "test_pattern.hpp"
+
+namespace pl::test {
+
+    class TestPatternCustomBuiltinType : public TestPattern {
+    public:
+        TestPatternCustomBuiltinType(core::Evaluator *evaluator) : TestPattern(evaluator, "CustomBuiltInType") {
+        }
+        ~TestPatternCustomBuiltinType() override = default;
+
+        virtual void setup() override{
+            const pl::api::Namespace ns = { "custom_type" };
+            m_runtime->addType(ns, "custom_type", pl::api::FunctionParameterCount::exactly(1), [](core::Evaluator *evaluator, auto params) -> std::unique_ptr<pl::ptrn::Pattern> {
+                auto pattern = std::make_unique<pl::ptrn::PatternUnsigned>(evaluator, 0, sizeof(u8), 0);
+                return pattern;
+            });
+        };
+
+        [[nodiscard]] std::string getSourceCode() const override {
+            return R"(
+                custom_type::custom_type<1> test @ 0;
+                std::assert(test == 137, "test should be 137");
+            )";
+        }
+
+        [[nodiscard]] size_t repeatTimes() const override {
+            return 2;
+        }
+    };
+}

tests/source/main.cpp

@@ -108,20 +108,23 @@ int runTests(int argc, char **argv) {
     auto &test = testPatterns[testName];
     test->m_runtime = &runtime;
     test->setup();
-    auto result = runtime.executeString(test->getSourceCode());
 
-    // Check if compilation succeeded
-    if (!result) {
-        fmt::print("Error during test!\n");
+    for(size_t i = 0; i < test->repeatTimes(); i++) {
+        auto result = runtime.executeString(test->getSourceCode());
 
-        if (auto error = runtime.getEvalError(); error.has_value())
-            fmt::print("Error: {}:{} : {}\n", error->line, error->column, error->message);
+        // Check if compilation succeeded
+        if (!result) {
+            fmt::print("Error during test!\n");
 
-        for (const auto& error : runtime.getCompileErrors()) {
-            fmt::print("{}", error.format());
-        }
+            if (auto error = runtime.getEvalError(); error.has_value())
+                fmt::print("Error: {}:{} : {}\n", error->line, error->column, error->message);
 
-        return failing ? EXIT_SUCCESS : EXIT_FAILURE;
+            for (const auto& error : runtime.getCompileErrors()) {
+                fmt::print("{}", error.format());
+            }
+
+            return failing ? EXIT_SUCCESS : EXIT_FAILURE;
+        }
     }
 
     const auto &evaluatedPatterns = runtime.getPatterns();

tests/source/tests.cpp

@@ -29,6 +29,7 @@
 #include "test_patterns/test_pattern_rvalues_assignment_in_struct.hpp"
 #include "test_patterns/test_pattern_template_parameters_scope.hpp"
 #include "test_patterns/test_pattern_typenameof.hpp"
+#include "test_patterns/test_pattern_custom_builtin_type.hpp"
 
 static pl::core::Evaluator s_evaluator;
 
@@ -63,4 +64,5 @@ std::array Tests = {
     TEST(RValuesAssignmentInStruct),
     TEST(TemplateParametersScope),
     TEST(TypeNameOf),
+    TEST(CustomBuiltinType),
 };