21 files changed, 245 insertions, 94 deletions
diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake
index 0fc9864..76adb83 100644
--- a/Source/CMakeVersion.cmake
+++ b/Source/CMakeVersion.cmake
@@ -1,7 +1,7 @@
 # CMake version number components.
 set(CMake_VERSION_MAJOR 3)
 set(CMake_VERSION_MINOR 16)
-set(CMake_VERSION_PATCH 20200202)
+set(CMake_VERSION_PATCH 20200204)
 #set(CMake_VERSION_RC 0)
 set(CMake_VERSION_IS_DIRTY 0)
 
diff --git a/Source/CPack/cmCPackOSXX11Generator.cxx b/Source/CPack/cmCPackOSXX11Generator.cxx
index 951c65f..5de4a6f 100644
--- a/Source/CPack/cmCPackOSXX11Generator.cxx
+++ b/Source/CPack/cmCPackOSXX11Generator.cxx
@@ -178,6 +178,9 @@ int cmCPackOSXX11Generator::PackageFiles()
 
 int cmCPackOSXX11Generator::InitializeInternal()
 {
+  cmCPackLogger(cmCPackLog::LOG_WARNING,
+                "The OSXX11 generator is deprecated "
+                "and will be removed in a future version.\n");
   cmCPackLogger(cmCPackLog::LOG_DEBUG,
                 "cmCPackOSXX11Generator::Initialize()" << std::endl);
   std::vector<std::string> path;
diff --git a/Source/CPack/cmCPackPackageMakerGenerator.cxx b/Source/CPack/cmCPackPackageMakerGenerator.cxx
index 12ea97b..f51ea42 100644
--- a/Source/CPack/cmCPackPackageMakerGenerator.cxx
+++ b/Source/CPack/cmCPackPackageMakerGenerator.cxx
@@ -321,6 +321,9 @@ int cmCPackPackageMakerGenerator::PackageFiles()
 
 int cmCPackPackageMakerGenerator::InitializeInternal()
 {
+  cmCPackLogger(cmCPackLog::LOG_WARNING,
+                "The PackageMaker generator is deprecated "
+                "and will be removed in a future version.\n");
   this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/usr");
 
   // Starting with Xcode 4.3, PackageMaker is a separate app, and you
diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx
index e70bc5a..78c68be 100644
--- a/Source/CTest/cmCTestTestHandler.cxx
+++ b/Source/CTest/cmCTestTestHandler.cxx
@@ -410,10 +410,15 @@ int cmCTestTestHandler::ProcessHandler()
 
   auto clock_finish = std::chrono::steady_clock::now();
 
+  bool noTestsFoundError = false;
   if (passed.size() + failed.size() == 0) {
-    if (!this->CTest->GetShowOnly() && !this->CTest->ShouldPrintLabels()) {
+    if (!this->CTest->GetShowOnly() && !this->CTest->ShouldPrintLabels() &&
+        this->CTest->GetNoTestsMode() != cmCTest::NoTests::Ignore) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
                  "No tests were found!!!" << std::endl);
+      if (this->CTest->GetNoTestsMode() == cmCTest::NoTests::Error) {
+        noTestsFoundError = true;
+      }
     }
   } else {
     if (this->HandlerVerbose && !passed.empty() &&
@@ -459,6 +464,12 @@ int cmCTestTestHandler::ProcessHandler()
     this->LogFile = nullptr;
     return -1;
   }
+
+  if (noTestsFoundError) {
+    this->LogFile = nullptr;
+    return -1;
+  }
+
   this->LogFile = nullptr;
   return 0;
 }
diff --git a/Source/cmArchiveWrite.cxx b/Source/cmArchiveWrite.cxx
index f8d1aa7..d29b2ac 100644
--- a/Source/cmArchiveWrite.cxx
+++ b/Source/cmArchiveWrite.cxx
@@ -200,7 +200,8 @@ bool cmArchiveWrite::Add(std::string path, size_t skip, const char* prefix,
 bool cmArchiveWrite::AddPath(const char* path, size_t skip, const char* prefix,
                              bool recursive)
 {
-  if (strcmp(path, ".") != 0 || this->Format != "zip") {
+  if (strcmp(path, ".") != 0 ||
+      (this->Format != "zip" && this->Format != "7zip")) {
     if (!this->AddFile(path, skip, prefix)) {
       return false;
     }
@@ -212,7 +213,7 @@ bool cmArchiveWrite::AddPath(const char* path, size_t skip, const char* prefix,
   cmsys::Directory d;
   if (d.Load(path)) {
     std::string next = cmStrCat(path, '/');
-    if (next == "./" && this->Format == "zip") {
+    if (next == "./" && (this->Format == "zip" || this->Format == "7zip")) {
       next.clear();
     }
     std::string::size_type end = next.size();
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
index 22a6e38..04f75bd 100644
--- a/Source/cmCTest.cxx
+++ b/Source/cmCTest.cxx
@@ -208,6 +208,8 @@ struct cmCTest::Private
   bool OutputColorCode = cmCTest::ColoredOutputSupportedByConsole();
 
   std::map<std::string, std::string> Definitions;
+
+  cmCTest::NoTests NoTestsMode = cmCTest::NoTests::Legacy;
 };
 
 struct tm* cmCTest::GetNightlyTime(std::string const& str, bool tomorrowtag)
@@ -2059,6 +2061,19 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
     this->SetNotesFiles(args[i].c_str());
   }
 
+  const std::string noTestsPrefix = "--no-tests=";
+  if (cmHasPrefix(arg, noTestsPrefix)) {
+    const std::string noTestsMode = arg.substr(noTestsPrefix.length());
+    if (noTestsMode == "error") {
+      this->Impl->NoTestsMode = cmCTest::NoTests::Error;
+    } else if (noTestsMode != "ignore") {
+      errormsg = "'--no-tests=' given unknown value '" + noTestsMode + "'";
+      return false;
+    } else {
+      this->Impl->NoTestsMode = cmCTest::NoTests::Ignore;
+    }
+  }
+
   // options that control what tests are run
   if (this->CheckArgument(arg, "-I", "--tests-information") &&
       i < args.size() - 1) {
@@ -2896,6 +2911,11 @@ cmCTest::Repeat cmCTest::GetRepeatMode() const
   return this->Impl->RepeatMode;
 }
 
+cmCTest::NoTests cmCTest::GetNoTestsMode() const
+{
+  return this->Impl->NoTestsMode;
+}
+
 void cmCTest::SetBuildID(const std::string& id)
 {
   this->Impl->BuildID = id;
diff --git a/Source/cmCTest.h b/Source/cmCTest.h
index e0ae100..7f8f913 100644
--- a/Source/cmCTest.h
+++ b/Source/cmCTest.h
@@ -442,6 +442,14 @@ public:
   };
   Repeat GetRepeatMode() const;
 
+  enum class NoTests
+  {
+    Legacy,
+    Error,
+    Ignore
+  };
+  NoTests GetNoTestsMode() const;
+
   void GenerateSubprojectsOutput(cmXMLWriter& xml);
   std::vector<std::string> GetLabelsForSubprojects();
 
diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx
index b8d8b96..5ff6f8c 100644
--- a/Source/cmCommonTargetGenerator.cxx
+++ b/Source/cmCommonTargetGenerator.cxx
@@ -17,6 +17,7 @@
 #include "cmSourceFile.h"
 #include "cmStateTypes.h"
 #include "cmStringAlgorithms.h"
+#include "cmTarget.h"
 
 cmCommonTargetGenerator::cmCommonTargetGenerator(cmGeneratorTarget* gt)
   : GeneratorTarget(gt)
@@ -216,6 +217,20 @@ std::string cmCommonTargetGenerator::GetManifests(const std::string& config)
   return cmJoin(manifests, " ");
 }
 
+std::string cmCommonTargetGenerator::GetAIXExports(std::string const&)
+{
+  std::string aixExports;
+  if (this->GeneratorTarget->Target->IsAIX()) {
+    if (const char* exportAll =
+          this->GeneratorTarget->GetProperty("AIX_EXPORT_ALL_SYMBOLS")) {
+      if (cmIsOff(exportAll)) {
+        aixExports = "-n";
+      }
+    }
+  }
+  return aixExports;
+}
+
 void cmCommonTargetGenerator::AppendOSXVerFlag(std::string& flags,
                                                const std::string& lang,
                                                const char* name, bool so)
diff --git a/Source/cmCommonTargetGenerator.h b/Source/cmCommonTargetGenerator.h
index 2796470..b40a2ed 100644
--- a/Source/cmCommonTargetGenerator.h
+++ b/Source/cmCommonTargetGenerator.h
@@ -55,6 +55,7 @@ protected:
   std::string GetDefines(const std::string& l, const std::string& config);
   std::string GetIncludes(std::string const& l, const std::string& config);
   std::string GetManifests(const std::string& config);
+  std::string GetAIXExports(std::string const& config);
 
   std::vector<std::string> GetLinkedTargetDirectories(
     const std::string& config) const;
diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx
index f6613d0..f7694ff 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -485,6 +485,9 @@ void cmGlobalNinjaGenerator::Generate()
                                            msg.str());
     return;
   }
+  if (!this->InspectConfigTypeVariables()) {
+    return;
+  }
   if (!this->OpenBuildFileStreams()) {
     return;
   }
@@ -544,6 +547,8 @@ void cmGlobalNinjaGenerator::CleanMetaData()
   auto run_ninja_tool = [this](std::vector<char const*> const& args) {
     std::vector<std::string> command;
     command.push_back(this->NinjaCommand);
+    command.emplace_back("-C");
+    command.emplace_back(this->GetCMakeInstance()->GetHomeOutputDirectory());
     command.emplace_back("-t");
     for (auto const& arg : args) {
       command.emplace_back(arg);
@@ -885,6 +890,28 @@ bool cmGlobalNinjaGenerator::OpenFileStream(
   return true;
 }
 
+cm::optional<std::set<std::string>> cmGlobalNinjaGenerator::ListSubsetWithAll(
+  const std::set<std::string>& defaults, const std::vector<std::string>& items)
+{
+  std::set<std::string> result;
+
+  for (auto const& item : items) {
+    if (item == "all") {
+      if (items.size() == 1) {
+        result = defaults;
+      } else {
+        return cm::nullopt;
+      }
+    } else if (defaults.count(item)) {
+      result.insert(item);
+    } else {
+      return cm::nullopt;
+    }
+  }
+
+  return cm::make_optional(result);
+}
+
 void cmGlobalNinjaGenerator::CloseBuildFileStreams()
 {
   if (this->BuildFileStream) {
@@ -1188,6 +1215,7 @@ void cmGlobalNinjaGenerator::AddTargetAlias(const std::string& alias,
   // uses the output as an alias.
   for (std::string const& output : outputs) {
     this->TargetAliases[output].GeneratorTarget = nullptr;
+    this->DefaultTargetAliases[output].GeneratorTarget = nullptr;
     for (const std::string& config2 :
          this->Makefiles.front()->GetGeneratorConfigs()) {
       this->Configs[config2].TargetAliases[output].GeneratorTarget = nullptr;
@@ -1199,18 +1227,28 @@ void cmGlobalNinjaGenerator::AddTargetAlias(const std::string& alias,
   TargetAlias ta;
   ta.GeneratorTarget = target;
   ta.Config = config;
-  std::pair<TargetAliasMap::iterator, bool> newAliasGlobal =
+
+  auto newAliasGlobal =
     this->TargetAliases.insert(std::make_pair(buildAlias, ta));
   if (newAliasGlobal.second &&
       newAliasGlobal.first->second.GeneratorTarget != target) {
     newAliasGlobal.first->second.GeneratorTarget = nullptr;
   }
-  std::pair<TargetAliasMap::iterator, bool> newAliasConfig =
+
+  auto newAliasConfig =
     this->Configs[config].TargetAliases.insert(std::make_pair(outputPath, ta));
   if (newAliasConfig.second &&
       newAliasConfig.first->second.GeneratorTarget != target) {
     newAliasConfig.first->second.GeneratorTarget = nullptr;
   }
+  if (this->DefaultConfigs.count(config)) {
+    auto newAliasDefaultGlobal =
+      this->DefaultTargetAliases.insert(std::make_pair(outputPath, ta));
+    if (newAliasDefaultGlobal.second &&
+        newAliasDefaultGlobal.first->second.GeneratorTarget != target) {
+      newAliasDefaultGlobal.first->second.GeneratorTarget = nullptr;
+    }
+  }
 }
 
 void cmGlobalNinjaGenerator::WriteTargetAliases(std::ostream& os)
@@ -1235,7 +1273,7 @@ void cmGlobalNinjaGenerator::WriteTargetAliases(std::ostream& os)
     build.Outputs.front() = ta.first;
     build.ExplicitDeps.clear();
     if (ta.second.Config == "all") {
-      for (auto const& config : this->GetCrossConfigs("")) {
+      for (auto const& config : this->CrossConfigs) {
         this->AppendTargetOutputs(ta.second.GeneratorTarget,
                                   build.ExplicitDeps, config);
       }
@@ -1245,7 +1283,7 @@ void cmGlobalNinjaGenerator::WriteTargetAliases(std::ostream& os)
     }
     this->WriteBuild(this->EnableCrossConfigBuild() &&
                          (ta.second.Config == "all" ||
-                          this->GetCrossConfigs("").count(ta.second.Config))
+                          this->CrossConfigs.count(ta.second.Config))
                        ? os
                        : *this->GetImplFileStream(ta.second.Config),
                      build);
@@ -1273,10 +1311,8 @@ void cmGlobalNinjaGenerator::WriteTargetAliases(std::ostream& os)
       }
     }
 
-    auto const* defaultConfig = this->GetDefaultBuildAlias();
-    if (defaultConfig) {
-      std::string config = defaultConfig;
-      for (auto const& ta : this->Configs[config].TargetAliases) {
+    if (!this->DefaultConfigs.empty()) {
+      for (auto const& ta : this->DefaultTargetAliases) {
         // Don't write ambiguous aliases.
         if (!ta.second.GeneratorTarget) {
           continue;
@@ -1290,13 +1326,7 @@ void cmGlobalNinjaGenerator::WriteTargetAliases(std::ostream& os)
 
         build.Outputs.front() = ta.first;
         build.ExplicitDeps.clear();
-        if (config == "all") {
-          for (auto const& config2 :
-               this->Makefiles.front()->GetGeneratorConfigs()) {
-            this->AppendTargetOutputs(ta.second.GeneratorTarget,
-                                      build.ExplicitDeps, config2);
-          }
-        } else {
+        for (auto const& config : this->DefaultConfigs) {
           this->AppendTargetOutputs(ta.second.GeneratorTarget,
                                     build.ExplicitDeps, config);
         }
@@ -1347,7 +1377,7 @@ void cmGlobalNinjaGenerator::WriteFolderTargets(std::ostream& os)
       }
       // Write target
       this->WriteBuild(this->EnableCrossConfigBuild() &&
-                           this->GetCrossConfigs("").count(config)
+                           this->CrossConfigs.count(config)
                          ? os
                          : *this->GetImplFileStream(config),
                        build);
@@ -1363,11 +1393,12 @@ void cmGlobalNinjaGenerator::WriteFolderTargets(std::ostream& os)
         this->WriteBuild(*this->GetConfigFileStream(config), build);
       }
 
-      auto const* defaultConfig = this->GetDefaultBuildAlias();
-      if (defaultConfig) {
-        std::string config = defaultConfig;
-        build.ExplicitDeps = { this->BuildAlias(
-          this->ConvertToNinjaPath(currentBinaryDir + "/all"), config) };
+      if (!this->DefaultFileConfig.empty()) {
+        build.ExplicitDeps.clear();
+        for (auto const& config : this->DefaultConfigs) {
+          build.ExplicitDeps.push_back(this->BuildAlias(
+            this->ConvertToNinjaPath(currentBinaryDir + "/all"), config));
+        }
         build.Outputs.front() =
           this->ConvertToNinjaPath(currentBinaryDir + "/all");
         this->WriteBuild(*this->GetDefaultFileStream(), build);
@@ -1377,7 +1408,7 @@ void cmGlobalNinjaGenerator::WriteFolderTargets(std::ostream& os)
     // Add target for all configs
     if (this->EnableCrossConfigBuild()) {
       build.ExplicitDeps.clear();
-      for (auto const& config : this->GetCrossConfigs("")) {
+      for (auto const& config : this->CrossConfigs) {
         build.ExplicitDeps.push_back(this->BuildAlias(
           this->ConvertToNinjaPath(currentBinaryDir + "/all"), config));
       }
@@ -1524,7 +1555,7 @@ void cmGlobalNinjaGenerator::WriteBuiltinTargets(std::ostream& os)
     this->WriteTargetDefault(*this->GetConfigFileStream(config));
   }
 
-  if (this->GetDefaultBuildType()) {
+  if (!this->DefaultFileConfig.empty()) {
     this->WriteTargetDefault(*this->GetDefaultFileStream());
   }
 }
@@ -1832,7 +1863,7 @@ void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os)
       build.ExplicitDeps.clear();
 
       if (additionalFiles) {
-        for (auto const& config : this->GetCrossConfigs("")) {
+        for (auto const& config : this->CrossConfigs) {
           build.ExplicitDeps.push_back(this->BuildAlias(
             this->NinjaOutputPath(this->GetAdditionalCleanTargetName()),
             config));
@@ -1840,7 +1871,7 @@ void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os)
       }
 
       std::vector<std::string> byproducts;
-      for (auto const& config : this->GetCrossConfigs("")) {
+      for (auto const& config : this->CrossConfigs) {
         byproducts.push_back(
           this->BuildAlias(GetByproductsForCleanTargetName(), config));
       }
@@ -1867,11 +1898,12 @@ void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os)
       this->WriteBuild(*this->GetConfigFileStream(config), build);
     }
 
-    auto const* defaultConfig = this->GetDefaultBuildAlias();
-    if (defaultConfig) {
-      std::string config = defaultConfig;
-      build.ExplicitDeps.front() = this->BuildAlias(
-        this->NinjaOutputPath(this->GetCleanTargetName()), config);
+    if (!this->DefaultConfigs.empty()) {
+      build.ExplicitDeps.clear();
+      for (auto const& config : this->DefaultConfigs) {
+        build.ExplicitDeps.push_back(this->BuildAlias(
+          this->NinjaOutputPath(this->GetCleanTargetName()), config));
+      }
       this->WriteBuild(*this->GetDefaultFileStream(), build);
     }
   }
@@ -2319,8 +2351,7 @@ bool cmGlobalNinjaGenerator::WriteDyndepFile(
 
 bool cmGlobalNinjaGenerator::EnableCrossConfigBuild() const
 {
-  return this->IsMultiConfig() &&
-    this->Makefiles.front()->IsOn("CMAKE_NINJA_MULTI_CROSS_CONFIG_ENABLE");
+  return !this->CrossConfigs.empty();
 }
 
 int cmcmd_cmake_ninja_dyndep(std::vector<std::string>::const_iterator argBeg,
@@ -2415,11 +2446,10 @@ void cmGlobalNinjaGenerator::AppendDirectoryForConfig(
 }
 
 std::set<std::string> cmGlobalNinjaGenerator::GetCrossConfigs(
-  const std::string& /*fileConfig*/) const
+  const std::string& fileConfig) const
 {
-  std::set<std::string> result;
-  result.insert(
-    this->Makefiles.front()->GetSafeDefinition("CMAKE_BUILD_TYPE"));
+  auto result = this->CrossConfigs;
+  result.insert(fileConfig);
   return result;
 }
 
@@ -2455,15 +2485,14 @@ bool cmGlobalNinjaMultiGenerator::OpenBuildFileStreams()
     return false;
   }
 
-  auto const* defaultConfig = this->GetDefaultBuildType();
-  if (defaultConfig) {
+  if (!this->DefaultFileConfig.empty()) {
     if (!this->OpenFileStream(this->DefaultFileStream, NINJA_BUILD_FILE)) {
       return false;
     }
     *this->DefaultFileStream
       << "# This file is a convenience file generated by\n"
-      << "# CMAKE_NINJA_MULTI_DEFAULT_BUILD_TYPE.\n\n"
-      << "include " << GetNinjaImplFilename(defaultConfig) << "\n\n";
+      << "# CMAKE_NMC_DEFAULT_BUILD_FILE_CONFIG.\n\n"
+      << "include " << GetNinjaImplFilename(this->DefaultFileConfig) << "\n\n";
   }
 
   // Write a comment about this file.
@@ -2555,8 +2584,7 @@ void cmGlobalNinjaMultiGenerator::AddRebuildManifestOutputs(
     outputs.push_back(this->NinjaOutputPath(GetNinjaImplFilename(config)));
     outputs.push_back(this->NinjaOutputPath(GetNinjaConfigFilename(config)));
   }
-  if (this->Makefiles.front()->GetDefinition(
-        "CMAKE_NINJA_MULTI_DEFAULT_BUILD_TYPE")) {
+  if (!this->DefaultFileConfig.empty()) {
     outputs.push_back(this->NinjaOutputPath(NINJA_BUILD_FILE));
   }
 }
@@ -2571,43 +2599,70 @@ void cmGlobalNinjaMultiGenerator::GetQtAutoGenConfigs(
   }
 }
 
-const char* cmGlobalNinjaMultiGenerator::GetDefaultBuildType() const
+bool cmGlobalNinjaMultiGenerator::InspectConfigTypeVariables()
 {
-  return this->Makefiles.front()->GetDefinition(
-    "CMAKE_NINJA_MULTI_DEFAULT_BUILD_TYPE");
-}
+  auto configsVec = this->Makefiles.front()->GetGeneratorConfigs();
+  std::set<std::string> configs(configsVec.cbegin(), configsVec.cend());
 
-const char* cmGlobalNinjaMultiGenerator::GetDefaultBuildAlias() const
-{
-  if (this->EnableCrossConfigBuild()) {
-    auto const* alias = this->Makefiles.front()->GetDefinition(
-      "CMAKE_NINJA_MULTI_DEFAULT_BUILD_ALIAS");
-    if (alias) {
-      return alias;
-    }
+  this->DefaultFileConfig = this->Makefiles.front()->GetSafeDefinition(
+    "CMAKE_NMC_DEFAULT_BUILD_FILE_CONFIG");
+  if (!this->DefaultFileConfig.empty() &&
+      !configs.count(this->DefaultFileConfig)) {
+    std::ostringstream msg;
+    msg << "The configuration specified by "
+        << "CMAKE_NMC_DEFAULT_BUILD_FILE_CONFIG (" << this->DefaultFileConfig
+        << ") is not present in CMAKE_CONFIGURATION_TYPES";
+    this->GetCMakeInstance()->IssueMessage(MessageType::FATAL_ERROR,
+                                           msg.str());
+    return false;
   }
 
-  return this->GetDefaultBuildType();
-}
+  std::vector<std::string> crossConfigsVec;
+  cmExpandList(
+    this->Makefiles.front()->GetSafeDefinition("CMAKE_NMC_CROSS_CONFIGS"),
+    crossConfigsVec);
+  auto crossConfigs = ListSubsetWithAll(configs, crossConfigsVec);
+  if (!crossConfigs) {
+    std::ostringstream msg;
+    msg << "CMAKE_NMC_CROSS_CONFIGS is not a subset of "
+        << "CMAKE_CONFIGURATION_TYPES";
+    this->GetCMakeInstance()->IssueMessage(MessageType::FATAL_ERROR,
+                                           msg.str());
+    return false;
+  }
+  this->CrossConfigs = *crossConfigs;
 
-std::set<std::string> cmGlobalNinjaMultiGenerator::GetCrossConfigs(
-  const std::string& fileConfig) const
-{
-  std::vector<std::string> configs;
-  if (this->EnableCrossConfigBuild()) {
-    auto configsValue = this->Makefiles.front()->GetSafeDefinition(
-      "CMAKE_NINJA_MULTI_CROSS_CONFIGS");
-    if (!configsValue.empty()) {
-      cmExpandList(configsValue, configs);
-    } else {
-      configs = this->Makefiles.front()->GetGeneratorConfigs();
-    }
+  auto defaultConfigsString =
+    this->Makefiles.front()->GetSafeDefinition("CMAKE_NMC_DEFAULT_CONFIGS");
+  if (defaultConfigsString.empty()) {
+    defaultConfigsString = this->DefaultFileConfig;
+  }
+  if (!defaultConfigsString.empty() &&
+      (this->DefaultFileConfig.empty() || this->CrossConfigs.empty())) {
+    std::ostringstream msg;
+    msg << "CMAKE_NMC_DEFAULT_CONFIGS cannot be used without "
+        << "CMAKE_NMC_DEFAULT_BUILD_FILE_CONFIG or "
+        << "CMAKE_NMC_CROSS_CONFIGS";
+    this->GetCMakeInstance()->IssueMessage(MessageType::FATAL_ERROR,
+                                           msg.str());
+    return false;
   }
 
-  std::set<std::string> result(configs.cbegin(), configs.cend());
-  if (!fileConfig.empty()) {
-    result.insert(fileConfig);
+  std::vector<std::string> defaultConfigsVec;
+  cmExpandList(defaultConfigsString, defaultConfigsVec);
+  if (!this->DefaultFileConfig.empty()) {
+    auto defaultConfigs = ListSubsetWithAll(
+      this->GetCrossConfigs(this->DefaultFileConfig), defaultConfigsVec);
+    if (!defaultConfigs) {
+      std::ostringstream msg;
+      msg << "CMAKE_NMC_DEFAULT_CONFIGS is not a subset of "
+          << "CMAKE_NMC_CROSS_CONFIGS";
+      this->GetCMakeInstance()->IssueMessage(MessageType::FATAL_ERROR,
+                                             msg.str());
+      return false;
+    }
+    this->DefaultConfigs = *defaultConfigs;
   }
 
-  return result;
+  return true;
 }
diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h
index 9d5521a..3b45249 100644
--- a/Source/cmGlobalNinjaGenerator.h
+++ b/Source/cmGlobalNinjaGenerator.h
@@ -15,6 +15,8 @@
 #include <utility>
 #include <vector>
 
+#include <cm/optional>
+
 #include "cm_codecvt.hxx"
 
 #include "cmGeneratedFileStream.h"
@@ -408,12 +410,7 @@ public:
 
   bool EnableCrossConfigBuild() const;
 
-  virtual const char* GetDefaultBuildType() const { return nullptr; }
-
-  virtual const char* GetDefaultBuildAlias() const { return nullptr; }
-
-  virtual std::set<std::string> GetCrossConfigs(
-    const std::string& fileConfig) const;
+  std::set<std::string> GetCrossConfigs(const std::string& config) const;
 
 protected:
   void Generate() override;
@@ -426,6 +423,16 @@ protected:
   bool OpenFileStream(std::unique_ptr<cmGeneratedFileStream>& stream,
                       const std::string& name);
 
+  static cm::optional<std::set<std::string>> ListSubsetWithAll(
+    const std::set<std::string>& defaults,
+    const std::vector<std::string>& items);
+
+  virtual bool InspectConfigTypeVariables() { return true; }
+
+  std::set<std::string> CrossConfigs;
+  std::set<std::string> DefaultConfigs;
+  std::string DefaultFileConfig;
+
 private:
   std::string GetEditCacheCommand() const override;
   bool FindMakeProgram(cmMakefile* mf) override;
@@ -504,6 +511,7 @@ private:
   };
   using TargetAliasMap = std::map<std::string, TargetAlias>;
   TargetAliasMap TargetAliases;
+  TargetAliasMap DefaultTargetAliases;
 
   /// the local cache for calls to ConvertToNinjaPath
   mutable std::unordered_map<std::string, std::string> ConvertToNinjaPathCache;
@@ -623,12 +631,7 @@ public:
 
   void GetQtAutoGenConfigs(std::vector<std::string>& configs) const override;
 
-  const char* GetDefaultBuildType() const override;
-
-  const char* GetDefaultBuildAlias() const override;
-
-  std::set<std::string> GetCrossConfigs(
-    const std::string& fileConfig) const override;
+  bool InspectConfigTypeVariables() override;
 
 protected:
   bool OpenBuildFileStreams() override;
diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx
index 1df5410..0471a45 100644
--- a/Source/cmMakefileExecutableTargetGenerator.cxx
+++ b/Source/cmMakefileExecutableTargetGenerator.cxx
@@ -196,6 +196,8 @@ void cmMakefileExecutableTargetGenerator::WriteDeviceExecutableRule(
     this->CreateObjectLists(useLinkScript, false, useResponseFileForObjects,
                             buildObjs, depends, useWatcomQuote);
 
+    std::string const& aixExports = this->GetAIXExports(this->GetConfigName());
+
     cmRulePlaceholderExpander::RuleVariables vars;
     std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
 
@@ -219,6 +221,7 @@ void cmMakefileExecutableTargetGenerator::WriteDeviceExecutableRule(
                                                   cmOutputConverter::SHELL);
 
     vars.Language = linkLanguage.c_str();
+    vars.AIXExports = aixExports.c_str();
     vars.Objects = buildObjs.c_str();
     vars.ObjectDir = objectDir.c_str();
     vars.Target = target.c_str();
diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx
index 357e273..d3f3a4f 100644
--- a/Source/cmMakefileLibraryTargetGenerator.cxx
+++ b/Source/cmMakefileLibraryTargetGenerator.cxx
@@ -727,6 +727,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
           cmOutputConverter::SHELL);
     }
 
+    std::string const& aixExports = this->GetAIXExports(this->GetConfigName());
+
     // maybe create .def file from list of objects
     this->GenDefFile(real_link_commands);
 
@@ -756,6 +758,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
     vars.CMTargetType =
       cmState::GetTargetTypeName(this->GeneratorTarget->GetType());
     vars.Language = linkLanguage.c_str();
+    vars.AIXExports = aixExports.c_str();
     vars.Objects = buildObjs.c_str();
     std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
 
diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx
index a2fa3b1..d7e2de6 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -788,7 +788,7 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
             driverMode = lang == "C" ? "gcc" : "g++";
           }
           run_iwyu += this->LocalGenerator->EscapeForShell(
-            cmStrCat(tidy, ";--driver-mode=", driverMode));
+            cmStrCat(tidy, ";--extra-arg-before=--driver-mode=", driverMode));
         }
         if (cpplint && *cpplint) {
           run_iwyu += " --cpplint=";
diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx
index 437548a..ff79a17 100644
--- a/Source/cmNinjaNormalTargetGenerator.cxx
+++ b/Source/cmNinjaNormalTargetGenerator.cxx
@@ -286,6 +286,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkRule(bool useResponseFile,
 
     std::string lang = this->TargetLinkLanguage(config);
     vars.Language = config.c_str();
+    vars.AIXExports = "$AIX_EXPORTS";
 
     if (this->TargetLinkLanguage(config) == "Swift") {
       vars.SwiftLibraryName = "$SWIFT_LIBRARY_NAME";
@@ -550,16 +551,23 @@ std::vector<std::string> cmNinjaNormalTargetGenerator::ComputeLinkCmd(
         linkCmds.push_back(cmakeCommand + " -E touch $TARGET_FILE");
       }
 #endif
-      return linkCmds;
-    }
+    } break;
     case cmStateEnums::SHARED_LIBRARY:
     case cmStateEnums::MODULE_LIBRARY:
+      break;
     case cmStateEnums::EXECUTABLE:
+      if (this->TargetLinkLanguage(config) == "Swift") {
+        if (this->GeneratorTarget->IsExecutableWithExports()) {
+          const std::string flags =
+            this->Makefile->GetSafeDefinition("CMAKE_EXE_EXPORTS_Swift_FLAG");
+          cmExpandList(flags, linkCmds);
+        }
+      }
       break;
     default:
       assert(false && "Unexpected target type");
   }
-  return std::vector<std::string>();
+  return linkCmds;
 }
 
 void cmNinjaNormalTargetGenerator::WriteDeviceLinkStatement(
@@ -955,6 +963,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement(
   vars["LINK_FLAGS"] = globalGen->EncodeLiteral(vars["LINK_FLAGS"]);
 
   vars["MANIFESTS"] = this->GetManifests(config);
+  vars["AIX_EXPORTS"] = this->GetAIXExports(config);
 
   vars["LINK_PATH"] = frameworkPath + linkPath;
   std::string lwyuFlags;
diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx
index 5e8cc7d..0e74678 100644
--- a/Source/cmNinjaTargetGenerator.cxx
+++ b/Source/cmNinjaTargetGenerator.cxx
@@ -767,7 +767,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
           driverMode = lang == "C" ? "gcc" : "g++";
         }
         run_iwyu += this->GetLocalGenerator()->EscapeForShell(
-          cmStrCat(tidy, ";--driver-mode=", driverMode));
+          cmStrCat(tidy, ";--extra-arg-before=--driver-mode=", driverMode));
       }
       if (cpplint && *cpplint) {
         run_iwyu += " --cpplint=";
diff --git a/Source/cmQtAutoGenInitializer.cxx b/Source/cmQtAutoGenInitializer.cxx
index 0493c0f..43e159c 100644
--- a/Source/cmQtAutoGenInitializer.cxx
+++ b/Source/cmQtAutoGenInitializer.cxx
@@ -1189,8 +1189,15 @@ bool cmQtAutoGenInitializer::InitAutogenTarget()
       const std::string outputFile =
         cmStrCat(this->Dir.Build, "/", timestampFileName);
       this->AutogenTarget.DepFile = cmStrCat(this->Dir.Build, "/deps");
+      auto relativeBinaryDir = cmSystemTools::RelativePath(
+        this->LocalGen->GetBinaryDirectory(),
+        this->LocalGen->GetCurrentBinaryDirectory());
+      if (!relativeBinaryDir.empty()) {
+        relativeBinaryDir = cmStrCat(relativeBinaryDir, "/");
+      }
       this->AutogenTarget.DepFileRuleName =
-        cmStrCat(this->GenTarget->GetName(), "_autogen/", timestampFileName);
+        cmStrCat(relativeBinaryDir, this->GenTarget->GetName(), "_autogen/",
+                 timestampFileName);
       commandLines.push_back(cmMakeCommandLine(
         { cmSystemTools::GetCMakeCommand(), "-E", "touch", outputFile }));
 
diff --git a/Source/cmRulePlaceholderExpander.cxx b/Source/cmRulePlaceholderExpander.cxx
index 0a1d109..5ab1b3a 100644
--- a/Source/cmRulePlaceholderExpander.cxx
+++ b/Source/cmRulePlaceholderExpander.cxx
@@ -85,6 +85,11 @@ std::string cmRulePlaceholderExpander::ExpandRuleVariable(
       return replaceValues.ObjectsQuoted;
     }
   }
+  if (replaceValues.AIXExports) {
+    if (variable == "AIX_EXPORTS") {
+      return replaceValues.AIXExports;
+    }
+  }
   if (replaceValues.Defines && variable == "DEFINES") {
     return replaceValues.Defines;
   }
diff --git a/Source/cmRulePlaceholderExpander.h b/Source/cmRulePlaceholderExpander.h
index 8f36196..09e8a3b 100644
--- a/Source/cmRulePlaceholderExpander.h
+++ b/Source/cmRulePlaceholderExpander.h
@@ -36,6 +36,7 @@ public:
     const char* TargetVersionMajor;
     const char* TargetVersionMinor;
     const char* Language;
+    const char* AIXExports;
     const char* Objects;
     const char* Target;
     const char* LinkLibraries;
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index a0c217b..d0b6f10 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -491,6 +491,7 @@ cmTarget::cmTarget(std::string const& name, cmStateEnums::TargetType type,
   }
   if (impl->TargetType == cmStateEnums::SHARED_LIBRARY ||
       impl->TargetType == cmStateEnums::EXECUTABLE) {
+    initProp("AIX_EXPORT_ALL_SYMBOLS");
     initProp("WINDOWS_EXPORT_ALL_SYMBOLS");
   }
 
diff --git a/Source/ctest.cxx b/Source/ctest.cxx
index 9b45bb0..fbdf75a 100644
--- a/Source/ctest.cxx
+++ b/Source/ctest.cxx
@@ -144,6 +144,8 @@ static const char* cmDocumentationOptions[][2] = {
   { "--http1.0", "Submit using HTTP 1.0." },
   { "--no-compress-output", "Do not compress test output when submitting." },
   { "--print-labels", "Print all available test labels." },
+  { "--no-tests=<[error|ignore]>",
+    "Regard no tests found either as 'error' or 'ignore' it." },
   { nullptr, nullptr }
 };