Merge topic 'ninja-strcat-usage'

6e65b869c3 cmNinjaTargetGenerator: cmStrCat usage
9f6544048f cmGlobalNinjaGenerator: cmStrCat usage
04ac0ea501 cmGlobalNinjaGenerator: factor out /all target name computation
a85bea173a cmGlobalNinjaGenerator: avoid unnecessary string addition

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !4347

2 files changed, 154 insertions, 151 deletions

diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx
index 072c6e1..3553ffd 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -148,15 +148,15 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
 {
   // Make sure there is a rule.
   if (build.Rule.empty()) {
-    cmSystemTools::Error("No rule for WriteBuild! called with comment: " +
-                         build.Comment);
+    cmSystemTools::Error(cmStrCat(
+      "No rule for WriteBuild! called with comment: ", build.Comment));
     return;
   }
 
   // Make sure there is at least one output file.
   if (build.Outputs.empty()) {
-    cmSystemTools::Error(
-      "No output files for WriteBuild! called with comment: " + build.Comment);
+    cmSystemTools::Error(cmStrCat(
+      "No output files for WriteBuild! called with comment: ", build.Comment));
     return;
   }
 
@@ -167,7 +167,7 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
   {
     // Write explicit outputs
     for (std::string const& output : build.Outputs) {
-      buildStr += " " + EncodePath(output);
+      buildStr += cmStrCat(' ', EncodePath(output));
       if (this->ComputingUnknownDependencies) {
         this->CombinedBuildOutputs.insert(output);
       }
@@ -176,14 +176,13 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
     if (!build.ImplicitOuts.empty()) {
       buildStr += " |";
       for (std::string const& implicitOut : build.ImplicitOuts) {
-        buildStr += " " + EncodePath(implicitOut);
+        buildStr += cmStrCat(' ', EncodePath(implicitOut));
       }
     }
-    buildStr += ":";
+    buildStr += ':';
 
     // Write the rule.
-    buildStr += " ";
-    buildStr += build.Rule;
+    buildStr += cmStrCat(' ', build.Rule);
   }
 
   std::string arguments;
@@ -192,14 +191,14 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
 
     // Write explicit dependencies.
     for (std::string const& explicitDep : build.ExplicitDeps) {
-      arguments += " " + EncodePath(explicitDep);
+      arguments += cmStrCat(' ', EncodePath(explicitDep));
     }
 
     // Write implicit dependencies.
     if (!build.ImplicitDeps.empty()) {
       arguments += " |";
       for (std::string const& implicitDep : build.ImplicitDeps) {
-        arguments += " " + EncodePath(implicitDep);
+        arguments += cmStrCat(' ', EncodePath(implicitDep));
       }
     }
 
@@ -207,11 +206,11 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
     if (!build.OrderOnlyDeps.empty()) {
       arguments += " ||";
       for (std::string const& orderOnlyDep : build.OrderOnlyDeps) {
-        arguments += " " + EncodePath(orderOnlyDep);
+        arguments += cmStrCat(' ', EncodePath(orderOnlyDep));
       }
     }
 
-    arguments += "\n";
+    arguments += '\n';
   }
 
   // Write the variables bound to this build statement.
@@ -310,7 +309,7 @@ void cmGlobalNinjaGenerator::WriteCustomCommandBuild(
 void cmGlobalNinjaGenerator::AddMacOSXContentRule()
 {
   cmNinjaRule rule("COPY_OSX_CONTENT");
-  rule.Command = CMakeCmd() + " -E copy $in $out";
+  rule.Command = cmStrCat(CMakeCmd(), " -E copy $in $out");
   rule.Description = "Copying OS X Content $out";
   rule.Comment = "Rule for copying OS X bundle content file.";
   this->AddRule(rule);
@@ -335,23 +334,24 @@ void cmGlobalNinjaGenerator::WriteRule(std::ostream& os,
   // -- Parameter checks
   // Make sure the rule has a name.
   if (rule.Name.empty()) {
-    cmSystemTools::Error("No name given for WriteRule! called with comment: " +
-                         rule.Comment);
+    cmSystemTools::Error(cmStrCat(
+      "No name given for WriteRule! called with comment: ", rule.Comment));
     return;
   }
 
   // Make sure a command is given.
   if (rule.Command.empty()) {
-    cmSystemTools::Error(
-      "No command given for WriteRule! called with comment: " + rule.Comment);
+    cmSystemTools::Error(cmStrCat(
+      "No command given for WriteRule! called with comment: ", rule.Comment));
     return;
   }
 
   // Make sure response file content is given
   if (!rule.RspFile.empty() && rule.RspContent.empty()) {
-    cmSystemTools::Error("rspfile but no rspfile_content given for WriteRule! "
-                         "called with comment: " +
-                         rule.Comment);
+    cmSystemTools::Error(
+      cmStrCat("rspfile but no rspfile_content given for WriteRule! "
+               "called with comment: ",
+               rule.Comment));
     return;
   }
 
@@ -393,9 +393,9 @@ void cmGlobalNinjaGenerator::WriteVariable(std::ostream& os,
 {
   // Make sure we have a name.
   if (name.empty()) {
-    cmSystemTools::Error("No name given for WriteVariable! called "
-                         "with comment: " +
-                         comment);
+    cmSystemTools::Error(cmStrCat("No name given for WriteVariable! called "
+                                  "with comment: ",
+                                  comment));
     return;
   }
 
@@ -559,11 +559,11 @@ void cmGlobalNinjaGenerator::CleanMetaData()
                                          nullptr,
                                          cmSystemTools::OUTPUT_NONE)) {
       this->GetCMakeInstance()->IssueMessage(MessageType::FATAL_ERROR,
-                                             "Running\n '" +
-                                               cmJoin(command, "' '") +
-                                               "'\n"
-                                               "failed with:\n " +
-                                               error);
+                                             cmStrCat("Running\n '",
+                                                      cmJoin(command, "' '"),
+                                                      "'\n"
+                                                      "failed with:\n ",
+                                                      error));
       cmSystemTools::SetFatalErrorOccured();
     }
   };
@@ -627,10 +627,10 @@ bool cmGlobalNinjaGenerator::FindMakeProgram(cmMakefile* mf)
                                          nullptr,
                                          cmSystemTools::OUTPUT_NONE)) {
       mf->IssueMessage(MessageType::FATAL_ERROR,
-                       "Running\n '" + cmJoin(command, "' '") +
-                         "'\n"
-                         "failed with:\n " +
-                         error);
+                       cmStrCat("Running\n '", cmJoin(command, "' '"),
+                                "'\n"
+                                "failed with:\n ",
+                                error));
       cmSystemTools::SetFatalErrorOccured();
       return false;
     }
@@ -714,7 +714,7 @@ bool cmGlobalNinjaGenerator::CheckFortran(cmMakefile* mf) const
   /* clang-format off */
   e <<
     "The Ninja generator does not support Fortran using Ninja version\n"
-    "  " + this->NinjaVersion + "\n"
+    "  " << this->NinjaVersion << "\n"
     "due to lack of required features.  "
     "Kitware has implemented the required features and they have been "
     "merged to upstream ninja for inclusion in Ninja 1.10 and higher.  "
@@ -999,7 +999,8 @@ void cmGlobalNinjaGenerator::AddCXXCompileCommand(
   std::string buildFileDir =
     this->GetCMakeInstance()->GetHomeOutputDirectory();
   if (!this->CompileCommandsStream) {
-    std::string buildFilePath = buildFileDir + "/compile_commands.json";
+    std::string buildFilePath =
+      cmStrCat(buildFileDir, "/compile_commands.json");
     if (this->ComputingUnknownDependencies) {
       this->CombinedBuildOutputs.insert(
         this->NinjaOutputPath("compile_commands.json"));
@@ -1065,8 +1066,8 @@ void cmGlobalNinjaGenerator::WriteAssumedSourceDependencies()
 std::string cmGlobalNinjaGenerator::OrderDependsTargetForTarget(
   cmGeneratorTarget const* target, const std::string& config)
 {
-  return "cmake_object_order_depends_target_" + target->GetName() + "_" +
-    config;
+  return cmStrCat("cmake_object_order_depends_target_", target->GetName(), '_',
+                  config);
 }
 
 void cmGlobalNinjaGenerator::AppendTargetOutputs(
@@ -1104,8 +1105,8 @@ void cmGlobalNinjaGenerator::AppendTargetOutputs(
     case cmStateEnums::GLOBAL_TARGET:
     case cmStateEnums::UTILITY: {
       std::string path =
-        target->GetLocalGenerator()->GetCurrentBinaryDirectory() +
-        std::string("/") + target->GetName();
+        cmStrCat(target->GetLocalGenerator()->GetCurrentBinaryDirectory(), '/',
+                 target->GetName());
       std::string output = this->ConvertToNinjaPath(path);
       if (target->Target->IsPerConfig()) {
         output = this->BuildAlias(output, config);
@@ -1128,8 +1129,8 @@ void cmGlobalNinjaGenerator::AppendTargetDepends(
     // These depend only on other CMake-provided targets, e.g. "all".
     for (BT<std::string> const& util : target->GetUtilities()) {
       std::string d =
-        target->GetLocalGenerator()->GetCurrentBinaryDirectory() + "/" +
-        util.Value;
+        cmStrCat(target->GetLocalGenerator()->GetCurrentBinaryDirectory(), '/',
+                 util.Value);
       outputs.push_back(this->BuildAlias(this->ConvertToNinjaPath(d), config));
     }
   } else {
@@ -1358,12 +1359,13 @@ void cmGlobalNinjaGenerator::WriteFolderTargets(std::ostream& os)
 
     // Setup target
     cmNinjaDeps configDeps;
-    build.Comment = "Folder: " + currentBinaryDir;
+    build.Comment = cmStrCat("Folder: ", currentBinaryDir);
     build.Outputs.emplace_back();
+    std::string const buildDirAllTarget =
+      this->ConvertToNinjaPath(cmStrCat(currentBinaryDir, "/all"));
     for (auto const& config : configs) {
       build.ExplicitDeps.clear();
-      build.Outputs.front() = this->BuildAlias(
-        this->ConvertToNinjaPath(currentBinaryDir + "/all"), config);
+      build.Outputs.front() = this->BuildAlias(buildDirAllTarget, config);
       configDeps.emplace_back(build.Outputs.front());
       for (DirectoryTarget::Target const& t : dt.Targets) {
         if (!t.ExcludeFromAll) {
@@ -1373,7 +1375,7 @@ void cmGlobalNinjaGenerator::WriteFolderTargets(std::ostream& os)
       for (DirectoryTarget::Dir const& d : dt.Children) {
         if (!d.ExcludeFromAll) {
           build.ExplicitDeps.emplace_back(this->BuildAlias(
-            this->ConvertToNinjaPath(d.Path + "/all"), config));
+            this->ConvertToNinjaPath(cmStrCat(d.Path, "/all")), config));
         }
       }
       // Write target
@@ -1387,21 +1389,18 @@ void cmGlobalNinjaGenerator::WriteFolderTargets(std::ostream& os)
     // Add shortcut target
     if (this->IsMultiConfig()) {
       for (auto const& config : configs) {
-        build.ExplicitDeps = { this->BuildAlias(
-          this->ConvertToNinjaPath(currentBinaryDir + "/all"), config) };
-        build.Outputs.front() =
-          this->ConvertToNinjaPath(currentBinaryDir + "/all");
+        build.ExplicitDeps = { this->BuildAlias(buildDirAllTarget, config) };
+        build.Outputs.front() = buildDirAllTarget;
         this->WriteBuild(*this->GetConfigFileStream(config), build);
       }
 
       if (!this->DefaultFileConfig.empty()) {
         build.ExplicitDeps.clear();
         for (auto const& config : this->DefaultConfigs) {
-          build.ExplicitDeps.push_back(this->BuildAlias(
-            this->ConvertToNinjaPath(currentBinaryDir + "/all"), config));
+          build.ExplicitDeps.push_back(
+            this->BuildAlias(buildDirAllTarget, config));
         }
-        build.Outputs.front() =
-          this->ConvertToNinjaPath(currentBinaryDir + "/all");
+        build.Outputs.front() = buildDirAllTarget;
         this->WriteBuild(*this->GetDefaultFileStream(), build);
       }
     }
@@ -1410,11 +1409,10 @@ void cmGlobalNinjaGenerator::WriteFolderTargets(std::ostream& os)
     if (this->EnableCrossConfigBuild()) {
       build.ExplicitDeps.clear();
       for (auto const& config : this->CrossConfigs) {
-        build.ExplicitDeps.push_back(this->BuildAlias(
-          this->ConvertToNinjaPath(currentBinaryDir + "/all"), config));
+        build.ExplicitDeps.push_back(
+          this->BuildAlias(buildDirAllTarget, config));
       }
-      build.Outputs.front() = this->BuildAlias(
-        this->ConvertToNinjaPath(currentBinaryDir + "/all"), "all");
+      build.Outputs.front() = this->BuildAlias(buildDirAllTarget, "all");
       this->WriteBuild(os, build);
     }
   }
@@ -1626,7 +1624,8 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
 
     cmNinjaBuild phonyBuild("phony");
     phonyBuild.Comment = "Phony target to force glob verification run.";
-    phonyBuild.Outputs.push_back(cm->GetGlobVerifyScript() + "_force");
+    phonyBuild.Outputs.push_back(
+      cmStrCat(cm->GetGlobVerifyScript(), "_force"));
     this->WriteBuild(os, phonyBuild);
 
     reBuild.Variables["restat"] = "1";
@@ -1817,7 +1816,7 @@ void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os)
   // Write rule
   {
     cmNinjaRule rule("CLEAN");
-    rule.Command = NinjaCmd() + " $FILE_ARG -t clean $TARGETS";
+    rule.Command = cmStrCat(NinjaCmd(), " $FILE_ARG -t clean $TARGETS");
     rule.Description = "Cleaning all built files...";
     rule.Comment = "Rule for cleaning all built files.";
     WriteRule(*this->RulesFileStream, rule);
@@ -1931,7 +1930,7 @@ void cmGlobalNinjaGenerator::WriteTargetHelp(std::ostream& os)
 {
   {
     cmNinjaRule rule("HELP");
-    rule.Command = NinjaCmd() + " -t targets";
+    rule.Command = cmStrCat(NinjaCmd(), " -t targets");
     rule.Description = "All primary targets available:";
     rule.Comment = "Rule for printing all primary targets available.";
     WriteRule(*this->RulesFileStream, rule);
@@ -1958,7 +1957,7 @@ std::string cmGlobalNinjaGenerator::NinjaOutputPath(
   if (!this->HasOutputPathPrefix() || cmSystemTools::FileIsFullPath(path)) {
     return path;
   }
-  return this->OutputPathPrefix + path;
+  return cmStrCat(this->OutputPathPrefix, path);
 }
 
 void cmGlobalNinjaGenerator::StripNinjaOutputPathPrefixAsSuffix(
@@ -2086,7 +2085,8 @@ int cmcmd_cmake_ninja_depends(std::vector<std::string>::const_iterator argBeg,
     } else if (cmHasLiteralPrefix(arg, "--lang=")) {
       arg_lang = arg.substr(7);
     } else {
-      cmSystemTools::Error("-E cmake_ninja_depends unknown argument: " + arg);
+      cmSystemTools::Error(
+        cmStrCat("-E cmake_ninja_depends unknown argument: ", arg));
       return 1;
     }
   }
@@ -2157,7 +2157,8 @@ int cmcmd_cmake_ninja_depends(std::vector<std::string>::const_iterator argBeg,
   cmGeneratedFileStream ddif(arg_ddi);
   ddif << ddi;
   if (!ddif) {
-    cmSystemTools::Error("-E cmake_ninja_depends failed to write " + arg_ddi);
+    cmSystemTools::Error(
+      cmStrCat("-E cmake_ninja_depends failed to write ", arg_ddi));
     return 1;
   }
   return 0;
@@ -2203,7 +2204,8 @@ std::unique_ptr<cmSourceInfo> cmcmd_cmake_ninja_depends_fortran(
   std::set<std::string> defines;
   cmFortranParser parser(fc, includes, defines, finfo);
   if (!cmFortranParser_FilePush(&parser, arg_pp.c_str())) {
-    cmSystemTools::Error("-E cmake_ninja_depends failed to open " + arg_pp);
+    cmSystemTools::Error(
+      cmStrCat("-E cmake_ninja_depends failed to open ", arg_pp));
     return nullptr;
   }
   if (cmFortran_yyparse(parser.Scanner) != 0) {
@@ -2306,7 +2308,7 @@ bool cmGlobalNinjaGenerator::WriteDyndepFile(
   Json::Value tm = Json::objectValue;
   for (cmDyndepObjectInfo const& object : objects) {
     for (std::string const& p : object.Provides) {
-      std::string const mod = module_dir + p;
+      std::string const mod = cmStrCat(module_dir, p);
       mod_files[p] = mod;
       tm[p] = mod;
     }
@@ -2342,8 +2344,8 @@ bool cmGlobalNinjaGenerator::WriteDyndepFile(
 
   // Store the map of modules provided by this target in a file for
   // use by dependents that reference this target in linked-target-dirs.
-  std::string const target_mods_file =
-    cmSystemTools::GetFilenamePath(arg_dd) + "/" + arg_lang + "Modules.json";
+  std::string const target_mods_file = cmStrCat(
+    cmSystemTools::GetFilenamePath(arg_dd), '/', arg_lang, "Modules.json");
   cmGeneratedFileStream tmf(target_mods_file);
   tmf << tm;
 
@@ -2376,7 +2378,8 @@ int cmcmd_cmake_ninja_dyndep(std::vector<std::string>::const_iterator argBeg,
                cmHasLiteralSuffix(arg, ".ddi")) {
       arg_ddis.push_back(arg);
     } else {
-      cmSystemTools::Error("-E cmake_ninja_dyndep unknown argument: " + arg);
+      cmSystemTools::Error(
+        cmStrCat("-E cmake_ninja_dyndep unknown argument: ", arg));
       return 1;
     }
   }
@@ -2412,7 +2415,7 @@ int cmcmd_cmake_ninja_dyndep(std::vector<std::string>::const_iterator argBeg,
   std::string const dir_top_src = tdi["dir-top-src"].asString();
   std::string module_dir = tdi["module-dir"].asString();
   if (!module_dir.empty() && !cmHasLiteralSuffix(module_dir, "/")) {
-    module_dir += "/";
+    module_dir += '/';
   }
   std::vector<std::string> linked_target_dirs;
   Json::Value const& tdi_linked_target_dirs = tdi["linked-target-dirs"];
@@ -2440,9 +2443,7 @@ void cmGlobalNinjaGenerator::AppendDirectoryForConfig(
   const std::string& suffix, std::string& dir)
 {
   if (!config.empty() && this->IsMultiConfig()) {
-    dir += prefix;
-    dir += config;
-    dir += suffix;
+    dir += cmStrCat(prefix, config, suffix);
   }
 }
 
diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx
index 0e74678..3803621 100644
--- a/Source/cmNinjaTargetGenerator.cxx
+++ b/Source/cmNinjaTargetGenerator.cxx
@@ -94,17 +94,19 @@ cmGlobalNinjaGenerator* cmNinjaTargetGenerator::GetGlobalGenerator() const
 std::string cmNinjaTargetGenerator::LanguageCompilerRule(
   const std::string& lang, const std::string& config) const
 {
-  return lang + "_COMPILER__" +
-    cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName()) +
-    "_" + config;
+  return cmStrCat(
+    lang, "_COMPILER__",
+    cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName()),
+    '_', config);
 }
 
 std::string cmNinjaTargetGenerator::LanguagePreprocessRule(
   std::string const& lang, const std::string& config) const
 {
-  return lang + "_PREPROCESS__" +
-    cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName()) +
-    "_" + config;
+  return cmStrCat(
+    lang, "_PREPROCESS__",
+    cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName()),
+    '_', config);
 }
 
 bool cmNinjaTargetGenerator::NeedExplicitPreprocessing(
@@ -129,9 +131,10 @@ bool cmNinjaTargetGenerator::CompilePreprocessedSourceWithDefines(
 std::string cmNinjaTargetGenerator::LanguageDyndepRule(
   const std::string& lang, const std::string& config) const
 {
-  return lang + "_DYNDEP__" +
-    cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName()) +
-    "_" + config;
+  return cmStrCat(
+    lang, "_DYNDEP__",
+    cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName()),
+    '_', config);
 }
 
 bool cmNinjaTargetGenerator::NeedDyndep(std::string const& lang) const
@@ -219,8 +222,8 @@ void cmNinjaTargetGenerator::AddIncludeFlags(std::string& languageFlags,
 
 bool cmNinjaTargetGenerator::NeedDepTypeMSVC(const std::string& lang) const
 {
-  std::string const& deptype =
-    this->GetMakefile()->GetSafeDefinition("CMAKE_NINJA_DEPTYPE_" + lang);
+  std::string const& deptype = this->GetMakefile()->GetSafeDefinition(
+    cmStrCat("CMAKE_NINJA_DEPTYPE_", lang));
   if (deptype == "msvc") {
     return true;
   }
@@ -355,13 +358,12 @@ std::string cmNinjaTargetGenerator::GetObjectFilePath(
 {
   std::string path = this->LocalGenerator->GetHomeRelativeOutputPath();
   if (!path.empty()) {
-    path += "/";
+    path += '/';
   }
   std::string const& objectName = this->GeneratorTarget->GetObjectName(source);
-  path += this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
-  path += this->GetGlobalGenerator()->ConfigDirectory(config);
-  path += "/";
-  path += objectName;
+  path += cmStrCat(
+    this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget),
+    this->GetGlobalGenerator()->ConfigDirectory(config), '/', objectName);
   return path;
 }
 
@@ -389,16 +391,15 @@ std::string cmNinjaTargetGenerator::GetPreprocessedFilePath(
     this->GetGlobalGenerator()->GetLanguageOutputExtension(*source);
   assert(objName.size() >= objExt.size());
   std::string const ppName =
-    objName.substr(0, objName.size() - objExt.size()) + "-pp." + ppExt;
+    cmStrCat(objName.substr(0, objName.size() - objExt.size()), "-pp.", ppExt);
 
   std::string path = this->LocalGenerator->GetHomeRelativeOutputPath();
   if (!path.empty()) {
-    path += "/";
+    path += '/';
   }
-  path += this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
-  path += this->GetGlobalGenerator()->ConfigDirectory(config);
-  path += "/";
-  path += ppName;
+  path +=
+    cmStrCat(this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget),
+             this->GetGlobalGenerator()->ConfigDirectory(config), '/', ppName);
   return path;
 }
 
@@ -407,13 +408,11 @@ std::string cmNinjaTargetGenerator::GetDyndepFilePath(
 {
   std::string path = this->LocalGenerator->GetHomeRelativeOutputPath();
   if (!path.empty()) {
-    path += "/";
+    path += '/';
   }
-  path += this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
-  path += this->GetGlobalGenerator()->ConfigDirectory(config);
-  path += "/";
-  path += lang;
-  path += ".dd";
+  path += cmStrCat(
+    this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget),
+    this->GetGlobalGenerator()->ConfigDirectory(config), '/', lang, ".dd");
   return path;
 }
 
@@ -442,8 +441,7 @@ std::string cmNinjaTargetGenerator::GetTargetFilePath(
   if (path.empty() || path == ".") {
     return name;
   }
-  path += "/";
-  path += name;
+  path += cmStrCat('/', name);
   return path;
 }
 
@@ -522,7 +520,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
   bool const lang_supports_response = lang != "RC";
   if (lang_supports_response && this->ForceResponseFile()) {
     std::string const responseFlagVar =
-      "CMAKE_" + lang + "_RESPONSE_FILE_FLAG";
+      cmStrCat("CMAKE_", lang, "_RESPONSE_FILE_FLAG");
     responseFlag = this->Makefile->GetSafeDefinition(responseFlagVar);
     if (responseFlag.empty() && lang != "CUDA") {
       responseFlag = "@";
@@ -587,7 +585,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
       rule.RspFile = "$RSP_FILE";
       rule.RspContent =
         cmStrCat(' ', ppVars.Defines, ' ', ppVars.Includes, ' ', ppFlags);
-      ppFlags = responseFlag + rule.RspFile;
+      ppFlags = cmStrCat(responseFlag, rule.RspFile);
       ppVars.Defines = "";
       ppVars.Includes = "";
     }
@@ -658,7 +656,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
     rule.RspFile = "$RSP_FILE";
     rule.RspContent =
       cmStrCat(' ', vars.Defines, ' ', vars.Includes, ' ', flags);
-    flags = responseFlag + rule.RspFile;
+    flags = cmStrCat(responseFlag, rule.RspFile);
     vars.Defines = "";
     vars.Includes = "";
   }
@@ -671,7 +669,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
     rule.DepType = "msvc";
     rule.DepFile.clear();
     flags += " /showIncludes";
-  } else if (mf->IsOn("CMAKE_NINJA_CMCLDEPS_" + lang)) {
+  } else if (mf->IsOn(cmStrCat("CMAKE_NINJA_CMCLDEPS_", lang))) {
     // For the MS resource compiler we need cmcldeps, but skip dependencies
     // for source-file try_compile cases because they are always fresh.
     if (!mf->GetIsSourceFileTryCompile()) {
@@ -688,14 +686,14 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
   } else {
     rule.DepType = "gcc";
     rule.DepFile = "$DEP_FILE";
-    const std::string flagsName = "CMAKE_DEPFILE_FLAGS_" + lang;
+    const std::string flagsName = cmStrCat("CMAKE_DEPFILE_FLAGS_", lang);
     std::string depfileFlags = mf->GetSafeDefinition(flagsName);
     if (!depfileFlags.empty()) {
       cmSystemTools::ReplaceString(depfileFlags, "<DEPFILE>", "$DEP_FILE");
       cmSystemTools::ReplaceString(depfileFlags, "<OBJECT>", "$out");
       cmSystemTools::ReplaceString(depfileFlags, "<CMAKE_C_COMPILER>",
                                    mf->GetDefinition("CMAKE_C_COMPILER"));
-      flags += " " + depfileFlags;
+      flags += cmStrCat(' ', depfileFlags);
     }
   }
 
@@ -718,7 +716,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
     const std::string& compileCmd = mf->GetRequiredDefinition(cmdVar);
     cmExpandList(compileCmd, compileCmds);
   } else {
-    const std::string cmdVar = "CMAKE_" + lang + "_COMPILE_OBJECT";
+    const std::string cmdVar = cmStrCat("CMAKE_", lang, "_COMPILE_OBJECT");
     const std::string& compileCmd = mf->GetRequiredDefinition(cmdVar);
     cmExpandList(compileCmd, compileCmds);
   }
@@ -728,7 +726,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
   if (!compileCmds.empty() &&
       (lang == "C" || lang == "CXX" || lang == "Fortran" || lang == "CUDA" ||
        lang == "OBJC" || lang == "OBJCXX")) {
-    std::string const clauncher_prop = lang + "_COMPILER_LAUNCHER";
+    std::string const clauncher_prop = cmStrCat(lang, "_COMPILER_LAUNCHER");
     const char* clauncher = this->GeneratorTarget->GetProperty(clauncher_prop);
     if (clauncher && *clauncher) {
       compilerLauncher = clauncher;
@@ -737,13 +735,13 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
 
   // Maybe insert an include-what-you-use runner.
   if (!compileCmds.empty() && (lang == "C" || lang == "CXX")) {
-    std::string const iwyu_prop = lang + "_INCLUDE_WHAT_YOU_USE";
+    std::string const iwyu_prop = cmStrCat(lang, "_INCLUDE_WHAT_YOU_USE");
     const char* iwyu = this->GeneratorTarget->GetProperty(iwyu_prop);
-    std::string const tidy_prop = lang + "_CLANG_TIDY";
+    std::string const tidy_prop = cmStrCat(lang, "_CLANG_TIDY");
     const char* tidy = this->GeneratorTarget->GetProperty(tidy_prop);
-    std::string const cpplint_prop = lang + "_CPPLINT";
+    std::string const cpplint_prop = cmStrCat(lang, "_CPPLINT");
     const char* cpplint = this->GeneratorTarget->GetProperty(cpplint_prop);
-    std::string const cppcheck_prop = lang + "_CPPCHECK";
+    std::string const cppcheck_prop = cmStrCat(lang, "_CPPCHECK");
     const char* cppcheck = this->GeneratorTarget->GetProperty(cppcheck_prop);
     if ((iwyu && *iwyu) || (tidy && *tidy) || (cpplint && *cpplint) ||
         (cppcheck && *cppcheck)) {
@@ -751,18 +749,19 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
       if (!compilerLauncher.empty()) {
         // In __run_co_compile case the launcher command is supplied
         // via --launcher=<maybe-list> and consumed
-        run_iwyu += " --launcher=";
-        run_iwyu += this->LocalGenerator->EscapeForShell(compilerLauncher);
+        run_iwyu +=
+          cmStrCat(" --launcher=",
+                   this->LocalGenerator->EscapeForShell(compilerLauncher));
         compilerLauncher.clear();
       }
       if (iwyu && *iwyu) {
-        run_iwyu += " --iwyu=";
-        run_iwyu += this->GetLocalGenerator()->EscapeForShell(iwyu);
+        run_iwyu += cmStrCat(" --iwyu=",
+                             this->GetLocalGenerator()->EscapeForShell(iwyu));
       }
       if (tidy && *tidy) {
         run_iwyu += " --tidy=";
         const char* driverMode = this->Makefile->GetDefinition(
-          "CMAKE_" + lang + "_CLANG_TIDY_DRIVER_MODE");
+          cmStrCat("CMAKE_", lang, "_CLANG_TIDY_DRIVER_MODE"));
         if (!(driverMode && *driverMode)) {
           driverMode = lang == "C" ? "gcc" : "g++";
         }
@@ -770,12 +769,12 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
           cmStrCat(tidy, ";--extra-arg-before=--driver-mode=", driverMode));
       }
       if (cpplint && *cpplint) {
-        run_iwyu += " --cpplint=";
-        run_iwyu += this->GetLocalGenerator()->EscapeForShell(cpplint);
+        run_iwyu += cmStrCat(
+          " --cpplint=", this->GetLocalGenerator()->EscapeForShell(cpplint));
       }
       if (cppcheck && *cppcheck) {
-        run_iwyu += " --cppcheck=";
-        run_iwyu += this->GetLocalGenerator()->EscapeForShell(cppcheck);
+        run_iwyu += cmStrCat(
+          " --cppcheck=", this->GetLocalGenerator()->EscapeForShell(cppcheck));
       }
       if ((tidy && *tidy) || (cpplint && *cpplint) ||
           (cppcheck && *cppcheck)) {
@@ -797,7 +796,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
         i = this->LocalGenerator->EscapeForShell(i);
       }
     }
-    compileCmds.front().insert(0, cmJoin(args, " ") + " ");
+    compileCmds.front().insert(0, cmStrCat(cmJoin(args, " "), ' '));
   }
 
   if (!compileCmds.empty()) {
@@ -872,7 +871,8 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements(
 
   {
     cmNinjaBuild build("phony");
-    build.Comment = "Order-only phony target for " + this->GetTargetName();
+    build.Comment =
+      cmStrCat("Order-only phony target for ", this->GetTargetName());
     build.Outputs.push_back(this->OrderDependsTargetForTarget(config));
 
     cmNinjaDeps& orderOnlyDeps = build.OrderOnlyDeps;
@@ -952,16 +952,16 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements(
   this->GetImplFileStream(fileConfig) << "\n";
 
   if (!this->Configs[config].SwiftOutputMap.empty()) {
-    std::string const mapFilePath =
-      this->GeneratorTarget->GetSupportDirectory() + "/output-file-map.json";
+    std::string const mapFilePath = cmStrCat(
+      this->GeneratorTarget->GetSupportDirectory(), "/output-file-map.json");
     std::string const targetSwiftDepsPath = [this, config]() -> std::string {
       cmGeneratorTarget const* target = this->GeneratorTarget;
       if (const char* name = target->GetProperty("Swift_DEPENDENCIES_FILE")) {
         return name;
       }
-      return this->ConvertToNinjaPath(target->GetSupportDirectory() + "/" +
-                                      config + "/" + target->GetName() +
-                                      ".swiftdeps");
+      return this->ConvertToNinjaPath(
+        cmStrCat(target->GetSupportDirectory(), '/', config, '/',
+                 target->GetName(), ".swiftdeps"));
     }();
 
     // build the global target dependencies
@@ -993,7 +993,7 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
   std::string cmakeVarLang = cmStrCat("CMAKE_", language);
 
   // build response file name
-  std::string cmakeLinkVar = cmakeVarLang + "_RESPONSE_FILE_FLAG";
+  std::string cmakeLinkVar = cmStrCat(cmakeVarLang, "_RESPONSE_FILE_FLAG");
 
   const char* flag = GetMakefile()->GetDefinition(cmakeLinkVar);
 
@@ -1018,14 +1018,15 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
     if (!replaceExt) {
       // use original code
       vars["DEP_FILE"] = this->GetLocalGenerator()->ConvertToOutputFormat(
-        objectFileName + ".d", cmOutputConverter::SHELL);
+        cmStrCat(objectFileName, ".d"), cmOutputConverter::SHELL);
     } else {
       // Replace the original source file extension with the
       // depend file extension.
-      std::string dependFileName =
-        cmSystemTools::GetFilenameWithoutLastExtension(objectFileName) + ".d";
+      std::string dependFileName = cmStrCat(
+        cmSystemTools::GetFilenameWithoutLastExtension(objectFileName), ".d");
       vars["DEP_FILE"] = this->GetLocalGenerator()->ConvertToOutputFormat(
-        objectFileDir + "/" + dependFileName, cmOutputConverter::SHELL);
+        cmStrCat(objectFileDir, '/', dependFileName),
+        cmOutputConverter::SHELL);
     }
   }
 
@@ -1100,7 +1101,7 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
       this->ConvertToNinjaPath(this->GetPreprocessedFilePath(source, config));
     ppBuild.Outputs.push_back(ppFileName);
 
-    ppBuild.RspFile = ppFileName + ".rsp";
+    ppBuild.RspFile = cmStrCat(ppFileName, ".rsp");
 
     bool const compilePP = this->UsePreprocessedSource(language);
     bool const compilePPWithDefines =
@@ -1129,7 +1130,7 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
       // In case compilation requires flags that are incompatible with
       // preprocessing, include them here.
       std::string const& postFlag = this->Makefile->GetSafeDefinition(
-        "CMAKE_" + language + "_POSTPROCESS_FLAG");
+        cmStrCat("CMAKE_", language, "_POSTPROCESS_FLAG"));
       this->LocalGenerator->AppendFlags(vars["FLAGS"], postFlag);
     }
 
@@ -1157,13 +1158,13 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
         sourceDirectory, this->GeneratorTarget, language, false, false,
         config);
 
-      vars["INCLUDES"] = sourceDirectoryFlag + " " + vars["INCLUDES"];
+      vars["INCLUDES"] = cmStrCat(sourceDirectoryFlag, ' ', vars["INCLUDES"]);
     }
 
     // Explicit preprocessing always uses a depfile.
     ppBuild.Variables["DEP_FILE"] =
       this->GetLocalGenerator()->ConvertToOutputFormat(
-        objectFileName + ".pp.d", cmOutputConverter::SHELL);
+        cmStrCat(objectFileName, ".pp.d"), cmOutputConverter::SHELL);
     if (compilePP) {
       // The actual compilation does not need a depfile because it
       // depends on the already-preprocessed source.
@@ -1176,7 +1177,7 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
       ppBuild.Variables["OBJ_FILE"] = objectFileName;
 
       // Tell dependency scanner where to store dyndep intermediate results.
-      std::string const ddiFile = objectFileName + ".ddi";
+      std::string const ddiFile = cmStrCat(objectFileName, ".ddi");
       ppBuild.Variables["DYNDEP_INTERMEDIATE_FILE"] = ddiFile;
       ppBuild.ImplicitOuts.push_back(ddiFile);
       if (firstForConfig) {
@@ -1215,7 +1216,7 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
 
   this->SetMsvcTargetPdbVariable(vars, config);
 
-  objBuild.RspFile = objectFileName + ".rsp";
+  objBuild.RspFile = cmStrCat(objectFileName, ".rsp");
 
   if (language == "Swift") {
     this->EmitSwiftDependencyInfo(source, config);
@@ -1241,8 +1242,8 @@ void cmNinjaTargetGenerator::WriteTargetDependInfo(std::string const& lang,
 {
   Json::Value tdi(Json::objectValue);
   tdi["language"] = lang;
-  tdi["compiler-id"] =
-    this->Makefile->GetSafeDefinition("CMAKE_" + lang + "_COMPILER_ID");
+  tdi["compiler-id"] = this->Makefile->GetSafeDefinition(
+    cmStrCat("CMAKE_", lang, "_COMPILER_ID"));
 
   if (lang == "Fortran") {
     std::string mod_dir = this->GeneratorTarget->GetFortranModuleDirectory(
@@ -1294,13 +1295,13 @@ void cmNinjaTargetGenerator::EmitSwiftDependencyInfo(
     if (const char* name = source->GetProperty("Swift_DEPENDENCIES_FILE")) {
       return name;
     }
-    return objectFilePath + ".swiftdeps";
+    return cmStrCat(objectFilePath, ".swiftdeps");
   }();
   std::string const swiftDiaPath = [source, objectFilePath]() -> std::string {
     if (const char* name = source->GetProperty("Swift_DIAGNOSTICS_FILE")) {
       return name;
     }
-    return objectFilePath + ".dia";
+    return cmStrCat(objectFilePath, ".dia");
   }();
   std::string const makeDepsPath = [this, source, config]() -> std::string {
     cmLocalNinjaGenerator const* local = this->GetLocalGenerator();
@@ -1310,12 +1311,13 @@ void cmNinjaTargetGenerator::EmitSwiftDependencyInfo(
       cmSystemTools::GetFilenamePath(objectFileName);
 
     if (this->Makefile->IsOn("CMAKE_Swift_DEPFLE_EXTNSION_REPLACE")) {
-      std::string dependFileName =
-        cmSystemTools::GetFilenameWithoutLastExtension(objectFileName) + ".d";
-      return local->ConvertToOutputFormat(objectFileDir + "/" + dependFileName,
-                                          cmOutputConverter::SHELL);
+      std::string dependFileName = cmStrCat(
+        cmSystemTools::GetFilenameWithoutLastExtension(objectFileName), ".d");
+      return local->ConvertToOutputFormat(
+        cmStrCat(objectFileDir, '/', dependFileName),
+        cmOutputConverter::SHELL);
     }
-    return local->ConvertToOutputFormat(objectFileName + ".d",
+    return local->ConvertToOutputFormat(cmStrCat(objectFileName, ".d"),
                                         cmOutputConverter::SHELL);
   }();
 
@@ -1380,7 +1382,7 @@ void cmNinjaTargetGenerator::ExportObjectCompileCommand(
       this->GetMakefile()->GetRequiredDefinition(cmdVar);
     cmExpandList(compileCmd, compileCmds);
   } else {
-    const std::string cmdVar = "CMAKE_" + language + "_COMPILE_OBJECT";
+    const std::string cmdVar = cmStrCat("CMAKE_", language, "_COMPILE_OBJECT");
     const std::string& compileCmd =
       this->GetMakefile()->GetRequiredDefinition(cmdVar);
     cmExpandList(compileCmd, compileCmds);