Used AddDefaultArgument to optimize construction

Author: coder137

buildcc/lib/target/include/target.h

@@ -261,19 +261,9 @@ class Target {
   std::unordered_set<std::string> current_cpp_compile_flags_;
   std::unordered_set<std::string> current_link_flags_;
 
-  // TODO, Make appending to this more efficient
   // TODO, Might not need to be persistent
-  // TODO, aggregates might not need to exist, check `std::insert` APIs over
-  // vector and unordered_set
-  std::string aggregated_include_dirs_;
-  std::string aggregated_lib_dirs_;
-  // NOTE, This contains current_external_lib_deps_ + current_lib_deps_
-  std::string aggregated_lib_deps_;
-
-  std::string aggregated_preprocessor_flags_;
   std::string aggregated_c_compile_flags_;
   std::string aggregated_cpp_compile_flags_;
-  std::string aggregated_link_flags_;
 
   // TODO, Add more internal variables
 

buildcc/lib/target/src/target/build.cpp

@@ -34,22 +34,42 @@ void Target::Build() {
   env::log_trace(name_, __FUNCTION__);
 
   // TODO, Optimize these
-  aggregated_preprocessor_flags_ =
-      internal::aggregate(current_preprocessor_flags_);
   aggregated_c_compile_flags_ = internal::aggregate(current_c_compile_flags_);
   aggregated_cpp_compile_flags_ =
       internal::aggregate(current_cpp_compile_flags_);
-  aggregated_link_flags_ = internal::aggregate(current_link_flags_);
 
-  aggregated_lib_deps_ =
+  // TODO, Segregate these if required
+  const std::string aggregated_lib_deps =
       fmt::format("{} {}", internal::aggregate(current_external_lib_deps_),
                   internal::aggregate(current_lib_deps_));
 
-  aggregated_include_dirs_ = internal::aggregate_with_prefix(
+  const std::string aggregated_preprocessor_flags =
+      internal::aggregate(current_preprocessor_flags_);
+  const std::string aggregated_link_flags =
+      internal::aggregate(current_link_flags_);
+
+  const std::string aggregated_include_dirs = internal::aggregate_with_prefix(
       prefix_include_dir_, current_include_dirs_);
-  aggregated_lib_dirs_ =
+  const std::string aggregated_lib_dirs =
       internal::aggregate_with_prefix(prefix_lib_dir_, current_lib_dirs_);
 
+  command_.AddDefaultArguments({
+      fmt::arg("lib_deps", aggregated_lib_deps),
+
+      fmt::arg("include_dirs", aggregated_include_dirs),
+      fmt::arg("lib_dirs", aggregated_lib_dirs),
+
+      fmt::arg("preprocessor_flags", aggregated_preprocessor_flags),
+      fmt::arg("link_flags", aggregated_link_flags),
+
+      // Toolchain executables here
+      fmt::arg("asm_compiler", toolchain_.GetAsmCompiler()),
+      fmt::arg("c_compiler", toolchain_.GetCCompiler()),
+      fmt::arg("cpp_compiler", toolchain_.GetCppCompiler()),
+      fmt::arg("archiver", toolchain_.GetArchiver()),
+      fmt::arg("linker", toolchain_.GetLinker()),
+  });
+
   const bool is_loaded = loader_.Load();
   // TODO, Add more checks for build files physically present
   // NOTE, This can go into the recompile logic
@@ -123,16 +143,7 @@ void Target::LinkTarget() {
   const bool success = command_.ConstructAndExecute(
       Link(), {
                   fmt::arg("output", output_target),
-                  fmt::arg("link_flags", aggregated_link_flags_),
                   fmt::arg("compiled_sources", aggregated_compiled_sources),
-                  fmt::arg("lib_dirs", aggregated_lib_dirs_),
-                  fmt::arg("lib_deps", aggregated_lib_deps_),
-                  // Toolchain executables here
-                  fmt::arg("asm_compiler", toolchain_.GetAsmCompiler()),
-                  fmt::arg("c_compiler", toolchain_.GetCCompiler()),
-                  fmt::arg("cpp_compiler", toolchain_.GetCppCompiler()),
-                  fmt::arg("archiver", toolchain_.GetArchiver()),
-                  fmt::arg("linker", toolchain_.GetLinker()),
               });
   env::assert_fatal(success, fmt::format("Compilation failed for: {}", name_));
 }

buildcc/lib/target/src/target/source.cpp

@@ -195,16 +195,12 @@ std::string Target::CompileCommand(const fs::path &current_source) const {
                                  : "";
 
   return command_.Construct(
-      CompileCommand(),
-      {
-          fmt::arg("compiler", compiler),
-          fmt::arg("compile_flags", aggregated_compile_flags),
-          fmt::arg("output", output),
-          fmt::arg("input", input),
-
-          fmt::arg("preprocessor_flags", aggregated_preprocessor_flags_),
-          fmt::arg("include_dirs", aggregated_include_dirs_),
-      });
+      CompileCommand(), {
+                            fmt::arg("compiler", compiler),
+                            fmt::arg("compile_flags", aggregated_compile_flags),
+                            fmt::arg("output", output),
+                            fmt::arg("input", input),
+                        });
 }
 
 std::string_view Target::CompileCommand() const {