cmStrCat: use character literals where possible

Found and replaced using the `cmstrcat-to-char-literal` rule for
`ast-grep`.

Source/CPack/cmCPackArchiveGenerator.cxx

@@ -55,7 +55,7 @@ private:
         : DeduplicateStatus::Skip;
     }
 
-    this->Files[path] = cmStrCat(localTopLevel, "/", path);
+    this->Files[path] = cmStrCat(localTopLevel, '/', path);
     return DeduplicateStatus::Add;
   }
 

Source/CPack/cmCPackBundleGenerator.cxx

@@ -231,7 +231,7 @@ int cmCPackBundleGenerator::SignBundle(std::string const& src_dir)
     // sign app bundle
     auto temp_codesign_cmd =
       cmStrCat(this->GetOption("CPACK_COMMAND_CODESIGN"), ' ', sign_parameter,
-               " -s \"", cpack_apple_cert_app, "\"");
+               " -s \"", cpack_apple_cert_app, '"');
     if (this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS")) {
       temp_codesign_cmd +=
         cmStrCat(" --entitlements ",

Source/CPack/cmCPackGenerator.cxx

@@ -100,18 +100,18 @@ int cmCPackGenerator::PrepareNames()
   std::string pkgFileName =
     cmStrCat(pkgBaseFileName, this->GetOutputExtension());
   // Determine path to the package.
-  std::string pkgFilePath = cmStrCat(pkgDirectory, "/", pkgFileName);
+  std::string pkgFilePath = cmStrCat(pkgDirectory, '/', pkgFileName);
   // Determine top-level directory for packaging.
   std::string topDirectory = cmStrCat(pkgDirectory, "/_CPack_Packages/");
   {
     cmValue toplevelTag = this->GetOption("CPACK_TOPLEVEL_TAG");
     if (toplevelTag) {
-      topDirectory += cmStrCat(toplevelTag, "/");
+      topDirectory += cmStrCat(toplevelTag, '/');
     }
   }
   topDirectory += *this->GetOption("CPACK_GENERATOR");
   // Determine temporary packaging-directory.
-  std::string tmpDirectory = cmStrCat(topDirectory, "/", pkgBaseFileName);
+  std::string tmpDirectory = cmStrCat(topDirectory, '/', pkgBaseFileName);
   // Determine path to temporary package file.
   std::string tmpPkgFilePath = topDirectory + "/" + pkgFileName;
 
@@ -982,7 +982,7 @@ bool cmCPackGenerator::GenerateChecksumFile(cmCryptoHash& crypto,
                                             cm::string_view filename) const
 {
   std::string packageFileName =
-    cmStrCat(this->GetOption("CPACK_OUTPUT_FILE_PREFIX"), "/", filename);
+    cmStrCat(this->GetOption("CPACK_OUTPUT_FILE_PREFIX"), '/', filename);
   std::string hashFile = cmStrCat(
     packageFileName, "." + cmSystemTools::LowerCase(crypto.GetHashAlgoName()));
   cmsys::ofstream outF(hashFile.c_str());
@@ -1001,7 +1001,7 @@ bool cmCPackGenerator::CopyPackageFile(std::string const& srcFilePath,
                                        cm::string_view filename) const
 {
   std::string destFilePath =
-    cmStrCat(this->GetOption("CPACK_OUTPUT_FILE_PREFIX"), "/", filename);
+    cmStrCat(this->GetOption("CPACK_OUTPUT_FILE_PREFIX"), '/', filename);
   cmCPackLogger(cmCPackLog::LOG_DEBUG,
                 "Copy final package(s): "
                   << (!srcFilePath.empty() ? srcFilePath : "(NULL)") << " to "

Source/CPack/cmCPackNSISGenerator.cxx

@@ -132,11 +132,11 @@ int cmCPackNSISGenerator::PackageFiles()
     std::string installerIconCode;
     if (cmValue v = this->GetOptionIfSet("CPACK_NSIS_MUI_ICON")) {
       std::string iconFile = cmSystemTools::ConvertToWindowsOutputPath(*v);
-      installerIconCode += cmStrCat("!define MUI_ICON ", iconFile, "\n");
+      installerIconCode += cmStrCat("!define MUI_ICON ", iconFile, '\n');
     }
     if (cmValue v = this->GetOptionIfSet("CPACK_NSIS_MUI_UNIICON")) {
       std::string iconFile = cmSystemTools::ConvertToWindowsOutputPath(*v);
-      installerIconCode += cmStrCat("!define MUI_UNICON ", iconFile, "\n");
+      installerIconCode += cmStrCat("!define MUI_UNICON ", iconFile, '\n');
     }
     this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_ICON_CODE",
                             installerIconCode.c_str());
@@ -151,7 +151,7 @@ int cmCPackNSISGenerator::PackageFiles()
     installerHeaderImage =
       cmSystemTools::ConvertToWindowsOutputPath(installerHeaderImage);
     std::string installerIconCode =
-      cmStrCat("!define MUI_HEADERIMAGE_BITMAP ", installerHeaderImage, "\n");
+      cmStrCat("!define MUI_HEADERIMAGE_BITMAP ", installerHeaderImage, '\n');
     this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_ICON_CODE",
                             installerIconCode);
   }
@@ -160,7 +160,7 @@ int cmCPackNSISGenerator::PackageFiles()
         this->GetOptionIfSet("CPACK_NSIS_MUI_WELCOMEFINISHPAGE_BITMAP")) {
     std::string bitmapFile = cmSystemTools::ConvertToWindowsOutputPath(*v);
     std::string installerBitmapCode =
-      cmStrCat("!define MUI_WELCOMEFINISHPAGE_BITMAP ", bitmapFile, "\n");
+      cmStrCat("!define MUI_WELCOMEFINISHPAGE_BITMAP ", bitmapFile, '\n');
     this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_WELCOMEFINISH_CODE",
                             installerBitmapCode);
   }
@@ -169,7 +169,7 @@ int cmCPackNSISGenerator::PackageFiles()
         this->GetOptionIfSet("CPACK_NSIS_MUI_UNWELCOMEFINISHPAGE_BITMAP")) {
     std::string bitmapFile = cmSystemTools::ConvertToWindowsOutputPath(*v);
     std::string installerBitmapCode =
-      cmStrCat("!define MUI_UNWELCOMEFINISHPAGE_BITMAP ", bitmapFile, "\n");
+      cmStrCat("!define MUI_UNWELCOMEFINISHPAGE_BITMAP ", bitmapFile, '\n');
     this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_UNWELCOMEFINISH_CODE",
                             installerBitmapCode);
   }
@@ -184,7 +184,7 @@ int cmCPackNSISGenerator::PackageFiles()
 
   if (cmValue v = this->GetOptionIfSet("CPACK_NSIS_WELCOME_TITLE")) {
     std::string welcomeTitleCode =
-      cmStrCat("!define MUI_WELCOMEPAGE_TITLE \"", *v, "\"");
+      cmStrCat("!define MUI_WELCOMEPAGE_TITLE \"", *v, '"');
     this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_WELCOME_TITLE_CODE",
                             welcomeTitleCode);
   }
@@ -196,7 +196,7 @@ int cmCPackNSISGenerator::PackageFiles()
 
   if (cmValue v = this->GetOptionIfSet("CPACK_NSIS_FINISH_TITLE")) {
     std::string finishTitleCode =
-      cmStrCat("!define MUI_FINISHPAGE_TITLE \"", *v, "\"");
+      cmStrCat("!define MUI_FINISHPAGE_TITLE \"", *v, '"');
     this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_FINISH_TITLE_CODE",
                             finishTitleCode);
   }
@@ -240,7 +240,7 @@ int cmCPackNSISGenerator::PackageFiles()
     cmValue v = this->GetOption("CPACK_RESOURCE_FILE_LICENSE");
     std::string licenseFile = cmSystemTools::ConvertToWindowsOutputPath(*v);
     std::string licenseCode =
-      cmStrCat("!insertmacro MUI_PAGE_LICENSE ", licenseFile, "\n");
+      cmStrCat("!insertmacro MUI_PAGE_LICENSE ", licenseFile, '\n');
     this->SetOptionIfNotSet("CPACK_NSIS_LICENSE_PAGE", licenseCode);
   }
 
@@ -388,7 +388,7 @@ int cmCPackNSISGenerator::PackageFiles()
     cmStrCat('"', this->GetOption("CPACK_INSTALLER_PROGRAM"), "\" ",
              nsisPreArguments, " \"", nsisFileName, '"');
   if (!nsisPostArguments.empty()) {
-    nsisCmd = cmStrCat(nsisCmd, " ", nsisPostArguments);
+    nsisCmd = cmStrCat(nsisCmd, ' ', nsisPostArguments);
   }
   cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << nsisCmd << std::endl);
   std::string output;

Source/CPack/cmCPackProductBuildGenerator.cxx

@@ -250,10 +250,10 @@ bool cmCPackProductBuildGenerator::GenerateComponentPackage(
          << "\""
             " --install-location \"/\""
          << (identityName.empty() ? std::string{}
-                                  : cmStrCat(" --sign \"", identityName, "\""))
+                                  : cmStrCat(" --sign \"", identityName, '"'))
          << (keychainPath.empty()
                ? std::string{}
-               : cmStrCat(" --keychain \"", keychainPath, "\""))
+               : cmStrCat(" --keychain \"", keychainPath, '"'))
          << " \"" << packageFile << '"';
 
   if (component && !component->Plist.empty()) {

Source/CTest/cmCTestEmptyBinaryDirectoryCommand.cxx

@@ -27,7 +27,7 @@ cmsys::Status TryToRemoveBinaryDirectoryOnce(std::string const& directoryPath)
       continue;
     }
 
-    std::string fullPath = cmStrCat(directoryPath, "/", path);
+    std::string fullPath = cmStrCat(directoryPath, '/', path);
 
     bool isDirectory = cmSystemTools::FileIsDirectory(fullPath) &&
       !cmSystemTools::FileIsSymlink(fullPath);

Source/CTest/cmCTestSubmitHandler.cxx

@@ -219,7 +219,7 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(
       std::string local_file = file;
       bool initialize_cdash_buildid = false;
       if (!cmSystemTools::FileExists(local_file)) {
-        local_file = cmStrCat(localprefix, "/", file);
+        local_file = cmStrCat(localprefix, '/', file);
         // If this file exists within the local Testing directory we assume
         // that it will be associated with the current build in CDash.
         initialize_cdash_buildid = true;

Source/CTest/cmCTestTestHandler.cxx

@@ -617,7 +617,7 @@ void cmCTestTestHandler::LogFailedTests(std::vector<std::string> const& failed,
           testColor = cmCTest::Color::YELLOW;
         }
         std::string ft_name_and_status =
-          cmStrCat(ft.Name, " (", this->GetTestStatus(ft), ")");
+          cmStrCat(ft.Name, " (", this->GetTestStatus(ft), ')');
         std::string labels;
         cmCTestTestProperties const& p = *ft.Properties;
         if (!p.Labels.empty()) {

Source/CTest/cmParseCoberturaCoverage.cxx

@@ -77,7 +77,7 @@ protected:
             // Check if this is a path that is relative to our source or
             // binary directories.
             for (std::string const& filePath : this->FilePaths) {
-              finalpath = cmStrCat(filePath, "/", filename);
+              finalpath = cmStrCat(filePath, '/', filename);
               if (cmSystemTools::FileExists(finalpath)) {
                 this->CurFileName = finalpath;
                 break;
@@ -88,7 +88,7 @@ protected:
           cmsys::ifstream fin(this->CurFileName.c_str());
           if (this->CurFileName.empty() || !fin) {
             this->CurFileName =
-              cmStrCat(this->Coverage.BinaryDir, "/", atts[tagCount + 1]);
+              cmStrCat(this->Coverage.BinaryDir, '/', atts[tagCount + 1]);
             fin.open(this->CurFileName.c_str());
             if (!fin) {
               cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,

Source/cmAddTestCommand.cxx

@@ -152,7 +152,7 @@ bool cmAddTestCommandHandleNameMode(std::vector<std::string> const& args,
       }
       doing = DoingNone;
     } else {
-      status.SetError(cmStrCat(" given unknown argument:\n  ", args[i], "\n"));
+      status.SetError(cmStrCat(" given unknown argument:\n  ", args[i], '\n'));
       return false;
     }
   }

Source/cmBuildCommand.cxx

@@ -60,7 +60,7 @@ bool MainSignature(std::vector<std::string> const& args,
       doing = DoingNone;
       parallel = args[i];
     } else {
-      status.SetError(cmStrCat("unknown argument \"", args[i], "\""));
+      status.SetError(cmStrCat("unknown argument \"", args[i], '"'));
       return false;
     }
   }

Source/cmCMakeLanguageCommand.cxx

@@ -220,7 +220,7 @@ bool cmCMakeLanguageCommandEVAL(std::vector<cmListFileArgument> const& args,
   std::string const code =
     cmJoin(cmMakeRange(expandedArgs.begin() + 2, expandedArgs.end()), " ");
   return makefile.ReadListFileAsString(
-    code, cmStrCat(context.FilePath, ":", context.Line, ":EVAL"));
+    code, cmStrCat(context.FilePath, ':', context.Line, ":EVAL"));
 }
 
 bool cmCMakeLanguageCommandSET_DEPENDENCY_PROVIDER(
@@ -252,7 +252,7 @@ bool cmCMakeLanguageCommandSET_DEPENDENCY_PROVIDER(
 
   if (!unparsed.empty()) {
     return FatalError(
-      status, cmStrCat("Unrecognized keyword: \"", unparsed.front(), "\""));
+      status, cmStrCat("Unrecognized keyword: \"", unparsed.front(), '"'));
   }
 
   // We store the command that FetchContent_MakeAvailable() can call in a
@@ -296,7 +296,7 @@ bool cmCMakeLanguageCommandSET_DEPENDENCY_PROVIDER(
     } else {
       return FatalError(
         status,
-        cmStrCat("Unknown dependency provider method \"", method, "\""));
+        cmStrCat("Unknown dependency provider method \"", method, '"'));
     }
   }
 

Source/cmCMakePathCommand.cxx

@@ -174,7 +174,7 @@ bool HandleGetCommand(std::vector<std::string> const& args,
 
   if (actions.find(action) == actions.end()) {
     status.SetError(
-      cmStrCat("GET called with an unknown action: ", action, "."));
+      cmStrCat("GET called with an unknown action: ", action, '.'));
     return false;
   }
 
@@ -609,7 +609,7 @@ bool HandleConvertCommand(std::vector<std::string> const& args,
 
   if (action != cmakePath && action != nativePath) {
     status.SetError(
-      cmStrCat("CONVERT called with an unknown action: ", action, "."));
+      cmStrCat("CONVERT called with an unknown action: ", action, '.'));
     return false;
   }
 
@@ -679,7 +679,7 @@ bool HandleCompareCommand(std::vector<std::string> const& args,
   auto const op = operators.find(args[2]);
   if (op == operators.end()) {
     status.SetError(cmStrCat(
-      "COMPARE called with an unknown comparison operator: ", args[2], "."));
+      "COMPARE called with an unknown comparison operator: ", args[2], '.'));
     return false;
   }
 

Source/cmCMakePkgConfigCommand.cxx

@@ -508,7 +508,7 @@ cm::optional<cmPkgConfigResult> ReadPackage(std::string const& package,
   cmsys::ifstream ifs(path.string().c_str(), std::ios::binary);
 
   if (!ifs) {
-    warn_or_error(cmStrCat("Could not open file '", path.string(), "'"),
+    warn_or_error(cmStrCat("Could not open file '", path.string(), '\''),
                   imEnv);
     return result;
   }
@@ -518,7 +518,7 @@ cm::optional<cmPkgConfigResult> ReadPackage(std::string const& package,
 
   // Shouldn't have hit eof on previous read, should hit eof now
   if (ifs.fail() || ifs.eof() || ifs.get() != EOF) {
-    warn_or_error(cmStrCat("Error while reading file '", path.string(), "'"),
+    warn_or_error(cmStrCat("Error while reading file '", path.string(), '\''),
                   imEnv);
     return result;
   }
@@ -530,7 +530,7 @@ cm::optional<cmPkgConfigResult> ReadPackage(std::string const& package,
 
   if (imEnv.strictness != StrictnessType::STRICTNESS_BEST_EFFORT &&
       err != PCE_OK) {
-    warn_or_error(cmStrCat("Parsing failed for file '", path.string(), "'"),
+    warn_or_error(cmStrCat("Parsing failed for file '", path.string(), '\''),
                   imEnv);
     return result;
   }
@@ -544,8 +544,8 @@ cm::optional<cmPkgConfigResult> ReadPackage(std::string const& package,
   }
 
   if (!result) {
-    warn_or_error(cmStrCat("Resolution failed for file '", path.string(), "'"),
-                  imEnv);
+    warn_or_error(
+      cmStrCat("Resolution failed for file '", path.string(), '\''), imEnv);
   }
 
   return result;
@@ -559,7 +559,7 @@ cm::optional<cmPkgConfigResult> ImportPackage(
 
   if (!result) {
     if (!imEnv.err) {
-      warn_or_error(cmStrCat("Could not find pkg-config: '", package, "'"),
+      warn_or_error(cmStrCat("Could not find pkg-config: '", package, '\''),
                     imEnv);
     }
     return result;
@@ -575,7 +575,7 @@ cm::optional<cmPkgConfigResult> ImportPackage(
     if (ver != result->Version()) {
       warn_or_error(
         cmStrCat("Package '", package, "' version '", result->Version(),
-                 "' does not meet exact version requirement '", ver, "'"),
+                 "' does not meet exact version requirement '", ver, '\''),
         imEnv);
       return {};
     }
@@ -585,7 +585,7 @@ cm::optional<cmPkgConfigResult> ImportPackage(
     if (!cmPkgConfigResolver::CheckVersion(rv, result->Version())) {
       warn_or_error(
         cmStrCat("Package '", package, "' version '", result->Version(),
-                 "' does not meet version requirement '", *version, "'"),
+                 "' does not meet version requirement '", *version, '\''),
         imEnv);
       return {};
     }
@@ -609,9 +609,9 @@ cm::optional<cmPkgConfigResult> ImportPackage(
 
   if (!result) {
     if (!imEnv.err) {
-      std::string req_str = cmStrCat("'", reqs.begin()->parent, "'");
+      std::string req_str = cmStrCat('\'', reqs.begin()->parent, '\'');
       for (auto it = reqs.begin() + 1; it != reqs.end(); ++it) {
-        req_str = cmStrCat(req_str, ", '", it->parent, "'");
+        req_str = cmStrCat(req_str, ", '", it->parent, '\'');
       }
       warn_or_error(cmStrCat("Could not find pkg-config: '", package,
                              "' required by: ", req_str),
@@ -626,7 +626,7 @@ cm::optional<cmPkgConfigResult> ImportPackage(
     if (!cmPkgConfigResolver::CheckVersion(req.ver, ver)) {
       warn_or_error(cmStrCat("Package '", package, "' version '", ver,
                              "' does not meet version requirement '",
-                             req.ver.string(), "' of '", req.parent, "'"),
+                             req.ver.string(), "' of '", req.parent, '\''),
                     imEnv);
       return {};
     }
@@ -856,7 +856,7 @@ bool CheckPackageDependencies(
       if (!cmPkgConfigResolver::CheckVersion(dep.VerReq, *ver)) {
         warn_or_error(cmStrCat("Package '", dep.Name, "' version '", *ver,
                                "' does not meet version requirement '",
-                               dep.VerReq.string(), "' of '", name, "'"),
+                               dep.VerReq.string(), "' of '", name, '\''),
                       imEnv);
         return false;
       }
@@ -869,7 +869,7 @@ bool CheckPackageDependencies(
       if (!cmPkgConfigResolver::CheckVersion(dep.VerReq, ver)) {
         warn_or_error(cmStrCat("Package '", dep.Name, "' version '", ver,
                                "' does not meet version requirement '",
-                               dep.VerReq.string(), "' of '", name, "'"),
+                               dep.VerReq.string(), "' of '", name, '\''),
                       imEnv);
         return false;
       }
@@ -920,7 +920,7 @@ std::pair<bool, bool> PopulatePCTarget(PopulateArguments& args,
                           provider_str.substr(assignment + 1));
       } else {
         imEnv.status.SetError(cmStrCat(
-          "No '=' found in BIND_PC_REQUIRES argument '", provider_str, "'"));
+          "No '=' found in BIND_PC_REQUIRES argument '", provider_str, '\''));
         cmSystemTools::SetFatalErrorOccurred();
         return { false, false };
       }

Source/cmCMakePolicyCommand.cxx

@@ -56,7 +56,7 @@ bool cmCMakePolicyCommand(std::vector<std::string> const& args,
     return HandleGetWarningMode(args, status);
   }
 
-  status.SetError(cmStrCat("given unknown first argument \"", args[0], "\""));
+  status.SetError(cmStrCat("given unknown first argument \"", args[0], '"'));
   return false;
 }
 
@@ -77,7 +77,7 @@ bool HandleSetMode(std::vector<std::string> const& args,
     policyStatus = cmPolicies::NEW;
   } else {
     status.SetError(
-      cmStrCat("SET given unrecognized policy status \"", args[2], "\""));
+      cmStrCat("SET given unrecognized policy status \"", args[2], '"'));
     return false;
   }
 

Source/cmCMakePresetsErrors.cxx

@@ -40,8 +40,8 @@ std::string getPresetName(cmJSONState* state)
 std::string getVariableName(cmJSONState* state)
 {
   std::string var = state->key_after("cacheVariables");
-  std::string errMsg = cmStrCat("variable \"", var, "\"");
-  errMsg = cmStrCat(errMsg, " for preset \"", getPresetName(state), "\"");
+  std::string errMsg = cmStrCat("variable \"", var, '"');
+  errMsg = cmStrCat(errMsg, " for preset \"", getPresetName(state), '"');
   return errMsg;
 }
 
@@ -82,7 +82,7 @@ void INVALID_PRESET(Json::Value const* value, cmJSONState* state)
 
 void INVALID_PRESET_NAMED(std::string const& presetName, cmJSONState* state)
 {
-  state->AddError(cmStrCat("Invalid preset: \"", presetName, "\""));
+  state->AddError(cmStrCat("Invalid preset: \"", presetName, '"'));
 }
 
 void INVALID_VARIABLE(Json::Value const* value, cmJSONState* state)
@@ -93,7 +93,7 @@ void INVALID_VARIABLE(Json::Value const* value, cmJSONState* state)
 
 void DUPLICATE_PRESETS(std::string const& presetName, cmJSONState* state)
 {
-  state->AddError(cmStrCat("Duplicate preset: \"", presetName, "\""));
+  state->AddError(cmStrCat("Duplicate preset: \"", presetName, '"'));
 }
 
 void CYCLIC_PRESET_INHERITANCE(std::string const& presetName,
@@ -101,7 +101,7 @@ void CYCLIC_PRESET_INHERITANCE(std::string const& presetName,
 
 {
   state->AddError(
-    cmStrCat("Cyclic preset inheritance for preset \"", presetName, "\""));
+    cmStrCat("Cyclic preset inheritance for preset \"", presetName, '"'));
 }
 
 void INHERITED_PRESET_UNREACHABLE_FROM_FILE(std::string const& presetName,
@@ -120,7 +120,7 @@ void CONFIGURE_PRESET_UNREACHABLE_FROM_FILE(std::string const& presetName,
 
 void INVALID_MACRO_EXPANSION(std::string const& presetName, cmJSONState* state)
 {
-  state->AddError(cmStrCat("Invalid macro expansion in \"", presetName, "\""));
+  state->AddError(cmStrCat("Invalid macro expansion in \"", presetName, '"'));
 }
 
 void BUILD_TEST_PRESETS_UNSUPPORTED(Json::Value const*, cmJSONState* state)
@@ -155,7 +155,7 @@ void INVALID_CONFIGURE_PRESET(std::string const& presetName,
                               cmJSONState* state)
 {
   state->AddError(
-    cmStrCat(R"(Invalid "configurePreset": ")", presetName, "\""));
+    cmStrCat(R"(Invalid "configurePreset": ")", presetName, '"'));
 }
 
 void INSTALL_PREFIX_UNSUPPORTED(Json::Value const* value, cmJSONState* state)
@@ -197,13 +197,13 @@ void TEST_OUTPUT_TRUNCATION_UNSUPPORTED(cmJSONState* state)
 void INVALID_WORKFLOW_STEPS(std::string const& workflowStep,
                             cmJSONState* state)
 {
-  state->AddError(cmStrCat("Invalid workflow step \"", workflowStep, "\""));
+  state->AddError(cmStrCat("Invalid workflow step \"", workflowStep, '"'));
 }
 
 void NO_WORKFLOW_STEPS(std::string const& presetName, cmJSONState* state)
 {
   state->AddError(
-    cmStrCat("No workflow steps specified for \"", presetName, "\""));
+    cmStrCat("No workflow steps specified for \"", presetName, '"'));
 }
 
 void FIRST_WORKFLOW_STEP_NOT_CONFIGURE(std::string const& stepName,
@@ -273,7 +273,7 @@ void INVALID_PRESET_NAME(Json::Value const* value, cmJSONState* state)
 void INVALID_CONDITION(Json::Value const* value, cmJSONState* state)
 {
   state->AddErrorAtValue(
-    cmStrCat("Invalid condition for preset \"", getPresetName(state), "\""),
+    cmStrCat("Invalid condition for preset \"", getPresetName(state), '"'),
     value);
 }
 
@@ -282,7 +282,7 @@ JsonErrors::ErrorGenerator INVALID_CONDITION_OBJECT(
 {
   return JsonErrors::INVALID_NAMED_OBJECT(
     [](Json::Value const*, cmJSONState* state) -> std::string {
-      return cmStrCat(" condition for preset \"", getPresetName(state), "\"");
+      return cmStrCat(" condition for preset \"", getPresetName(state), '"');
     })(errorType, extraFields);
 }
 
@@ -316,7 +316,7 @@ void PRESET_MISSING_FIELD(std::string const& presetName,
                           std::string const& missingField, cmJSONState* state)
 {
   state->AddError(cmStrCat("Preset \"", presetName, "\" missing field \"",
-                           missingField, "\""));
+                           missingField, '"'));
 }
 
 void SCHEMA_UNSUPPORTED(cmJSONState* state)

Source/cmComputeLinkInformation.cxx

@@ -2258,7 +2258,7 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
               cmSystemTools::IsSubDirectory(d, topBinaryDir)) {
             d = cmSystemTools::RelativePath(targetOutputDir, d);
             if (!d.empty()) {
-              d = cmStrCat(originToken, "/", d);
+              d = cmStrCat(originToken, '/', d);
             } else {
               d = originToken;
             }

Source/cmCoreTryCompile.cxx

@@ -1293,7 +1293,7 @@ cm::optional<cmTryCompileResult> cmCoreTryCompile::TryCompileCode(
           "to destination specified by COPY_FILE:\n"
           "  '", copyFile, "'\n"
           "because:\n"
-          "  ", err, "\n",
+          "  ", err, '\n',
           this->FindErrorMessage);
         /* clang-format on */
         if (!arguments.CopyFileError) {
@@ -1412,7 +1412,7 @@ void cmCoreTryCompile::FindOutputFile(std::string const& targetName)
   if (!cmSystemTools::FileExists(command)) {
     std::ostringstream emsg;
     emsg << "Unable to find the recorded try_compile output location:\n";
-    emsg << cmStrCat("  ", command, "\n");
+    emsg << cmStrCat("  ", command, '\n');
     this->FindErrorMessage = emsg.str();
     return;
   }
@@ -1423,7 +1423,7 @@ void cmCoreTryCompile::FindOutputFile(std::string const& targetName)
   if (!cmSystemTools::FileExists(outputFileLocation)) {
     std::ostringstream emsg;
     emsg << "Recorded try_compile output location doesn't exist:\n";
-    emsg << cmStrCat("  ", outputFileLocation, "\n");
+    emsg << cmStrCat("  ", outputFileLocation, '\n');
     this->FindErrorMessage = emsg.str();
     return;
   }

Source/cmCxxModuleMapper.cxx

@@ -275,7 +275,7 @@ bool CxxModuleUsage::AddReference(std::string const& logical,
                                   ref.Path, "' via ", method_name(ref.Method),
                                   "; "
                                   "Location B: '",
-                                  loc, "' via ", method_name(method), "."));
+                                  loc, "' via ", method_name(method), '.'));
     return false;
   }
 

Source/cmDefinePropertyCommand.cxx

@@ -89,7 +89,7 @@ bool cmDefinePropertyCommand(std::vector<std::string> const& args,
     if (!cmHasSuffix(initializeFromVariable, PropertyName)) {
       status.SetError(cmStrCat("Variable name \"", initializeFromVariable,
                                "\" does not end with property name \"",
-                               PropertyName, "\""));
+                               PropertyName, '"'));
       return false;
     }
     if (PropertyName.find('_') == std::string::npos) {

Source/cmExportCommand.cxx

@@ -184,7 +184,7 @@ bool cmExportCommand(std::vector<std::string> const& args,
         } else {
           status.SetError(
             cmStrCat("Invalid enable setting for package dependency: \"",
-                     packageDependencyArguments.Enabled, "\""));
+                     packageDependencyArguments.Enabled, '"'));
           return false;
         }
       }

Source/cmExtraCodeBlocksGenerator.cxx

@@ -183,19 +183,19 @@ void Tree::BuildUnitImpl(cmXMLWriter& xml,
 {
   for (std::string const& f : this->files) {
     xml.StartElement("Unit");
-    xml.Attribute("filename", cmStrCat(fsPath, this->path, "/", f));
+    xml.Attribute("filename", cmStrCat(fsPath, this->path, '/', f));
 
     xml.StartElement("Option");
     xml.Attribute(
       "virtualFolder",
-      cmStrCat("CMake Files\\", virtualFolderPath, this->path, "\\"));
+      cmStrCat("CMake Files\\", virtualFolderPath, this->path, '\\'));
     xml.EndElement();
 
     xml.EndElement();
   }
   for (Tree const& folder : this->folders) {
-    folder.BuildUnitImpl(xml, cmStrCat(virtualFolderPath, this->path, "\\"),
-                         cmStrCat(fsPath, this->path, "/"));
+    folder.BuildUnitImpl(xml, cmStrCat(virtualFolderPath, this->path, '\\'),
+                         cmStrCat(fsPath, this->path, '/'));
   }
 }
 

Source/cmExtraCodeLiteGenerator.cxx

@@ -123,7 +123,7 @@ std::vector<std::string> cmExtraCodeLiteGenerator::CreateProjectsByTarget(
       cmStateEnums::TargetType type = lt->GetType();
       std::string const& outputDir = lg->GetCurrentBinaryDirectory();
       std::string targetName = lt->GetName();
-      std::string filename = cmStrCat(outputDir, "/", targetName, ".project");
+      std::string filename = cmStrCat(outputDir, '/', targetName, ".project");
       retval.push_back(targetName);
       // Make the project file relative to the workspace
       std::string relafilename =
@@ -163,7 +163,7 @@ std::vector<std::string> cmExtraCodeLiteGenerator::CreateProjectsByProjectMaps(
     std::string const& outputDir = it.second[0]->GetCurrentBinaryDirectory();
     std::string projectName = it.second[0]->GetProjectName();
     retval.push_back(projectName);
-    std::string filename = cmStrCat(outputDir, "/", projectName, ".project");
+    std::string filename = cmStrCat(outputDir, '/', projectName, ".project");
 
     // Make the project file relative to the workspace
     filename = cmSystemTools::RelativePath(this->WorkspacePath, filename);

Source/cmExtraSublimeTextGenerator.cxx

@@ -270,7 +270,7 @@ void cmExtraSublimeTextGenerator::AppendTarget(
         R"((^|[ ])-[DIOUWfgs][^= ]+(=\"[^"]+\"|=[^"][^ ]+)?)";
       flagRegex.compile(regexString);
       std::string workString =
-        cmStrCat(flagsString, " ", definesString, " ", includesString);
+        cmStrCat(flagsString, ' ', definesString, ' ', includesString);
       while (flagRegex.find(workString)) {
         std::string::size_type start = flagRegex.start();
         if (workString[start] == ' ') {

Source/cmFLTKWrapUICommand.cxx

@@ -78,9 +78,9 @@ bool cmFLTKWrapUICommand(std::vector<std::string> const& args,
     // to generate .cxx and .h files
     if (!curr || !curr->GetPropertyAsBool("WRAP_EXCLUDE")) {
       std::string outName = cmStrCat(
-        outputDirectory, "/", cmSystemTools::GetFilenameWithoutExtension(arg));
+        outputDirectory, '/', cmSystemTools::GetFilenameWithoutExtension(arg));
       std::string hname = cmStrCat(outName, ".h");
-      std::string origname = cmStrCat(cdir, "/", arg);
+      std::string origname = cmStrCat(cdir, '/', arg);
       // add starting depends
       std::vector<std::string> depends;
       depends.push_back(origname);

Source/cmFileAPI.cxx

@@ -142,7 +142,7 @@ void cmFileAPI::RemoveOldReplyFiles()
   std::vector<std::string> files = this->LoadDir(reply_dir);
   for (std::string const& f : files) {
     if (this->ReplyFiles.find(f) == this->ReplyFiles.end()) {
-      std::string file = cmStrCat(reply_dir, "/", f);
+      std::string file = cmStrCat(reply_dir, '/', f);
       cmSystemTools::RemoveFile(file);
     }
   }
@@ -207,7 +207,7 @@ std::string cmFileAPI::WriteJsonFile(
 
   // Compute the final name for the file.
   std::string suffix = computeSuffix(tmpFile);
-  std::string suffixWithExtension = cmStrCat("-", suffix, ".json");
+  std::string suffixWithExtension = cmStrCat('-', suffix, ".json");
   fileName = cmStrCat(prefix, suffixWithExtension);
 
   // Truncate the file name length
@@ -225,7 +225,7 @@ std::string cmFileAPI::WriteJsonFile(
     suffix = cmCryptoHash(cmCryptoHash::AlgoSHA256)
                .HashString(toBeRemoved)
                .substr(0, newHashLength);
-    suffixWithExtension = cmStrCat("-", suffix, ".json");
+    suffixWithExtension = cmStrCat('-', suffix, ".json");
     fileName.replace(startPos, overLength, suffixWithExtension);
   }
 

Source/cmFileAPICommand.cxx

@@ -51,7 +51,7 @@ std::string processObjectKindVersions(cmFileAPI& fileApi,
     }
     if (majorVersion < 1 || minorVersion < 0) {
       return cmStrCat("Given a malformed version \"", ver, "\" for ", keyword,
-                      ".");
+                      '.');
     }
     if (fileApi.AddProjectQuery(objectKind,
                                 static_cast<unsigned>(majorVersion),

Source/cmFileAPIToolchains.cxx

@@ -122,7 +122,7 @@ void Toolchains::DumpToolchainVariable(cmMakefile const* mf,
                                        ToolchainVariable const& variable)
 {
   std::string const variableName =
-    cmStrCat("CMAKE_", lang, "_", variable.VariableSuffix);
+    cmStrCat("CMAKE_", lang, '_', variable.VariableSuffix);
 
   if (variable.IsList) {
     cmValue data = mf->GetDefinition(variableName);

Source/cmFileCommand.cxx

@@ -447,7 +447,7 @@ bool HandleStringsCommand(std::vector<std::string> const& args,
       arg_mode = arg_none;
     } else {
       status.SetError(
-        cmStrCat("STRINGS given unknown argument \"", args[i], "\""));
+        cmStrCat("STRINGS given unknown argument \"", args[i], '"'));
       return false;
     }
   }

Source/cmFileCopier.cxx

@@ -498,7 +498,7 @@ bool cmFileCopier::InstallSymlinkChain(std::string& fromFile,
   while (cmSystemTools::ReadSymlink(fromFile, newFromFile)) {
     if (!cmSystemTools::FileIsFullPath(newFromFile)) {
       std::string fromFilePath = cmSystemTools::GetFilenamePath(fromFile);
-      newFromFile = cmStrCat(fromFilePath, "/", newFromFile);
+      newFromFile = cmStrCat(fromFilePath, '/', newFromFile);
     }
 
     std::string symlinkTarget = cmSystemTools::GetFilenameName(newFromFile);
@@ -530,7 +530,7 @@ bool cmFileCopier::InstallSymlinkChain(std::string& fromFile,
     }
 
     fromFile = newFromFile;
-    toFile = cmStrCat(toFilePath, "/", symlinkTarget);
+    toFile = cmStrCat(toFilePath, '/', symlinkTarget);
   }
 
   return true;

Source/cmFindBase.cxx

@@ -679,7 +679,7 @@ void cmFindBaseDebugState::WriteDebug() const
       "\n    Only Search AppBundle: ", this->FindBaseCommand->SearchAppBundleOnly,
       "\n    Search AppBundle Last: ", this->FindBaseCommand->SearchAppBundleLast,
       "\n    Search AppBundle First: ", this->FindBaseCommand->SearchAppBundleFirst,
-      "\n"
+      '\n'
     );
   // clang-format on
 
@@ -693,7 +693,7 @@ void cmFindBaseDebugState::WriteDebug() const
       "\n  CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: ", !this->FindCommand->NoSystemEnvironmentPath,
       "\n  CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: ", !this->FindCommand->NoCMakeSystemPath,
       "\n  CMAKE_FIND_USE_INSTALL_PREFIX: ", !this->FindCommand->NoCMakeInstallPath,
-      "\n"
+      '\n'
      );
     // clang-format on
   }

Source/cmFindLibraryCommand.cxx

@@ -93,7 +93,7 @@ void cmFindLibraryCommand::AddArchitecturePaths(char const* suffix)
       std::string msg = cmStrCat(
         "find_library(", this->VariableName, ") removed original suffix ", o,
         " from PATH_SUFFIXES while adding architecture paths for suffix '",
-        suffix, "'");
+        suffix, '\'');
       this->DebugMessage(msg);
     }
   }
@@ -160,7 +160,7 @@ void cmFindLibraryCommand::AddArchitecturePath(
       if (this->DebugModeEnabled()) {
         std::string msg = cmStrCat(
           "find_library(", this->VariableName, ") added replacement path ",
-          dirX, " to PATH_SUFFIXES for architecture suffix '", suffix, "'");
+          dirX, " to PATH_SUFFIXES for architecture suffix '", suffix, '\'');
         this->DebugMessage(msg);
       }
       this->SearchPaths.push_back(std::move(dirX));
@@ -171,7 +171,7 @@ void cmFindLibraryCommand::AddArchitecturePath(
       if (this->DebugModeEnabled()) {
         std::string msg = cmStrCat(
           "find_library(", this->VariableName, ") added replacement path ",
-          dir, " to PATH_SUFFIXES for architecture suffix '", suffix, "'");
+          dir, " to PATH_SUFFIXES for architecture suffix '", suffix, '\'');
         this->DebugMessage(msg);
       }
     }

Source/cmFindPackageCommand.cxx

@@ -880,7 +880,7 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args)
       this->VersionComplete = args[i];
     } else {
       this->SetError(
-        cmStrCat("called with invalid argument \"", args[i], "\""));
+        cmStrCat("called with invalid argument \"", args[i], '"'));
       return false;
     }
   }

Source/cmGeneratorTarget.cxx

@@ -461,7 +461,7 @@ cmValue cmGeneratorTarget::GetFilePrefixInternal(
   if (!targetPrefix) {
     char const* prefixVar = this->Target->GetPrefixVariableInternal(artifact);
     if (!language.empty() && cmNonempty(prefixVar)) {
-      std::string langPrefix = cmStrCat(prefixVar, "_", language);
+      std::string langPrefix = cmStrCat(prefixVar, '_', language);
       targetPrefix = this->Makefile->GetDefinition(langPrefix);
     }
 
@@ -512,7 +512,7 @@ cmValue cmGeneratorTarget::GetFileSuffixInternal(
   if (!targetSuffix) {
     char const* suffixVar = this->Target->GetSuffixVariableInternal(artifact);
     if (!language.empty() && cmNonempty(suffixVar)) {
-      std::string langSuffix = cmStrCat(suffixVar, "_", language);
+      std::string langSuffix = cmStrCat(suffixVar, '_', language);
       targetSuffix = this->Makefile->GetDefinition(langSuffix);
     }
 
@@ -605,7 +605,7 @@ void cmGeneratorTarget::AddSystemIncludeDirectory(std::string const& inc,
       cmSystemTools::ReplaceString(inc_with_config, "$<CONFIG>", config);
       config_upper = cmSystemTools::UpperCase(config);
     }
-    auto const& key = cmStrCat(config_upper, "/", lang);
+    auto const& key = cmStrCat(config_upper, '/', lang);
     this->Target->AddSystemIncludeDirectories({ inc_with_config });
     if (this->SystemIncludesCache.find(key) ==
         this->SystemIncludesCache.end()) {
@@ -2854,11 +2854,11 @@ std::string cmGeneratorTarget::GetPchHeader(std::string const& config,
     filename = generatorTarget->GetSupportDirectory();
 
     if (this->GetGlobalGenerator()->IsMultiConfig()) {
-      filename = cmStrCat(filename, "/", config);
+      filename = cmStrCat(filename, '/', config);
     }
 
     filename =
-      cmStrCat(filename, "/cmake_pch", arch.empty() ? "" : cmStrCat("_", arch),
+      cmStrCat(filename, "/cmake_pch", arch.empty() ? "" : cmStrCat('_', arch),
                languageToExtension.at(language));
 
     std::string const filename_tmp = cmStrCat(filename, ".tmp");
@@ -2955,14 +2955,14 @@ std::string cmGeneratorTarget::GetPchSource(std::string const& config,
         { "OBJCXX", ".objcxx.hxx.mm" }
       };
 
-      filename = cmStrCat(filename, arch.empty() ? "" : cmStrCat("_", arch),
+      filename = cmStrCat(filename, arch.empty() ? "" : cmStrCat('_', arch),
                           languageToExtension.at(language));
     } else {
       std::map<std::string, std::string> const languageToExtension = {
         { "C", ".c" }, { "CXX", ".cxx" }, { "OBJC", ".m" }, { "OBJCXX", ".mm" }
       };
 
-      filename = cmStrCat(filename, arch.empty() ? "" : cmStrCat("_", arch),
+      filename = cmStrCat(filename, arch.empty() ? "" : cmStrCat('_', arch),
                           languageToExtension.at(language));
     }
 
@@ -3073,7 +3073,7 @@ std::string cmGeneratorTarget::GetPchCreateCompileOptions(
       std::string instantiateOption =
         this->Makefile->GetSafeDefinition(varName);
       if (!instantiateOption.empty()) {
-        createOptionList = cmStrCat(createOptionList, ";", instantiateOption);
+        createOptionList = cmStrCat(createOptionList, ';', instantiateOption);
       }
     }
 
@@ -3081,7 +3081,7 @@ std::string cmGeneratorTarget::GetPchCreateCompileOptions(
       cmStrCat("CMAKE_", language, "_COMPILE_OPTIONS_CREATE_PCH");
 
     createOptionList = cmStrCat(
-      createOptionList, ";", this->Makefile->GetSafeDefinition(createOptVar));
+      createOptionList, ';', this->Makefile->GetSafeDefinition(createOptVar));
 
     std::string const pchHeader = this->GetPchHeader(config, language, arch);
     std::string const pchFile = this->GetPchFile(config, language, arch);
@@ -3113,7 +3113,7 @@ std::string cmGeneratorTarget::GetPchUseCompileOptions(
       this->GetSafeProperty(useOptVar);
 
     useOptionList = cmStrCat(
-      useOptionList, ";",
+      useOptionList, ';',
       useOptionListProperty.empty()
         ? this->Makefile->GetSafeDefinition(cmStrCat("CMAKE_", useOptVar))
         : useOptionListProperty);
@@ -5489,7 +5489,7 @@ bool cmGeneratorTarget::AddHeaderSetVerification()
           }
 
           if (fileCgesContextSensitive) {
-            filename = cmStrCat("$<$<CONFIG:", config, ">:", filename, ">");
+            filename = cmStrCat("$<$<CONFIG:", config, ">:", filename, '>');
           }
           verifyTarget->AddSource(filename);
         }

Source/cmGhsMultiTargetGenerator.cxx

@@ -756,7 +756,7 @@ std::string cmGhsMultiTargetGenerator::WriteObjectLangOverride(
   std::string ret;
   cmValue rawLangProp = sourceFile->GetProperty("LANGUAGE");
   if (rawLangProp) {
-    ret = cmStrCat(" [", *rawLangProp, "]");
+    ret = cmStrCat(" [", *rawLangProp, ']');
   }
 
   return ret;

Source/cmGlobalGhsMultiGenerator.cxx

@@ -380,7 +380,7 @@ void cmGlobalGhsMultiGenerator::WriteTargets(cmLocalGenerator* root)
 
     // create target build file
     std::string name = cmStrCat(target->GetName(), ".tgt", FILE_EXTENSION);
-    std::string fname = cmStrCat(rootBinaryDir, "/", name);
+    std::string fname = cmStrCat(rootBinaryDir, '/', name);
     cmGeneratedFileStream fbld(fname);
     fbld.SetCopyIfDifferent(true);
     this->WriteFileHeader(fbld);

Source/cmGlobalNinjaGenerator.cxx

@@ -1799,7 +1799,7 @@ void cmGlobalNinjaGenerator::WriteBuiltinTargets(std::ostream& os)
     build.Outputs.emplace_back(this->GetInstallParallelTargetName());
     for (auto const& mf : this->Makefiles) {
       build.ExplicitDeps.emplace_back(
-        this->ConvertToNinjaPath(cmStrCat(mf->GetCurrentBinaryDirectory(), "/",
+        this->ConvertToNinjaPath(cmStrCat(mf->GetCurrentBinaryDirectory(), '/',
                                           this->GetInstallLocalTargetName())));
     }
     WriteBuild(os, build);
@@ -2098,7 +2098,7 @@ void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os)
         build.Variables["TARGETS"] = cmStrCat(
           this->BuildAlias(
             this->NinjaOutputPath(GetByproductsForCleanTargetName()), config),
-          " ", this->NinjaOutputPath(GetByproductsForCleanTargetName()));
+          ' ', this->NinjaOutputPath(GetByproductsForCleanTargetName()));
       }
       build.ExplicitDeps.clear();
       if (additionalFiles) {
@@ -2217,8 +2217,8 @@ void cmGlobalNinjaGenerator::WriteTargetInstrument(std::ostream& os)
   {
     cmNinjaRule rule("START_INSTRUMENT");
     rule.Command = cmStrCat(
-      "\"", cmSystemTools::GetCTestCommand(), "\" --start-instrumentation \"",
-      this->GetCMakeInstance()->GetHomeOutputDirectory(), "\"");
+      '"', cmSystemTools::GetCTestCommand(), "\" --start-instrumentation \"",
+      this->GetCMakeInstance()->GetHomeOutputDirectory(), '"');
     /*
      * On Unix systems, Ninja will prefix the command with `/bin/sh -c`.
      * Use exec so that Ninja is the parent process of the command.

Source/cmGlobalXCodeGenerator.cxx

@@ -2553,7 +2553,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
           this->CurrentLocalGenerator->IssueMessage(
             MessageType::AUTHOR_WARNING,
             cmStrCat("Unknown Swift_COMPILATION_MODE on target '",
-                     gtgt->GetName(), "'"));
+                     gtgt->GetName(), '\''));
           break;
       }
     }
@@ -3182,7 +3182,7 @@ cmXCodeObject* cmGlobalXCodeGenerator::CreateUtilityTarget(
 
   cmXCodeObject* target = this->CreateObject(
     cmXCodeObject::PBXAggregateTarget,
-    cmStrCat("PBXAggregateTarget:", gtgt->GetName(), ":", targetBinaryPath));
+    cmStrCat("PBXAggregateTarget:", gtgt->GetName(), ':', targetBinaryPath));
   target->SetComment(gtgt->GetName());
   cmXCodeObject* buildPhases = this->CreateObject(cmXCodeObject::OBJECT_LIST);
   std::vector<cmXCodeObject*> emptyContentVector;
@@ -3412,7 +3412,7 @@ cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeTarget(
 
   cmXCodeObject* target = this->CreateObject(
     cmXCodeObject::PBXNativeTarget,
-    cmStrCat("PBXNativeTarget:", gtgt->GetName(), ":", targetBinaryPath));
+    cmStrCat("PBXNativeTarget:", gtgt->GetName(), ':', targetBinaryPath));
 
   target->AddAttribute("buildPhases", buildPhases);
   cmXCodeObject* buildRules = this->CreateObject(cmXCodeObject::OBJECT_LIST);

Source/cmIncludeCommand.cxx

@@ -96,7 +96,7 @@ bool cmIncludeCommand(std::vector<std::string> const& args,
             status.GetMakefile().IssueMessage(
               MessageType::AUTHOR_WARNING,
               cmStrCat(cmPolicies::GetPolicyWarning(ModulePolicy->second),
-                       "\n"));
+                       '\n'));
             CM_FALLTHROUGH;
           }
           case cmPolicies::OLD:

Source/cmInstallCommand.cxx

@@ -999,7 +999,7 @@ bool HandleTargetsMode(std::vector<std::string> const& args,
           if (!target.HasKnownObjectFileLocation(&reason)) {
             status.SetError(
               cmStrCat("TARGETS given OBJECT library \"", target.GetName(),
-                       "\" whose objects may not be installed", reason, "."));
+                       "\" whose objects may not be installed", reason, '.'));
             return false;
           }
 

Source/cmInstallDirectoryGenerator.cxx

@@ -85,7 +85,7 @@ void cmInstallDirectoryGenerator::GenerateScriptForConfig(
   cmMakefile const& mf = *this->LocalGenerator->GetMakefile();
   for (std::string& d : dirs) {
     if (!cmSystemTools::FileIsFullPath(d)) {
-      d = cmStrCat(mf.GetCurrentSourceDirectory(), "/", d);
+      d = cmStrCat(mf.GetCurrentSourceDirectory(), '/', d);
     }
   }
 

Source/cmInstallScriptHandler.cxx

@@ -165,7 +165,7 @@ int cmInstallScriptHandler::Install(unsigned int j,
         cmStrCat("install_manifest_", md5.HashString(this->component), ".txt");
     }
   }
-  cmGeneratedFileStream fout(cmStrCat(this->binaryDir, "/", install_manifest));
+  cmGeneratedFileStream fout(cmStrCat(this->binaryDir, '/', install_manifest));
   fout.SetCopyIfDifferent(true);
   for (auto const& dir : this->directories) {
     auto local_manifest = cmStrCat(dir, "/install_local_manifest.txt");

Source/cmInstallTargetGenerator.cxx

@@ -425,7 +425,7 @@ void cmInstallTargetGenerator::GetInstallObjectNames(
 {
   this->Target->GetTargetObjectNames(config, objects);
   for (std::string& o : objects) {
-    o = cmStrCat(computeInstallObjectDir(this->Target, config), "/", o);
+    o = cmStrCat(computeInstallObjectDir(this->Target, config), '/', o);
   }
 }
 

Source/cmInstrumentation.cxx

@@ -229,7 +229,7 @@ int cmInstrumentation::CollectTimingData(cmInstrumentationQuery::Hook hook)
   std::string const& directory = cmStrCat(this->timingDirv1, "/data");
   std::string const& file_name =
     cmStrCat("index-", ComputeSuffixTime(), ".json");
-  std::string index_path = cmStrCat(directory, "/", file_name);
+  std::string index_path = cmStrCat(directory, '/', file_name);
   cmSystemTools::Touch(index_path, true);
 
   // Gather Snippets
@@ -287,7 +287,7 @@ int cmInstrumentation::CollectTimingData(cmInstrumentationQuery::Hook hook)
 
   // Execute callbacks
   for (auto& cb : this->callbacks) {
-    cmSystemTools::RunSingleCommand(cmStrCat(cb, " \"", index_path, "\""),
+    cmSystemTools::RunSingleCommand(cmStrCat(cb, " \"", index_path, '"'),
                                     nullptr, nullptr, nullptr, nullptr,
                                     cmSystemTools::OUTPUT_PASSTHROUGH);
   }
@@ -299,7 +299,7 @@ int cmInstrumentation::CollectTimingData(cmInstrumentationQuery::Hook hook)
 
   // Delete files
   for (auto const& f : index["snippets"]) {
-    cmSystemTools::RemoveFile(cmStrCat(directory, "/", f.asString()));
+    cmSystemTools::RemoveFile(cmStrCat(directory, '/', f.asString()));
   }
   cmSystemTools::RemoveFile(index_path);
 
@@ -386,9 +386,9 @@ void cmInstrumentation::WriteInstrumentationJson(Json::Value& root,
   wbuilder["indentation"] = "\t";
   std::unique_ptr<Json::StreamWriter> JsonWriter =
     std::unique_ptr<Json::StreamWriter>(wbuilder.newStreamWriter());
-  std::string const& directory = cmStrCat(this->timingDirv1, "/", subdir);
+  std::string const& directory = cmStrCat(this->timingDirv1, '/', subdir);
   cmSystemTools::MakeDirectory(directory);
-  cmsys::ofstream ftmp(cmStrCat(directory, "/", file_name).c_str());
+  cmsys::ofstream ftmp(cmStrCat(directory, '/', file_name).c_str());
   JsonWriter->write(root, &ftmp);
   ftmp << "\n";
   ftmp.close();
@@ -531,7 +531,7 @@ int cmInstrumentation::InstrumentCommand(
         for (auto const& output : root["outputs"]) {
           root["outputSizes"].append(
             static_cast<Json::Value::UInt64>(cmSystemTools::FileLength(
-              cmStrCat(this->binaryDir, "/", output.asCString()))));
+              cmStrCat(this->binaryDir, '/', output.asCString()))));
         }
       }
     }
@@ -542,7 +542,7 @@ int cmInstrumentation::InstrumentCommand(
   // Write Json
   cmsys::SystemInformation info;
   std::string const& file_name = cmStrCat(
-    command_type, "-",
+    command_type, '-',
     this->ComputeSuffixHash(cmStrCat(command_str, info.GetProcessId())),
     this->ComputeSuffixTime(), ".json");
   this->WriteInstrumentationJson(root, "data", file_name);

Source/cmInstrumentationCommand.cxx

@@ -30,7 +30,7 @@ bool validateVersion(std::string const& key, std::string const& versionString,
                      int& version, cmExecutionStatus& status)
 {
   if (!std::all_of(versionString.begin(), versionString.end(), isCharDigit)) {
-    status.SetError(cmStrCat("given a non-integer ", key, "."));
+    status.SetError(cmStrCat("given a non-integer ", key, '.'));
     return false;
   }
   version = std::atoi(versionString.c_str());
@@ -118,7 +118,7 @@ bool cmInstrumentationCommand(std::vector<std::string> const& args,
     cmInstrumentationQuery::Query query;
     if (!queryParser(arg, query)) {
       status.SetError(
-        cmStrCat("given invalid argument to QUERIES \"", arg, "\""));
+        cmStrCat("given invalid argument to QUERIES \"", arg, '"'));
       return false;
     }
     queries.insert(query);
@@ -131,7 +131,7 @@ bool cmInstrumentationCommand(std::vector<std::string> const& args,
     cmInstrumentationQuery::Hook hook;
     if (!hookParser(arg, hook)) {
       status.SetError(
-        cmStrCat("given invalid argument to HOOKS \"", arg, "\""));
+        cmStrCat("given invalid argument to HOOKS \"", arg, '"'));
       return false;
     }
     hooks.insert(hook);

Source/cmInstrumentationQuery.cxx

@@ -60,7 +60,7 @@ static std::function<bool(E&, Json::Value const*, cmJSONState*)> EnumHelper(
       }
     }
     state->AddErrorAtValue(
-      cmStrCat("Not a valid ", type, ": \"", value->asString(), "\""), value);
+      cmStrCat("Not a valid ", type, ": \"", value->asString(), '"'), value);
     return false;
   };
 }

Source/cmJSONHelpers.cxx

@@ -20,7 +20,7 @@ ErrorGenerator EXPECTED_TYPE(std::string const& type)
       state->AddErrorAtValue(cmStrCat("Expected ", type), value);
       return;
     }
-    std::string errMsg = cmStrCat("\"", state->key(), "\" expected ", type);
+    std::string errMsg = cmStrCat('"', state->key(), "\" expected ", type);
     if (value && value->isConvertibleTo(Json::ValueType::stringValue)) {
       errMsg = cmStrCat(errMsg, ", got: ", value->asString());
     }
@@ -114,7 +114,7 @@ ErrorGenerator INVALID_NAMED_OBJECT_KEY(
         if (it->first.rfind("$vector_item_", 0) == 0) {
           continue;
         }
-        return cmStrCat("\"", it->first, "\"");
+        return cmStrCat('"', it->first, '"');
       }
       return "root";
     })(errorType, extraFields);

Source/cmJSONState.cxx

@@ -95,9 +95,9 @@ std::string cmJSONState::GetErrorMessage(bool showContext)
     if (!filenameName.empty() && loc.line > 0) {
       message = cmStrCat(message, filenameName, ':', loc.line, ": ");
     }
-    message = cmStrCat(message, error.GetErrorMessage(), "\n");
+    message = cmStrCat(message, error.GetErrorMessage(), '\n');
     if (showContext && loc.line > 0) {
-      message = cmStrCat(message, GetJsonContext(loc), "\n");
+      message = cmStrCat(message, GetJsonContext(loc), '\n');
     }
   }
   message.pop_back();

Source/cmLinkLineComputer.cxx

@@ -145,10 +145,10 @@ void cmLinkLineComputer::ComputeLinkPath(
         }
 
         linkPathNoBT +=
-          cmStrCat(" ", libPathFlag,
+          cmStrCat(' ', libPathFlag,
                    this->ConvertToOutputForExisting(
                      item.Target->GetDirectory(cli.GetConfig(), type)),
-                   libPathTerminator, " ");
+                   libPathTerminator, ' ');
       }
     }
 
@@ -158,9 +158,9 @@ void cmLinkLineComputer::ComputeLinkPath(
   }
 
   for (BT<std::string> libDir : cli.GetDirectoriesWithBacktraces()) {
-    libDir.Value = cmStrCat(" ", libPathFlag,
+    libDir.Value = cmStrCat(' ', libPathFlag,
                             this->ConvertToOutputForExisting(libDir.Value),
-                            libPathTerminator, " ");
+                            libPathTerminator, ' ');
     linkPath.emplace_back(libDir);
   }
 

Source/cmList.cxx

@@ -359,7 +359,7 @@ public:
       throw transform_error(
         cmStrCat("sub-command TRANSFORM, selector FOR "
                  "expects <start> to be no greater than <stop> (",
-                 this->Start, " > ", this->Stop, ")"));
+                 this->Start, " > ", this->Stop, ')'));
     }
 
     // compute indexes
@@ -534,7 +534,7 @@ public:
     }
     if (!this->ReplaceHelper->IsReplaceExpressionValid()) {
       throw transform_error(cmStrCat("sub-command TRANSFORM, action REPLACE: ",
-                                     this->ReplaceHelper->GetError(), "."));
+                                     this->ReplaceHelper->GetError(), '.'));
     }
   }
   void Initialize(TransformSelector* selector,
@@ -552,7 +552,7 @@ public:
       if (!this->ReplaceHelper->Replace(s, output)) {
         throw transform_error(
           cmStrCat("sub-command TRANSFORM, action REPLACE: ",
-                   this->ReplaceHelper->GetError(), "."));
+                   this->ReplaceHelper->GetError(), '.'));
       }
 
       return output;
@@ -855,7 +855,7 @@ cmList::size_type cmList::ComputeIndex(index_type pos, bool boundCheck) const
       if (index < 0 || length <= static_cast<size_type>(index)) {
         throw std::out_of_range(cmStrCat("index: ", pos, " out of range (-",
                                          this->Values.size(), ", ",
-                                         this->Values.size() - 1, ")"));
+                                         this->Values.size() - 1, ')'));
       }
     }
     return index;
@@ -881,7 +881,7 @@ cmList::size_type cmList::ComputeInsertIndex(index_type pos,
       if (index < 0 || length < static_cast<size_type>(index)) {
         throw std::out_of_range(cmStrCat("index: ", pos, " out of range (-",
                                          this->Values.size(), ", ",
-                                         this->Values.size(), ")"));
+                                         this->Values.size(), ')'));
       }
     }
     return index;

Source/cmLocalGenerator.cxx

@@ -1742,7 +1742,7 @@ std::vector<BT<std::string>> cmLocalGenerator::GetTargetCompileFlags(
           this->IssueMessage(
             MessageType::AUTHOR_WARNING,
             cmStrCat("Unknown Swift_COMPILATION_MODE on target '",
-                     target->GetName(), "'"));
+                     target->GetName(), '\''));
         }
       }
       this->AppendFlags(compileFlags, swiftCompileModeFlag);
@@ -2776,7 +2776,7 @@ void cmLocalGenerator::AddPchDependencies(cmGeneratorTarget* target)
 
           target->Target->AppendProperty(
             cmStrCat(lang, "_COMPILE_OPTIONS_USE_PCH"),
-            cmStrCat("$<$<CONFIG:", config, ">:", useMultiArchPch, ">"));
+            cmStrCat("$<$<CONFIG:", config, ">:", useMultiArchPch, '>'));
         }
       }
 
@@ -2825,7 +2825,7 @@ void cmLocalGenerator::AddPchDependencies(cmGeneratorTarget* target)
             if (!ReuseFrom) {
               pch_sf->AppendProperty(
                 "OBJECT_OUTPUTS",
-                cmStrCat("$<$<CONFIG:", config, ">:", pchFile, ">"));
+                cmStrCat("$<$<CONFIG:", config, ">:", pchFile, '>'));
             } else {
               auto* reuseTarget =
                 this->GlobalGenerator->FindGeneratorTarget(*ReuseFrom);
@@ -2894,7 +2894,7 @@ void cmLocalGenerator::AddPchDependencies(cmGeneratorTarget* target)
                 }
                 target->Target->AppendProperty(
                   cmStrCat(linkerProperty, configUpper),
-                  cmStrCat(" ",
+                  cmStrCat(' ',
                            this->ConvertToOutputFormat(pchSourceObj, SHELL)),
                   cm::nullopt, true);
               } else if (reuseTarget->GetType() ==
@@ -2935,10 +2935,10 @@ void cmLocalGenerator::CopyPchCompilePdb(
   cmGeneratorTarget* reuseTarget, std::vector<std::string> const& extensions)
 {
   std::string const pdb_prefix =
-    this->GetGlobalGenerator()->IsMultiConfig() ? cmStrCat(config, "/") : "";
+    this->GetGlobalGenerator()->IsMultiConfig() ? cmStrCat(config, '/') : "";
 
   std::string const target_compile_pdb_dir =
-    cmStrCat(target->GetLocalGenerator()->GetCurrentBinaryDirectory(), "/",
+    cmStrCat(target->GetLocalGenerator()->GetCurrentBinaryDirectory(), '/',
              target->GetName(), ".dir/");
 
   std::string const copy_script = cmStrCat(
@@ -2954,10 +2954,10 @@ void cmLocalGenerator::CopyPchCompilePdb(
   for (auto const& extension : extensions) {
     std::string const from_file =
       cmStrCat(reuseTarget->GetLocalGenerator()->GetCurrentBinaryDirectory(),
-               "/", ReuseFrom, ".dir/${PDB_PREFIX}", ReuseFrom, extension);
+               '/', ReuseFrom, ".dir/${PDB_PREFIX}", ReuseFrom, extension);
 
     std::string const to_dir =
-      cmStrCat(target->GetLocalGenerator()->GetCurrentBinaryDirectory(), "/",
+      cmStrCat(target->GetLocalGenerator()->GetCurrentBinaryDirectory(), '/',
                target->GetName(), ".dir/${PDB_PREFIX}");
 
     std::string const to_file = cmStrCat(to_dir, ReuseFrom, extension);
@@ -2996,7 +2996,7 @@ void cmLocalGenerator::CopyPchCompilePdb(
 
   auto configGenex = [&](cm::string_view expr) -> std::string {
     if (this->GetGlobalGenerator()->IsMultiConfig()) {
-      return cmStrCat("$<$<CONFIG:", config, ">:", expr, ">");
+      return cmStrCat("$<$<CONFIG:", config, ">:", expr, '>');
     }
     return std::string(expr);
   };
@@ -3122,7 +3122,7 @@ cmLocalGenerator::UnitySource cmLocalGenerator::WriteUnitySource(
       cm::string_view sep;
       for (size_t ci : ubs.Configs) {
         cond = cmStrCat(*cond, sep, "defined(CMAKE_UNITY_CONFIG_",
-                        cmSystemTools::UpperCase(configs[ci]), ")");
+                        cmSystemTools::UpperCase(configs[ci]), ')');
         sep = " || "_s;
       }
     }
@@ -4781,7 +4781,7 @@ std::vector<std::string> ComputeISPCExtraObjects(
 
   for (auto const& ispcTarget : ispcSuffixes) {
     computedObjects.emplace_back(
-      cmStrCat(normalizedDir, "/", objNameNoExt, "_", ispcTarget, extension));
+      cmStrCat(normalizedDir, '/', objNameNoExt, '_', ispcTarget, extension));
   }
 
   return computedObjects;

Source/cmLocalNinjaGenerator.cxx

@@ -920,7 +920,7 @@ std::string cmLocalNinjaGenerator::MakeCustomLauncher(
                           : outputs[i],
                         cmOutputConverter::SHELL));
     if (i != outputs.size() - 1) {
-      output = cmStrCat(output, ",");
+      output = cmStrCat(output, ',');
     }
   }
   vars.Output = output.c_str();

Source/cmLocalUnixMakefileGenerator3.cxx

@@ -1046,7 +1046,7 @@ void cmLocalUnixMakefileGenerator3::AppendCustomCommand(
                                 : outputs[i],
                               cmOutputConverter::SHELL));
           if (i != outputs.size() - 1) {
-            output = cmStrCat(output, ",");
+            output = cmStrCat(output, ',');
           }
         }
         vars.Output = output.c_str();
@@ -1107,7 +1107,7 @@ void cmLocalUnixMakefileGenerator3::AppendCustomCommand(
   // Prefix the commands with the jobserver prefix "+"
   if (ccg.GetCC().GetJobserverAware() && gg->IsGNUMakeJobServerAware()) {
     std::transform(commands1.begin(), commands1.end(), commands1.begin(),
-                   [](std::string const& cmd) { return cmStrCat("+", cmd); });
+                   [](std::string const& cmd) { return cmStrCat('+', cmd); });
   }
 
   // push back the custom commands

Source/cmMakefileTargetGenerator.cxx

@@ -753,7 +753,7 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
 
   // Add language-specific flags.
   std::string const langFlags =
-    cmStrCat("$(", lang, "_FLAGS", filterArch, ")");
+    cmStrCat("$(", lang, "_FLAGS", filterArch, ')');
   this->LocalGenerator->AppendFlags(flags, langFlags);
 
   cmGeneratorExpressionInterpreter genexInterpreter(
@@ -1008,7 +1008,7 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
             "CUDA_SEPARABLE_COMPILATION")) {
         std::string const& rdcFlag =
           this->Makefile->GetRequiredDefinition("_CMAKE_CUDA_RDC_FLAG");
-        cudaCompileMode = cmStrCat(cudaCompileMode, rdcFlag, " ");
+        cudaCompileMode = cmStrCat(cudaCompileMode, rdcFlag, ' ');
       }
 
       static std::array<cm::string_view, 4> const compileModes{

Source/cmNinjaNormalTargetGenerator.cxx

@@ -204,24 +204,24 @@ std::string cmNinjaNormalTargetGenerator::LanguageLinkerRule(
   std::string const& config) const
 {
   return cmStrCat(
-    this->TargetLinkLanguage(config), "_",
+    this->TargetLinkLanguage(config), '_',
     cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()),
     "_LINKER__",
     cmGlobalNinjaGenerator::EncodeRuleName(
       this->GetGeneratorTarget()->GetName()),
-    "_", config);
+    '_', config);
 }
 
 std::string cmNinjaNormalTargetGenerator::LanguageLinkerDeviceRule(
   std::string const& config) const
 {
   return cmStrCat(
-    this->TargetLinkLanguage(config), "_",
+    this->TargetLinkLanguage(config), '_',
     cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()),
     "_DEVICE_LINKER__",
     cmGlobalNinjaGenerator::EncodeRuleName(
       this->GetGeneratorTarget()->GetName()),
-    "_", config);
+    '_', config);
 }
 
 std::string cmNinjaNormalTargetGenerator::LanguageLinkerCudaDeviceRule(
@@ -845,7 +845,7 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkStatement(
 
   std::string targetOutputDir =
     cmStrCat(this->GetLocalGenerator()->GetTargetDirectory(genTarget),
-             globalGen->ConfigDirectory(config), "/");
+             globalGen->ConfigDirectory(config), '/');
   targetOutputDir = globalGen->ExpandCFGIntDir(targetOutputDir, config);
 
   std::string targetOutputReal =
@@ -981,7 +981,7 @@ void cmNinjaNormalTargetGenerator::WriteNvidiaDeviceLinkStatement(
   if (config != fileConfig) {
     std::string targetOutputFileConfigDir =
       cmStrCat(this->GetLocalGenerator()->GetTargetDirectory(genTarget),
-               globalGen->ConfigDirectory(fileConfig), "/");
+               globalGen->ConfigDirectory(fileConfig), '/');
     targetOutputFileConfigDir =
       globalGen->ExpandCFGIntDir(outputDir, fileConfig);
     if (outputDir == targetOutputFileConfigDir) {

Source/cmNinjaTargetGenerator.cxx

@@ -930,7 +930,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(std::string const& lang,
           "CUDA_SEPARABLE_COMPILATION")) {
       std::string const& rdcFlag =
         this->Makefile->GetRequiredDefinition("_CMAKE_CUDA_RDC_FLAG");
-      cudaCompileMode = cmStrCat(cudaCompileMode, rdcFlag, " ");
+      cudaCompileMode = cmStrCat(cudaCompileMode, rdcFlag, ' ');
     }
     static std::array<cm::string_view, 4> const compileModes{
       { "PTX"_s, "CUBIN"_s, "FATBIN"_s, "OPTIX"_s }
@@ -2303,7 +2303,7 @@ void cmNinjaTargetGenerator::ExportObjectCompileCommand(
           "CUDA_SEPARABLE_COMPILATION")) {
       std::string const& rdcFlag =
         this->Makefile->GetRequiredDefinition("_CMAKE_CUDA_RDC_FLAG");
-      cudaCompileMode = cmStrCat(cudaCompileMode, rdcFlag, " ");
+      cudaCompileMode = cmStrCat(cudaCompileMode, rdcFlag, ' ');
     }
     static std::array<cm::string_view, 4> const compileModes{
       { "PTX"_s, "CUBIN"_s, "FATBIN"_s, "OPTIX"_s }

Source/cmNinjaUtilityTargetGenerator.cxx

@@ -68,7 +68,7 @@ void cmNinjaUtilityTargetGenerator::WriteUtilBuildStatements(
     configDir = gg->ConfigDirectory(fileConfig);
   }
   std::string utilCommandName =
-    cmStrCat(lg->GetCurrentBinaryDirectory(), "/CMakeFiles", configDir, "/",
+    cmStrCat(lg->GetCurrentBinaryDirectory(), "/CMakeFiles", configDir, '/',
              this->GetTargetName(), ".util");
   utilCommandName = this->ConvertToNinjaPath(utilCommandName);
 

Source/cmPkgConfigResolver.cxx

@@ -64,17 +64,17 @@ std::string cmPkgConfigVersionReq::string() const
     case ANY:
       return "";
     case LT:
-      return cmStrCat("<", Version);
+      return cmStrCat('<', Version);
     case LT_EQ:
       return cmStrCat("<=", Version);
     case EQ:
-      return cmStrCat("=", Version);
+      return cmStrCat('=', Version);
     case NEQ:
       return cmStrCat("!=", Version);
     case GT_EQ:
       return cmStrCat(">=", Version);
     case GT:
-      return cmStrCat(">", Version);
+      return cmStrCat('>', Version);
   }
   return "";
 }

Source/cmQtAutoGenInitializer.cxx

@@ -1536,7 +1536,7 @@ bool cmQtAutoGenInitializer::InitAutogenTarget()
           cmStrCat(this->Dir.Build, "/deps_");
         std::string const timestampFileName =
           timestampFileWithoutConfig + configView;
-        outputFile = cmStrCat(this->Dir.Build, "/", timestampFileName);
+        outputFile = cmStrCat(this->Dir.Build, '/', timestampFileName);
         auto const depFileWithConfig =
           cmStrCat(depFileWithoutConfig, configView);
         depFile = depFileWithConfig;
@@ -1549,18 +1549,18 @@ bool cmQtAutoGenInitializer::InitAutogenTarget()
           auto tempDepFile = depFileWithoutConfig + config;
           outputFileWithConfig.Config[config] = tempTimestampFileName;
           this->AutogenTarget.DepFileRuleName.Config[config] =
-            cmStrCat(this->Dir.RelativeBuild, "/", tempTimestampFileName);
+            cmStrCat(this->Dir.RelativeBuild, '/', tempTimestampFileName);
           this->AutogenTarget.DepFile.Config[config] = tempDepFile;
         }
         this->AddGeneratedSource(outputFileWithConfig, this->Moc);
       } else {
         cm::string_view const timestampFileName = "timestamp";
-        outputFile = cmStrCat(this->Dir.Build, "/", timestampFileName);
+        outputFile = cmStrCat(this->Dir.Build, '/', timestampFileName);
         this->AutogenTarget.DepFile.Default =
           cmStrCat(this->Dir.Build, "/deps");
         depFile = this->AutogenTarget.DepFile.Default;
         this->AutogenTarget.DepFileRuleName.Default =
-          cmStrCat(this->Dir.RelativeBuild, "/", timestampFileName);
+          cmStrCat(this->Dir.RelativeBuild, '/', timestampFileName);
         commandLines.push_back(cmMakeCommandLine(
           { cmSystemTools::GetCMakeCommand(), "-E", "touch", outputFile }));
         this->AddGeneratedSource(outputFile, this->Moc);
@@ -1736,7 +1736,7 @@ bool cmQtAutoGenInitializer::InitRccTargets()
             auto resourceFilesWithConfig = cmStrCat(
               "$<$<CONFIG:", config,
               ">:", cmList{ qrc.Resources.Config.at(config) }.to_string(),
-              ">");
+              '>');
             ccDepends.emplace_back(std::move(resourceFilesWithConfig));
           }
         } else {

Source/cmQtAutoRcc.cxx

@@ -144,7 +144,7 @@ bool cmQtAutoRccT::InitFromInfo(InfoT const& info)
   this->QrcFileDir_ = cmSystemTools::GetFilenamePath(this->QrcFile_);
   if (IsMultiConfig() && !this->IsXcode() && this->UseBetterGraph_) {
     this->RccFilePublic_ =
-      cmStrCat(this->AutogenBuildDir_, '/', this->RccPathChecksum_, "_",
+      cmStrCat(this->AutogenBuildDir_, '/', this->RccPathChecksum_, '_',
                this->InfoConfig(), '/', this->RccFileName_);
   } else {
     this->RccFilePublic_ =

Source/cmRST.cxx

@@ -348,7 +348,7 @@ void cmRST::OutputMarkupLines(bool inlineMarkup)
 {
   for (auto line : this->MarkupLines) {
     if (!line.empty()) {
-      line = cmStrCat(" ", line);
+      line = cmStrCat(' ', line);
     }
     this->OutputLine(line, inlineMarkup);
   }

Source/cmRulePlaceholderExpander.cxx

@@ -36,7 +36,7 @@ std::string cmRulePlaceholderExpander::ExpandVariable(
         // Add launcher as part of expansion so that it always appears
         // immediately before the command itself, regardless of whether the
         // overall rule template contains other content at the front.
-        result = cmStrCat(this->ReplaceValues->Launcher, " ", result);
+        result = cmStrCat(this->ReplaceValues->Launcher, ' ', result);
       }
       return result;
     }
@@ -317,7 +317,7 @@ std::string cmRulePlaceholderExpander::ExpandVariable(
       // Add launcher as part of expansion so that it always appears
       // immediately before the command itself, regardless of whether the
       // overall rule template contains other content at the front.
-      ret = cmStrCat(this->ReplaceValues->Launcher, " ", ret);
+      ret = cmStrCat(this->ReplaceValues->Launcher, ' ', ret);
     }
 
     // if there are required arguments to the compiler add it

Source/cmSetPropertyCommand.cxx

@@ -799,7 +799,7 @@ bool HandleCacheMode(cmExecutionStatus& status,
   } else if (propertyName == "TYPE") {
     if (!cmState::IsCacheEntryType(propertyValue)) {
       status.SetError(
-        cmStrCat("given invalid CACHE entry TYPE \"", propertyValue, "\""));
+        cmStrCat("given invalid CACHE entry TYPE \"", propertyValue, '"'));
       return false;
     }
   } else if (propertyName != "HELPSTRING" && propertyName != "STRINGS" &&

Source/cmStringCommand.cxx

@@ -171,7 +171,7 @@ bool HandleConfigureCommand(std::vector<std::string> const& args,
     } else if (args[i] == "ESCAPE_QUOTES") {
       escapeQuotes = true;
     } else {
-      status.SetError(cmStrCat("Unrecognized argument \"", args[i], "\""));
+      status.SetError(cmStrCat("Unrecognized argument \"", args[i], '"'));
       return false;
     }
   }

Source/cmSystemTools.cxx

@@ -1076,7 +1076,7 @@ std::string cmSystemTools::FileExistsInParentDirectories(
   cmSystemTools::ConvertToUnixSlashes(dir);
   std::string prevDir;
   while (dir != prevDir) {
-    std::string path = cmStrCat(dir, "/", file);
+    std::string path = cmStrCat(dir, '/', file);
     if (cmSystemTools::FileExists(path)) {
       return path;
     }

Source/cmTarget.cxx

@@ -729,8 +729,7 @@ bool FileSetType::WriteProperties(cmTarget* tgt, cmTargetInternals* impl,
     } else {
       impl->AddDirectoryToFileSet(
         tgt, fileSetName, value, this->TypeName,
-        cmStrCat(this->ArbitraryDescription, " \"", fileSetName, "\""),
-        action);
+        cmStrCat(this->ArbitraryDescription, " \"", fileSetName, '"'), action);
     }
     return true;
   }
@@ -743,8 +742,7 @@ bool FileSetType::WriteProperties(cmTarget* tgt, cmTargetInternals* impl,
     } else {
       impl->AddPathToFileSet(
         tgt, fileSetName, value, this->TypeName,
-        cmStrCat(this->ArbitraryDescription, " \"", fileSetName, "\""),
-        action);
+        cmStrCat(this->ArbitraryDescription, " \"", fileSetName, '"'), action);
     }
     return true;
   }
@@ -2140,7 +2138,7 @@ void cmTarget::SetProperty(std::string const& prop, cmValue value)
       this->impl->Properties.SetProperty(prop, value);
     } else {
       auto e = cmStrCat(prop, " property is not supported by ", compiler,
-                        "  compiler version ", compilerVersion, ".");
+                        "  compiler version ", compilerVersion, '.');
       this->impl->Makefile->IssueMessage(MessageType::FATAL_ERROR, e);
       return;
     }
@@ -3094,11 +3092,11 @@ std::string cmTarget::ImportedGetFullPath(
         }
 
         if (!config.empty()) {
-          configuration = cmStrCat(" configuration \"", config, "\"");
+          configuration = cmStrCat(" configuration \"", config, '"');
         }
 
         return cmStrCat(unset, " not set for imported target \"",
-                        this->GetName(), "\"", configuration, ".");
+                        this->GetName(), '"', configuration, '.');
       };
 
       switch (this->GetPolicyStatus(cmPolicies::CMP0111)) {

Source/cmTargetSourcesCommand.cxx

@@ -213,7 +213,7 @@ bool TargetSourcesImpl::HandleOneFileSet(
 
   if (!unparsed.empty()) {
     this->SetError(
-      cmStrCat("Unrecognized keyword: \"", unparsed.front(), "\""));
+      cmStrCat("Unrecognized keyword: \"", unparsed.front(), '"'));
     return false;
   }
 
@@ -289,7 +289,7 @@ bool TargetSourcesImpl::HandleOneFileSet(
     if (!args.Type.empty() && args.Type != type) {
       this->SetError(cmStrCat(
         "Type \"", args.Type, "\" for file set \"", fileSet.first->GetName(),
-        "\" does not match original type \"", type, "\""));
+        "\" does not match original type \"", type, '"'));
       return false;
     }
 
@@ -317,7 +317,7 @@ bool TargetSourcesImpl::HandleOneFileSet(
     if (type == "HEADERS"_s) {
       for (auto const& dir : cmList{ baseDirectories }) {
         auto interfaceDirectoriesGenex =
-          cmStrCat("$<BUILD_INTERFACE:", dir, ">");
+          cmStrCat("$<BUILD_INTERFACE:", dir, '>');
         if (cmFileSetVisibilityIsForSelf(visibility)) {
           this->Target->AppendProperty("INCLUDE_DIRECTORIES",
                                        interfaceDirectoriesGenex,

Source/cmTryRunCommand.cxx

@@ -176,7 +176,7 @@ bool TryRunCommandImpl::TryRunCode(std::vector<std::string> const& argv)
     } else {
       std::string runArgs;
       if (arguments.RunArgs) {
-        runArgs = cmStrCat(" ", cmJoin(*arguments.RunArgs, " "));
+        runArgs = cmStrCat(' ', cmJoin(*arguments.RunArgs, " "));
       }
 
       // "run" it and capture the output

Source/cmake.cxx

@@ -1468,7 +1468,7 @@ void cmake::SetArgs(std::vector<std::string> const& args)
   if (!extraProvidedPath.empty() && this->GetWorkingMode() == NORMAL_MODE) {
     this->IssueMessage(MessageType::WARNING,
                        cmStrCat("Ignoring extra path from command line:\n \"",
-                                extraProvidedPath, "\""));
+                                extraProvidedPath, '"'));
   }
   if (!possibleUnknownArg.empty() && this->GetWorkingMode() != SCRIPT_MODE) {
     cmSystemTools::Error(cmStrCat("Unknown argument ", possibleUnknownArg));
@@ -1591,7 +1591,7 @@ void cmake::SetArgs(std::vector<std::string> const& args)
     }
     if (!expandedPreset->ConditionResult) {
       cmSystemTools::Error(cmStrCat("Could not use disabled preset \"",
-                                    preset->second.Unexpanded.Name, "\""));
+                                    preset->second.Unexpanded.Name, '"'));
       return;
     }
 
@@ -2121,9 +2121,9 @@ void cmake::SetHomeDirectoryViaCommandLine(std::string const& path)
   auto prev_path = this->GetHomeDirectory();
   if (prev_path != path && !prev_path.empty() &&
       this->GetWorkingMode() == NORMAL_MODE) {
-    this->IssueMessage(MessageType::WARNING,
-                       cmStrCat("Ignoring extra path from command line:\n \"",
-                                prev_path, "\""));
+    this->IssueMessage(
+      MessageType::WARNING,
+      cmStrCat("Ignoring extra path from command line:\n \"", prev_path, '"'));
   }
   this->SetHomeDirectory(path);
 }
@@ -2224,7 +2224,7 @@ int cmake::DoPreConfigureChecks()
 {
   // Make sure the Source directory contains a CMakeLists.txt file.
   std::string srcList =
-    cmStrCat(this->GetHomeDirectory(), "/", this->CMakeListName);
+    cmStrCat(this->GetHomeDirectory(), '/', this->CMakeListName);
   if (!cmSystemTools::FileExists(srcList)) {
     std::ostringstream err;
     if (cmSystemTools::FileIsDirectory(this->GetHomeDirectory())) {
@@ -2704,12 +2704,12 @@ int cmake::ActualConfigure()
   if (this->Instrumentation->HasQuery()) {
     std::string launcher;
     if (mf->IsOn("CTEST_USE_LAUNCHERS")) {
-      launcher = cmStrCat("\"", cmSystemTools::GetCTestCommand(),
+      launcher = cmStrCat('"', cmSystemTools::GetCTestCommand(),
                           "\" --launch "
                           "--current-build-dir <CMAKE_CURRENT_BINARY_DIR> ");
     } else {
       launcher =
-        cmStrCat("\"", cmSystemTools::GetCTestCommand(), "\" --instrument ");
+        cmStrCat('"', cmSystemTools::GetCTestCommand(), "\" --instrument ");
     }
     std::string common_args =
       cmStrCat(" --target-name <TARGET_NAME> --build-dir \"",

Tests/CMakeLib/testStringAlgorithms.cxx

@@ -142,7 +142,7 @@ int testStringAlgorithms(int /*unused*/, char* /*unused*/[])
     long long int nlli = -130000ll;
     unsigned long long int nulli = 130000ull;
     std::string val =
-      cmStrCat("<test>", ni, ',', nui, ',', nli, ",", nuli, ", ", nlli,
+      cmStrCat("<test>", ni, ',', nui, ',', nli, ',', nuli, ", ", nlli,
                std::string(", "), nulli, cm::string_view("</test>"));
     std::string expect =
       "<test>-1100,1100,-12000,12000, -130000, 130000</test>";