Added lambda operator() arguments to messages in sequence diagrams

src/sequence_diagram/visitor/translation_unit_visitor.cc

@@ -446,13 +446,8 @@ bool translation_unit_visitor::VisitLambdaExpr(clang::LambdaExpr *expr)
 
     set_unique_id(cls->getID(), cls_id);
 
-    // Create lambda class operator() participant
     auto lambda_method_model_ptr =
-        std::make_unique<sequence_diagram::model::method>(
+        create_lambda_method_model(expr->getCallOperator());
-            config().using_namespace());
-
-    const auto *method_name = "operator()";
-    lambda_method_model_ptr->set_method_name(method_name);
 
     lambda_method_model_ptr->set_class_id(cls_id);
 
@@ -462,8 +457,9 @@ bool translation_unit_visitor::VisitLambdaExpr(clang::LambdaExpr *expr)
 
     diagram().add_participant(std::move(lambda_class_model_ptr));
 
-    lambda_method_model_ptr->set_id(common::to_id(
+    lambda_method_model_ptr->set_id(
-        get_participant(cls_id).value().full_name(false) + "::" + method_name));
+        common::to_id(get_participant(cls_id).value().full_name(false) +
+            "::" + lambda_method_model_ptr->full_name_no_ns()));
 
     get_participant<model::class_>(cls_id).value().set_lambda_operator_id(
         lambda_method_model_ptr->id());
@@ -1992,7 +1988,8 @@ void translation_unit_visitor::finalize()
 }
 
 std::unique_ptr<clanguml::sequence_diagram::model::method>
-translation_unit_visitor::create_method_model(clang::CXXMethodDecl *declaration)
+translation_unit_visitor::create_lambda_method_model(
+    clang::CXXMethodDecl *declaration)
 {
     auto method_model_ptr = std::make_unique<sequence_diagram::model::method>(
         config().using_namespace());
@@ -2009,6 +2006,44 @@ translation_unit_visitor::create_method_model(clang::CXXMethodDecl *declaration)
         declaration->isMoveAssignmentOperator());
     method_model_ptr->is_const(declaration->isConst());
     method_model_ptr->is_static(declaration->isStatic());
+    method_model_ptr->is_operator(declaration->isOverloadedOperator());
+    method_model_ptr->is_constructor(
+        clang::dyn_cast<clang::CXXConstructorDecl>(declaration) != nullptr);
+
+    method_model_ptr->is_void(declaration->getReturnType()->isVoidType());
+
+    method_model_ptr->return_type(common::to_string(
+        declaration->getReturnType(), declaration->getASTContext()));
+
+    for (const auto *param : declaration->parameters()) {
+        auto parameter_type =
+            common::to_string(param->getType(), param->getASTContext());
+        common::ensure_lambda_type_is_relative(config(), parameter_type);
+        parameter_type = simplify_system_template(parameter_type);
+        method_model_ptr->add_parameter(config().using_namespace().relative(
+            simplify_system_template(parameter_type)));
+    }
+
+    return method_model_ptr;
+}
+
+std::unique_ptr<clanguml::sequence_diagram::model::method>
+translation_unit_visitor::create_method_model(clang::CXXMethodDecl *declaration)
+{
+    auto method_model_ptr = std::make_unique<sequence_diagram::model::method>(
+        config().using_namespace());
+
+    common::model::namespace_ ns{declaration->getQualifiedNameAsString()};
+    auto method_name = ns.name();
+    method_model_ptr->set_method_name(method_name);
+    ns.pop_back();
+    method_model_ptr->set_name(ns.name());
+    ns.pop_back();
+
+    method_model_ptr->is_defaulted(declaration->isDefaulted());
+    method_model_ptr->is_assignment(declaration->isCopyAssignmentOperator() ||
+        declaration->isMoveAssignmentOperator());
+    method_model_ptr->is_const(declaration->isConst());
     method_model_ptr->is_static(declaration->isStatic());
     method_model_ptr->is_operator(declaration->isOverloadedOperator());
     method_model_ptr->is_constructor(
@@ -2040,7 +2075,6 @@ translation_unit_visitor::create_method_model(clang::CXXMethodDecl *declaration)
                                    .value()
                                    .full_name_no_ns() +
         "::" + declaration->getNameAsString());
-    method_model_ptr->is_static(declaration->isStatic());
 
     method_model_ptr->return_type(common::to_string(
         declaration->getReturnType(), declaration->getASTContext()));

src/sequence_diagram/visitor/translation_unit_visitor.h

@@ -314,6 +314,9 @@ private:
     std::unique_ptr<clanguml::sequence_diagram::model::method>
     create_method_model(clang::CXXMethodDecl *cls);
 
+    std::unique_ptr<clanguml::sequence_diagram::model::method>
+    create_lambda_method_model(clang::CXXMethodDecl *cls);
+
     std::unique_ptr<model::function_template>
     build_function_template_instantiation(const clang::FunctionDecl &pDecl);
 

tests/t20012/test_case.h

@@ -37,7 +37,7 @@ TEST_CASE("t20012", "[test-case][sequence]")
         // Check if all calls exist
         REQUIRE_THAT(src,
             HasCall(_A("tmain()"), _A("tmain()::(lambda t20012.cc:67:20)"),
-                "operator()()"));
+                "operator()() const"));
         REQUIRE_THAT(src,
             HasCall(_A("tmain()::(lambda t20012.cc:67:20)"), _A("A"), "a()"));
         REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "aa()"));
@@ -54,7 +54,7 @@ TEST_CASE("t20012", "[test-case][sequence]")
         REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
         REQUIRE_THAT(src,
             HasCall(_A("tmain()::(lambda t20012.cc:80:20)"),
-                _A("tmain()::(lambda t20012.cc:67:20)"), "operator()()"));
+                _A("tmain()::(lambda t20012.cc:67:20)"), "operator()() const"));
 
         REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
 
@@ -65,7 +65,7 @@ TEST_CASE("t20012", "[test-case][sequence]")
             HasCall(_A("tmain()"), _A("R<(lambda at t20012.cc:86:9)>"), "r()"));
         REQUIRE_THAT(src,
             HasCall(_A("R<(lambda at t20012.cc:86:9)>"),
-                _A("tmain()::(lambda t20012.cc:86:9)"), "operator()()"));
+                _A("tmain()::(lambda t20012.cc:86:9)"), "operator()() const"));
         REQUIRE_THAT(src,
             HasCall(_A("tmain()::(lambda t20012.cc:86:9)"), _A("C"), "c()"));
 
@@ -82,7 +82,7 @@ TEST_CASE("t20012", "[test-case][sequence]")
 
         std::vector<int> messages = {
             FindMessage(j, "tmain()", "tmain()::(lambda t20012.cc:67:20)",
-                "operator()()"),
+                "operator()() const"),
             FindMessage(j, "tmain()::(lambda t20012.cc:67:20)", "A", "a()"),
             FindMessage(j, "A", "A", "aa()"), FindMessage(j, "A", "A", "aaa()"),
             FindMessage(j, "tmain()::(lambda t20012.cc:67:20)", "B", "b()"),
@@ -90,10 +90,10 @@ TEST_CASE("t20012", "[test-case][sequence]")
             FindMessage(j, "tmain()::(lambda t20012.cc:80:20)", "C", "c()"),
             FindMessage(j, "C", "C", "cc()"), FindMessage(j, "C", "C", "ccc()"),
             FindMessage(j, "tmain()::(lambda t20012.cc:80:20)",
-                "tmain()::(lambda t20012.cc:67:20)", "operator()()"),
+                "tmain()::(lambda t20012.cc:67:20)", "operator()() const"),
             FindMessage(j, "tmain()", "R<(lambda at t20012.cc:86:9)>", "r()"),
             FindMessage(j, "R<(lambda at t20012.cc:86:9)>",
-                "tmain()::(lambda t20012.cc:86:9)", "operator()()"),
+                "tmain()::(lambda t20012.cc:86:9)", "operator()() const"),
             FindMessage(j, "tmain()::(lambda t20012.cc:86:9)", "C", "c()"),
             // @todo #168
             // FindMessage(j, "tmain()", "D", "add5(int)")
@@ -112,7 +112,7 @@ TEST_CASE("t20012", "[test-case][sequence]")
 
         REQUIRE_THAT(src,
             HasCall(_A("tmain()"), _A("tmain()::(lambda t20012.cc:67:20)"),
-                "operator()()"));
+                "operator()() const"));
         REQUIRE_THAT(src,
             HasCall(_A("tmain()::(lambda t20012.cc:67:20)"), _A("A"), "a()"));
         REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "aa()"));
@@ -129,7 +129,7 @@ TEST_CASE("t20012", "[test-case][sequence]")
         REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
         REQUIRE_THAT(src,
             HasCall(_A("tmain()::(lambda t20012.cc:80:20)"),
-                _A("tmain()::(lambda t20012.cc:67:20)"), "operator()()"));
+                _A("tmain()::(lambda t20012.cc:67:20)"), "operator()() const"));
 
         REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
 
@@ -137,7 +137,7 @@ TEST_CASE("t20012", "[test-case][sequence]")
             HasCall(_A("tmain()"), _A("R<(lambda at t20012.cc:86:9)>"), "r()"));
         REQUIRE_THAT(src,
             HasCall(_A("R<(lambda at t20012.cc:86:9)>"),
-                _A("tmain()::(lambda t20012.cc:86:9)"), "operator()()"));
+                _A("tmain()::(lambda t20012.cc:86:9)"), "operator()() const"));
         REQUIRE_THAT(src,
             HasCall(_A("tmain()::(lambda t20012.cc:86:9)"), _A("C"), "c()"));
 

tests/t20044/test_case.h

@@ -59,7 +59,8 @@ TEST_CASE("t20044", "[test-case][sequence]")
 
         REQUIRE_THAT(src,
             HasCall(_A("detail::expected<int,error>"),
-                _A("tmain()::(lambda t20044.cc:90:19)"), "operator()()"));
+                _A("tmain()::(lambda t20044.cc:90:19)"),
+                "operator()(auto &&) const"));
 
         REQUIRE_THAT(src,
             HasCall(

tests/t20045/test_case.h

@@ -46,7 +46,8 @@ TEST_CASE("t20045", "[test-case][sequence]")
         REQUIRE_THAT(src,
             HasCall(_A("a1<(lambda at t20045.cc:35:18)>((lambda at "
                        "t20045.cc:35:18) &&)"),
-                _A("tmain()::(lambda t20045.cc:35:18)"), "operator()()"));
+                _A("tmain()::(lambda t20045.cc:35:18)"),
+                "operator()(auto &&) const"));
 
         REQUIRE_THAT(src,
             HasCall(

tests/t20046/test_case.h

@@ -37,12 +37,12 @@ TEST_CASE("t20046", "[test-case][sequence]")
 
         REQUIRE_THAT(src,
             HasCall(_A("tmain()"), _A("tmain()::(lambda t20046.cc:13:15)"),
-                "operator()()"));
+                "operator()(auto &&) const"));
         REQUIRE_THAT(src,
             HasCall(_A("tmain()::(lambda t20046.cc:13:15)"),
                 _A("tmain()::(lambda t20046.cc:13:15)::(lambda "
                    "t20046.cc:14:16)"),
-                "operator()()"));
+                "operator()(auto &&) const"));
 
         REQUIRE_THAT(src,
             HasCall(_A("tmain()::(lambda t20046.cc:13:15)::(lambda "
@@ -59,13 +59,14 @@ TEST_CASE("t20046", "[test-case][sequence]")
             HasCall(
                 _A("a1<(lambda at t20046.cc:19:9)>((lambda at t20046.cc:19:9) "
                    "&&)"),
-                _A("tmain()::(lambda t20046.cc:19:9)"), "operator()()"));
+                _A("tmain()::(lambda t20046.cc:19:9)"),
+                "operator()(auto &&) const"));
 
         REQUIRE_THAT(src,
             HasCall(_A("tmain()::(lambda t20046.cc:19:9)"),
                 _A("tmain()::(lambda t20046.cc:19:9)::(lambda "
                    "t20046.cc:19:34)"),
-                "operator()()"));
+                "operator()(auto &&) const"));
 
         REQUIRE_THAT(src,
             HasCall(_A("tmain()::(lambda t20046.cc:19:9)::(lambda "

tests/t20048/test_case.h

@@ -45,7 +45,7 @@ TEST_CASE("t20048", "[test-case][sequence]")
 
         REQUIRE_THAT(src,
             HasCall(_A("tmain()"), _A("tmain()::(lambda t20048.cc:26:11)"),
-                "operator()()"));
+                "operator()(auto &&) const"));
         REQUIRE_THAT(src,
             HasCall(
                 _A("tmain()::(lambda t20048.cc:26:11)"), _A("a4(int)"), ""));