evaluator: fix type name for non-placement template variablesFix type name for non-placement template variables

Fix the result of the type name for non-placement variables with template types.
We still need to evaluate the arguments of the template before setting the type name.
For typeNameOf the type, we can skip creating the pattern as only the arguments matter.

Author: AkiSakurai

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

@@ -25,6 +25,8 @@ namespace pl::core::ast {
                     }
             } else if (auto typeNode = dynamic_cast<ASTNodeTypeApplication*>(templateArgument.get()); typeNode != nullptr) {
                 templateTypeString += fmt::format("{}, ", typeNode->getTypeName());
+            } else {
+                templateTypeString += ", ";
             }
         }
 

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

@@ -43,6 +43,14 @@ namespace pl::core::ast {
             };
 
             std::vector<std::shared_ptr<ptrn::Pattern>> patterns;
+            if (this->getOperator() == Token::Operator::TypeNameOf) {
+                if (auto typeApp = dynamic_cast<ASTNodeTypeApplication*>(this->m_expression.get()); typeApp != nullptr) {
+                    auto evaluatedType = typeApp->evaluate(evaluator);
+                    result = dynamic_cast<ASTNodeTypeApplication*>(evaluatedType.get())->getTypeName();
+                    return std::unique_ptr<ASTNode>(new ASTNodeLiteral(result));
+                }
+            }
+
             this->m_expression->createPatterns(evaluator, patterns);
             if (patterns.empty())
                 err::E0005.throwError("'auto' can only be used with parameters.", { }, this->getLocation());
@@ -56,16 +64,9 @@ namespace pl::core::ast {
                 case Token::Operator::SizeOf:
                     result = u128(pattern->getSize());
                     break;
-                case Token::Operator::TypeNameOf: {
-                    if (auto typeApp = dynamic_cast<ASTNodeTypeApplication*>(this->m_expression.get()); typeApp != nullptr) {
-                        auto evaluatedType = typeApp->evaluate(evaluator);
-                        result = dynamic_cast<ASTNodeTypeApplication*>(evaluatedType.get())->getTypeName();
-                    } else {
-                        result = pattern->getTypeName();
-                    }
-
+                case Token::Operator::TypeNameOf:
+                    result = pattern->getTypeName();
                     break;
-                }
                 default:
                     err::E0001.throwError("Invalid type operation.", {}, this->getLocation());
             }

lib/source/pl/core/evaluator.cpp

@@ -354,7 +354,8 @@ namespace pl::core {
             }
             else {
                 pattern = std::make_shared<ptrn::PatternPadding>(this, 0, 0, 0);
-                pattern->setTypeName(type->getTypeName());
+                auto evaluatedType = type->evaluate(this);
+                pattern->setTypeName(dynamic_cast<ast::ASTNodeTypeApplication*>(evaluatedType.get())->getTypeName());
             }
         }
 

lib/source/pl/core/parser.cpp

@@ -1310,7 +1310,7 @@ namespace pl::core {
             size_t index = 0;
             for (const auto &templateParameter : this->m_currTemplateType.front()->getTemplateParameters()) {
                 if (const auto templateType = dynamic_cast<ast::ASTNodeTemplateParameter*>(templateParameter.get()); templateType != nullptr){
-                    if (templateType->getName().get() == baseTypeName) {
+                    if (templateType->getName().get() == baseTypeName && templateType->isType()) {
                         auto type = create<ast::ASTNodeTypeApplication>(nullptr);
                         type->setTemplateParameterIndex(index);
                         return type;

tests/include/test_patterns/test_pattern_typenameof.hpp

@@ -25,12 +25,35 @@ namespace pl::test {
                 };
 
                 u32 P = 16;
+                A q @ 0;
+                B<u32, q> r;
                 TypeName<u32, "u32"> a @ 0;
                 TypeName<A, "A"> b @ 0;
                 TypeName<B<u32, 2>, "B<u32, 2>"> c @ 0;
                 TypeName<B<B<u32, P>, 2>, "B<B<u32, 16>, 2>"> d @ 0;
                 TypeName<TypeName<A, "A"> , "TypeName<A, \"A\">"> e @ 0;
+                TypeName<B<u32, q>, "B<u32, A{ }>"> f @ 0;
                 std::assert(typenameof(B<B<u32, P>, 2>) == "B<B<u32, 16>, 2>", "type name should match");
+                std::assert(typenameof(B<u32, q>) == "B<u32, A{ }>", "type name should match");
+
+                B<u32, P> t;
+                std::assert(typenameof(t) == "B<u32, 16>", "type name should match");
+
+                struct S {
+                    u32 e = 16;
+                    B<u32, e> a = t;
+                    str typename = typenameof(a);
+                };
+
+                S s @ 0;
+                std::assert(s.typename == "B<u32, 16>", "type name should match");
+
+                struct U {
+                    u8 size;
+                    u32 value[size];
+                };
+
+                std::assert(typenameof(U) == "U", "type name should match");
             )";
         }
     };