Adding template class specialization sequence diagram test case

src/sequence_diagram/model/participant.cc

@@ -63,6 +63,38 @@ template_trait::templates() const
     return templates_;
 }
 
+int template_trait::calculate_template_specialization_match(
+    const template_trait &other, const std::string &full_name) const
+{
+    int res{};
+
+//    std::string left = name_and_ns();
+//    // TODO: handle variadic templates
+//    if ((name_and_ns() != full_name) ||
+//        (templates().size() != other.templates().size())) {
+//        return res;
+//    }
+
+    // Iterate over all template arguments
+    for (auto i = 0U; i < other.templates().size(); i++) {
+        const auto &template_arg = templates().at(i);
+        const auto &other_template_arg = other.templates().at(i);
+
+        if (template_arg == other_template_arg) {
+            res++;
+        }
+        else if (other_template_arg.is_specialization_of(template_arg)) {
+            continue;
+        }
+        else {
+            res = 0;
+            break;
+        }
+    }
+
+    return res;
+}
+
 class_::class_(const common::model::namespace_ &using_namespace)
     : participant{using_namespace}
 {
@@ -122,6 +154,9 @@ std::string class_::full_name(bool relative) const
     return res;
 }
 
+bool operator==(const class_ &l, const class_ &r) { return l.id() == r.id(); }
+
+
 function::function(const common::model::namespace_ &using_namespace)
     : participant{using_namespace}
 {

src/sequence_diagram/model/participant.h

@@ -39,6 +39,9 @@ struct template_trait {
     const std::vector<class_diagram::model::template_parameter> &
     templates() const;
 
+    int calculate_template_specialization_match(
+        const template_trait &other, const std::string &full_name) const;
+
 private:
     std::vector<class_diagram::model::template_parameter> templates_;
     std::string base_template_full_name_;

src/sequence_diagram/visitor/translation_unit_visitor.h

@@ -169,7 +169,10 @@ public:
 
     virtual bool VisitCXXRecordDecl(clang::CXXRecordDecl *cls);
 
-    bool VisitClassTemplateDecl(clang::ClassTemplateDecl *cls);
+    virtual bool VisitClassTemplateDecl(clang::ClassTemplateDecl *cls);
+
+    virtual bool VisitClassTemplateSpecializationDecl(
+        clang::ClassTemplateSpecializationDecl *cls);
 
     virtual bool VisitFunctionDecl(clang::FunctionDecl *function_declaration);
 
@@ -203,7 +206,7 @@ private:
     build_function_template_instantiation(const clang::FunctionDecl &pDecl);
 
     void build_template_instantiation_process_template_arguments(
-        std::optional<model::template_trait *> &parent,
+        model::template_trait *parent,
         std::deque<std::tuple<std::string, int, bool>> &template_base_params,
         const clang::ArrayRef<clang::TemplateArgument> &template_args,
         model::template_trait &template_instantiation,
@@ -230,13 +233,30 @@ private:
         class_diagram::model::template_parameter &argument) const;
 
     void build_template_instantiation_process_type_argument(
-        std::optional<model::template_trait *> &parent,
+        model::template_trait *parent,
         const std::string &full_template_specialization_name,
         const clang::TemplateDecl *template_decl,
         const clang::TemplateArgument &arg,
         model::template_trait &template_instantiation,
         class_diagram::model::template_parameter &argument);
 
+    std::unique_ptr<model::class_> process_template_specialization(
+        clang::ClassTemplateSpecializationDecl *cls);
+
+    void process_template_specialization_argument(
+        const clang::ClassTemplateSpecializationDecl *cls,
+        model::class_ &template_instantiation,
+        const clang::TemplateArgument &arg, size_t argument_index,
+        bool in_parameter_pack = false);
+
+    void process_unexposed_template_specialization_parameters(
+        const std::string &type_name,
+        class_diagram::model::template_parameter &tp, model::class_ &c) const;
+
+    std::unique_ptr<model::class_> build_template_instantiation(
+        const clang::TemplateSpecializationType &template_type_decl,
+        model::class_ *parent);
+
     bool simplify_system_template(class_diagram::model::template_parameter &ct,
         const std::string &full_name);
 

tests/t20001/t20001.cc

@@ -64,7 +64,9 @@ int tmain()
     A a;
     B b(a);
 
-    return b.wrap_add3(1, 2, 3);
+    auto tmp = a.add(1, 2);
+
+    return b.wrap_add3(tmp, 2, 3);
 }
 }
 }

tests/t20006/.clang-uml

@@ -0,0 +1,14 @@
+compilation_database_dir: ..
+output_directory: puml
+diagrams:
+  t20006_sequence:
+    type: sequence
+    glob:
+      - ../../tests/t20006/t20006.cc
+    include:
+      namespaces:
+        - clanguml::t20006
+    using_namespace:
+      - clanguml::t20006
+    start_from:
+      - function: "clanguml::t20006::tmain()"

tests/t20006/t20006.cc

@@ -0,0 +1,30 @@
+#include <string>
+
+namespace clanguml {
+namespace t20006 {
+
+template <typename T> struct A {
+    T a(T arg) { return arg; }
+    T a1(T arg) { return arg; }
+};
+
+template <typename T> struct B {
+    T b(T arg) { return a_.a(arg); }
+    A<T> a_;
+};
+
+template <> struct B<std::string> {
+    std::string b(std::string arg) { return arg; }
+    A<std::string> a_;
+};
+
+void tmain()
+{
+    B<int> bint;
+    B<std::string> bstring;
+
+    bint.b(1);
+    bstring.b("bstring");
+}
+}
+}

tests/t20006/test_case.h

@@ -0,0 +1,47 @@
+/**
+ * tests/t20006/test_case.h
+ *
+ * Copyright (c) 2021-2022 Bartek Kryza <bkryza@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+TEST_CASE("t20006", "[test-case][sequence]")
+{
+    auto [config, db] = load_config("t20006");
+
+    auto diagram = config.diagrams["t20006_sequence"];
+
+    REQUIRE(diagram->name == "t20006_sequence");
+
+    auto model = generate_sequence_diagram(*db, diagram);
+
+    REQUIRE(model->name() == "t20006_sequence");
+
+    auto puml = generate_sequence_puml(diagram, *model);
+    AliasMatcher _A(puml);
+
+    REQUIRE_THAT(puml, StartsWith("@startuml"));
+    REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+
+    // Check if all calls exist
+    REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B<int>"), "b"));
+    REQUIRE_THAT(puml, HasCall(_A("B<int>"), _A("A<int>"), "a"));
+
+    REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B<std::string>"), "b"));
+    REQUIRE_THAT(
+        puml, !HasCall(_A("B<std::string>"), _A("A<std::string>"), "a"));
+
+    save_puml(
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
+}

tests/test_cases.cc

@@ -252,6 +252,7 @@ using namespace clanguml::test::matchers;
 #include "t20003/test_case.h"
 #include "t20004/test_case.h"
 #include "t20005/test_case.h"
+#include "t20006/test_case.h"
 
 ///
 /// Package diagram tests