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

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
   {

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;
 }

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_;
 };

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;
     }
   }
 

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;

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);

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_;
 };

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);
 }

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);

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);
 }

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);

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
 

Tests/RunCMake/Autogen/RunCMakeTest.cmake

@@ -151,10 +151,7 @@ if (DEFINED with_qt_version)
             # Touch just the library source file, which shouldn't cause a rerun of AUTOMOC
             # for app_with_qt target.
             file(TOUCH "${RunCMake_SOURCE_DIR}/simple_lib.cpp")
-            set(RunCMake_TEST_NOT_EXPECT_stdout "Automatic MOC for target app_with_qt|\
-Automatic MOC for target sub_exe_1|\
-Automatic MOC for target sub_exe_2")
-            set(RunCMake_TEST_VARIANT_DESCRIPTION "-Don't execute AUTOMOC for 'app_with_qt', 'sub_exe_1' and 'sub_exe_2'")
+
             # Build and assert that AUTOMOC was not run for app_with_qt, sub_exe_1 and sub_exe_2.
             run_cmake_command(QtAutoMocDeps-build ${CMAKE_COMMAND} --build . --verbose ${config_param})
             unset(RunCMake_TEST_VARIANT_DESCRIPTION)
@@ -172,13 +169,13 @@ Automatic MOC for target sub_exe_2")
               message(${message_type} "QtAutoMocDeps-build-\"${file}\" was generated - ${check_result}")
             endmacro()
 
-            check_file_exists("${RunCMake_TEST_BINARY_DIR}/app_with_qt_autogen/deps${config_suffix}")
-            check_file_exists("${RunCMake_TEST_BINARY_DIR}/QtSubDir1/sub_exe_1_autogen/deps${config_suffix}")
-            check_file_exists("${RunCMake_TEST_BINARY_DIR}/QtSubDir2/sub_exe_2_autogen/deps${config_suffix}")
+            check_file_exists("${RunCMake_TEST_BINARY_DIR}/app_with_qt_autogen/deps")
+            check_file_exists("${RunCMake_TEST_BINARY_DIR}/QtSubDir1/sub_exe_1_autogen/deps")
+            check_file_exists("${RunCMake_TEST_BINARY_DIR}/QtSubDir2/sub_exe_2_autogen/deps")
 
-            check_file_exists("${RunCMake_TEST_BINARY_DIR}/app_with_qt_autogen/timestamp${config_suffix}")
-            check_file_exists("${RunCMake_TEST_BINARY_DIR}/QtSubDir1/sub_exe_1_autogen/timestamp${config_suffix}")
-            check_file_exists("${RunCMake_TEST_BINARY_DIR}/QtSubDir2/sub_exe_2_autogen/timestamp${config_suffix}")
+            check_file_exists("${RunCMake_TEST_BINARY_DIR}/app_with_qt_autogen/timestamp")
+            check_file_exists("${RunCMake_TEST_BINARY_DIR}/QtSubDir1/sub_exe_1_autogen/timestamp")
+            check_file_exists("${RunCMake_TEST_BINARY_DIR}/QtSubDir2/sub_exe_2_autogen/timestamp")
 
             # Touch a header file to make sure an automoc dependency cycle is not introduced.
             file(TOUCH "${RunCMake_SOURCE_DIR}/MyWindow.h")
@@ -192,266 +189,4 @@ Automatic MOC for target sub_exe_2")
       endif()
     endblock()
   endif()
-
-  function(run_make_program dir)
-    execute_process(
-      COMMAND "${RunCMake_MAKE_PROGRAM}" ${ARGN}
-      WORKING_DIRECTORY "${dir}"
-      OUTPUT_VARIABLE make_program_stdout
-      ERROR_VARIABLE make_program_stderr
-      RESULT_VARIABLE make_program_result
-      )
-      if (NOT DEFINED RunMakeProgram_expected_result)
-        set(RunMakeProgram_expected_result 0)
-      endif()
-      if(NOT "${make_program_result}" MATCHES "${RunMakeProgram_expected_result}")
-        message(STATUS "
-============ beginning of ${RunCMake_MAKE_PROGRAM}'s stdout ============
-${make_program_stdout}
-=============== end of ${RunCMake_MAKE_PROGRAM}'s stdout ===============
-")
-        message(STATUS "
-============ beginning of ${RunCMake_MAKE_PROGRAM}'s stderr ============
-${make_program_stderr}
-=============== end of ${RunCMake_MAKE_PROGRAM}'s stderr ===============
-")
-        message(FATAL_ERROR
-                "top ${RunCMake_MAKE_PROGRAM} build failed exited with status ${make_program_result}")
-    endif()
-    set(make_program_stdout "${make_program_stdout}" PARENT_SCOPE)
-  endfunction(run_make_program)
-
-  function(count_substring STRING SUBSTRING COUNT_VAR)
-      string(LENGTH "${STRING}" STRING_LENGTH)
-      string(LENGTH "${SUBSTRING}" SUBSTRING_LENGTH)
-      if (SUBSTRING_LENGTH EQUAL 0)
-          message(FATAL_ERROR "SUBSTRING_LENGTH is 0")
-      endif()
-
-      if (STRING_LENGTH EQUAL 0)
-          message(FATAL_ERROR "STRING_LENGTH is 0")
-      endif()
-
-      if (STRING_LENGTH LESS SUBSTRING_LENGTH)
-          message(FATAL_ERROR "STRING_LENGTH is less than SUBSTRING_LENGTH")
-      endif()
-
-      set(COUNT 0)
-      string(FIND "${STRING}" "${SUBSTRING}" SUBSTRING_START)
-      while(SUBSTRING_START GREATER_EQUAL 0)
-          math(EXPR COUNT "${COUNT} + 1")
-          math(EXPR SUBSTRING_START "${SUBSTRING_START} + ${SUBSTRING_LENGTH}")
-          string(SUBSTRING "${STRING}" ${SUBSTRING_START} -1 STRING)
-          string(FIND "${STRING}" "${SUBSTRING}" SUBSTRING_START)
-      endwhile()
-
-      set(${COUNT_VAR} ${COUNT} PARENT_SCOPE)
-  endfunction()
-
-  function(expect_only_once make_program_stdout expected_output test_name)
-    count_substring("${make_program_stdout}" "${expected_output}" count)
-    if(NOT count EQUAL 1)
-      message(STATUS "${test_name}-expect_only_once - FAILED")
-      message(FATAL_ERROR "Expected to find ${expected_output} exactly once in ${make_program_stdout} but found ${count} occurrences of ${expected_output}")
-    else()
-      message(STATUS "${test_name}-expect_only_once - PASSED")
-    endif()
-  endfunction()
-
-  function(expect_n_times string_to_check expected_output expected_count test_name)
-    count_substring("${string_to_check}" "${expected_output}" count)
-    if(NOT count EQUAL ${expected_count})
-      message(STATUS "${test_name}-expect_${expected_count}_times - FAILED")
-      message(FATAL_ERROR "Expected to find ${expected_output} exactly ${expected_count} times in ${string_to_check} but found ${count} occurrences of ${expected_output}")
-    else()
-      message(STATUS "${test_name}-expect_${expected_count}_times - PASSED")
-    endif()
-  endfunction()
-
-  function(not_expect make_program_stdout unexpected_output test_name)
-    count_substring("${make_program_stdout}" "${unexpected_output}" count)
-    if(NOT count EQUAL 0)
-      message(STATUS "${test_name}-not_expect - FAILED")
-      message(FATAL_ERROR "Expected to find ${unexpected_output} exactly 0 times in ${make_program_stdout} but found ${count} occurrences of ${unexpected_output}")
-    else()
-      message(STATUS "${test_name}-not_expect - PASSED")
-    endif()
-  endfunction()
-
-  if (QtCore_VERSION VERSION_GREATER_EQUAL 5.15.0)
-    foreach(exe IN ITEMS Moc Uic Rcc)
-      if(RunCMake_GENERATOR MATCHES "Ninja Multi-Config")
-        block()
-          set(RunCMake_TEST_VARIANT_DESCRIPTION "-CMake-configure")
-          set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/Auto${exe}ExecutableConfig-multi-config-build)
-          run_cmake_with_options(Auto${exe}ExecutableConfig ${RunCMake_TEST_OPTIONS} -DCMAKE_AUTOGEN_VERBOSE=ON)
-          unset(RunCMake_TEST_VARIANT_DESCRIPTION)
-          set(RunCMake_TEST_NO_CLEAN 1)
-          foreach(config IN ITEMS Debug Release RelWithDebInfo)
-            block()
-              set(RunCMake_TEST_EXPECT_stdout ".*running_exe_${config}*")
-              set(RunCMake_TEST_VARIANT_DESCRIPTION "-${config}-expect_running_exe_${config}")
-              run_cmake_command(Auto${exe}ExecutableConfig-multi-config-build ${CMAKE_COMMAND} --build . --config ${config})
-            endblock()
-          endforeach()
-          set(RunCMake_TEST_EXPECT_stdout "ninja: no work to do")
-          foreach(config IN ITEMS Debug Release RelWithDebInfo)
-            block()
-            set(RunCMake_TEST_VARIANT_DESCRIPTION "-${config}-expect_no_work_to_do")
-              run_cmake_command(Auto${exe}ExecutableConfig-multi-config-build ${CMAKE_COMMAND} --build . --config ${config})
-            endblock()
-          endforeach()
-        endblock()
-        block()
-          set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/Auto${exe}ExecutableConfig-build)
-          run_cmake_with_options(Auto${exe}ExecutableConfig ${RunCMake_TEST_OPTIONS} -DCMAKE_AUTOGEN_VERBOSE=ON)
-          foreach(config IN ITEMS Debug Release RelWithDebInfo)
-            block()
-              run_make_program(${RunCMake_TEST_BINARY_DIR} --verbose -f build-${config}.ninja)
-
-              set(expected_output "running_exe_${config}")
-              expect_only_once("${make_program_stdout}" "${expected_output}" "Auto${exe}ExecutableConfig-${config}-${expected_output}")
-
-              foreach(sub_config IN ITEMS Debug Release RelWithDebInfo)
-                if(NOT sub_config STREQUAL config)
-                  set(unexpected_output "running_exe_${sub_config}")
-                  not_expect("${make_program_stdout}" "${unexpected_output}" "Auto${exe}ExecutableConfig-${config}-${unexpected_output}")
-                endif()
-              endforeach()
-
-              if (exe STREQUAL "Moc" OR exe STREQUAL "Uic")
-                set(expected_output "cmake_autogen")
-              else()
-                set(expected_output "cmake_autorcc")
-              endif()
-              expect_only_once("${make_program_stdout}" "${expected_output}" "Auto${exe}ExecutableConfig-${config}-${expected_output}")
-            endblock()
-          endforeach()
-        endblock()
-        block()
-          foreach(ninja_config IN ITEMS Debug Release RelWithDebInfo)
-            foreach(target_config IN ITEMS Debug Release RelWithDebInfo)
-              block()
-                set(TEST_SUFFIX "-CrossConfig-${ninja_config}-${target_config}")
-                set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/Auto${exe}ExecutableConfig${TEST_SUFFIX}-build)
-                set(RunCMake_TEST_VARIANT_DESCRIPTION ${TEST_SUFFIX})
-                run_cmake_with_options(Auto${exe}ExecutableConfig ${RunCMake_TEST_OPTIONS} -DCMAKE_CROSS_CONFIGS=all -DCMAKE_DEFAULT_BUILD_TYPE=${ninja_config})
-                unset(RunCMake_TEST_VARIANT_DESCRIPTION)
-
-                run_make_program(${RunCMake_TEST_BINARY_DIR} --verbose -f build-${ninja_config}.ninja dummy:${target_config})
-
-                set(expected_output "running_exe_${ninja_config}")
-                expect_only_once("${make_program_stdout}" "${expected_output}" "Auto${exe}ExecutableConfig${TEST_SUFFIX}-${expected_output}")
-
-                foreach(sub_config IN ITEMS Debug Release RelWithDebInfo)
-                  if(NOT sub_config STREQUAL ninja_config)
-                    set(unexpected_output "running_exe_${sub_config}")
-                    not_expect("${make_program_stdout}" "${unexpected_output}" "Auto${exe}ExecutableConfig${TEST_SUFFIX}-${unexpected_output}")
-                  endif()
-                endforeach()
-
-                if (exe STREQUAL "Moc" OR exe STREQUAL "Uic")
-                  set(expected_output "cmake_autogen")
-                else()
-                  set(expected_output "cmake_autorcc")
-                endif()
-                expect_only_once("${make_program_stdout}" "${expected_output}" "Auto${exe}ExecutableConfig${TEST_SUFFIX}-${expected_output}")
-              endblock()
-            endforeach()
-          endforeach()
-        endblock()
-        block()
-          foreach(ninja_config IN ITEMS Debug Release RelWithDebInfo)
-            set(TEST_SUFFIX "-CrossConfig-${ninja_config}-all-all")
-            set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/Auto${exe}ExecutableConfig${TEST_SUFFIX}-build)
-            set(RunCMake_TEST_VARIANT_DESCRIPTION ${TEST_SUFFIX})
-            run_cmake_with_options(Auto${exe}ExecutableConfig ${RunCMake_TEST_OPTIONS} -DCMAKE_CROSS_CONFIGS=all)
-            unset(RunCMake_TEST_VARIANT_DESCRIPTION)
-            run_make_program(${RunCMake_TEST_BINARY_DIR} --verbose -f build-${ninja_config}.ninja all:all)
-          endforeach()
-        endblock()
-      elseif (RunCMake_GENERATOR MATCHES "Ninja|Make")
-        block()
-          set(RunCMake_TEST_BINARY_DIR  ${RunCMake_BINARY_DIR}/Auto${exe}ExecutableConfig-build)
-          foreach(config IN ITEMS Debug Release RelWithDebInfo)
-            block()
-              set(RunCMake_TEST_VARIANT_DESCRIPTION "-${config}")
-              run_cmake_with_options(Auto${exe}ExecutableConfig ${RunCMake_TEST_OPTIONS} -DCMAKE_BUILD_TYPE=${config} -DCMAKE_AUTOGEN_VERBOSE=ON)
-              unset(RunCMake_TEST_VARIANT_DESCRIPTION)
-              set(RunCMake_TEST_NO_CLEAN 1)
-              set(RunCMake_TEST_EXPECT_stdout ".*running_exe_${config}*")
-              run_cmake_command(Auto${exe}ExecutableConfig-${config}-build ${CMAKE_COMMAND} --build .)
-            endblock()
-          endforeach()
-        endblock()
-      endif()
-    endforeach()
-  endif()
-
-  # Visual Studio specific dependency tests
-  if (RunCMake_GENERATOR MATCHES "Visual Studio")
-      foreach(exe IN ITEMS Moc Uic Rcc)
-          block()
-            set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/${exe}Example-build)
-            set(RunCMake_TEST_VARIANT_DESCRIPTION "-CMake-configure")
-            run_cmake_with_options(${exe}Example ${RunCMake_TEST_OPTIONS} -DCMAKE_AUTOGEN_VERBOSE=ON)
-            unset(RunCMake_TEST_VARIANT_DESCRIPTION)
-            set(RunCMake_TEST_NO_CLEAN 1)
-            foreach(config IN ITEMS Debug Release RelWithDebInfo)
-              block()
-                set(RunCMake_TEST_VARIANT_DESCRIPTION "-${config}-first-build")
-                run_cmake_command(${exe}Example-build ${CMAKE_COMMAND} --build . --config ${config})
-              endblock()
-            endforeach()
-            foreach(config IN ITEMS Debug Release RelWithDebInfo)
-              block()
-                if (exe STREQUAL "Moc" OR exe STREQUAL "Uic")
-                  set(RunCMake_TEST_NOT_EXPECT_stdout "Auto${exe}")
-                  set(not_expect_descripton "Auto${exe}")
-                else ()
-                  set(RunCMake_TEST_NOT_EXPECT_stdout "qrc_data.cpp|Auto${exe}")
-                  set(not_expect_descripton "qrc_data.cpp_and_Auto${exe}")
-                endif()
-                set(RunCMake_TEST_VARIANT_DESCRIPTION "-second-build-${config}_expect_no_${not_expect_descripton}")
-                run_cmake_command(${exe}Example-build ${CMAKE_COMMAND} --build . --config ${config})
-              endblock()
-            endforeach()
-          endblock()
-      endforeach()
-  endif()
-
-  if (RunCMake_GENERATOR MATCHES "Xcode")
-    foreach(exe IN ITEMS Moc Uic Rcc)
-      block()
-        set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/${exe}Example-build)
-        set(RunCMake_TEST_VARIANT_DESCRIPTION "-CMake-configure")
-        set(RunCMake_TEST_EXPECT_stderr ".*")
-        run_cmake_with_options(${exe}Example ${RunCMake_TEST_OPTIONS} -DCMAKE_AUTOGEN_VERBOSE=ON)
-        set(RunCMake_TEST_NO_CLEAN 1)
-        set(RunCMake_MAKE_PROGRAM ${CMAKE_COMMAND})
-        run_make_program(${RunCMake_TEST_BINARY_DIR}  --build . --config Debug)
-        if (exe STREQUAL "Moc")
-          set(expected_count 16)
-        elseif (exe STREQUAL "Uic")
-          set(expected_count 4)
-        else()
-          set(expected_count 12)
-        endif()
-        expect_n_times("${make_program_stdout}" "Auto${exe}:" ${expected_count} "${exe}Example-build-Auto${exe}")
-        expect_n_times("${make_program_stdout}" "Auto${exe}:" ${expected_count} "${exe}Example-build-Auto${exe}")
-
-        if (exe STREQUAL "Moc" OR exe STREQUAL "Uic")
-          expect_n_times("${make_program_stdout}" "AutoGen:" 20 "${exe}Example-build-AutoGen:")
-        endif()
-
-        foreach(config IN ITEMS Debug Release RelWithDebInfo)
-          block()
-            run_make_program(${RunCMake_TEST_BINARY_DIR} --build . --config ${config})
-            not_expect("${make_program_stdout}" "Auto${exe}" "${exe}Example-${config}_Auto${exe}")
-            not_expect("${make_program_stdout}" "AutoGen:" "${exe}Example-${config}_AutoGen")
-          endblock()
-        endforeach()
-      endblock()
-    endforeach()
-  endif()
 endif ()

Tests/RunCMake/Autogen/data.qrc

@@ -1,4 +0,0 @@
-<!DOCTYPE RCC><RCC version="1.0">
-<qresource prefix="/res/affine">
-</qresource>
-</RCC>

Tests/RunCMake/Autogen/example.cpp

@@ -1,5 +0,0 @@
-#include "example.h"
-
-Example::Example()
-{
-}

Tests/RunCMake/Autogen/example.h

@@ -1,12 +0,0 @@
-#ifndef EXAMPLE_H
-#define EXAMPLE_H
-
-#include <QObject>
-
-class Example : public QObject
-{
-  Q_OBJECT
-  Example();
-};
-
-#endif

Tests/RunCMake/Autogen/example_ui.cpp

@@ -1,5 +0,0 @@
-#include "example_ui.h"
-
-Example::Example()
-{
-}

Tests/RunCMake/Autogen/example_ui.h

@@ -1,14 +0,0 @@
-#ifndef EXAMPLE_UI_H
-#define EXAMPLE_UI_H
-
-#include <QObject>
-
-#include "ui_uiA.h"
-
-class Example : public QObject
-{
-  Q_OBJECT
-  Example();
-};
-
-#endif

Tests/RunCMake/Autogen/exe.cpp

@@ -1,4 +0,0 @@
-int main()
-{
-  return 0;
-}

Tests/RunCMake/Autogen/exe_common.h

@@ -1,48 +0,0 @@
-#ifndef EXE_COMMON_H
-#define EXE_COMMON_H
-
-#include <cstdlib>
-#include <fstream>
-#include <string>
-#include <vector>
-
-inline int runRealExe(const int argc, char** argv)
-{
-  std::vector<std::string> args;
-  std::string realMocPath;
-  std::string const pathArg = "EXE_PATH=";
-  std::string cmd;
-  if (argc > 1) {
-    for (int i = 1; i < argc; ++i) {
-      std::string const arg = argv[i];
-      if (arg.find(pathArg) != std::string::npos) {
-        realMocPath = arg.substr(pathArg.length());
-        // if EXE_PATH contains spaces, wrap it in quotes
-        if (realMocPath.find(" ") != std::string::npos) {
-          realMocPath = "\"" + realMocPath + "\"";
-        }
-      } else {
-        args.push_back(arg);
-      }
-    }
-  }
-#ifdef _WIN32
-  cmd += "cmd /C \"";
-#endif
-  cmd += realMocPath + " ";
-  for (auto arg : args) {
-    // if arg contains spaces, wrap it in quotes
-    if (arg.find(' ') != std::string::npos) {
-      cmd += " \"" + arg + "\"";
-    } else {
-      cmd += " " + arg;
-    }
-  }
-#ifdef _WIN32
-  cmd += "\"";
-#endif
-  std::cout << "Running real exe:" << cmd << std::endl;
-  return std::system(cmd.c_str());
-}
-
-#endif

Tests/RunCMake/Autogen/exe_debug.cpp

@@ -1,10 +0,0 @@
-#include <fstream>
-#include <iostream>
-
-#include "exe_common.h"
-
-int main(int argc, char* argv[])
-{
-  std::cout << "running_exe_Debug\n";
-  return runRealExe(argc, argv);
-}

Tests/RunCMake/Autogen/exe_release.cpp

@@ -1,10 +0,0 @@
-#include <fstream>
-#include <iostream>
-
-#include "exe_common.h"
-
-int main(int argc, char* argv[])
-{
-  std::cout << "running_exe_Release\n";
-  return runRealExe(argc, argv);
-}

Tests/RunCMake/Autogen/exe_relwithdebinfo.cpp

@@ -1,10 +0,0 @@
-#include <fstream>
-#include <iostream>
-
-#include "exe_common.h"
-
-int main(int argc, char* argv[])
-{
-  std::cout << "running_exe_RelWithDebInfo\n";
-  return runRealExe(argc, argv);
-}

Tests/RunCMake/Autogen/uiA.ui

@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>UiA</class>
- <widget class="QWidget" name="UiA">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>400</width>
-    <height>300</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
-  <layout class="QHBoxLayout" name="horizontalLayout">
-   <item>
-    <widget class="QTreeView" name="treeView"/>
-   </item>
-  </layout>
- </widget>
- <resources/>
- <connections/>
-</ui>