Autogen: Revert "AUTO*_EXECUTABLE: add support for per-config values"

Changing the `timestamp` file to `timestamp_$<CONFIG>` causes some user
projects to break when using Qt versions older than 6.6.

Revert commit fddd0f0443 (Autogen: AUTO*_EXECUTABLE: add support for
per-config values, 2023-06-14, v3.28.0-rc1~96^2~1) pending further
investigation.

Issue: #20074

12 files changed, 175 insertions, 451 deletions

diff --git a/Source/cmQtAutoGen.h b/Source/cmQtAutoGen.h
index 2e750b6..d111422 100644
--- a/Source/cmQtAutoGen.h
+++ b/Source/cmQtAutoGen.h
@@ -6,7 +6,6 @@
 
 #include <memory>
 #include <string>
-#include <unordered_map>
 #include <vector>
 
 #include <cm/string_view>
@@ -17,22 +16,6 @@
 class cmQtAutoGen
 {
 public:
-  /** String value with per configuration variants.  */
-  class ConfigString
-  {
-  public:
-    std::string Default;
-    std::unordered_map<std::string, std::string> Config;
-  };
-
-  /** String values with per configuration variants.  */
-  template <typename C>
-  class ConfigStrings
-  {
-  public:
-    C Default;
-    std::unordered_map<std::string, C> Config;
-  };
   /** Integer version.  */
   struct IntegerVersion
   {
diff --git a/Source/cmQtAutoGenGlobalInitializer.cxx b/Source/cmQtAutoGenGlobalInitializer.cxx
index 214df25..1da8847 100644
--- a/Source/cmQtAutoGenGlobalInitializer.cxx
+++ b/Source/cmQtAutoGenGlobalInitializer.cxx
@@ -213,81 +213,24 @@ void cmQtAutoGenGlobalInitializer::AddToGlobalAutoRcc(
   }
 }
 
-cmQtAutoGen::ConfigStrings<cmQtAutoGen::CompilerFeaturesHandle>
+cmQtAutoGen::CompilerFeaturesHandle
 cmQtAutoGenGlobalInitializer::GetCompilerFeatures(
-  std::string const& generator, cmQtAutoGen::ConfigString const& executable,
-  std::string& error, bool const isMultiConfig)
+  std::string const& generator, std::string const& executable,
+  std::string& error)
 {
-  cmQtAutoGen::ConfigStrings<cmQtAutoGen::CompilerFeaturesHandle> res;
-  if (isMultiConfig) {
-    for (auto const& config : executable.Config) {
-      auto const exe = config.second;
-      // Check if we have cached features
-      {
-        auto it = this->CompilerFeatures_.Config[config.first].find(exe);
-        if (it != this->CompilerFeatures_.Config[config.first].end()) {
-          res.Config[config.first] = it->second;
-          continue;
-        }
-      }
-
-      // Check if the executable exists
-      if (!cmSystemTools::FileExists(exe, true)) {
-        error = cmStrCat("The \"", generator, "\" executable ",
-                         cmQtAutoGen::Quoted(exe), " does not exist.");
-        res.Config[config.first] = {};
-        continue;
-      }
-
-      // Test the executable
-      std::string stdOut;
-      {
-        std::string stdErr;
-        std::vector<std::string> command;
-        command.emplace_back(exe);
-        command.emplace_back("-h");
-        int retVal = 0;
-        const bool runResult = cmSystemTools::RunSingleCommand(
-          command, &stdOut, &stdErr, &retVal, nullptr,
-          cmSystemTools::OUTPUT_NONE, cmDuration::zero(),
-          cmProcessOutput::Auto);
-        if (!runResult) {
-          error = cmStrCat("Test run of \"", generator, "\" executable ",
-                           cmQtAutoGen::Quoted(exe), " failed.\n",
-                           cmQtAutoGen::QuotedCommand(command), '\n', stdOut,
-                           '\n', stdErr);
-          res.Config[config.first] = {};
-          continue;
-        }
-      }
-
-      // Create valid handle
-      res.Config[config.first] =
-        std::make_shared<cmQtAutoGen::CompilerFeatures>();
-      res.Config[config.first]->HelpOutput = std::move(stdOut);
-
-      // Register compiler features
-      this->CompilerFeatures_.Config[config.first].emplace(
-        exe, res.Config[config.first]);
-    }
-    return res;
-  }
-
   // Check if we have cached features
   {
-    auto it = this->CompilerFeatures_.Default.find(executable.Default);
-    if (it != this->CompilerFeatures_.Default.end()) {
-      res.Default = it->second;
-      return res;
+    auto it = this->CompilerFeatures_.find(executable);
+    if (it != this->CompilerFeatures_.end()) {
+      return it->second;
     }
   }
 
   // Check if the executable exists
-  if (!cmSystemTools::FileExists(executable.Default, true)) {
-    error =
-      cmStrCat("The \"", generator, "\" executable ",
-               cmQtAutoGen::Quoted(executable.Default), " does not exist.");
-    return cmQtAutoGen::ConfigStrings<cmQtAutoGen::CompilerFeaturesHandle>();
+  if (!cmSystemTools::FileExists(executable, true)) {
+    error = cmStrCat("The \"", generator, "\" executable ",
+                     cmQtAutoGen::Quoted(executable), " does not exist.");
+    return cmQtAutoGen::CompilerFeaturesHandle();
   }
 
   // Test the executable
@@ -295,7 +238,7 @@ cmQtAutoGenGlobalInitializer::GetCompilerFeatures(
   {
     std::string stdErr;
     std::vector<std::string> command;
-    command.emplace_back(executable.Default);
+    command.emplace_back(executable);
     command.emplace_back("-h");
     int retVal = 0;
     const bool runResult = cmSystemTools::RunSingleCommand(
@@ -303,18 +246,20 @@ cmQtAutoGenGlobalInitializer::GetCompilerFeatures(
       cmDuration::zero(), cmProcessOutput::Auto);
     if (!runResult) {
       error = cmStrCat("Test run of \"", generator, "\" executable ",
-                       cmQtAutoGen::Quoted(executable.Default), " failed.\n",
+                       cmQtAutoGen::Quoted(executable), " failed.\n",
                        cmQtAutoGen::QuotedCommand(command), '\n', stdOut, '\n',
                        stdErr);
-      return cmQtAutoGen::ConfigStrings<cmQtAutoGen::CompilerFeaturesHandle>();
+      return cmQtAutoGen::CompilerFeaturesHandle();
     }
   }
 
-  res.Default = std::make_shared<cmQtAutoGen::CompilerFeatures>();
-  res.Default->HelpOutput = std::move(stdOut);
+  // Create valid handle
+  cmQtAutoGen::CompilerFeaturesHandle res =
+    std::make_shared<cmQtAutoGen::CompilerFeatures>();
+  res->HelpOutput = std::move(stdOut);
 
   // Register compiler features
-  this->CompilerFeatures_.Default.emplace(executable.Default, res.Default);
+  this->CompilerFeatures_.emplace(executable, res);
 
   return res;
 }
diff --git a/Source/cmQtAutoGenGlobalInitializer.h b/Source/cmQtAutoGenGlobalInitializer.h
index 5ea5997..e8569a5 100644
--- a/Source/cmQtAutoGenGlobalInitializer.h
+++ b/Source/cmQtAutoGenGlobalInitializer.h
@@ -66,16 +66,14 @@ private:
   void AddToGlobalAutoRcc(cmLocalGenerator* localGen,
                           std::string const& targetName);
 
-  cmQtAutoGen::ConfigStrings<cmQtAutoGen::CompilerFeaturesHandle>
-  GetCompilerFeatures(std::string const& generator,
-                      cmQtAutoGen::ConfigString const& executable,
-                      std::string& error, bool isMultiConfig);
+  cmQtAutoGen::CompilerFeaturesHandle GetCompilerFeatures(
+    std::string const& generator, std::string const& executable,
+    std::string& error);
 
   std::vector<std::unique_ptr<cmQtAutoGenInitializer>> Initializers_;
   std::map<cmLocalGenerator*, std::string> GlobalAutoGenTargets_;
   std::map<cmLocalGenerator*, std::string> GlobalAutoRccTargets_;
-  cmQtAutoGen::ConfigStrings<
-    std::unordered_map<std::string, cmQtAutoGen::CompilerFeaturesHandle>>
+  std::unordered_map<std::string, cmQtAutoGen::CompilerFeaturesHandle>
     CompilerFeatures_;
   Keywords const Keywords_;
 };
diff --git a/Source/cmQtAutoGenInitializer.cxx b/Source/cmQtAutoGenInitializer.cxx
index a33c5db..81752a6 100644
--- a/Source/cmQtAutoGenInitializer.cxx
+++ b/Source/cmQtAutoGenInitializer.cxx
@@ -2,7 +2,6 @@
    file Copyright.txt or https://cmake.org/licensing for details.  */
 #include "cmQtAutoGenInitializer.h"
 
-#include <array>
 #include <cstddef>
 #include <deque>
 #include <initializer_list>
@@ -18,7 +17,6 @@
 #include <cm/algorithm>
 #include <cm/iterator>
 #include <cm/memory>
-#include <cm/string_view>
 #include <cmext/algorithm>
 #include <cmext/string_view>
 
@@ -303,22 +301,15 @@ bool InfoWriter::Save(std::string const& filename)
   return fileStream.Close();
 }
 
-cmQtAutoGen::ConfigStrings<std::vector<std::string>> generateListOptions(
-  cmQtAutoGen::ConfigStrings<cmQtAutoGen::CompilerFeaturesHandle> const&
-    executableFeatures,
-  bool IsMultiConfig)
+void AddAutogenExecutableToDependencies(
+  cmQtAutoGenInitializer::GenVarsT const& genVars,
+  std::vector<std::string>& dependencies)
 {
-  cmQtAutoGen::ConfigStrings<std::vector<std::string>> tempListOptions;
-  if (IsMultiConfig) {
-    for (auto const& executableFeature : executableFeatures.Config) {
-      tempListOptions.Config[executableFeature.first] =
-        executableFeature.second->ListOptions;
-    }
-  } else {
-    tempListOptions.Default = executableFeatures.Default->ListOptions;
+  if (genVars.ExecutableTarget != nullptr) {
+    dependencies.push_back(genVars.ExecutableTarget->Target->GetName());
+  } else if (!genVars.Executable.empty()) {
+    dependencies.push_back(genVars.Executable);
   }
-
-  return tempListOptions;
 }
 
 } // End of unnamed namespace
@@ -345,34 +336,6 @@ cmQtAutoGenInitializer::cmQtAutoGenInitializer(
     !this->Makefile->GetSafeDefinition("CMAKE_CROSS_CONFIGS").empty();
 }
 
-void cmQtAutoGenInitializer::AddAutogenExecutableToDependencies(
-  cmQtAutoGenInitializer::GenVarsT const& genVars,
-  std::vector<std::string>& dependencies) const
-{
-  if (genVars.ExecutableTarget != nullptr) {
-    dependencies.push_back(genVars.ExecutableTarget->Target->GetName());
-  } else if (this->MultiConfig) {
-    cm::string_view const& configGenexWithCommandConfig =
-      "$<COMMAND_CONFIG:$<$<CONFIG:";
-    cm::string_view const& configGenex = "$<$<CONFIG:";
-    cm::string_view const& configGenexEnd = ">";
-    cm::string_view const& configGenexEndWithCommandConfig = ">>";
-    auto genexBegin =
-      this->CrossConfig ? configGenexWithCommandConfig : configGenex;
-    auto genexEnd =
-      this->CrossConfig ? configGenexEndWithCommandConfig : configGenexEnd;
-    for (auto const& config : genVars.Executable.Config) {
-      auto executableWithConfig =
-        cmStrCat(genexBegin, config.first, ">:", config.second, genexEnd);
-      dependencies.emplace_back(std::move(executableWithConfig));
-    }
-  } else {
-    if (!genVars.Executable.Default.empty()) {
-      dependencies.push_back(genVars.Executable.Default);
-    }
-  }
-}
-
 bool cmQtAutoGenInitializer::InitCustomTargets()
 {
   // Configurations
@@ -816,30 +779,18 @@ bool cmQtAutoGenInitializer::InitRcc()
       return false;
     }
     // Evaluate test output on demand
-    auto& features = this->Rcc.ExecutableFeatures;
-    auto checkAndAddOptions = [this](CompilerFeaturesHandle& feature) {
-      if (!feature->Evaluated) {
-        // Look for list options
-        if (this->QtVersion.Major == 5 || this->QtVersion.Major == 6) {
-          static std::array<std::string, 2> const listOptions{ { "--list",
-                                                                 "-list" } };
-          for (std::string const& opt : listOptions) {
-            if (feature->HelpOutput.find(opt) != std::string::npos) {
-              feature->ListOptions.emplace_back(opt);
-              break;
-            }
-          }
+    CompilerFeatures& features = *this->Rcc.ExecutableFeatures;
+    if (!features.Evaluated) {
+      // Look for list options
+      if (this->QtVersion.Major == 5 || this->QtVersion.Major == 6) {
+        if (features.HelpOutput.find("--list") != std::string::npos) {
+          features.ListOptions.emplace_back("--list");
+        } else if (features.HelpOutput.find("-list") != std::string::npos) {
+          features.ListOptions.emplace_back("-list");
         }
-        // Evaluation finished
-        feature->Evaluated = true;
-      }
-    };
-    if (this->MultiConfig) {
-      for (auto const& config : this->ConfigsList) {
-        checkAndAddOptions(features.Config[config]);
       }
-    } else {
-      checkAndAddOptions(features.Default);
+      // Evaluation finished
+      features.Evaluated = true;
     }
   }
 
@@ -1175,13 +1126,8 @@ bool cmQtAutoGenInitializer::InitScanFiles()
       // Path checksum
       qrc.QrcPathChecksum = this->PathCheckSum.getPart(qrc.QrcFile);
       // Output file name
-      if (this->MultiConfig && !this->GlobalGen->IsXcode()) {
-        qrc.OutputFile = cmStrCat(this->Dir.Build, '/', qrc.QrcPathChecksum,
-                                  "_$<CONFIG>", "/qrc_", qrc.QrcName, ".cpp");
-      } else {
-        qrc.OutputFile = cmStrCat(this->Dir.Build, '/', qrc.QrcPathChecksum,
-                                  "/qrc_", qrc.QrcName, ".cpp");
-      }
+      qrc.OutputFile = cmStrCat(this->Dir.Build, '/', qrc.QrcPathChecksum,
+                                "/qrc_", qrc.QrcName, ".cpp");
       std::string const base = cmStrCat(this->Dir.Info, "/AutoRcc_",
                                         qrc.QrcName, '_', qrc.QrcPathChecksum);
       qrc.LockFile = cmStrCat(base, "_Lock.lock");
@@ -1213,25 +1159,11 @@ bool cmQtAutoGenInitializer::InitScanFiles()
     for (Qrc& qrc : this->Rcc.Qrcs) {
       if (!qrc.Generated) {
         std::string error;
-        if (this->MultiConfig) {
-          for (auto const& config : this->ConfigsList) {
-            RccLister const lister(
-              this->Rcc.Executable.Config[config],
-              this->Rcc.ExecutableFeatures.Config[config]->ListOptions);
-            if (!lister.list(qrc.QrcFile, qrc.Resources.Config[config],
-                             error)) {
-              cmSystemTools::Error(error);
-              return false;
-            }
-          }
-        } else {
-          RccLister const lister(
-            this->Rcc.Executable.Default,
-            this->Rcc.ExecutableFeatures.Default->ListOptions);
-          if (!lister.list(qrc.QrcFile, qrc.Resources.Default, error)) {
-            cmSystemTools::Error(error);
-            return false;
-          }
+        RccLister const lister(this->Rcc.Executable,
+                               this->Rcc.ExecutableFeatures->ListOptions);
+        if (!lister.list(qrc.QrcFile, qrc.Resources, error)) {
+          cmSystemTools::Error(error);
+          return false;
         }
       }
     }
@@ -1259,7 +1191,18 @@ bool cmQtAutoGenInitializer::InitAutogenTarget()
   if (this->Moc.Enabled) {
     this->AddGeneratedSource(this->Moc.CompilationFile, this->Moc, true);
     if (useDepfile) {
-      timestampByproducts.push_back(this->Moc.CompilationFileGenex);
+      if (this->MultiConfig && this->CrossConfig &&
+          this->GlobalGen->GetName().find("Ninja") != std::string::npos) {
+        // Make all mocs_compilation_<CONFIG>.cpp files byproducts of the
+        // ${target}_autogen/timestamp custom command.
+        // We cannot just use Moc.CompilationFileGenex here, because that
+        // custom command runs cmake_autogen for each configuration.
+        for (const auto& p : this->Moc.CompilationFile.Config) {
+          timestampByproducts.push_back(p.second);
+        }
+      } else {
+        timestampByproducts.push_back(this->Moc.CompilationFileGenex);
+      }
     } else {
       autogenByproducts.push_back(this->Moc.CompilationFileGenex);
     }
@@ -1292,11 +1235,28 @@ bool cmQtAutoGenInitializer::InitAutogenTarget()
   // Compose command lines
   // FIXME: Take advantage of our per-config mocs_compilation_$<CONFIG>.cpp
   // instead of fiddling with the include directories
-
+  std::vector<std::string> configs;
+  this->GlobalGen->GetQtAutoGenConfigs(configs);
   bool constexpr stdPipesUTF8 = true;
   cmCustomCommandLines commandLines;
-  AddCMakeProcessToCommandLines(this->AutogenTarget.InfoFile, "cmake_autogen",
-                                commandLines);
+  if (!this->CrossConfig) {
+    std::string autogenInfoFileConfig;
+    if (this->MultiConfig) {
+      autogenInfoFileConfig = "$<CONFIG>";
+    } else {
+      autogenInfoFileConfig = configs[0];
+    }
+    commandLines.push_back(cmMakeCommandLine(
+      { cmSystemTools::GetCMakeCommand(), "-E", "cmake_autogen",
+        this->AutogenTarget.InfoFile, autogenInfoFileConfig }));
+
+  } else {
+    for (auto const& config : configs) {
+      commandLines.push_back(cmMakeCommandLine(
+        { cmSystemTools::GetCMakeCommand(), "-E", "cmake_autogen",
+          this->AutogenTarget.InfoFile, config }));
+    }
+  }
 
   // Use PRE_BUILD on demand
   bool usePRE_BUILD = false;
@@ -1464,47 +1424,18 @@ bool cmQtAutoGenInitializer::InitAutogenTarget()
 
       AddAutogenExecutableToDependencies(this->Moc, dependencies);
       AddAutogenExecutableToDependencies(this->Uic, dependencies);
-      std::string outputFile;
-      std::string depFile;
+
       // Create the custom command that outputs the timestamp file.
-      if (this->MultiConfig) {
-        // create timestamp file with $<CONFIG> in the name so that
-        // every cmake_autogen target has its own timestamp file
-        std::string const configView = "$<CONFIG>";
-        std::string const timestampFileWithoutConfig = "timestamp_";
-        std::string const depFileWithoutConfig =
-          cmStrCat(this->Dir.Build, "/deps_");
-        std::string const timestampFileName =
-          timestampFileWithoutConfig + configView;
-        outputFile = cmStrCat(this->Dir.Build, "/", timestampFileName);
-        auto const depFileWithConfig =
-          cmStrCat(depFileWithoutConfig, configView);
-        depFile = depFileWithConfig;
-        commandLines.push_back(cmMakeCommandLine(
-          { cmSystemTools::GetCMakeCommand(), "-E", "touch", outputFile }));
-
-        ConfigString outputFileWithConfig;
-        for (std::string const& config : this->ConfigsList) {
-          auto tempTimestampFileName = timestampFileWithoutConfig + config;
-          auto tempDepFile = depFileWithoutConfig + config;
-          outputFileWithConfig.Config[config] = tempTimestampFileName;
-          this->AutogenTarget.DepFileRuleName.Config[config] =
-            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);
-        this->AutogenTarget.DepFile.Default =
-          cmStrCat(this->Dir.Build, "/deps");
-        depFile = this->AutogenTarget.DepFile.Default;
-        this->AutogenTarget.DepFileRuleName.Default =
-          cmStrCat(this->Dir.RelativeBuild, "/", timestampFileName);
-        commandLines.push_back(cmMakeCommandLine(
-          { cmSystemTools::GetCMakeCommand(), "-E", "touch", outputFile }));
-        this->AddGeneratedSource(outputFile, this->Moc);
-      }
+      const char timestampFileName[] = "timestamp";
+      const std::string outputFile =
+        cmStrCat(this->Dir.Build, "/", timestampFileName);
+      this->AutogenTarget.DepFile = cmStrCat(this->Dir.Build, "/deps");
+      this->AutogenTarget.DepFileRuleName =
+        cmStrCat(this->Dir.RelativeBuild, "/", timestampFileName);
+      commandLines.push_back(cmMakeCommandLine(
+        { cmSystemTools::GetCMakeCommand(), "-E", "touch", outputFile }));
+
+      this->AddGeneratedSource(outputFile, this->Moc);
       cc = cm::make_unique<cmCustomCommand>();
       cc->SetOutputs(outputFile);
       cc->SetByproducts(timestampByproducts);
@@ -1513,11 +1444,14 @@ bool cmQtAutoGenInitializer::InitAutogenTarget()
       cc->SetComment(autogenComment.c_str());
       cc->SetWorkingDirectory(this->Dir.Work.c_str());
       cc->SetEscapeOldStyle(false);
-      cc->SetDepfile(depFile);
+      cc->SetDepfile(this->AutogenTarget.DepFile);
       cc->SetStdPipesUTF8(stdPipesUTF8);
       this->LocalGen->AddCustomCommandToOutput(std::move(cc));
+
+      // Alter variables for the autogen target which now merely wraps the
+      // custom command
       dependencies.clear();
-      dependencies.emplace_back(std::move(outputFile));
+      dependencies.emplace_back(outputFile);
       commandLines.clear();
       autogenComment.clear();
     }
@@ -1569,35 +1503,6 @@ bool cmQtAutoGenInitializer::InitAutogenTarget()
   return true;
 }
 
-void cmQtAutoGenInitializer::AddCMakeProcessToCommandLines(
-  std::string const& infoFile, std::string const& processName,
-  cmCustomCommandLines& commandLines)
-{
-  if (this->CrossConfig) {
-    commandLines.push_back(cmMakeCommandLine(
-      { cmSystemTools::GetCMakeCommand(), "-E", processName, infoFile,
-        "$<CONFIG>", "$<COMMAND_CONFIG:$<CONFIG>>" }));
-  } else if (this->MultiConfig && this->GlobalGen->IsXcode()) {
-    for (std::string const& config : this->ConfigsList) {
-      commandLines.push_back(
-        cmMakeCommandLine({ cmSystemTools::GetCMakeCommand(), "-E",
-                            processName, infoFile, config }));
-    }
-  } else {
-    std::string autoInfoFileConfig;
-    if (this->MultiConfig) {
-      autoInfoFileConfig = "$<CONFIG>";
-    } else {
-      std::vector<std::string> configs;
-      this->GlobalGen->GetQtAutoGenConfigs(configs);
-      autoInfoFileConfig = configs[0];
-    }
-    commandLines.push_back(
-      cmMakeCommandLine({ cmSystemTools::GetCMakeCommand(), "-E", processName,
-                          infoFile, autoInfoFileConfig }));
-  }
-}
-
 bool cmQtAutoGenInitializer::InitRccTargets()
 {
   for (Qrc const& qrc : this->Rcc.Qrcs) {
@@ -1618,7 +1523,18 @@ bool cmQtAutoGenInitializer::InitRccTargets()
     ccDepends.push_back(qrc.InfoFile);
 
     cmCustomCommandLines commandLines;
-    AddCMakeProcessToCommandLines(qrc.InfoFile, "cmake_autorcc", commandLines);
+    if (this->MultiConfig) {
+      // Build for all configurations
+      for (std::string const& config : this->ConfigsList) {
+        commandLines.push_back(
+          cmMakeCommandLine({ cmSystemTools::GetCMakeCommand(), "-E",
+                              "cmake_autorcc", qrc.InfoFile, config }));
+      }
+    } else {
+      commandLines.push_back(
+        cmMakeCommandLine({ cmSystemTools::GetCMakeCommand(), "-E",
+                            "cmake_autorcc", qrc.InfoFile, "$<CONFIG>" }));
+    }
 
     std::string const ccComment =
       cmStrCat("Automatic RCC for ",
@@ -1669,28 +1585,13 @@ bool cmQtAutoGenInitializer::InitRccTargets()
       // Create custom rcc command
       {
         // Add the resource files to the dependencies
-        if (this->MultiConfig) {
-          for (auto const& config : this->ConfigsList) {
-            // Add resource file to the custom command dependencies
-            auto resourceFilesWithConfig = cmStrCat(
-              "$<$<CONFIG:", config,
-              ">:", cmList{ qrc.Resources.Config.at(config) }.to_string(),
-              ">");
-            ccDepends.emplace_back(std::move(resourceFilesWithConfig));
-          }
-        } else {
-          for (std::string const& fileName : qrc.Resources.Default) {
-            // Add resource file to the custom command dependencies
-            ccDepends.push_back(fileName);
-          }
+        for (std::string const& fileName : qrc.Resources) {
+          // Add resource file to the custom command dependencies
+          ccDepends.push_back(fileName);
         }
-
         if (!this->Rcc.ExecutableTargetName.empty()) {
           ccDepends.push_back(this->Rcc.ExecutableTargetName);
         }
-
-        AddAutogenExecutableToDependencies(this->Rcc, ccDepends);
-
         cc->SetOutputs(ccOutput);
         cc->SetDepends(ccDepends);
         this->LocalGen->AddCustomCommandToOutput(std::move(cc));
@@ -1790,7 +1691,6 @@ bool cmQtAutoGenInitializer::SetupWriteAutogenInfo()
 
   // General
   info.SetBool("MULTI_CONFIG", this->MultiConfig);
-  info.SetBool("CROSS_CONFIG", this->CrossConfig);
   info.SetUInt("PARALLEL", this->AutogenTarget.Parallel);
   info.SetUInt("VERBOSITY", this->Verbosity);
 
@@ -1804,14 +1704,14 @@ bool cmQtAutoGenInitializer::SetupWriteAutogenInfo()
 
   info.SetUInt("QT_VERSION_MAJOR", this->QtVersion.Major);
   info.SetUInt("QT_VERSION_MINOR", this->QtVersion.Minor);
-  info.SetConfig("QT_MOC_EXECUTABLE", this->Moc.Executable);
-  info.SetConfig("QT_UIC_EXECUTABLE", this->Uic.Executable);
+  info.Set("QT_MOC_EXECUTABLE", this->Moc.Executable);
+  info.Set("QT_UIC_EXECUTABLE", this->Uic.Executable);
 
   info.Set("CMAKE_EXECUTABLE", cmSystemTools::GetCMakeCommand());
   info.SetConfig("SETTINGS_FILE", this->AutogenTarget.SettingsFile);
   info.SetConfig("PARSE_CACHE_FILE", this->AutogenTarget.ParseCacheFile);
-  info.SetConfig("DEP_FILE", this->AutogenTarget.DepFile);
-  info.SetConfig("DEP_FILE_RULE_NAME", this->AutogenTarget.DepFileRuleName);
+  info.Set("DEP_FILE", this->AutogenTarget.DepFile);
+  info.Set("DEP_FILE_RULE_NAME", this->AutogenTarget.DepFileRuleName);
   info.SetArray("CMAKE_LIST_FILES", this->Makefile->GetListFiles());
   info.SetArray("HEADER_EXTENSIONS",
                 this->Makefile->GetCMakeInstance()->GetHeaderExtensions());
@@ -1938,7 +1838,6 @@ bool cmQtAutoGenInitializer::SetupWriteRccInfo()
 
     // General
     info.SetBool("MULTI_CONFIG", this->MultiConfig);
-    info.SetBool("CROSS_CONFIG", this->CrossConfig);
     info.SetUInt("VERBOSITY", this->Verbosity);
     info.Set("GENERATOR", this->GlobalGen->GetName());
 
@@ -1955,17 +1854,16 @@ bool cmQtAutoGenInitializer::SetupWriteRccInfo()
     info.SetConfig("INCLUDE_DIR", this->Dir.Include);
 
     // rcc executable
-    info.SetConfig("RCC_EXECUTABLE", this->Rcc.Executable);
-    info.SetConfigArray(
-      "RCC_LIST_OPTIONS",
-      generateListOptions(this->Rcc.ExecutableFeatures, this->MultiConfig));
+    info.Set("RCC_EXECUTABLE", this->Rcc.Executable);
+    info.SetArray("RCC_LIST_OPTIONS",
+                  this->Rcc.ExecutableFeatures->ListOptions);
 
     // qrc file
     info.Set("SOURCE", qrc.QrcFile);
     info.Set("OUTPUT_CHECKSUM", qrc.QrcPathChecksum);
     info.Set("OUTPUT_NAME", cmSystemTools::GetFilenameName(qrc.OutputFile));
     info.SetArray("OPTIONS", qrc.Options);
-    info.SetConfigArray("INPUTS", qrc.Resources);
+    info.SetArray("INPUTS", qrc.Resources);
 
     info.Save(qrc.InfoFile);
   }
@@ -2309,32 +2207,16 @@ bool cmQtAutoGenInitializer::GetQtExecutable(GenVarsT& genVars,
         cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
         cmGeneratorExpression ge(*this->Makefile->GetCMakeInstance(), lfbt);
         std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(val);
-        if (this->MultiConfig) {
-          for (auto const& config : this->ConfigsList) {
-            genVars.Executable.Config[config] =
-              cge->Evaluate(this->LocalGen, config);
-          }
-        } else {
-          genVars.Executable.Default = cge->Evaluate(this->LocalGen, "");
-        }
+        genVars.Executable = cge->Evaluate(this->LocalGen, "");
       }
-
-      if (genVars.Executable.Default.empty() &&
-          genVars.Executable.Config.empty() && !ignoreMissingTarget) {
+      if (genVars.Executable.empty() && !ignoreMissingTarget) {
         print_err(prop + " evaluates to an empty value");
         return false;
       }
 
       // Create empty compiler features.
-      if (this->MultiConfig) {
-        for (auto const& config : this->ConfigsList) {
-          genVars.ExecutableFeatures.Config[config] =
-            std::make_shared<cmQtAutoGen::CompilerFeatures>();
-        }
-      } else {
-        genVars.ExecutableFeatures.Default =
-          std::make_shared<cmQtAutoGen::CompilerFeatures>();
-      }
+      genVars.ExecutableFeatures =
+        std::make_shared<cmQtAutoGen::CompilerFeatures>();
       return true;
     }
   }
@@ -2359,39 +2241,15 @@ bool cmQtAutoGenInitializer::GetQtExecutable(GenVarsT& genVars,
       genVars.ExecutableTargetName = targetName;
       genVars.ExecutableTarget = genTarget;
       if (genTarget->IsImported()) {
-        if (this->MultiConfig) {
-          for (auto const& config : this->ConfigsList) {
-            genVars.Executable.Config[config] =
-              genTarget->ImportedGetLocation(config);
-          }
-        } else {
-          genVars.Executable.Default =
-            genTarget->ImportedGetLocation(this->ConfigDefault);
-        }
-
+        genVars.Executable = genTarget->ImportedGetLocation("");
       } else {
-        if (this->MultiConfig) {
-          for (auto const& config : this->ConfigsList) {
-            genVars.Executable.Config[config] = genTarget->GetLocation(config);
-          }
-        } else {
-          genVars.Executable.Default =
-            genTarget->GetLocation(this->ConfigDefault);
-        }
+        genVars.Executable = genTarget->GetLocation("");
       }
     } else {
       if (ignoreMissingTarget) {
         // Create empty compiler features.
-        if (this->MultiConfig) {
-          for (auto const& config : this->ConfigsList) {
-            genVars.ExecutableFeatures.Config[config] =
-              std::make_shared<cmQtAutoGen::CompilerFeatures>();
-          }
-        } else {
-          genVars.ExecutableFeatures.Default =
-            std::make_shared<cmQtAutoGen::CompilerFeatures>();
-        }
-
+        genVars.ExecutableFeatures =
+          std::make_shared<cmQtAutoGen::CompilerFeatures>();
         return true;
       }
       print_err(cmStrCat("Could not find ", executable, " executable target ",
@@ -2404,21 +2262,10 @@ bool cmQtAutoGenInitializer::GetQtExecutable(GenVarsT& genVars,
   {
     std::string err;
     genVars.ExecutableFeatures = this->GlobalInitializer->GetCompilerFeatures(
-      executable, genVars.Executable, err, this->MultiConfig);
-    if (this->MultiConfig) {
-      for (auto const& config : this->ConfigsList) {
-        if (!genVars.ExecutableFeatures.Config[config]) {
-          if (!genVars.ExecutableFeatures.Config[config]) {
-            print_err(err);
-            return false;
-          }
-        }
-      }
-    } else {
-      if (!genVars.ExecutableFeatures.Default) {
-        print_err(err);
-        return false;
-      }
+      executable, genVars.Executable, err);
+    if (!genVars.ExecutableFeatures) {
+      print_err(err);
+      return false;
     }
   }
 
diff --git a/Source/cmQtAutoGenInitializer.h b/Source/cmQtAutoGenInitializer.h
index ee37d2f..a44d33f 100644
--- a/Source/cmQtAutoGenInitializer.h
+++ b/Source/cmQtAutoGenInitializer.h
@@ -18,7 +18,6 @@
 #include "cmFilePathChecksum.h"
 #include "cmQtAutoGen.h"
 
-class cmCustomCommandLines;
 class cmGeneratorTarget;
 class cmGlobalGenerator;
 class cmLocalGenerator;
@@ -33,6 +32,23 @@ class cmTarget;
 class cmQtAutoGenInitializer : public cmQtAutoGen
 {
 public:
+  /** String value with per configuration variants.  */
+  class ConfigString
+  {
+  public:
+    std::string Default;
+    std::unordered_map<std::string, std::string> Config;
+  };
+
+  /** String values with per configuration variants.  */
+  template <typename C>
+  class ConfigStrings
+  {
+  public:
+    C Default;
+    std::unordered_map<std::string, C> Config;
+  };
+
   /** rcc job.  */
   class Qrc
   {
@@ -47,7 +63,7 @@ public:
     bool Generated = false;
     bool Unique = false;
     std::vector<std::string> Options;
-    ConfigStrings<std::vector<std::string>> Resources;
+    std::vector<std::string> Resources;
   };
 
   /** moc and/or uic file.  */
@@ -74,8 +90,8 @@ public:
     // Executable
     std::string ExecutableTargetName;
     cmGeneratorTarget* ExecutableTarget = nullptr;
-    ConfigString Executable;
-    ConfigStrings<CompilerFeaturesHandle> ExecutableFeatures;
+    std::string Executable;
+    CompilerFeaturesHandle ExecutableFeatures;
 
     GenVarsT(GenT gen)
       : Gen(gen)
@@ -125,9 +141,6 @@ private:
                           GenVarsT const& genVars, bool prepend = false);
   void AddToSourceGroup(std::string const& fileName,
                         cm::string_view genNameUpper);
-  void AddCMakeProcessToCommandLines(std::string const& infoFile,
-                                     std::string const& processName,
-                                     cmCustomCommandLines& commandLines);
   void AddCleanFile(std::string const& fileName);
 
   void ConfigFileNames(ConfigString& configString, cm::string_view prefix,
@@ -142,9 +155,6 @@ private:
                        bool ignoreMissingTarget) const;
 
   void handleSkipPch(cmSourceFile* sf);
-  void AddAutogenExecutableToDependencies(
-    cmQtAutoGenInitializer::GenVarsT const& genVars,
-    std::vector<std::string>& dependencies) const;
 
   cmQtAutoGenGlobalInitializer* GlobalInitializer = nullptr;
   cmGeneratorTarget* GenTarget = nullptr;
@@ -192,8 +202,8 @@ private:
     bool DependOrigin = false;
     std::set<std::string> DependFiles;
     std::set<cmTarget*> DependTargets;
-    ConfigString DepFile;
-    ConfigString DepFileRuleName;
+    std::string DepFile;
+    std::string DepFileRuleName;
     // Sources to process
     std::unordered_map<cmSourceFile*, MUFileHandle> Headers;
     std::unordered_map<cmSourceFile*, MUFileHandle> Sources;
diff --git a/Source/cmQtAutoGenerator.cxx b/Source/cmQtAutoGenerator.cxx
index ebdec12..c048312 100644
--- a/Source/cmQtAutoGenerator.cxx
+++ b/Source/cmQtAutoGenerator.cxx
@@ -430,12 +430,10 @@ std::string cmQtAutoGenerator::MessagePath(cm::string_view path) const
   return cmQtAutoGen::Quoted(res);
 }
 
-bool cmQtAutoGenerator::Run(cm::string_view infoFile, cm::string_view config,
-                            cm::string_view executableConfig)
+bool cmQtAutoGenerator::Run(cm::string_view infoFile, cm::string_view config)
 {
   // Info config
   this->InfoConfig_ = std::string(config);
-  this->ExecutableConfig_ = std::string(executableConfig);
 
   // Info file
   this->InfoFile_ = std::string(infoFile);
diff --git a/Source/cmQtAutoGenerator.h b/Source/cmQtAutoGenerator.h
index 4b15fc7..5c3a8ad 100644
--- a/Source/cmQtAutoGenerator.h
+++ b/Source/cmQtAutoGenerator.h
@@ -90,10 +90,6 @@ public:
   std::string const& InfoDir() const { return this->InfoDir_; }
   cmFileTime const& InfoFileTime() const { return this->InfoFileTime_; }
   std::string const& InfoConfig() const { return this->InfoConfig_; }
-  std::string const& ExecutableConfig() const
-  {
-    return this->ExecutableConfig_;
-  }
 
   // -- Info file parsing
   /** Info file reader class. */
@@ -155,8 +151,7 @@ public:
   std::string MessagePath(cm::string_view path) const;
 
   // -- Run
-  bool Run(cm::string_view infoFile, cm::string_view config,
-           cm::string_view executableConfig);
+  bool Run(cm::string_view infoFile, cm::string_view config);
 
 protected:
   // -- Abstract processing interface
@@ -175,7 +170,6 @@ private:
   std::string InfoDir_;
   cmFileTime InfoFileTime_;
   std::string InfoConfig_;
-  std::string ExecutableConfig_;
   // -- Directories
   ProjectDirsT ProjectDirs_;
 };
diff --git a/Source/cmQtAutoMocUic.cxx b/Source/cmQtAutoMocUic.cxx
index 68d2897..ece657d 100644
--- a/Source/cmQtAutoMocUic.cxx
+++ b/Source/cmQtAutoMocUic.cxx
@@ -170,7 +170,6 @@ public:
     // -- Attributes
     // - Config
     bool MultiConfig = false;
-    bool CrossConfig = false;
     IntegerVersion QtVersion = { 4, 0 };
     unsigned int ThreadCount = 0;
     // - Directories
@@ -2373,7 +2372,6 @@ bool cmQtAutoMocUicT::InitFromInfo(InfoT const& info)
 {
   // -- Required settings
   if (!info.GetBool("MULTI_CONFIG", this->BaseConst_.MultiConfig, true) ||
-      !info.GetBool("CROSS_CONFIG", this->BaseConst_.CrossConfig, true) ||
       !info.GetUInt("QT_VERSION_MAJOR", this->BaseConst_.QtVersion.Major,
                     true) ||
       !info.GetUInt("QT_VERSION_MINOR", this->BaseConst_.QtVersion.Minor,
@@ -2386,34 +2384,19 @@ bool cmQtAutoMocUicT::InitFromInfo(InfoT const& info)
                       true) ||
       !info.GetStringConfig("PARSE_CACHE_FILE",
                             this->BaseConst_.ParseCacheFile, true) ||
-      !info.GetStringConfig("DEP_FILE", this->BaseConst_.DepFile, false) ||
-      !info.GetStringConfig("DEP_FILE_RULE_NAME",
-                            this->BaseConst_.DepFileRuleName, false) ||
+      !info.GetString("DEP_FILE", this->BaseConst_.DepFile, false) ||
+      !info.GetString("DEP_FILE_RULE_NAME", this->BaseConst_.DepFileRuleName,
+                      false) ||
       !info.GetStringConfig("SETTINGS_FILE", this->SettingsFile_, true) ||
       !info.GetArray("CMAKE_LIST_FILES", this->BaseConst_.ListFiles, true) ||
       !info.GetArray("HEADER_EXTENSIONS", this->BaseConst_.HeaderExtensions,
-                     true)) {
+                     true) ||
+      !info.GetString("QT_MOC_EXECUTABLE", this->MocConst_.Executable,
+                      false) ||
+      !info.GetString("QT_UIC_EXECUTABLE", this->UicConst_.Executable,
+                      false)) {
     return false;
   }
-  if (this->BaseConst_.CrossConfig) {
-    std::string const mocExecutableWithConfig =
-      "QT_MOC_EXECUTABLE_" + this->ExecutableConfig();
-    std::string const uicExecutableWithConfig =
-      "QT_UIC_EXECUTABLE_" + this->ExecutableConfig();
-    if (!info.GetString(mocExecutableWithConfig, this->MocConst_.Executable,
-                        false) ||
-        !info.GetString(uicExecutableWithConfig, this->UicConst_.Executable,
-                        false)) {
-      return false;
-    }
-  } else {
-    if (!info.GetStringConfig("QT_MOC_EXECUTABLE", this->MocConst_.Executable,
-                              false) ||
-        !info.GetStringConfig("QT_UIC_EXECUTABLE", this->UicConst_.Executable,
-                              false)) {
-      return false;
-    }
-  }
 
   // -- Checks
   if (!this->BaseConst_.CMakeExecutableTime.Load(
@@ -3080,8 +3063,7 @@ std::string cmQtAutoMocUicT::AbsoluteIncludePath(
 
 } // End of unnamed namespace
 
-bool cmQtAutoMocUic(cm::string_view infoFile, cm::string_view config,
-                    cm::string_view executableConfig)
+bool cmQtAutoMocUic(cm::string_view infoFile, cm::string_view config)
 {
-  return cmQtAutoMocUicT().Run(infoFile, config, executableConfig);
+  return cmQtAutoMocUicT().Run(infoFile, config);
 }
diff --git a/Source/cmQtAutoMocUic.h b/Source/cmQtAutoMocUic.h
index 5cb4ff1..20f9d6e 100644
--- a/Source/cmQtAutoMocUic.h
+++ b/Source/cmQtAutoMocUic.h
@@ -10,5 +10,4 @@
  * Process AUTOMOC and AUTOUIC
  * @return true on success
  */
-bool cmQtAutoMocUic(cm::string_view infoFile, cm::string_view config,
-                    cm::string_view executableConfig);
+bool cmQtAutoMocUic(cm::string_view infoFile, cm::string_view config);
diff --git a/Source/cmQtAutoRcc.cxx b/Source/cmQtAutoRcc.cxx
index 576f611..e288645 100644
--- a/Source/cmQtAutoRcc.cxx
+++ b/Source/cmQtAutoRcc.cxx
@@ -35,11 +35,6 @@ public:
 private:
   // -- Utility
   bool IsMultiConfig() const { return this->MultiConfig_; }
-  std::string const& GetGenerator() const { return this->Generator_; }
-  bool IsXcode() const
-  {
-    return this->GetGenerator().find("Xcode") != std::string::npos;
-  }
   std::string MultiConfigOutput() const;
 
   // -- Abstract processing interface
@@ -58,8 +53,6 @@ private:
 
   // -- Config settings
   bool MultiConfig_ = false;
-  bool CrossConfig_ = false;
-  std::string Generator_;
   // -- Directories
   std::string AutogenBuildDir_;
   std::string IncludeDir_;
@@ -99,45 +92,26 @@ bool cmQtAutoRccT::InitFromInfo(InfoT const& info)
 {
   // -- Required settings
   if (!info.GetBool("MULTI_CONFIG", this->MultiConfig_, true) ||
-      !info.GetString("GENERATOR", this->Generator_, true) ||
-      !info.GetBool("CROSS_CONFIG", this->CrossConfig_, true) ||
       !info.GetString("BUILD_DIR", this->AutogenBuildDir_, true) ||
       !info.GetStringConfig("INCLUDE_DIR", this->IncludeDir_, true) ||
-      !info.GetArrayConfig("RCC_LIST_OPTIONS", this->RccListOptions_, false) ||
+      !info.GetString("RCC_EXECUTABLE", this->RccExecutable_, true) ||
+      !info.GetArray("RCC_LIST_OPTIONS", this->RccListOptions_, false) ||
       !info.GetString("LOCK_FILE", this->LockFile_, true) ||
       !info.GetStringConfig("SETTINGS_FILE", this->SettingsFile_, true) ||
       !info.GetString("SOURCE", this->QrcFile_, true) ||
       !info.GetString("OUTPUT_CHECKSUM", this->RccPathChecksum_, true) ||
       !info.GetString("OUTPUT_NAME", this->RccFileName_, true) ||
       !info.GetArray("OPTIONS", this->Options_, false) ||
-      !info.GetArrayConfig("INPUTS", this->Inputs_, false)) {
+      !info.GetArray("INPUTS", this->Inputs_, false)) {
     return false;
   }
 
-  if (this->CrossConfig_) {
-    std::string const rccExecutableWithConfig =
-      "RCC_EXECUTABLE_" + this->ExecutableConfig();
-    if (!info.GetString(rccExecutableWithConfig, this->RccExecutable_, true)) {
-      return false;
-    }
-  } else {
-    if (!info.GetStringConfig("RCC_EXECUTABLE", this->RccExecutable_, true)) {
-      return false;
-    }
-  }
-
   // -- Derive information
   this->QrcFileName_ = cmSystemTools::GetFilenameName(this->QrcFile_);
   this->QrcFileDir_ = cmSystemTools::GetFilenamePath(this->QrcFile_);
-  if (IsMultiConfig() && !this->IsXcode()) {
-    this->RccFilePublic_ =
-      cmStrCat(this->AutogenBuildDir_, '/', this->RccPathChecksum_, "_",
-               this->InfoConfig(), '/', this->RccFileName_);
-  } else {
-    this->RccFilePublic_ =
-      cmStrCat(this->AutogenBuildDir_, '/', this->RccPathChecksum_, '/',
-               this->RccFileName_);
-  }
+  this->RccFilePublic_ =
+    cmStrCat(this->AutogenBuildDir_, '/', this->RccPathChecksum_, '/',
+             this->RccFileName_);
 
   // rcc output file name
   if (this->IsMultiConfig()) {
@@ -546,8 +520,7 @@ bool cmQtAutoRccT::GenerateWrapper()
 
 } // End of unnamed namespace
 
-bool cmQtAutoRcc(cm::string_view infoFile, cm::string_view config,
-                 cm::string_view executableConfig)
+bool cmQtAutoRcc(cm::string_view infoFile, cm::string_view config)
 {
-  return cmQtAutoRccT().Run(infoFile, config, executableConfig);
+  return cmQtAutoRccT().Run(infoFile, config);
 }
diff --git a/Source/cmQtAutoRcc.h b/Source/cmQtAutoRcc.h
index 9c0a4e9..d525efa 100644
--- a/Source/cmQtAutoRcc.h
+++ b/Source/cmQtAutoRcc.h
@@ -10,5 +10,4 @@
  * Process AUTORCC
  * @return true on success
  */
-bool cmQtAutoRcc(cm::string_view infoFile, cm::string_view config,
-                 cm::string_view executableConfig);
+bool cmQtAutoRcc(cm::string_view infoFile, cm::string_view config);
diff --git a/Source/cmcmd.cxx b/Source/cmcmd.cxx
index 3dcfbf1..43a945f 100644
--- a/Source/cmcmd.cxx
+++ b/Source/cmcmd.cxx
@@ -1433,17 +1433,13 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string> const& args,
     if ((args[1] == "cmake_autogen") && (args.size() >= 4)) {
       cm::string_view const infoFile = args[2];
       cm::string_view const config = args[3];
-      cm::string_view const executableConfig =
-        (args.size() >= 5) ? cm::string_view(args[4]) : cm::string_view();
-      return cmQtAutoMocUic(infoFile, config, executableConfig) ? 0 : 1;
+      return cmQtAutoMocUic(infoFile, config) ? 0 : 1;
     }
     if ((args[1] == "cmake_autorcc") && (args.size() >= 3)) {
       cm::string_view const infoFile = args[2];
       cm::string_view const config =
         (args.size() > 3) ? cm::string_view(args[3]) : cm::string_view();
-      cm::string_view const executableConfig =
-        (args.size() >= 5) ? cm::string_view(args[4]) : cm::string_view();
-      return cmQtAutoRcc(infoFile, config, executableConfig) ? 0 : 1;
+      return cmQtAutoRcc(infoFile, config) ? 0 : 1;
     }
 #endif