style: Use designated initializers

This feature has been introduced with C++20.

1 files changed, 50 insertions, 34 deletions

diff --git a/src/buildtool/build_engine/target_map/target_map.cpp b/src/buildtool/build_engine/target_map/target_map.cpp
index c61e3670..d5e0c05b 100644
--- a/src/buildtool/build_engine/target_map/target_map.cpp
+++ b/src/buildtool/build_engine/target_map/target_map.cpp
@@ -199,7 +199,8 @@ struct TargetData {
             targets.reserve(nodes.size());
             for (auto const& node_expr : nodes) {
                 targets.emplace_back(ExpressionPtr{BuildMaps::Base::EntityName{
-                    BuildMaps::Base::AnonymousTarget{rule_map, node_expr}}});
+                    BuildMaps::Base::AnonymousTarget{
+                        .rule_map = rule_map, .target_node = node_expr}}});
             }
             target_exprs.emplace(field_name, targets);
         }
@@ -268,7 +269,8 @@ void withDependencies(
         declared_and_implicit_count, dependency_values.size(), &anonymous_deps);
     auto deps_info = TargetGraphInformation{
         std::make_shared<BuildMaps::Target::ConfiguredTarget>(
-            BuildMaps::Target::ConfiguredTarget{key.target, effective_conf}),
+            BuildMaps::Target::ConfiguredTarget{.target = key.target,
+                                                .config = effective_conf}),
         declared_deps,
         implicit_deps,
         anonymous_deps};
@@ -713,10 +715,10 @@ void withDependencies(
               check_entries(
                   target_fields, is_node, "target_fields", "target node");
 
-              return ExpressionPtr{
-                  TargetNode{TargetNode::Abstract{type->String(),
-                                                  std::move(string_fields),
-                                                  std::move(target_fields)}}};
+              return ExpressionPtr{TargetNode{TargetNode::Abstract{
+                  .node_type = type->String(),
+                  .string_fields = std::move(string_fields),
+                  .target_fields = std::move(target_fields)}}};
           }},
          {"RESULT", [](auto&& eval, auto const& expr, auto const& env) {
               auto const& empty_map_exp = Expression::kEmptyMapExpr;
@@ -785,7 +787,9 @@ void withDependencies(
                       fmt::format("provides has to be a map, but found {}",
                                   provides->ToString())};
               }
-              return ExpressionPtr{TargetResult{artifacts, provides, runfiles}};
+              return ExpressionPtr{TargetResult{.artifact_stage = artifacts,
+                                                .provides = provides,
+                                                .runfiles = runfiles}};
           }}});
 
     auto result = rule->Expression()->Evaluate(
@@ -1035,11 +1039,12 @@ void withRuleDefinition(
                 }
 
                 dependency_keys.emplace_back(
-                    BuildMaps::Target::ConfiguredTarget{dep->Name(),
-                                                        transitioned_config});
+                    BuildMaps::Target::ConfiguredTarget{
+                        .target = dep->Name(), .config = transitioned_config});
                 transition_keys.emplace_back(
                     BuildMaps::Target::ConfiguredTarget{
-                        dep->Name(), Configuration{transition}});
+                        .target = dep->Name(),
+                        .config = Configuration{transition}});
             }
         }
         params.emplace(target_field_name,
@@ -1058,11 +1063,11 @@ void withRuleDefinition(
                 }
 
                 dependency_keys.emplace_back(
-                    BuildMaps::Target::ConfiguredTarget{dep,
-                                                        transitioned_config});
+                    BuildMaps::Target::ConfiguredTarget{
+                        .target = dep, .config = transitioned_config});
                 transition_keys.emplace_back(
                     BuildMaps::Target::ConfiguredTarget{
-                        dep, Configuration{transition}});
+                        .target = dep, .config = Configuration{transition}});
             }
         }
     }
@@ -1128,8 +1133,9 @@ void withRuleDefinition(
                             return;
                         }
                         anon_names.emplace_back(BuildMaps::Base::EntityName{
-                            BuildMaps::Base::AnonymousTarget{def.rule_map,
-                                                             node}});
+                            BuildMaps::Base::AnonymousTarget{
+                                .rule_map = def.rule_map,
+                                .target_node = node}});
                     }
                 }
 
@@ -1139,11 +1145,13 @@ void withRuleDefinition(
                     for (auto const& anon : anon_names) {
                         anonymous_keys.emplace_back(
                             BuildMaps::Target::ConfiguredTarget{
-                                anon->Name(), transitioned_config});
+                                .target = anon->Name(),
+                                .config = transitioned_config});
 
                         transition_keys.emplace_back(
                             BuildMaps::Target::ConfiguredTarget{
-                                anon->Name(), Configuration{transition}});
+                                .target = anon->Name(),
+                                .config = Configuration{transition}});
                     }
                 }
 
@@ -1404,7 +1412,9 @@ void TreeTarget(
                     Expression::map_t{target.name, ExpressionPtr{*known_tree}}};
 
                 auto analysis_result = std::make_shared<AnalysedTarget const>(
-                    TargetResult{tree, {}, tree},
+                    TargetResult{.artifact_stage = tree,
+                                 .provides = {},
+                                 .runfiles = tree},
                     std::vector<ActionDescription::Ptr>{},
                     std::vector<std::string>{},
                     std::vector<Tree::Ptr>{},
@@ -1428,23 +1438,25 @@ void TreeTarget(
             std::vector<ConfiguredTarget> v;
 
             for (const auto& x : dir_entries.FilesIterator()) {
-                v.emplace_back(
-                    ConfiguredTarget{BuildMaps::Base::EntityName{
-                                         target.repository,
-                                         dir_name,
-                                         x,
-                                         BuildMaps::Base::ReferenceType::kFile},
-                                     Configuration{}});
+                v.emplace_back(ConfiguredTarget{
+                    .target =
+                        BuildMaps::Base::EntityName{
+                            target.repository,
+                            dir_name,
+                            x,
+                            BuildMaps::Base::ReferenceType::kFile},
+                    .config = Configuration{}});
             }
 
             for (const auto& x : dir_entries.DirectoriesIterator()) {
-                v.emplace_back(
-                    ConfiguredTarget{BuildMaps::Base::EntityName{
-                                         target.repository,
-                                         dir_name,
-                                         x,
-                                         BuildMaps::Base::ReferenceType::kTree},
-                                     Configuration{}});
+                v.emplace_back(ConfiguredTarget{
+                    .target =
+                        BuildMaps::Base::EntityName{
+                            target.repository,
+                            dir_name,
+                            x,
+                            BuildMaps::Base::ReferenceType::kTree},
+                    .config = Configuration{}});
             }
             (*subcaller)(
                 std::move(v),
@@ -1474,7 +1486,9 @@ void TreeTarget(
                         name, ExpressionPtr{ArtifactDescription{tree_id}}}};
                     auto analysis_result =
                         std::make_shared<AnalysedTarget const>(
-                            TargetResult{tree_map, {}, tree_map},
+                            TargetResult{.artifact_stage = tree_map,
+                                         .provides = {},
+                                         .runfiles = tree_map},
                             std::vector<ActionDescription::Ptr>{},
                             std::vector<std::string>{},
                             std::vector<Tree::Ptr>{tree},
@@ -1505,7 +1519,9 @@ void GlobResult(const std::vector<AnalysedTargetPtr const*>& values,
     }
     auto stage = ExpressionPtr{Expression::map_t{result}};
     auto target = std::make_shared<AnalysedTarget const>(
-        TargetResult{stage, Expression::kEmptyMap, stage},
+        TargetResult{.artifact_stage = stage,
+                     .provides = Expression::kEmptyMap,
+                     .runfiles = stage},
         std::vector<ActionDescription::Ptr>{},
         std::vector<std::string>{},
         std::vector<Tree::Ptr>{},