Autogen: Add support for global ``autogen`` and ``autorcc`` targets

This teaches CMake the variables

- CMAKE_GLOBAL_AUTOGEN_TARGET
- CMAKE_GLOBAL_AUTOGEN_TARGET_NAME
- CMAKE_GLOBAL_AUTORCC_TARGET
- CMAKE_GLOBAL_AUTORCC_TARGET_NAME

which control the generation of global
``autogen`` and ``autorcc`` targets.

Closes #17721

1 files changed, 115 insertions, 6 deletions

diff --git a/Source/cmQtAutoGenGlobalInitializer.cxx b/Source/cmQtAutoGenGlobalInitializer.cxx
index d815a43..5470ec3 100644
--- a/Source/cmQtAutoGenGlobalInitializer.cxx
+++ b/Source/cmQtAutoGenGlobalInitializer.cxx
@@ -1,15 +1,56 @@
 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing for details.  */
 #include "cmQtAutoGenGlobalInitializer.h"
+#include "cmQtAutoGen.h"
+#include "cmQtAutoGenInitializer.h"
+
 #include "cmAlgorithms.h"
+#include "cmCustomCommandLines.h"
 #include "cmGeneratorTarget.h"
 #include "cmLocalGenerator.h"
-#include "cmQtAutoGenInitializer.h"
+#include "cmMakefile.h"
+#include "cmState.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+
+#include <memory>
+#include <utility>
 
 cmQtAutoGenGlobalInitializer::cmQtAutoGenGlobalInitializer(
   std::vector<cmLocalGenerator*> const& localGenerators)
 {
   for (cmLocalGenerator* localGen : localGenerators) {
+    // Detect global autogen and autorcc target names
+    bool globalAutoGenTarget = false;
+    bool globalAutoRccTarget = false;
+    {
+      cmMakefile* makefile = localGen->GetMakefile();
+      // Detect global autogen target name
+      if (cmSystemTools::IsOn(
+            makefile->GetSafeDefinition("CMAKE_GLOBAL_AUTOGEN_TARGET"))) {
+        std::string targetName =
+          makefile->GetSafeDefinition("CMAKE_GLOBAL_AUTOGEN_TARGET_NAME");
+        if (targetName.empty()) {
+          targetName = "autogen";
+        }
+        GlobalAutoGenTargets_.emplace(localGen, std::move(targetName));
+        globalAutoGenTarget = true;
+      }
+
+      // Detect global autorcc target name
+      if (cmSystemTools::IsOn(
+            makefile->GetSafeDefinition("CMAKE_GLOBAL_AUTORCC_TARGET"))) {
+        std::string targetName =
+          makefile->GetSafeDefinition("CMAKE_GLOBAL_AUTORCC_TARGET_NAME");
+        if (targetName.empty()) {
+          targetName = "autorcc";
+        }
+        GlobalAutoRccTargets_.emplace(localGen, std::move(targetName));
+        globalAutoRccTarget = true;
+      }
+    }
+
     // Find targets that require AUTOMOC/UIC/RCC processing
     for (cmGeneratorTarget* target : localGen->GetGeneratorTargets()) {
       // Process only certain target types
@@ -39,7 +80,8 @@ cmQtAutoGenGlobalInitializer::cmQtAutoGenGlobalInitializer(
         if ((qtVersion.Major == 4) || (qtVersion.Major == 5)) {
           // Create autogen target initializer
           Initializers_.emplace_back(cm::make_unique<cmQtAutoGenInitializer>(
-            target, moc, uic, rcc, qtVersion));
+            this, target, qtVersion, moc, uic, rcc, globalAutoGenTarget,
+            globalAutoRccTarget));
         }
       }
     }
@@ -50,6 +92,58 @@ cmQtAutoGenGlobalInitializer::~cmQtAutoGenGlobalInitializer()
 {
 }
 
+void cmQtAutoGenGlobalInitializer::GetOrCreateGlobalTarget(
+  cmLocalGenerator* localGen, std::string const& name,
+  std::string const& comment)
+{
+  // Test if the target already exists
+  if (localGen->FindGeneratorTargetToUse(name) == nullptr) {
+    cmMakefile* makefile = localGen->GetMakefile();
+
+    // Create utility target
+    cmTarget* target = makefile->AddUtilityCommand(
+      name, cmMakefile::TargetOrigin::Generator, true,
+      makefile->GetHomeOutputDirectory().c_str() /*work dir*/,
+      std::vector<std::string>() /*output*/,
+      std::vector<std::string>() /*depends*/, cmCustomCommandLines(), false,
+      comment.c_str());
+    localGen->AddGeneratorTarget(new cmGeneratorTarget(target, localGen));
+
+    // Set FOLDER property in the target
+    {
+      char const* folder =
+        makefile->GetState()->GetGlobalProperty("AUTOGEN_TARGETS_FOLDER");
+      if (folder != nullptr) {
+        target->SetProperty("FOLDER", folder);
+      }
+    }
+  }
+}
+
+void cmQtAutoGenGlobalInitializer::AddToGlobalAutoGen(
+  cmLocalGenerator* localGen, std::string const& targetName)
+{
+  auto it = GlobalAutoGenTargets_.find(localGen);
+  if (it != GlobalAutoGenTargets_.end()) {
+    cmGeneratorTarget* target = localGen->FindGeneratorTargetToUse(it->second);
+    if (target != nullptr) {
+      target->Target->AddUtility(targetName, localGen->GetMakefile());
+    }
+  }
+}
+
+void cmQtAutoGenGlobalInitializer::AddToGlobalAutoRcc(
+  cmLocalGenerator* localGen, std::string const& targetName)
+{
+  auto it = GlobalAutoRccTargets_.find(localGen);
+  if (it != GlobalAutoRccTargets_.end()) {
+    cmGeneratorTarget* target = localGen->FindGeneratorTargetToUse(it->second);
+    if (target != nullptr) {
+      target->Target->AddUtility(targetName, localGen->GetMakefile());
+    }
+  }
+}
+
 bool cmQtAutoGenGlobalInitializer::generate()
 {
   return (InitializeCustomTargets() && SetupCustomTargets());
@@ -57,8 +151,23 @@ bool cmQtAutoGenGlobalInitializer::generate()
 
 bool cmQtAutoGenGlobalInitializer::InitializeCustomTargets()
 {
-  for (auto& autoGen : Initializers_) {
-    if (!autoGen->InitCustomTargets()) {
+  // Initialize global autogen targets
+  {
+    std::string const comment = "Global AUTOGEN target";
+    for (auto const& pair : GlobalAutoGenTargets_) {
+      GetOrCreateGlobalTarget(pair.first, pair.second, comment);
+    }
+  }
+  // Initialize global autorcc targets
+  {
+    std::string const comment = "Global AUTORCC target";
+    for (auto const& pair : GlobalAutoRccTargets_) {
+      GetOrCreateGlobalTarget(pair.first, pair.second, comment);
+    }
+  }
+  // Initialize per target autogen targets
+  for (auto& initializer : Initializers_) {
+    if (!initializer->InitCustomTargets()) {
       return false;
     }
   }
@@ -67,8 +176,8 @@ bool cmQtAutoGenGlobalInitializer::InitializeCustomTargets()
 
 bool cmQtAutoGenGlobalInitializer::SetupCustomTargets()
 {
-  for (auto& autoGen : Initializers_) {
-    if (!autoGen->SetupCustomTargets()) {
+  for (auto& initializer : Initializers_) {
+    if (!initializer->SetupCustomTargets()) {
       return false;
     }
   }