Fix formatting style

AkiSakurai · AkiSakurai · commit fbd6da1d4550 · 2025-12-06T20:40:05.000+08:00
diff --git a/cli/source/subcommands/docs.cpp b/cli/source/subcommands/docs.cpp
@@ -35,7 +35,7 @@ namespace pl::cli::sub {
         }
 
         std::string getTypeName(const core::ast::ASTNode *type) {
-            if(auto typeApp = dynamic_cast<const core::ast::ASTNodeTypeApplication*>(type); typeApp != nullptr) {
+            if (auto typeApp = dynamic_cast<const core::ast::ASTNodeTypeApplication*>(type); typeApp != nullptr) {
                 return fmt::format("{}{}", getTypeEndian(typeApp), getTypeName(typeApp->getType().get()));
             } else if (auto typeDecl = dynamic_cast<const core::ast::ASTNodeTypeDecl*>(type); typeDecl != nullptr) {
                 return typeDecl->getName();
diff --git a/lib/include/pl/core/parser_manager.hpp b/lib/include/pl/core/parser_manager.hpp
@@ -36,11 +36,11 @@ namespace pl::core {
 
         void reset() {
             this->m_onceIncluded.clear();
-            for(const auto &[_, types] : this->m_parsedTypes) {
-                for(const auto &[_, type] : types) {
-                    if(type != nullptr && type->isValid()) {
-                        if(auto builtinType = dynamic_cast<ast::ASTNodeBuiltinType*>(type->getType().get()); builtinType != nullptr) {
-                            if(builtinType->getType() != Token::ValueType::CustomType) {
+            for (const auto &[_, types] : this->m_parsedTypes) {
+                for (const auto &[_, type] : types) {
+                    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);
                             }
                         }
@@ -49,6 +49,7 @@ namespace pl::core {
                     }
                 }
             }
+
             this->m_parsedTypes.clear();
         }
 
diff --git a/lib/source/pl/core/ast/ast_node_type_application.cpp b/lib/source/pl/core/ast/ast_node_type_application.cpp
@@ -57,9 +57,9 @@ namespace pl::core::ast {
         [[maybe_unused]] auto context = evaluator->updateRuntime(this);
         auto evaluatedTemplateArguments = this->evaluateTemplateArguments(evaluator);
         auto evaluatedType = std::make_unique<ASTNodeTypeApplication>(this->m_type);
-        if(this->m_type == nullptr) {
+        if (this->m_type == nullptr) {
             auto& templateTypeParameters = evaluator->getTypeTemplateParameters();
-            if(this->m_templateParameterIndex >= templateTypeParameters.size()) {
+            if (this->m_templateParameterIndex >= templateTypeParameters.size()) {
                 err::E0004.throwError("Template parameter index out of bounds.", {}, this->getLocation());
             } else {
                 evaluatedType->m_type = templateTypeParameters[this->m_templateParameterIndex];
@@ -78,14 +78,14 @@ namespace pl::core::ast {
     void ASTNodeTypeApplication::createPatterns(Evaluator *evaluator, std::vector<std::shared_ptr<ptrn::Pattern>> &resultPatterns) const {
         [[maybe_unused]] auto context = evaluator->updateRuntime(this);
         auto actualType = this->m_type;
-        if(actualType == nullptr) {
+        if (actualType == nullptr) {
             auto& templateTypeParameters = evaluator->getTypeTemplateParameters();
-            if(this->m_templateParameterIndex >= templateTypeParameters.size()) {
+            if (this->m_templateParameterIndex >= templateTypeParameters.size()) {
                 err::E0004.throwError("Template parameter index out of bounds.", {}, this->getLocation());
             }
             actualType = templateTypeParameters[this->m_templateParameterIndex];
 
-            if(actualType.get() == this) {
+            if (actualType.get() == this) {
                 err::E0004.throwError("Recursive type definition detected.", {}, this->getLocation());
             }
         }
@@ -101,9 +101,9 @@ namespace pl::core::ast {
         for(auto& pattern : resultPatterns) {
             if (!pattern->hasOverriddenEndian())
                 pattern->setEndian(evaluator->getDefaultEndian());
-            if(auto typeDecl = dynamic_cast<ASTNodeTypeDecl*>(actualType.get()); typeDecl != nullptr) {
+            if (auto typeDecl = dynamic_cast<ASTNodeTypeDecl*>(actualType.get()); typeDecl != nullptr) {
                 if (!typeDecl->getName().empty()) {
-                    if(this->m_templateArguments.empty()) {
+                    if (this->m_templateArguments.empty()) {
                         pattern->setTypeName(typeDecl->getName());
                     } else {
                         pattern->setTypeName(fmt::format("{}<{}>", typeDecl->getName(), templateTypeString));
@@ -114,13 +114,13 @@ namespace pl::core::ast {
     }
 
     const ast::ASTNode* ASTNodeTypeApplication::getTypeDefinition(Evaluator *evaluator) const{
-        if(this->m_type == nullptr) {
+        if (this->m_type == nullptr) {
             auto& templateTypeParameters = evaluator->getTypeTemplateParameters();
-            if(this->m_templateParameterIndex >= templateTypeParameters.size()) {
+            if (this->m_templateParameterIndex >= templateTypeParameters.size()) {
                 err::E0004.throwError("Template parameter index out of bounds.", {}, this->getLocation());
             }
             auto type = templateTypeParameters[this->m_templateParameterIndex].get();
-            if(auto typeApp = dynamic_cast<ASTNodeTypeApplication*>(type); typeApp != nullptr) {
+            if (auto typeApp = dynamic_cast<ASTNodeTypeApplication*>(type); typeApp != nullptr) {
                 return typeApp->getTypeDefinition(evaluator);
             }
         }
@@ -138,7 +138,7 @@ namespace pl::core::ast {
     [[nodiscard]] const std::string ASTNodeTypeApplication::getTypeName() const {
         if(auto typeDecl = dynamic_cast<const ASTNodeTypeDecl*>(this->m_type.get()); typeDecl != nullptr) {
             std::string typeName = typeDecl->getName();
-            if(this->m_templateArguments.empty()) {
+            if (this->m_templateArguments.empty()) {
                 return typeName;
             } else {
                 return fmt::format("{}<{}>", typeName, computeTemplateTypeString(this->m_templateArguments));
diff --git a/lib/source/pl/core/ast/ast_node_type_decl.cpp b/lib/source/pl/core/ast/ast_node_type_decl.cpp
@@ -80,10 +80,10 @@ namespace pl::core::ast {
 
             for (size_t i = 0; i < this->m_templateParameters.size(); i++) {
                 auto &templateParameter = this->m_templateParameters[i];
-                if(i >= templateArguments.size()) {
-
+                if (i >= templateArguments.size()) {
                     break;
                 }
+
                 if (!templateParameter->isType()) {
                     auto& argument = templateArguments[i];
                     auto literal = dynamic_cast<ASTNodeLiteral*>(argument.get());
@@ -144,21 +144,21 @@ namespace pl::core::ast {
     }
 
     const ASTNode* ASTNodeTypeDecl::getTypeDefinition(Evaluator *evaluator) const {
-        if(m_type == nullptr)
+        if (m_type == nullptr)
             err::E0004.throwError(fmt::format("Cannot use incomplete type '{}' before it has been defined.", this->m_name), "Try defining this type further up in your code before trying to instantiate it.", this->getLocation());
-        else if(auto typeApp = dynamic_cast<ASTNodeTypeApplication*>(m_type.get()); typeApp != nullptr)
+        else if (auto typeApp = dynamic_cast<ASTNodeTypeApplication*>(m_type.get()); typeApp != nullptr)
             return typeApp->getTypeDefinition(evaluator);
         else
             return m_type.get();
     }
 
     [[nodiscard]] const std::string ASTNodeTypeDecl::getTypeName() const {
-        if(this->isTemplateType()) {
+        if (this->isTemplateType()) {
             std::string typeName = this->m_name + "<";
-            for(const auto& param : this->m_templateParameters) {
+            for (const auto& param : this->m_templateParameters) {
                 typeName += param->getName().get() + ", ";
             }
-            if(!this->m_templateParameters.empty()) {
+            if (!this->m_templateParameters.empty()) {
                 typeName = typeName.substr(0, typeName.size() - 2);
             }
             typeName += ">";
diff --git a/lib/source/pl/core/parser.cpp b/lib/source/pl/core/parser.cpp
@@ -1315,7 +1315,7 @@ namespace pl::core {
                         type->setTemplateParameterIndex(index);
                         return type;
                     }
-                    if(templateType->isType()){
+                    if (templateType->isType()){
                         index++;
                     }
                 }
@@ -1558,7 +1558,6 @@ namespace pl::core {
 
         if (!sequence(tkn::Operator::Assign)) {
             // Forward declaration
-
             auto typeName = getNamespacePrefixedNames(name).back();
             if (typedefIdentifier != nullptr)
                 typedefIdentifier->setType(Token::Identifier::IdentifierType::UDT);
@@ -2813,17 +2812,18 @@ namespace pl::core {
     }
 
     void Parser::reset() {
-        for(const auto &[_, type] : this->m_types) {
-            if(type != nullptr && type->isValid()) {
-                if(auto builtinType = dynamic_cast<ast::ASTNodeBuiltinType*>(type->getType().get()); builtinType != nullptr) {
-                    if(builtinType->getType() != Token::ValueType::CustomType) {
+        for (const auto &[_, type] : this->m_types) {
+            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();
         this->m_currTemplateType.clear();
         this->m_matchedOptionals.clear();
diff --git a/lib/source/pl/core/validator.cpp b/lib/source/pl/core/validator.cpp
@@ -186,7 +186,7 @@ namespace pl::core {
                     return false;
                 }
             }
-        } else if(const auto compoundNode = dynamic_cast<ast::ASTNodeCompoundStatement *>(node); compoundNode != nullptr) {
+        } else if (const auto compoundNode = dynamic_cast<ast::ASTNodeCompoundStatement *>(node); compoundNode != nullptr) {
             if (!this->validateNodes(compoundNode->getStatements(), false))
                 return false;
         }
diff --git a/lib/source/pl/pattern_language.cpp b/lib/source/pl/pattern_language.cpp
@@ -53,7 +53,7 @@ namespace pl {
         if (this->m_flattenThread.joinable())
             this->m_flattenThread.join();
         this->m_parserManager.reset();
-        if(this->m_internals.parser)
+        if (this->m_internals.parser)
             this->m_internals.parser->reset();
         this->m_patterns.clear();
         this->m_flattenedPatterns.clear();
diff --git a/tests/include/test_patterns/test_pattern_custom_builtin_type.hpp b/tests/include/test_patterns/test_pattern_custom_builtin_type.hpp
@@ -29,4 +29,5 @@ namespace pl::test {
             return 2;
         }
     };
+
 }
diff --git a/tests/include/test_patterns/test_pattern_template_parameters_scope.hpp b/tests/include/test_patterns/test_pattern_template_parameters_scope.hpp
@@ -118,4 +118,5 @@ namespace pl::test {
             )";
         }
     };
+
 }
diff --git a/tests/source/main.cpp b/tests/source/main.cpp
@@ -109,7 +109,7 @@ int runTests(int argc, char **argv) {
     test->m_runtime = &runtime;
     test->setup();
 
-    for(size_t i = 0; i < test->repeatTimes(); i++) {
+    for (size_t i = 0; i < test->repeatTimes(); i++) {
         auto result = runtime.executeString(test->getSourceCode());
 
         // Check if compilation succeeded

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ namespace pl::cli::sub {`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`std::string getTypeName(const core::ast::ASTNode *type) {`
`38`		`- if(auto typeApp = dynamic_cast<const core::ast::ASTNodeTypeApplication*>(type); typeApp != nullptr) {`
	`38`	`+ if (auto typeApp = dynamic_cast<const core::ast::ASTNodeTypeApplication*>(type); typeApp != nullptr) {`
`39`	`39`	`return fmt::format("{}{}", getTypeEndian(typeApp), getTypeName(typeApp->getType().get()));`
`40`	`40`	`} else if (auto typeDecl = dynamic_cast<const core::ast::ASTNodeTypeDecl*>(type); typeDecl != nullptr) {`
`41`	`41`	`return typeDecl->getName();`
Original file line number	Diff line number	Diff line change
`@@ -36,11 +36,11 @@ namespace pl::core {`
`36`	`36`
`37`	`37`	`void reset() {`
`38`	`38`	`this->m_onceIncluded.clear();`
`39`		`- for(const auto &[_, types] : this->m_parsedTypes) {`
`40`		`- for(const auto &[_, type] : types) {`
`41`		`- if(type != nullptr && type->isValid()) {`
`42`		`- if(auto builtinType = dynamic_cast<ast::ASTNodeBuiltinType*>(type->getType().get()); builtinType != nullptr) {`
`43`		`- if(builtinType->getType() != Token::ValueType::CustomType) {`
	`39`	`+ for (const auto &[_, types] : this->m_parsedTypes) {`
	`40`	`+ for (const auto &[_, type] : types) {`
	`41`	`+ if (type != nullptr && type->isValid()) {`
	`42`	`+ if (auto builtinType = dynamic_cast<ast::ASTNodeBuiltinType*>(type->getType().get()); builtinType != nullptr) {`
	`43`	`+ if (builtinType->getType() != Token::ValueType::CustomType) {`
`44`	`44`	`type->setType(nullptr);`
`45`	`45`	`}`
`46`	`46`	`}`
`@@ -49,6 +49,7 @@ namespace pl::core {`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`	`}`
	`52`	`+`
`52`	`53`	`this->m_parsedTypes.clear();`
`53`	`54`	`}`
`54`	`55`
Original file line number	Diff line number	Diff line change
`@@ -1315,7 +1315,7 @@ namespace pl::core {`
`1315`	`1315`	`type->setTemplateParameterIndex(index);`
`1316`	`1316`	`return type;`
`1317`	`1317`	`}`
`1318`		`- if(templateType->isType()){`
	`1318`	`+ if (templateType->isType()){`
`1319`	`1319`	`index++;`
`1320`	`1320`	`}`
`1321`	`1321`	`}`
`@@ -1558,7 +1558,6 @@ namespace pl::core {`
`1558`	`1558`
`1559`	`1559`	`if (!sequence(tkn::Operator::Assign)) {`
`1560`	`1560`	`// Forward declaration`
`1561`		`-`
`1562`	`1561`	`auto typeName = getNamespacePrefixedNames(name).back();`
`1563`	`1562`	`if (typedefIdentifier != nullptr)`
`1564`	`1563`	`typedefIdentifier->setType(Token::Identifier::IdentifierType::UDT);`
`@@ -2813,17 +2812,18 @@ namespace pl::core {`
`2813`	`2812`	`}`
`2814`	`2813`
`2815`	`2814`	`void Parser::reset() {`
`2816`		`- for(const auto &[_, type] : this->m_types) {`
`2817`		`- if(type != nullptr && type->isValid()) {`
`2818`		`- if(auto builtinType = dynamic_cast<ast::ASTNodeBuiltinType*>(type->getType().get()); builtinType != nullptr) {`
`2819`		`- if(builtinType->getType() != Token::ValueType::CustomType) {`
	`2815`	`+ for (const auto &[_, type] : this->m_types) {`
	`2816`	`+ if (type != nullptr && type->isValid()) {`
	`2817`	`+ if (auto builtinType = dynamic_cast<ast::ASTNodeBuiltinType*>(type->getType().get()); builtinType != nullptr) {`
	`2818`	`+ if (builtinType->getType() != Token::ValueType::CustomType) {`
`2820`	`2819`	`type->setType(nullptr);`
`2821`	`2820`	`}`
`2822`	`2821`	`} else {`
`2823`	`2822`	`type->setType(nullptr);`
`2824`	`2823`	`}`
`2825`	`2824`	`}`
`2826`	`2825`	`}`
	`2826`	`+`
`2827`	`2827`	`this->m_types.clear();`
`2828`	`2828`	`this->m_currTemplateType.clear();`
`2829`	`2829`	`this->m_matchedOptionals.clear();`
Original file line number	Diff line number	Diff line change
`@@ -186,7 +186,7 @@ namespace pl::core {`
`186`	`186`	`return false;`
`187`	`187`	`}`
`188`	`188`	`}`
`189`		`- } else if(const auto compoundNode = dynamic_cast<ast::ASTNodeCompoundStatement *>(node); compoundNode != nullptr) {`
	`189`	`+ } else if (const auto compoundNode = dynamic_cast<ast::ASTNodeCompoundStatement *>(node); compoundNode != nullptr) {`
`190`	`190`	`if (!this->validateNodes(compoundNode->getStatements(), false))`
`191`	`191`	`return false;`
`192`	`192`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,4 +29,5 @@ namespace pl::test {`
`29`	`29`	`return 2;`
`30`	`30`	`}`
`31`	`31`	`};`
	`32`	`+`
`32`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -118,4 +118,5 @@ namespace pl::test {`
`118`	`118`	`)";`
`119`	`119`	`}`
`120`	`120`	`};`
	`121`	`+`
`121`	`122`	`}`