/src/CMake/Source/cmGlobalNinjaGenerator.cxx

Source
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */
#include "cmGlobalNinjaGenerator.h"

#include <algorithm>
#include <cstdio>
#include <functional>
#include <iterator>
#include <set>
#include <sstream>
#include <utility>

#include <cm/memory>
#include <cm/optional>
#include <cm/string_view>
#include <cmext/algorithm>
#include <cmext/memory>
#include <cmext/string_view>

#include <cm3p/json/value.h>
#include <cm3p/json/writer.h>

#include "cmsys/String.h"

#include "cmCustomCommand.h"
#include "cmCustomCommandGenerator.h"
#include "cmCxxModuleMapper.h"
#include "cmDiagnostics.h"
#include "cmDyndepCollation.h"
#include "cmFortranParser.h"
#include "cmGeneratedFileStream.h"
#include "cmGeneratorTarget.h"
#include "cmGlobalGenerator.h"
#include "cmInstrumentation.h"
#include "cmJSONState.h"
#include "cmLinkLineComputer.h"
#include "cmList.h"
#include "cmListFileCache.h"
#include "cmLocalGenerator.h"
#include "cmLocalNinjaGenerator.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmNinjaLinkLineComputer.h"
#include "cmOutputConverter.h"
#include "cmRange.h"
#include "cmScanDepFormat.h"
#include "cmScriptGenerator.h"
#include "cmSourceFile.h"
#include "cmState.h"
#include "cmStateDirectory.h"
#include "cmStateSnapshot.h"
#include "cmStateTypes.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include "cmTarget.h"
#include "cmTargetDepend.h"
#include "cmTargetTypes.h"
#include "cmTest.h"
#include "cmTestGenerator.h"
#include "cmUnreachable.h"
#include "cmValue.h"
#include "cmVersion.h"
#include "cmake.h"

char const* cmGlobalNinjaGenerator::NINJA_BUILD_FILE = "build.ninja";
char const* cmGlobalNinjaGenerator::NINJA_RULES_FILE =
  "CMakeFiles/rules.ninja";
char const* cmGlobalNinjaGenerator::INDENT = "  ";
#ifdef _WIN32
std::string const cmGlobalNinjaGenerator::SHELL_NOOP = "cd .";
#else
std::string const cmGlobalNinjaGenerator::SHELL_NOOP = ":";
#endif

namespace {
#ifdef _WIN32
bool DetectGCCOnWindows(cm::string_view compilerId, cm::string_view simulateId,
                        cm::string_view compilerFrontendVariant)
{
  return (((compilerId == "Clang"_s || compilerId == "DPClang"_s) &&
           compilerFrontendVariant == "GNU"_s) ||
          (simulateId != "MSVC"_s &&
           (compilerId == "GNU"_s || compilerId == "QCC"_s ||
            cmHasLiteralSuffix(compilerId, "Clang"))));
}
#endif
}

bool operator==(
  cmGlobalNinjaGenerator::ByConfig::TargetDependsClosureKey const& lhs,
  cmGlobalNinjaGenerator::ByConfig::TargetDependsClosureKey const& rhs)
{
  return lhs.Target == rhs.Target && lhs.Config == rhs.Config &&
    lhs.GenexOutput == rhs.GenexOutput;
}

bool operator!=(
  cmGlobalNinjaGenerator::ByConfig::TargetDependsClosureKey const& lhs,
  cmGlobalNinjaGenerator::ByConfig::TargetDependsClosureKey const& rhs)
{
  return !(lhs == rhs);
}

bool operator<(
  cmGlobalNinjaGenerator::ByConfig::TargetDependsClosureKey const& lhs,
  cmGlobalNinjaGenerator::ByConfig::TargetDependsClosureKey const& rhs)
{
  return lhs.Target < rhs.Target ||
    (lhs.Target == rhs.Target &&
     (lhs.Config < rhs.Config ||
      (lhs.Config == rhs.Config && lhs.GenexOutput < rhs.GenexOutput)));
}

bool operator>(
  cmGlobalNinjaGenerator::ByConfig::TargetDependsClosureKey const& lhs,
  cmGlobalNinjaGenerator::ByConfig::TargetDependsClosureKey const& rhs)
{
  return rhs < lhs;
}

bool operator<=(
  cmGlobalNinjaGenerator::ByConfig::TargetDependsClosureKey const& lhs,
  cmGlobalNinjaGenerator::ByConfig::TargetDependsClosureKey const& rhs)
{
  return !(lhs > rhs);
}

bool operator>=(
  cmGlobalNinjaGenerator::ByConfig::TargetDependsClosureKey const& lhs,
  cmGlobalNinjaGenerator::ByConfig::TargetDependsClosureKey const& rhs)
{
  return rhs <= lhs;
}

void cmGlobalNinjaGenerator::Indent(std::ostream& os, int count)
{
  for (int i = 0; i < count; ++i) {
    os << cmGlobalNinjaGenerator::INDENT;
  }
}

void cmGlobalNinjaGenerator::WriteDivider(std::ostream& os)
{
  os << "# ======================================"
        "=======================================\n";
}

void cmGlobalNinjaGenerator::WriteComment(std::ostream& os,
                                          std::string const& comment)
{
  if (comment.empty()) {
    return;
  }

  std::string::size_type lpos = 0;
  std::string::size_type rpos;
  os << "\n#############################################\n";
  while ((rpos = comment.find('\n', lpos)) != std::string::npos) {
    os << "# " << comment.substr(lpos, rpos - lpos) << "\n";
    lpos = rpos + 1;
  }
  os << "# " << comment.substr(lpos) << "\n\n";
}

std::unique_ptr<cmLinkLineComputer>
cmGlobalNinjaGenerator::CreateLinkLineComputer(
  cmOutputConverter* outputConverter,
  cmStateDirectory const& /* stateDir */) const
{
  return std::unique_ptr<cmLinkLineComputer>(
    cm::make_unique<cmNinjaLinkLineComputer>(
      outputConverter,
      this->LocalGenerators[0]->GetStateSnapshot().GetDirectory(), this));
}

std::string cmGlobalNinjaGenerator::EncodeRuleName(std::string const& name)
{
  // Ninja rule names must match "[a-zA-Z0-9_.-]+".  Use ".xx" to encode
  // "." and all invalid characters as hexadecimal.
  std::string encoded;
  for (char i : name) {
    if (cmsysString_isalnum(i) || i == '_' || i == '-') {
      encoded += i;
    } else {
      char buf[16];
      snprintf(buf, sizeof(buf), ".%02x", static_cast<unsigned int>(i));
      encoded += buf;
    }
  }
  return encoded;
}

std::string& cmGlobalNinjaGenerator::EncodeLiteral(std::string& lit)
{
  cmSystemTools::ReplaceString(lit, "$", "$$");
  cmSystemTools::ReplaceString(lit, "\n", "$\n");
  if (this->IsMultiConfig()) {
    cmSystemTools::ReplaceString(lit, cmStrCat('$', this->GetCMakeCFGIntDir()),
                                 this->GetCMakeCFGIntDir());
  }
  return lit;
}

std::string cmGlobalNinjaGenerator::EncodePath(std::string const& path)
{
  std::string result = path;
#ifdef _WIN32
  if (this->IsGCCOnWindows())
    std::replace(result.begin(), result.end(), '\\', '/');
  else
    std::replace(result.begin(), result.end(), '/', '\\');
#endif
  this->EncodeLiteral(result);
  cmSystemTools::ReplaceString(result, " ", "$ ");
  cmSystemTools::ReplaceString(result, ":", "$:");
  return result;
}

void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
                                        cmNinjaBuild const& build,
                                        int cmdLineLimit,
                                        bool* usedResponseFile)
{
  // Make sure there is a rule.
  if (build.Rule.empty()) {
    cmSystemTools::Error(cmStrCat(
      "No rule for WriteBuild! called with comment: ", build.Comment));
    return;
  }

  // Make sure there is at least one output file.
  if (build.Outputs.empty()) {
    cmSystemTools::Error(cmStrCat(
      "No output files for WriteBuild! called with comment: ", build.Comment));
    return;
  }

  cmGlobalNinjaGenerator::WriteComment(os, build.Comment);

  // Write output files.
  std::string buildStr("build");
  {
    // Write explicit outputs
    for (std::string const& output : build.Outputs) {
      buildStr = cmStrCat(std::move(buildStr), ' ', this->EncodePath(output));
    }
    // Write implicit outputs
    if (!build.ImplicitOuts.empty()) {
      // Assume Ninja is new enough to support implicit outputs.
      // Callers should not populate this field otherwise.
      buildStr = cmStrCat(std::move(buildStr), " |");
      for (std::string const& implicitOut : build.ImplicitOuts) {
        buildStr =
          cmStrCat(std::move(buildStr), ' ', this->EncodePath(implicitOut));
      }
    }

    // Repeat some outputs, but expressed as absolute paths.
    // This helps Ninja handle absolute paths found in a depfile.
    // FIXME: Unfortunately this causes Ninja to stat the file twice.
    // We could avoid this if Ninja Issue 1251 were fixed.
    if (!build.WorkDirOuts.empty()) {
      if (this->SupportsImplicitOuts() && build.ImplicitOuts.empty()) {
        // Make them implicit outputs if supported by this version of Ninja.
        buildStr = cmStrCat(std::move(buildStr), " |");
      }
      for (std::string const& workdirOut : build.WorkDirOuts) {
        buildStr = cmStrCat(std::move(buildStr), " ${cmake_ninja_workdir}",
                            this->EncodePath(workdirOut));
      }
    }

    // Write the rule.
    buildStr = cmStrCat(std::move(buildStr), ": ", build.Rule);
  }

  std::string arguments;
  {
    // TODO: Better formatting for when there are multiple input/output files.

    // Write explicit dependencies.
    for (std::string const& explicitDep : build.ExplicitDeps) {
      arguments =
        cmStrCat(std::move(arguments), ' ', this->EncodePath(explicitDep));
    }

    // Write implicit dependencies.
    if (!build.ImplicitDeps.empty()) {
      arguments += " |";
      for (std::string const& implicitDep : build.ImplicitDeps) {
        arguments =
          cmStrCat(std::move(arguments), ' ', this->EncodePath(implicitDep));
      }
    }

    // Write order-only dependencies.
    if (!build.OrderOnlyDeps.empty()) {
      arguments += " ||";
      for (std::string const& orderOnlyDep : build.OrderOnlyDeps) {
        arguments =
          cmStrCat(std::move(arguments), ' ', this->EncodePath(orderOnlyDep));
      }
    }

    arguments += '\n';
  }

  // Write the variables bound to this build statement.
  std::string assignments;
  {
    std::ostringstream variable_assignments;
    for (auto const& variable : build.Variables) {
      cmGlobalNinjaGenerator::WriteVariable(
        variable_assignments, variable.first, variable.second, "", 1);
    }

    // check if a response file rule should be used
    assignments = variable_assignments.str();
    bool useResponseFile = false;
    if (cmdLineLimit < 0 ||
        (cmdLineLimit > 0 &&
         (arguments.size() + buildStr.size() + assignments.size() + 1000) >
           static_cast<size_t>(cmdLineLimit))) {
      variable_assignments.str(std::string());
      cmGlobalNinjaGenerator::WriteVariable(variable_assignments, "RSP_FILE",
                                            build.RspFile, "", 1);
      assignments += variable_assignments.str();
      useResponseFile = true;
    }
    if (usedResponseFile) {
      *usedResponseFile = useResponseFile;
    }
  }

  os << buildStr << arguments << assignments << "\n";
}

void cmGlobalNinjaGenerator::AddCustomCommandRule()
{
  cmNinjaRule rule("CUSTOM_COMMAND");
  rule.Command = "$COMMAND";
  rule.Description = "$DESC";
  rule.Comment = "Rule for running custom commands.";
  this->AddRule(rule);
}

void cmGlobalNinjaGenerator::CCOutputs::Add(
  std::vector<std::string> const& paths)
{
  for (std::string const& path : paths) {
    std::string out = this->GG->ConvertToNinjaPath(path);
    if (!cmSystemTools::FileIsFullPath(out)) {
      // This output is expressed as a relative path.  Repeat it,
      // but expressed as an absolute path for Ninja Issue 1251.
      this->WorkDirOuts.emplace_back(out);
      this->GG->SeenCustomCommandOutput(this->GG->ConvertToNinjaAbsPath(path));
    }
    this->GG->SeenCustomCommandOutput(out);
    this->ExplicitOuts.emplace_back(std::move(out));
  }
}

void cmGlobalNinjaGenerator::WriteCustomCommandBuild(
  std::string const& command, std::string const& description,
  std::string const& comment, std::string const& depfile,
  std::string const& job_pool, bool uses_terminal, bool restat,
  std::string const& config, CCOutputs outputs, cmNinjaDeps explicitDeps,
  cmNinjaDeps orderOnlyDeps)
{
  this->AddCustomCommandRule();

  {
    std::string ninjaDepfilePath;
    bool depfileIsOutput = false;
    if (!depfile.empty()) {
      ninjaDepfilePath = this->ConvertToNinjaPath(depfile);
      depfileIsOutput =
        std::find(outputs.ExplicitOuts.begin(), outputs.ExplicitOuts.end(),
                  ninjaDepfilePath) != outputs.ExplicitOuts.end();
    }

    cmNinjaBuild build("CUSTOM_COMMAND");
    build.Comment = comment;
    build.Outputs = std::move(outputs.ExplicitOuts);
    build.WorkDirOuts = std::move(outputs.WorkDirOuts);
    build.ExplicitDeps = std::move(explicitDeps);
    build.OrderOnlyDeps = std::move(orderOnlyDeps);

    cmNinjaVars& vars = build.Variables;
    {
      std::string cmd = command; // NOLINT(*)
#ifdef _WIN32
      if (cmd.empty())
        cmd = "cmd.exe /c";
#endif
      vars["COMMAND"] = std::move(cmd);
    }
    vars["DESC"] = this->GetEncodedLiteral(description);
    if (restat) {
      vars["restat"] = "1";
    }
    if (uses_terminal && this->SupportsDirectConsole()) {
      vars["pool"] = "console";
    } else if (!job_pool.empty()) {
      vars["pool"] = job_pool;
    }
    if (!depfile.empty()) {
      vars["depfile"] = ninjaDepfilePath;
      // Add the depfile to the `.ninja_deps` database. Since this (generally)
      // removes the file, it cannot be declared as an output or byproduct of
      // the command.
      if (!depfileIsOutput) {
        vars["deps"] = "gcc";
      }
    }
    if (config.empty()) {
      this->WriteBuild(*this->GetCommonFileStream(), build);
    } else {
      this->WriteBuild(*this->GetImplFileStream(config), build);
    }
  }
}

void cmGlobalNinjaGenerator::AddMacOSXContentRule()
{
  {
    cmNinjaRule rule("COPY_OSX_CONTENT_FILE");
    rule.Command = cmStrCat(this->CMakeCmd(), " -E copy $in $out");
    rule.Description = "Copying OS X Content $out";
    rule.Comment = "Rule for copying OS X bundle content file, with style.";
    this->AddRule(rule);
  }
  {
    cmNinjaRule rule("COPY_OSX_CONTENT_DIR");
    rule.Command = cmStrCat(this->CMakeCmd(), " -E copy_directory $in $out");
    rule.Description = "Copying OS X Content $out";
    rule.Comment = "Rule for copying OS X bundle content dir, with style.";
    this->AddRule(rule);
  }
}
void cmGlobalNinjaGenerator::WriteMacOSXContentBuild(std::string input,
                                                     std::string output,
                                                     std::string const& config)
{
  this->AddMacOSXContentRule();
  {
    cmNinjaBuild build(cmSystemTools::FileIsDirectory(input)
                         ? "COPY_OSX_CONTENT_DIR"
                         : "COPY_OSX_CONTENT_FILE");
    build.Outputs.push_back(std::move(output));
    build.ExplicitDeps.push_back(std::move(input));
    this->WriteBuild(*this->GetImplFileStream(config), build);
  }
}

void cmGlobalNinjaGenerator::WriteRule(std::ostream& os,
                                       cmNinjaRule const& rule)
{
  // -- Parameter checks
  // Make sure the rule has a name.
  if (rule.Name.empty()) {
    cmSystemTools::Error(cmStrCat(
      "No name given for WriteRule! called with comment: ", rule.Comment));
    return;
  }

  // Make sure a command is given.
  if (rule.Command.empty()) {
    cmSystemTools::Error(cmStrCat(
      "No command given for WriteRule! called with comment: ", rule.Comment));
    return;
  }

  // Make sure response file content is given
  if (!rule.RspFile.empty() && rule.RspContent.empty()) {
    cmSystemTools::Error(
      cmStrCat("rspfile but no rspfile_content given for WriteRule! "
               "called with comment: ",
               rule.Comment));
    return;
  }

  // -- Write rule
  // Write rule intro
  cmGlobalNinjaGenerator::WriteComment(os, rule.Comment);
  os << "rule " << rule.Name << '\n';

  // Write rule key/value pairs
  auto writeKV = [&os](char const* key, std::string const& value) {
    if (!value.empty()) {
      cmGlobalNinjaGenerator::Indent(os, 1);
      os << key << " = " << value << '\n';
    }
  };

  writeKV("depfile", rule.DepFile);
  writeKV("deps", rule.DepType);
  writeKV("command", rule.Command);
  writeKV("description", rule.Description);
  if (!rule.RspFile.empty()) {
    writeKV("rspfile", rule.RspFile);
    writeKV("rspfile_content", rule.RspContent);
  }
  writeKV("restat", rule.Restat);
  if (rule.Generator) {
    writeKV("generator", "1");
  }

  // Finish rule
  os << '\n';
}

void cmGlobalNinjaGenerator::WriteVariable(std::ostream& os,
                                           std::string const& name,
                                           std::string const& value,
                                           std::string const& comment,
                                           int indent)
{
  // Make sure we have a name.
  if (name.empty()) {
    cmSystemTools::Error(cmStrCat("No name given for WriteVariable! called "
                                  "with comment: ",
                                  comment));
    return;
  }

  std::string val;
  static std::unordered_set<std::string> const variablesShouldNotBeTrimmed = {
    "CODE_CHECK", "LAUNCHER"
  };
  if (variablesShouldNotBeTrimmed.find(name) ==
      variablesShouldNotBeTrimmed.end()) {
    val = cmTrimWhitespace(value);
    // If the value ends with `\n` and a `$` was left at the end of the trimmed
    // value, put the newline back. Otherwise the next stanza is hidden by the
    // trailing `$` escaping the newline.
    if (cmSystemTools::StringEndsWith(value, "\n") &&
        cmSystemTools::StringEndsWith(val, "$")) {
      val += '\n';
    }
  } else {
    val = value;
  }

  // Do not add a variable if the value is empty.
  if (val.empty()) {
    return;
  }

  cmGlobalNinjaGenerator::WriteComment(os, comment);
  cmGlobalNinjaGenerator::Indent(os, indent);
  os << name << " = " << val << "\n";
}

void cmGlobalNinjaGenerator::WriteInclude(std::ostream& os,
                                          std::string const& filename,
                                          std::string const& comment)
{
  cmGlobalNinjaGenerator::WriteComment(os, comment);
  os << "include " << filename << "\n";
}

void cmGlobalNinjaGenerator::WriteDefault(std::ostream& os,
                                          cmNinjaDeps const& targets,
                                          std::string const& comment)
{
  cmGlobalNinjaGenerator::WriteComment(os, comment);
  os << "default";
  for (std::string const& target : targets) {
    os << " " << target;
  }
  os << "\n";
}

cmGlobalNinjaGenerator::cmGlobalNinjaGenerator(cmake* cm)
  : cmGlobalCommonGenerator(cm)
{
#ifdef _WIN32
  cm->GetState()->SetWindowsShell(true);

  // Attempt to use full path to COMSPEC, default "cmd.exe"
  this->Comspec = cmSystemTools::GetComspec();
#endif
  cm->GetState()->SetNinja(true);
  this->FindMakeProgramFile = "CMakeNinjaFindMake.cmake";
}

// Virtual public methods.

std::unique_ptr<cmLocalGenerator> cmGlobalNinjaGenerator::CreateLocalGenerator(
  cmMakefile* mf)
{
  return std::unique_ptr<cmLocalGenerator>(
    cm::make_unique<cmLocalNinjaGenerator>(this, mf));
}

codecvt_Encoding cmGlobalNinjaGenerator::GetMakefileEncoding() const
{
  return this->NinjaExpectedEncoding;
}

cmDocumentationEntry cmGlobalNinjaGenerator::GetDocumentation()
{
  return { cmGlobalNinjaGenerator::GetActualName(),
           "Generates build.ninja files." };
}

std::vector<std::string> const& cmGlobalNinjaGenerator::GetConfigNames() const
{
  return static_cast<cmLocalNinjaGenerator const*>(
           this->LocalGenerators.front().get())
    ->GetConfigNames();
}

// Implemented in all cmGlobaleGenerator sub-classes.
// Used in:
//   Source/cmLocalGenerator.cxx
//   Source/cmake.cxx
void cmGlobalNinjaGenerator::Generate()
{
  // Check minimum Ninja version.
  if (cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, this->NinjaVersion,
                                    RequiredNinjaVersion())) {
    this->GetCMakeInstance()->IssueMessage(
      MessageType::FATAL_ERROR,
      cmStrCat("The detected version of Ninja (", this->NinjaVersion,
               ") is less than the version of Ninja required by CMake (",
               cmGlobalNinjaGenerator::RequiredNinjaVersion(), ")."));
    return;
  }
  this->InitOutputPathPrefix();
  if (!this->OpenBuildFileStreams()) {
    return;
  }
  if (!this->OpenRulesFileStream()) {
    return;
  }

  for (auto& it : this->Configs) {
    it.second.TargetDependsClosures.clear();
  }
  this->ExistingDirectories.clear();

  this->TargetAll = this->NinjaOutputPath("all");
  this->CMakeCacheFile = this->NinjaOutputPath("CMakeCache.txt");
  this->DiagnosedCxxModuleNinjaSupport = false;
  this->ClangTidyExportFixesDirs.clear();
  this->ClangTidyExportFixesFiles.clear();

  this->cmGlobalGenerator::Generate();

  this->WriteAssumedSourceDependencies();
  this->WriteInstallPrepTargets();
  this->WriteTestPrepTargets();
  this->WriteTargetAliases(*this->GetCommonFileStream());
  this->WriteFolderTargets(*this->GetCommonFileStream());
  this->WriteBuiltinTargets(*this->GetCommonFileStream());

  if (cmSystemTools::GetErrorOccurredFlag()) {
    this->RulesFileStream->setstate(std::ios::failbit);
    for (std::string const& config : this->GetConfigNames()) {
      this->GetImplFileStream(config)->setstate(std::ios::failbit);
      this->GetConfigFileStream(config)->setstate(std::ios::failbit);
    }
    this->GetCommonFileStream()->setstate(std::ios::failbit);
  }

  this->CloseCompileCommandsStream();
  this->CloseRulesFileStream();
  this->CloseBuildFileStreams();

#ifdef _WIN32
  // Older ninja tools will not be able to update metadata on Windows
  // when we are re-generating inside an existing 'ninja' invocation
  // because the outer tool has the files open for write.
  if (this->NinjaSupportsMetadataOnRegeneration ||
      !this->GetCMakeInstance()->GetRegenerateDuringBuild())
#endif
  {
    this->CleanMetaData();
  }

  this->RemoveUnknownClangTidyExportFixesFiles();
}

void cmGlobalNinjaGenerator::CleanMetaData()
{
  constexpr size_t ninja_tool_arg_size = 8; // 2 `-_` flags and 4 separators
  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);
    }
    std::string error;
    if (!cmSystemTools::RunSingleCommand(command, nullptr, &error, nullptr,
                                         nullptr,
                                         cmSystemTools::OUTPUT_NONE)) {
      this->GetCMakeInstance()->IssueMessage(MessageType::FATAL_ERROR,
                                             cmStrCat("Running\n '",
                                                      cmJoin(command, "' '"),
                                                      "'\n"
                                                      "failed with:\n ",
                                                      error));
      cmSystemTools::SetFatalErrorOccurred();
    }
  };

  // Can the tools below expect 'build.ninja' to be loadable?
  bool const expectBuildManifest =
    !this->IsMultiConfig() && this->OutputPathPrefix.empty();

  // Skip some ninja tools if they need 'build.ninja' but it is missing.
  bool const missingBuildManifest = expectBuildManifest &&
    this->NinjaSupportsUnconditionalRecompactTool &&
    !cmSystemTools::FileExists("build.ninja");

  // The `recompact` tool loads the manifest. As above, we don't have a single
  // `build.ninja` to load for this in Ninja-Multi. This may be relaxed in the
  // future pending further investigation into how Ninja works upstream
  // (ninja#1721).
  if (this->NinjaSupportsUnconditionalRecompactTool &&
      !this->GetCMakeInstance()->GetRegenerateDuringBuild() &&
      expectBuildManifest && !missingBuildManifest) {
    run_ninja_tool({ "recompact" });
  }
  if (this->NinjaSupportsRestatTool && this->OutputPathPrefix.empty()) {
    cmNinjaDeps outputs;
    this->AddRebuildManifestOutputs(outputs);
    auto output_it = outputs.begin();
    size_t static_arg_size = ninja_tool_arg_size + this->NinjaCommand.size() +
      this->GetCMakeInstance()->GetHomeOutputDirectory().size();
    // The Windows command-line length limit is 32768, but if `ninja` is
    // wrapped by a `.bat` file, the limit is 8192.  Leave plenty.
    constexpr size_t maximum_arg_size = 8000;
    while (output_it != outputs.end()) {
      size_t total_arg_size = static_arg_size;
      std::vector<char const*> args;
      args.reserve(std::distance(output_it, outputs.end()) + 1);
      args.push_back("restat");
      total_arg_size += 7; // restat + 1
      while (output_it != outputs.end() &&
             total_arg_size + output_it->size() + 1 < maximum_arg_size) {
        args.push_back(output_it->c_str());
        total_arg_size += output_it->size() + 1;
        ++output_it;
      }
      run_ninja_tool(args);
    }
  }
}

bool cmGlobalNinjaGenerator::FindMakeProgram(cmMakefile* mf)
{
  if (!this->cmGlobalGenerator::FindMakeProgram(mf)) {
    return false;
  }
  if (cmValue ninjaCommand = mf->GetDefinition("CMAKE_MAKE_PROGRAM")) {
    this->NinjaCommand = *ninjaCommand;
    std::vector<std::string> command;
    command.push_back(this->NinjaCommand);
    command.emplace_back("--version");
    std::string version;
    std::string error;
    if (!cmSystemTools::RunSingleCommand(command, &version, &error, nullptr,
                                         nullptr,
                                         cmSystemTools::OUTPUT_NONE)) {
      mf->IssueMessage(MessageType::FATAL_ERROR,
                       cmStrCat("Running\n '", cmJoin(command, "' '"),
                                "'\n"
                                "failed with:\n ",
                                error));
      cmSystemTools::SetFatalErrorOccurred();
      return false;
    }
    this->NinjaVersion = cmTrimWhitespace(version);
    this->CheckNinjaFeatures();
  }
  return true;
}

void cmGlobalNinjaGenerator::CheckNinjaFeatures()
{
  this->NinjaSupportsConsolePool =
    !cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, this->NinjaVersion,
                                   RequiredNinjaVersionForConsolePool());
  this->NinjaSupportsImplicitOuts = !cmSystemTools::VersionCompare(
    cmSystemTools::OP_LESS, this->NinjaVersion,
    cmGlobalNinjaGenerator::RequiredNinjaVersionForImplicitOuts());
  this->NinjaSupportsManifestRestat =
    !cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, this->NinjaVersion,
                                   RequiredNinjaVersionForManifestRestat());
  this->NinjaSupportsMultilineDepfile =
    !cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, this->NinjaVersion,
                                   RequiredNinjaVersionForMultilineDepfile());
  this->NinjaSupportsDyndepsCxx =
    !cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, this->NinjaVersion,
                                   RequiredNinjaVersionForDyndepsCxx());
  this->NinjaSupportsDyndepsFortran =
    !cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, this->NinjaVersion,
                                   RequiredNinjaVersionForDyndepsFortran());
  if (!this->NinjaSupportsDyndepsFortran) {
    // The ninja version number is not new enough to have upstream support.
    // Our ninja branch adds ".dyndep-#" to its version number,
    // where '#' is a feature-specific version number.  Extract it.
    static std::string const k_DYNDEP_ = ".dyndep-";
    std::string::size_type pos = this->NinjaVersion.find(k_DYNDEP_);
    if (pos != std::string::npos) {
      char const* fv = &this->NinjaVersion[pos + k_DYNDEP_.size()];
      unsigned long dyndep = 0;
      cmStrToULong(fv, &dyndep);
      if (dyndep == 1) {
        this->NinjaSupportsDyndepsFortran = true;
      }
    }
  }
  this->NinjaSupportsUnconditionalRecompactTool =
    !cmSystemTools::VersionCompare(
      cmSystemTools::OP_LESS, this->NinjaVersion,
      RequiredNinjaVersionForUnconditionalRecompactTool());
  this->NinjaSupportsRestatTool =
    !cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, this->NinjaVersion,
                                   RequiredNinjaVersionForRestatTool());
  this->NinjaSupportsMultipleOutputs =
    !cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, this->NinjaVersion,
                                   RequiredNinjaVersionForMultipleOutputs());
  this->NinjaSupportsMetadataOnRegeneration = !cmSystemTools::VersionCompare(
    cmSystemTools::OP_LESS, this->NinjaVersion,
    RequiredNinjaVersionForMetadataOnRegeneration());
#ifdef _WIN32
  this->NinjaSupportsCodePage =
    !cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, this->NinjaVersion,
                                   RequiredNinjaVersionForCodePage());
  if (this->NinjaSupportsCodePage) {
    this->CheckNinjaCodePage();
  } else {
    this->NinjaExpectedEncoding = codecvt_Encoding::ANSI;
  }
#endif
  this->NinjaSupportsCWDDepend =
    !cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, this->NinjaVersion,
                                   RequiredNinjaVersionForCWDDepend());
}

void cmGlobalNinjaGenerator::CheckNinjaCodePage()
{
  std::vector<std::string> command{ this->NinjaCommand, "-t", "wincodepage" };
  std::string output;
  std::string error;
  int result;
  if (!cmSystemTools::RunSingleCommand(command, &output, &error, &result,
                                       nullptr, cmSystemTools::OUTPUT_NONE)) {
    this->GetCMakeInstance()->IssueMessage(MessageType::FATAL_ERROR,
                                           cmStrCat("Running\n '",
                                                    cmJoin(command, "' '"),
                                                    "'\n"
                                                    "failed with:\n ",
                                                    error));
    cmSystemTools::SetFatalErrorOccurred();
  } else if (result == 0) {
    std::istringstream outputStream(output);
    std::string line;
    bool found = false;
    while (cmSystemTools::GetLineFromStream(outputStream, line)) {
      if (cmHasLiteralPrefix(line, "Build file encoding: ")) {
        cm::string_view lineView(line);
        cm::string_view encoding =
          lineView.substr(cmStrLen("Build file encoding: "));
        if (encoding == "UTF-8") {
          // Ninja expects UTF-8. We use that internally. No conversion needed.
          this->NinjaExpectedEncoding = codecvt_Encoding::None;
        } else {
          this->NinjaExpectedEncoding = codecvt_Encoding::ANSI;
        }
        found = true;
        break;
      }
    }
    if (!found) {
      this->GetCMakeInstance()->IssueMessage(
        MessageType::WARNING,
        "Could not determine Ninja's code page, defaulting to UTF-8");
      this->NinjaExpectedEncoding = codecvt_Encoding::None;
    }
  } else {
    this->NinjaExpectedEncoding = codecvt_Encoding::ANSI;
  }
}

bool cmGlobalNinjaGenerator::CheckLanguages(
  std::vector<std::string> const& languages, cmMakefile* mf) const
{
  if (cm::contains(languages, "Fortran")) {
    return this->CheckFortran(mf);
  }
  if (cm::contains(languages, "ISPC")) {
    return this->CheckISPC(mf);
  }
  if (cm::contains(languages, "Swift")) {
    std::string const architectures =
      mf->GetSafeDefinition("CMAKE_OSX_ARCHITECTURES");
    if (architectures.find_first_of(';') != std::string::npos) {
      mf->IssueMessage(MessageType::FATAL_ERROR,
                       "multiple values for CMAKE_OSX_ARCHITECTURES not "
                       "supported with Swift");
      cmSystemTools::SetFatalErrorOccurred();
      return false;
    }
  }
  return true;
}

bool cmGlobalNinjaGenerator::CheckCxxModuleSupport(CxxModuleSupportQuery query)
{
  if (this->NinjaSupportsDyndepsCxx) {
    return true;
  }
  bool const diagnose = !this->DiagnosedCxxModuleNinjaSupport &&
    !this->CMakeInstance->GetIsInTryCompile() &&
    query == CxxModuleSupportQuery::Expected;
  if (diagnose) {
    this->GetCMakeInstance()->IssueMessage(
      MessageType::FATAL_ERROR,
      cmStrCat("The Ninja generator does not support C++20 modules "
               "using Ninja version \n"
               "  ",
               this->NinjaVersion,
               "\n"
               "due to lack of required features.  "
               "Ninja ",
               RequiredNinjaVersionForDyndepsCxx(),
               " or higher is required."));
    cmSystemTools::SetFatalErrorOccurred();
  }
  return false;
}

bool cmGlobalNinjaGenerator::CheckFortran(cmMakefile* mf) const
{
  if (this->NinjaSupportsDyndepsFortran) {
    return true;
  }

  mf->IssueMessage(
    MessageType::FATAL_ERROR,
    cmStrCat("The Ninja generator does not support Fortran using Ninja "
             "version\n"
             "  ",
             this->NinjaVersion,
             "\n"
             "due to lack of required features.  "
             "Ninja ",
             RequiredNinjaVersionForDyndepsFortran(),
             " or higher is required."));
  cmSystemTools::SetFatalErrorOccurred();
  return false;
}

bool cmGlobalNinjaGenerator::CheckISPC(cmMakefile* mf) const
{
  if (this->NinjaSupportsMultipleOutputs) {
    return true;
  }

  mf->IssueMessage(
    MessageType::FATAL_ERROR,
    cmStrCat("The Ninja generator does not support ISPC using Ninja version\n"
             "  ",
             this->NinjaVersion,
             "\n"
             "due to lack of required features.  "
             "Ninja ",
             RequiredNinjaVersionForMultipleOutputs(),
             " or higher is required."));
  cmSystemTools::SetFatalErrorOccurred();
  return false;
}

void cmGlobalNinjaGenerator::EnableLanguage(
  std::vector<std::string> const& langs, cmMakefile* mf, bool optional)
{
  if (this->IsMultiConfig()) {
    mf->InitCMAKE_CONFIGURATION_TYPES("Debug;Release;RelWithDebInfo");
  }

  this->cmGlobalGenerator::EnableLanguage(langs, mf, optional);
  for (std::string const& l : langs) {
    if (l == "NONE") {
      continue;
    }
    this->ResolveLanguageCompiler(l, mf, optional);
#ifdef _WIN32
    std::string const& compilerId =
      mf->GetSafeDefinition(cmStrCat("CMAKE_", l, "_COMPILER_ID"));
    std::string const& simulateId =
      mf->GetSafeDefinition(cmStrCat("CMAKE_", l, "_SIMULATE_ID"));
    std::string const& compilerFrontendVariant = mf->GetSafeDefinition(
      cmStrCat("CMAKE_", l, "_COMPILER_FRONTEND_VARIANT"));
    if (DetectGCCOnWindows(compilerId, simulateId, compilerFrontendVariant)) {
      this->MarkAsGCCOnWindows();
    }
#endif
  }
}

// Implemented by:
//   cmGlobalUnixMakefileGenerator3
//   cmGlobalGhsMultiGenerator
//   cmGlobalVisualStudio10Generator
//   cmGlobalVisualStudio7Generator
//   cmGlobalXCodeGenerator
// Called by:
//   cmGlobalGenerator::Build()
std::vector<cmGlobalGenerator::GeneratedMakeCommand>
cmGlobalNinjaGenerator::GenerateBuildCommand(
  std::string const& makeProgram, std::string const& /*projectName*/,
  std::string const& /*projectDir*/,
  std::vector<std::string> const& targetNames, std::string const& config,
  int jobs, bool verbose, cmBuildOptions /*buildOptions*/,
  std::vector<std::string> const& makeOptions,
  BuildTryCompile /*isInTryCompile*/)
{
  GeneratedMakeCommand makeCommand;
  makeCommand.Add(this->SelectMakeProgram(makeProgram));

  if (verbose) {
    makeCommand.Add("-v");
  }

  if ((jobs != cmake::NO_BUILD_PARALLEL_LEVEL) &&
      (jobs != cmake::DEFAULT_BUILD_PARALLEL_LEVEL)) {
    makeCommand.Add("-j", std::to_string(jobs));
  }

  this->AppendNinjaFileArgument(makeCommand, config);

  makeCommand.Add(makeOptions.begin(), makeOptions.end());
  for (auto const& tname : targetNames) {
    if (!tname.empty()) {
      makeCommand.Add(tname);
    }
  }
  return { std::move(makeCommand) };
}

// Non-virtual public methods.

void cmGlobalNinjaGenerator::AddRule(cmNinjaRule const& rule)
{
  // Do not add the same rule twice.
  if (!this->Rules.insert(rule.Name).second) {
    return;
  }
  // Store command length
  this->RuleCmdLength[rule.Name] = static_cast<int>(rule.Command.size());
  // Write rule
  cmGlobalNinjaGenerator::WriteRule(*this->RulesFileStream, rule);
}

bool cmGlobalNinjaGenerator::HasRule(std::string const& name)
{
  return (this->Rules.find(name) != this->Rules.end());
}

// Private virtual overrides

bool cmGlobalNinjaGenerator::SupportsShortObjectNames() const
{
  return true;
}

void cmGlobalNinjaGenerator::ComputeTargetObjectDirectory(
  cmGeneratorTarget* gt) const
{
  // Compute full path to object file directory for this target.
  std::string dir =
    cmStrCat(gt->GetSupportDirectory(), '/', this->GetCMakeCFGIntDir(), '/');
  gt->ObjectDirectory = dir;
}

// Private methods

bool cmGlobalNinjaGenerator::OpenBuildFileStreams()
{
  if (!this->OpenFileStream(this->BuildFileStream,
                            cmGlobalNinjaGenerator::NINJA_BUILD_FILE)) {
    return false;
  }

  // Write a comment about this file.
  *this->BuildFileStream
    << "# This file contains all the build statements describing the\n"
    << "# compilation DAG.\n\n";

  return true;
}

bool cmGlobalNinjaGenerator::OpenFileStream(
  std::unique_ptr<cmGeneratedFileStream>& stream, std::string const& name)
{
  // Get a stream where to generate things.
  if (!stream) {
    // Compute Ninja's build file path.
    std::string path =
      cmStrCat(this->GetCMakeInstance()->GetHomeOutputDirectory(), '/', name);
    stream = cm::make_unique<cmGeneratedFileStream>(
      path, false, this->GetMakefileEncoding());
    if (!(*stream)) {
      // An error message is generated by the constructor if it cannot
      // open the file.
      return false;
    }

    // Write the do not edit header.
    this->WriteDisclaimer(*stream);
  }

  return true;
}

cm::optional<std::set<std::string>> cmGlobalNinjaGenerator::ListSubsetWithAll(
  std::set<std::string> const& all, std::set<std::string> const& defaults,
  std::vector<std::string> const& 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 (all.count(item)) {
      result.insert(item);
    } else {
      return cm::nullopt;
    }
  }

  return cm::make_optional(result);
}

void cmGlobalNinjaGenerator::CloseBuildFileStreams()
{
  if (this->BuildFileStream) {
    this->BuildFileStream.reset();
  } else {
    cmSystemTools::Error("Build file stream was not open.");
  }
}

bool cmGlobalNinjaGenerator::OpenRulesFileStream()
{
  if (!this->OpenFileStream(this->RulesFileStream,
                            cmGlobalNinjaGenerator::NINJA_RULES_FILE)) {
    return false;
  }

  // Write comment about this file.
  /* clang-format off */
  *this->RulesFileStream
    << "# This file contains all the rules used to get the outputs files\n"
    << "# built from the input files.\n"
    << "# It is included in the main '" << NINJA_BUILD_FILE << "'.\n\n"
    ;
  /* clang-format on */
  return true;
}

void cmGlobalNinjaGenerator::CloseRulesFileStream()
{
  if (this->RulesFileStream) {
    this->RulesFileStream.reset();
  } else {
    cmSystemTools::Error("Rules file stream was not open.");
  }
}

static void EnsureTrailingSlash(std::string& path)
{
  if (path.empty()) {
    return;
  }
  std::string::value_type last = path.back();
#ifdef _WIN32
  if (last != '\\') {
    path += '\\';
  }
#else
  if (last != '/') {
    path += '/';
  }
#endif
}

std::string const& cmGlobalNinjaGenerator::ConvertToNinjaPath(
  std::string const& path) const
{
  auto const f = this->ConvertToNinjaPathCache.find(path);
  if (f != this->ConvertToNinjaPathCache.end()) {
    return f->second;
  }

  std::string convPath =
    this->LocalGenerators[0]->MaybeRelativeToTopBinDir(path);
  convPath = this->NinjaOutputPath(convPath);
#ifdef _WIN32
  std::replace(convPath.begin(), convPath.end(), '/', '\\');
#endif
  return this->ConvertToNinjaPathCache.emplace(path, std::move(convPath))
    .first->second;
}

std::string cmGlobalNinjaGenerator::ConvertToNinjaAbsPath(
  std::string path) const
{
#ifdef _WIN32
  std::replace(path.begin(), path.end(), '/', '\\');
#endif
  return path;
}

void cmGlobalNinjaGenerator::AddAdditionalCleanFile(std::string fileName,
                                                    std::string const& config)
{
  this->Configs[config].AdditionalCleanFiles.emplace(std::move(fileName));
}

void cmGlobalNinjaGenerator::AddCXXCompileCommand(
  std::string const& commandLine, std::string const& sourceFile,
  std::string const& objPath)
{
  // Compute Ninja's build file path.
  std::string buildFileDir =
    this->GetCMakeInstance()->GetHomeOutputDirectory();
  if (!this->CompileCommandsStream) {
    std::string buildFilePath =
      cmStrCat(buildFileDir, "/compile_commands.json");

    // Get a stream where to generate things.
    this->CompileCommandsStream =
      cm::make_unique<cmGeneratedFileStream>(buildFilePath);
    *this->CompileCommandsStream << "[\n";
  } else {
    *this->CompileCommandsStream << ",\n";
  }

  std::string sourceFileName =
    cmSystemTools::CollapseFullPath(sourceFile, buildFileDir);

  /* clang-format off */
  *this->CompileCommandsStream << "{\n"
     << R"(  "directory": ")"
     << cmGlobalGenerator::EscapeJSON(buildFileDir) << "\",\n"
     << R"(  "command": ")"
     << cmGlobalGenerator::EscapeJSON(commandLine) << "\",\n"
     << R"(  "file": ")"
     << cmGlobalGenerator::EscapeJSON(sourceFileName) << "\",\n"
     << R"(  "output": ")"
     << cmGlobalGenerator::EscapeJSON(
           cmSystemTools::CollapseFullPath(objPath, buildFileDir))
           << "\"\n"
     << "}";
  /* clang-format on */
}

void cmGlobalNinjaGenerator::CloseCompileCommandsStream()
{
  if (this->CompileCommandsStream) {
    *this->CompileCommandsStream << "\n]\n";
    this->CompileCommandsStream.reset();
  }
}

void cmGlobalNinjaGenerator::WriteDisclaimer(std::ostream& os) const
{
  os << "# CMAKE generated file: DO NOT EDIT!\n"
     << "# Generated by \"" << this->GetName() << "\""
     << " Generator, CMake Version " << cmVersion::GetMajorVersion() << "."
     << cmVersion::GetMinorVersion() << "\n\n";
}

void cmGlobalNinjaGenerator::WriteAssumedSourceDependencies()
{
  for (auto const& asd : this->AssumedSourceDependencies) {
    CCOutputs outputs(this);
    outputs.ExplicitOuts.emplace_back(asd.first);
    cmNinjaDeps orderOnlyDeps;
    std::copy(asd.second.begin(), asd.second.end(),
              std::back_inserter(orderOnlyDeps));
    this->WriteCustomCommandBuild(
      /*command=*/"", /*description=*/"",
      "Assume dependencies for generated source file.",
      /*depfile*/ "", /*job_pool*/ "",
      /*uses_terminal*/ false,
      /*restat*/ true, std::string(), outputs, cmNinjaDeps(),
      std::move(orderOnlyDeps));
  }
}

void cmGlobalNinjaGenerator::WriteInstallPrepTargets()
{
  if (!this->AreInstallPrepTargetsEnabled()) {
    return;
  }
  this->CheckInstallPrepTargets();

  std::map<std::string, std::set<std::string>> configsByName;
  auto writeConfig = [this, &configsByName](std::string const& config) {
    auto writePrepTarget =
      [this, &config, &configsByName](
        std::string const& name,
        cmGlobalGenerator::InstallPrepTargets::TargetMap const& targets,
        std::set<std::string> const& files) {
        std::string const prepName = this->ConvertToNinjaPath(name);
        configsByName[prepName].insert(config);
        cmNinjaBuild build("phony");
        build.Outputs.push_back(this->BuildAlias(prepName, config));
        for (std::string const& file : files) {
          build.ExplicitDeps.push_back(this->ConvertToNinjaPath(file));
        }
        for (auto const& target : targets) {
          if (target.second.Normal || target.second.InstallArtifact) {
            this->AppendTargetOutputs(target.first, build.ExplicitDeps, config,
                                      DependOnTargetArtifact);
          }
          for (std::string const& file : target.second.GeneratedFiles) {
            build.ExplicitDeps.push_back(this->ConvertToNinjaPath(file));
          }
        }
        std::sort(build.ExplicitDeps.begin(), build.ExplicitDeps.end());
        build.ExplicitDeps.erase(
          std::unique(build.ExplicitDeps.begin(), build.ExplicitDeps.end()),
          build.ExplicitDeps.end());
        this->WritePerConfigPhony(config, build);
      };

    InstallPrepTargets const prepTargets = this->GetInstallPrepTargets(config);
    std::set<std::string> const noFiles;
    for (auto const& component : prepTargets.Components) {
      auto const it = prepTargets.ComponentFiles.find(component.first);
      std::set<std::string> const& files =
        it == prepTargets.ComponentFiles.end() ? noFiles : it->second;
      writePrepTarget(cmStrCat("install_prep/", component.first),
                      component.second, files);
    }
    writePrepTarget("install_prep/all", prepTargets.All, prepTargets.AllFiles);
  };

  if (this->IsMultiConfig()) {
    for (std::string const& config : this->GetConfigNames()) {
      writeConfig(config);
    }
  } else {
    writeConfig(this->GetConfigNames().front());
  }
  this->WritePerConfigPhonyAliases(configsByName);
}

void cmGlobalNinjaGenerator::WriteTestPrepTargets()
{
  if (this->Makefiles.front()->IsOn("CMAKE_SKIP_TEST_PREP_TARGETS")) {
    return;
  }

  std::map<std::string, std::set<std::string>> configsByName;
  auto writeConfig = [this, &configsByName](std::string const& config) {
    struct TestPrepTarget
    {
      std::string Comment;
      cmNinjaDeps ExplicitDeps;
    };

    std::map<std::string, TestPrepTarget> testPrepTargets;
    for (auto const& localGen : this->LocalGenerators) {
      cmLocalGenerator* lg = localGen.get();
      auto const& testGenerators = lg->GetMakefile()->GetTestGenerators();
      for (auto const& tester : testGenerators) {
        cmTestGenerator::BuildDependencies testDeps;
        if (!tester->GetBuildDependencies(lg, config, testDeps)) {
          continue;
        }
        std::string const depName = this->ConvertToNinjaPath(
          cmStrCat("test_prep/", tester->GetTest()->GetName()));
        // Merge with existing target if multiple tests have the same name
        auto& testPrepTarget = testPrepTargets[depName];
        testPrepTarget.Comment = cmStrCat("Build dependencies for test ",
                                          tester->GetTest()->GetName());

        for (cmGeneratorTarget* depTarget : testDeps.Targets) {
          this->AppendTargetOutputs(depTarget, testPrepTarget.ExplicitDeps,
                                    config, DependOnTargetArtifact);
        }
        for (cmTestGenerator::BuildDependencies::FileDependency const& file :
             testDeps.Files) {
          testPrepTarget.ExplicitDeps.push_back(
            this->ConvertToNinjaPath(file.Path));
        }
      }

      cmLocalGenerator::DirectoryTestPrepTarget directoryTarget;
      if (!lg->GetDirectoryTestPrepTarget(directoryTarget, config)) {
        continue;
      }

      std::string const depName =
        this->ConvertToNinjaPath(directoryTarget.Name);
      TestPrepTarget& testPrepTarget = testPrepTargets[depName];
      testPrepTarget.Comment = std::move(directoryTarget.Comment);

      for (cmLocalGenerator::DirectoryTestPrepDependency const& dep :
           directoryTarget.Dependencies) {
        if (dep.Target) {
          this->AppendTargetOutputs(dep.Target, testPrepTarget.ExplicitDeps,
                                    config, DependOnTargetArtifact);
        } else {
          testPrepTarget.ExplicitDeps.push_back(
            this->ConvertToNinjaPath(dep.Raw));
        }
      }
    }

    std::vector<std::string> allDeps;
    for (auto& prepTarget : testPrepTargets) {
      configsByName[prepTarget.first].insert(config);
      cmNinjaBuild build("phony");
      build.Comment = prepTarget.second.Comment;
      build.Outputs.push_back(this->BuildAlias(prepTarget.first, config));

      // Avoid duplicate dependencies when merging test_prep/ targets
      auto& explicitDeps = prepTarget.second.ExplicitDeps;
      std::sort(explicitDeps.begin(), explicitDeps.end());
      explicitDeps.erase(std::unique(explicitDeps.begin(), explicitDeps.end()),
                         explicitDeps.end());
      build.ExplicitDeps = std::move(explicitDeps);

      allDeps.push_back(build.Outputs.front());
      this->WritePerConfigPhony(config, build);
    }

    std::string const allName = this->ConvertToNinjaPath("test_prep/all");
    configsByName[allName].insert(config);
    cmNinjaBuild build("phony");
    build.Comment = "Build dependencies for all tests";
    build.Outputs.push_back(this->BuildAlias(allName, config));
    build.ExplicitDeps = std::move(allDeps);
    this->WritePerConfigPhony(config, build);
  };

  if (this->IsMultiConfig()) {
    for (std::string const& config : this->GetConfigNames()) {
      writeConfig(config);
    }
  } else {
    writeConfig(
      this->Makefiles.front()->GetSafeDefinition("CMAKE_BUILD_TYPE"));
  }
  this->WritePerConfigPhonyAliases(configsByName);
}

void cmGlobalNinjaGenerator::WritePerConfigPhony(std::string const& config,
                                                 cmNinjaBuild const& build)
{
  this->WriteBuild(this->EnableCrossConfigBuild() &&
                       this->CrossConfigs.count(config)
                     ? *this->GetCommonFileStream()
                     : *this->GetImplFileStream(config),
                   build);
}

void cmGlobalNinjaGenerator::WritePerConfigPhonyAliases(
  std::map<std::string, std::set<std::string>> const& configsByName)
{
  if (!this->IsMultiConfig()) {
    return;
  }

  cmNinjaBuild build("phony");
  build.Outputs.emplace_back();
  for (auto const& entry : configsByName) {
    std::string const& name = entry.first;
    std::set<std::string> const& configs = entry.second;

    // Add shortcut target in each config's build file
    build.Outputs.front() = name;
    for (std::string const& config : configs) {
      build.ExplicitDeps = { this->BuildAlias(name, config) };
      this->WriteBuild(*this->GetConfigFileStream(config), build);
    }

    // Add shortcut target in the default build file
    if (!this->DefaultConfigs.empty()) {
      build.ExplicitDeps.clear();
      for (std::string const& config : this->DefaultConfigs) {
        if (configs.count(config)) {
          build.ExplicitDeps.push_back(this->BuildAlias(name, config));
        }
      }
      if (!build.ExplicitDeps.empty()) {
        this->WriteBuild(*this->GetDefaultFileStream(), build);
      }
    }

    // Add target for all configs
    if (this->EnableCrossConfigBuild()) {
      build.ExplicitDeps.clear();
      for (std::string const& config : this->CrossConfigs) {
        if (configs.count(config)) {
          build.ExplicitDeps.push_back(this->BuildAlias(name, config));
        }
      }
      if (!build.ExplicitDeps.empty()) {
        build.Outputs.front() = this->BuildAlias(name, "all");
        this->WriteBuild(*this->GetCommonFileStream(), build);
      }
    }
  }
}

std::string cmGlobalNinjaGenerator::OrderDependsTargetForTarget(
  cmGeneratorTarget const* target, std::string const& /*config*/) const
{
  return cmStrCat("cmake_object_order_depends_target_", target->GetName());
}

std::string cmGlobalNinjaGenerator::OrderDependsTargetForTargetPrivate(
  cmGeneratorTarget const* target, std::string const& config) const
{
  return cmStrCat(this->OrderDependsTargetForTarget(target, config),
                  "_private");
}

void cmGlobalNinjaGenerator::AppendTargetOutputs(
  cmGeneratorTarget const* target, cmNinjaDeps& outputs,
  std::string const& config, cmNinjaTargetDepends depends) const
{
  // for frameworks, we want the real name, not sample name
  // frameworks always appear versioned, and the build.ninja
  // will always attempt to manage symbolic links instead
  // of letting cmOSXBundleGenerator do it.
  bool realname = target->IsFrameworkOnApple();

  switch (target->GetType()) {
    case cm::TargetType::SHARED_LIBRARY:
    case cm::TargetType::STATIC_LIBRARY:
    case cm::TargetType::MODULE_LIBRARY: {
      if (depends == DependOnTargetOrdering) {
        outputs.push_back(this->OrderDependsTargetForTarget(target, config));
        break;
      }
    }
      CM_FALLTHROUGH;
    case cm::TargetType::EXECUTABLE: {
      if (target->IsApple() && target->HasImportLibrary(config)) {
        outputs.push_back(this->ConvertToNinjaPath(target->GetFullPath(
          config, cmStateEnums::ImportLibraryArtifact, realname)));
      }
      outputs.push_back(this->ConvertToNinjaPath(target->GetFullPath(
        config, cmStateEnums::RuntimeBinaryArtifact, realname)));
      break;
    }
    case cm::TargetType::OBJECT_LIBRARY: {
      if (depends == DependOnTargetOrdering) {
        outputs.push_back(this->OrderDependsTargetForTarget(target, config));
        break;
      }
    }
      CM_FALLTHROUGH;
    case cm::TargetType::GLOBAL_TARGET:
    case cm::TargetType::INTERFACE_LIBRARY:
    case cm::TargetType::UTILITY: {
      std::string path =
        cmStrCat(target->GetLocalGenerator()->GetCurrentBinaryDirectory(), '/',
                 target->GetName());
      std::string output = this->ConvertToNinjaPath(path);
      if (target->Target->IsPerConfig()) {
        output = this->BuildAlias(output, config);
      }
      outputs.push_back(output);
      break;
    }

    case cm::TargetType::UNKNOWN_LIBRARY:
      break;
  }
}

void cmGlobalNinjaGenerator::AppendTargetDepends(
  cmGeneratorTarget const* target, cmNinjaDeps& outputs,
  std::string const& config, std::string const& fileConfig,
  cmNinjaTargetDepends depends)
{
  if (target->GetType() == cm::TargetType::GLOBAL_TARGET) {
    // These depend only on other CMake-provided targets, e.g. "all".
    for (BT<std::pair<std::string, bool>> const& util :
         target->GetUtilities()) {
      std::string d =
        cmStrCat(target->GetLocalGenerator()->GetCurrentBinaryDirectory(), '/',
                 util.Value.first);
      outputs.push_back(this->BuildAlias(this->ConvertToNinjaPath(d), config));
    }
  } else {
    cmNinjaDeps outs;

    auto computeISPCOutputs = [](cmGlobalNinjaGenerator* gg,
                                 cmGeneratorTarget const* depTarget,
                                 cmNinjaDeps& outputDeps,
                                 std::string const& targetConfig) {
      if (depTarget->CanCompileSources()) {
        auto headers = depTarget->GetGeneratedISPCHeaders(targetConfig);
        auto const mapToNinjaPath = gg->MapToNinjaPath();
        if (!headers.empty()) {
          std::transform(headers.begin(), headers.end(), headers.begin(),
                         mapToNinjaPath);
          outputDeps.insert(outputDeps.end(), headers.begin(), headers.end());
        }
        auto objs = depTarget->GetGeneratedISPCObjects(targetConfig);
        std::transform(
          objs.begin(), objs.end(), std::back_inserter(outputDeps),
          [&mapToNinjaPath](
            std::pair<cmSourceFile const*, std::string> const& obj)
            -> std::string { return mapToNinjaPath(obj.second); });
      }
    };

    for (cmTargetDepend const& targetDep :
         this->GetTargetDirectDepends(target)) {
      if (!targetDep->IsInBuildSystem()) {
        continue;
      }
      if (targetDep.IsCross()) {
        this->AppendTargetOutputs(targetDep, outs, fileConfig, depends);
        computeISPCOutputs(this, targetDep, outs, fileConfig);
      } else {
        this->AppendTargetOutputs(targetDep, outs, config, depends);
        computeISPCOutputs(this, targetDep, outs, config);
      }
    }
    std::sort(outs.begin(), outs.end());
    cm::append(outputs, outs);
  }
}

void cmGlobalNinjaGenerator::AppendTargetDependsClosure(
  cmGeneratorTarget const* target, std::unordered_set<std::string>& outputs,
  std::string const& config, std::string const& fileConfig, bool genexOutput,
  bool omit_self)
{

  // try to locate the target in the cache
  ByConfig::TargetDependsClosureKey key{
    target,
    config,
    genexOutput,
  };
  auto find = this->Configs[fileConfig].TargetDependsClosures.lower_bound(key);

  if (find == this->Configs[fileConfig].TargetDependsClosures.end() ||
      find->first != key) {
    // We now calculate the closure outputs by inspecting the dependent
    // targets recursively.
    // For that we have to distinguish between a local result set that is only
    // relevant for filling the cache entries properly isolated and a global
    // result set that is relevant for the result of the top level call to
    // AppendTargetDependsClosure.
    std::unordered_set<std::string>
      this_outs; // this will be the new cache entry

    for (auto const& dep_target : this->GetTargetDirectDepends(target)) {
      if (!dep_target->IsInBuildSystem()) {
        continue;
      }

      if (!this->IsSingleConfigUtility(target) &&
          !this->IsSingleConfigUtility(dep_target) &&
          this->EnableCrossConfigBuild() && !dep_target.IsCross() &&
          !genexOutput) {
        continue;
      }

      if (dep_target.IsCross()) {
        this->AppendTargetDependsClosure(dep_target, this_outs, fileConfig,
                                         fileConfig, genexOutput, false);
      } else {
        this->AppendTargetDependsClosure(dep_target, this_outs, config,
                                         fileConfig, genexOutput, false);
      }
    }
    find = this->Configs[fileConfig].TargetDependsClosures.emplace_hint(
      find, key, std::move(this_outs));
  }

  // now fill the outputs of the final result from the newly generated cache
  // entry
  outputs.insert(find->second.begin(), find->second.end());

  // finally generate the outputs of the target itself, if applicable
  cmNinjaDeps outs;
  if (!omit_self) {
    this->AppendTargetOutputs(target, outs, config, DependOnTargetArtifact);
  }
  outputs.insert(outs.begin(), outs.end());
}

void cmGlobalNinjaGenerator::AppendCodegenOutputs(
  cmGeneratorTarget const* target, cmNinjaDeps& deps,
  std::string const& config)
{
  std::vector<cmSourceFile const*> customCommandSources;
  target->GetCustomCommands(customCommandSources, config);
  for (cmSourceFile const* sf : customCommandSources) {
    cmCustomCommand const* cc = sf->GetCustomCommand();
    if (cc->GetCodegen()) {
      cmCustomCommandGenerator ccg(*cc, config, target->GetLocalGenerator());
      std::vector<std::string> const& outputs = ccg.GetOutputs();
      std::transform(outputs.begin(), outputs.end(), std::back_inserter(deps),
                     this->MapToNinjaPath());
    }
  }
}

void cmGlobalNinjaGenerator::AppendCodegenTargetDepends(
  cmGeneratorTarget const* target, cmNinjaDeps& deps,
  std::string const& config, std::set<cmGeneratorTarget const*>& visited)
{
  std::set<std::string> const& codegenDeps = target->Target->GetCodegenDeps();
  for (cmTargetDepend const& targetDep :
       this->GetTargetDirectDepends(target)) {
    if (targetDep->IsInBuildSystem() &&
        codegenDeps.count(targetDep->GetName()) &&
        visited.insert(targetDep).second) {
      this->AppendCodegenOutputs(targetDep, deps, config);
      this->AppendCodegenTargetDepends(targetDep, deps, config, visited);
    }
  }
}

void cmGlobalNinjaGenerator::AddTargetAlias(std::string const& alias,
                                            cmGeneratorTarget* target,
                                            std::string const& config)
{
  std::string outputPath = this->NinjaOutputPath(alias);
  std::string buildAlias = this->BuildAlias(outputPath, config);
  cmNinjaDeps outputs;
  if (config != "all") {
    this->AppendTargetOutputs(target, outputs, config, DependOnTargetArtifact);
  }
  // Mark the target's outputs as ambiguous to ensure that no other target
  // uses the output as an alias.
  for (std::string const& output : outputs) {
    this->TargetAliases[output].GeneratorTarget = nullptr;
    this->DefaultTargetAliases[output].GeneratorTarget = nullptr;
    for (std::string const& config2 : this->GetConfigNames()) {
      this->Configs[config2].TargetAliases[output].GeneratorTarget = nullptr;
    }
  }

  // Insert the alias into the map.  If the alias was already present in the
  // map and referred to another target, mark it as ambiguous.
  TargetAlias ta;
  ta.GeneratorTarget = target;
  ta.Config = config;

  auto newAliasGlobal =
    this->TargetAliases.insert(std::make_pair(buildAlias, ta));
  if (newAliasGlobal.second &&
      newAliasGlobal.first->second.GeneratorTarget != target) {
    newAliasGlobal.first->second.GeneratorTarget = nullptr;
  }

  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)
{
  cmGlobalNinjaGenerator::WriteDivider(os);
  os << "# Target aliases.\n\n";

  cmNinjaBuild build("phony");
  build.Outputs.emplace_back();
  for (auto const& ta : this->TargetAliases) {
    // Don't write ambiguous aliases.
    if (!ta.second.GeneratorTarget) {
      continue;
    }

    // Don't write alias if there is a already a custom command with
    // matching output
    if (this->HasCustomCommandOutput(ta.first)) {
      continue;
    }

    build.Outputs.front() = ta.first;
    build.ExplicitDeps.clear();
    if (ta.second.Config == "all") {
      for (auto const& config : this->CrossConfigs) {
        this->AppendTargetOutputs(ta.second.GeneratorTarget,
                                  build.ExplicitDeps, config,
                                  DependOnTargetArtifact);
      }
    } else {
      this->AppendTargetOutputs(ta.second.GeneratorTarget, build.ExplicitDeps,
                                ta.second.Config, DependOnTargetArtifact);
    }
    this->WriteBuild(this->EnableCrossConfigBuild() &&
                         (ta.second.Config == "all" ||
                          this->CrossConfigs.count(ta.second.Config))
                       ? os
                       : *this->GetImplFileStream(ta.second.Config),
                     build);
  }

  if (this->IsMultiConfig()) {
    for (std::string const& config : this->GetConfigNames()) {
      for (auto const& ta : this->Configs[config].TargetAliases) {
        // Don't write ambiguous aliases.
        if (!ta.second.GeneratorTarget) {
          continue;
        }

        // Don't write alias if there is a already a custom command with
        // matching output
        if (this->HasCustomCommandOutput(ta.first)) {
          continue;
        }

        build.Outputs.front() = ta.first;
        build.ExplicitDeps.clear();
        this->AppendTargetOutputs(ta.second.GeneratorTarget,
                                  build.ExplicitDeps, config,
                                  DependOnTargetArtifact);
        this->WriteBuild(*this->GetConfigFileStream(config), build);
      }
    }

    if (!this->DefaultConfigs.empty()) {
      for (auto const& ta : this->DefaultTargetAliases) {
        // Don't write ambiguous aliases.
        if (!ta.second.GeneratorTarget) {
          continue;
        }

        // Don't write alias if there is a already a custom command with
        // matching output
        if (this->HasCustomCommandOutput(ta.first)) {
          continue;
        }

        build.Outputs.front() = ta.first;
        build.ExplicitDeps.clear();
        for (auto const& config : this->DefaultConfigs) {
          this->AppendTargetOutputs(ta.second.GeneratorTarget,
                                    build.ExplicitDeps, config,
                                    DependOnTargetArtifact);
        }
        this->WriteBuild(*this->GetDefaultFileStream(), build);
      }
    }
  }
}

void cmGlobalNinjaGenerator::WriteFolderTargets(std::ostream& os)
{
  cmGlobalNinjaGenerator::WriteDivider(os);
  os << "# Folder targets.\n\n";

  std::map<std::string, DirectoryTarget> dirTargets =
    this->ComputeDirectoryTargets();

  // Codegen target
  if (this->CheckCMP0171()) {
    for (auto const& it : dirTargets) {
      cmNinjaBuild build("phony");
      cmGlobalNinjaGenerator::WriteDivider(os);
      std::string const& currentBinaryDir = it.first;
      DirectoryTarget const& dt = it.second;
      std::vector<std::string> configs =
        static_cast<cmLocalNinjaGenerator const*>(dt.LG)->GetConfigNames();

      // Setup target
      build.Comment = cmStrCat("Folder: ", currentBinaryDir);
      build.Outputs.emplace_back();
      std::string const buildDirCodegenTarget =
        this->ConvertToNinjaPath(cmStrCat(currentBinaryDir, "/codegen"));
      for (auto const& config : configs) {
        build.ExplicitDeps.clear();
        build.Outputs.front() =
          this->BuildAlias(buildDirCodegenTarget, config);

        std::set<cmGeneratorTarget const*> visited;

        for (DirectoryTarget::Target const& t : dt.Targets) {
          if (this->IsExcludedFromAllInConfig(t, config)) {
            continue;
          }

          if (visited.insert(t.GT).second) {
            this->AppendCodegenOutputs(t.GT, build.ExplicitDeps, config);
          }
          this->AppendCodegenTargetDepends(t.GT, build.ExplicitDeps, config,
                                           visited);
        }

        for (DirectoryTarget::Dir const& d : dt.Children) {
          if (!d.ExcludeFromAll) {
            build.ExplicitDeps.emplace_back(this->BuildAlias(
              this->ConvertToNinjaPath(cmStrCat(d.Path, "/codegen")), config));
          }
        }

        // Write target
        this->WriteBuild(this->EnableCrossConfigBuild() &&
                             this->CrossConfigs.count(config)
                           ? os
                           : *this->GetImplFileStream(config),
                         build);
      }

      // Add shortcut target
      if (this->IsMultiConfig()) {
        for (auto const& config : configs) {
          build.ExplicitDeps = { this->BuildAlias(buildDirCodegenTarget,
                                                  config) };
          build.Outputs.front() = buildDirCodegenTarget;
          this->WriteBuild(*this->GetConfigFileStream(config), build);
        }

        if (!this->DefaultFileConfig.empty()) {
          build.ExplicitDeps.clear();
          for (auto const& config : this->DefaultConfigs) {
            build.ExplicitDeps.push_back(
              this->BuildAlias(buildDirCodegenTarget, config));
          }
          build.Outputs.front() = buildDirCodegenTarget;
          this->WriteBuild(*this->GetDefaultFileStream(), build);
        }
      }

      // Add target for all configs
      if (this->EnableCrossConfigBuild()) {
        build.ExplicitDeps.clear();
        for (auto const& config : this->CrossConfigs) {
          build.ExplicitDeps.push_back(
            this->BuildAlias(buildDirCodegenTarget, config));
        }
        build.Outputs.front() = this->BuildAlias(buildDirCodegenTarget, "all");
        this->WriteBuild(os, build);
      }
    }
  }

  // All target
  for (auto const& it : dirTargets) {
    cmNinjaBuild build("phony");
    cmGlobalNinjaGenerator::WriteDivider(os);
    std::string const& currentBinaryDir = it.first;
    DirectoryTarget const& dt = it.second;
    std::vector<std::string> configs =
      static_cast<cmLocalNinjaGenerator const*>(dt.LG)->GetConfigNames();

    // Setup target
    build.Comment = cmStrCat("Folder: ", currentBinaryDir);
    build.Outputs.emplace_back();
    std::string const buildDirAllTarget =
      this->ConvertToNinjaPath(cmStrCat(currentBinaryDir, "/all"));
    for (auto const& config : configs) {
      build.ExplicitDeps.clear();
      build.Outputs.front() = this->BuildAlias(buildDirAllTarget, config);
      for (DirectoryTarget::Target const& t : dt.Targets) {
        if (!this->IsExcludedFromAllInConfig(t, config)) {
          this->AppendTargetOutputs(t.GT, build.ExplicitDeps, config,
                                    DependOnTargetArtifact);
        }
      }
      for (DirectoryTarget::Dir const& d : dt.Children) {
        if (!d.ExcludeFromAll) {
          build.ExplicitDeps.emplace_back(this->BuildAlias(
            this->ConvertToNinjaPath(cmStrCat(d.Path, "/all")), config));
        }
      }
      // Write target
      this->WriteBuild(this->EnableCrossConfigBuild() &&
                           this->CrossConfigs.count(config)
                         ? os
                         : *this->GetImplFileStream(config),
                       build);
    }

    // Add shortcut target
    if (this->IsMultiConfig()) {
      for (auto const& config : configs) {
        build.ExplicitDeps = { this->BuildAlias(buildDirAllTarget, config) };
        build.Outputs.front() = buildDirAllTarget;
        this->WriteBuild(*this->GetConfigFileStream(config), build);
      }

      if (!this->DefaultFileConfig.empty()) {
        build.ExplicitDeps.clear();
        for (auto const& config : this->DefaultConfigs) {
          build.ExplicitDeps.push_back(
            this->BuildAlias(buildDirAllTarget, config));
        }
        build.Outputs.front() = buildDirAllTarget;
        this->WriteBuild(*this->GetDefaultFileStream(), build);
      }
    }

    // Add target for all configs
    if (this->EnableCrossConfigBuild()) {
      build.ExplicitDeps.clear();
      for (auto const& config : this->CrossConfigs) {
        build.ExplicitDeps.push_back(
          this->BuildAlias(buildDirAllTarget, config));
      }
      build.Outputs.front() = this->BuildAlias(buildDirAllTarget, "all");
      this->WriteBuild(os, build);
    }
  }
}

void cmGlobalNinjaGenerator::WriteBuiltinTargets(std::ostream& os)
{
  // Write headers.
  cmGlobalNinjaGenerator::WriteDivider(os);
  os << "# Built-in targets\n\n";

  this->WriteTargetRebuildManifest(os);
  this->WriteTargetClean(os);
  this->WriteTargetHelp(os);
#ifndef CMAKE_BOOTSTRAP
  if (this->GetCMakeInstance()->GetInstrumentation()->HasQuery()) {
    this->WriteTargetInstrument(os);
  }
#endif

  for (std::string const& config : this->GetConfigNames()) {
    this->WriteTargetDefault(*this->GetConfigFileStream(config));
  }

  if (!this->DefaultFileConfig.empty()) {
    this->WriteTargetDefault(*this->GetDefaultFileStream());
  }

  if (this->InstallTargetEnabled &&
      this->GetCMakeInstance()->GetState()->GetGlobalPropertyAsBool(
        "INSTALL_PARALLEL") &&
      !this->Makefiles[0]->IsOn("CMAKE_SKIP_INSTALL_RULES")) {
    cmNinjaBuild build("phony");
    build.Comment = "Install every subdirectory in parallel";
    build.Outputs.emplace_back(this->GetInstallParallelTargetName());
    for (auto const& mf : this->Makefiles) {
      build.ExplicitDeps.emplace_back(
        this->ConvertToNinjaPath(cmStrCat(mf->GetCurrentBinaryDirectory(), '/',
                                          this->GetInstallLocalTargetName())));
    }
    WriteBuild(os, build);
  }
}

void cmGlobalNinjaGenerator::WriteTargetDefault(std::ostream& os)
{
  if (!this->HasOutputPathPrefix()) {
    cmNinjaDeps all;
    all.push_back(this->TargetAll);
    cmGlobalNinjaGenerator::WriteDefault(os, all,
                                         "Make the all target the default.");
  }
}

void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
{
  if (this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION")) {
    return;
  }

  cmake* cm = this->GetCMakeInstance();
  auto const& lg = this->LocalGenerators[0];

  {
    cmNinjaRule rule("RERUN_CMAKE");
    rule.Command = cmStrCat(
      this->CMakeCmd(), " --regenerate-during-build",
      cm->GetIgnoreCompileWarningAsError() ? " --compile-no-warning-as-error"
                                           : "",
      cm->GetIgnoreLinkWarningAsError() ? " --link-no-warning-as-error" : "",
      " -S",
      lg->ConvertToOutputFormat(lg->GetSourceDirectory(),
                                cmOutputConverter::SHELL),
      " -B",
      lg->ConvertToOutputFormat(lg->GetBinaryDirectory(),
                                cmOutputConverter::SHELL));
    rule.Description = "Re-running CMake...";
    rule.Comment = "Rule for re-running cmake.";
    rule.Generator = true;
    WriteRule(*this->RulesFileStream, rule);
  }

  cmNinjaBuild reBuild("RERUN_CMAKE");
  reBuild.Comment = "Re-run CMake if any of its inputs changed.";
  this->AddRebuildManifestOutputs(reBuild.Outputs);

  for (auto const& localGen : this->LocalGenerators) {
    for (std::string const& fi : localGen->GetMakefile()->GetListFiles()) {
      reBuild.ImplicitDeps.push_back(this->ConvertToNinjaPath(fi));
    }
  }
  reBuild.ImplicitDeps.push_back(this->CMakeCacheFile);

#ifndef CMAKE_BOOTSTRAP
  if (this->GetCMakeInstance()->GetInstrumentation()->HasQuery()) {
    reBuild.ExplicitDeps.push_back(this->NinjaOutputPath("start_instrument"));
  }
#endif

  // Use 'console' pool to get non buffered output of the CMake re-run call
  // Available since Ninja 1.5
  if (this->SupportsDirectConsole()) {
    reBuild.Variables["pool"] = "console";
  }

  if (this->SupportsManifestRestat() && cm->DoWriteGlobVerifyTarget()) {
    {
      cmNinjaRule rule("VERIFY_GLOBS");
      rule.Command =
        cmStrCat(this->CMakeCmd(), " -P ",
                 lg->ConvertToOutputFormat(cm->GetGlobVerifyScript(),
                                           cmOutputConverter::SHELL));
      rule.Description = "Re-checking globbed directories...";
      rule.Comment = "Rule for re-checking globbed directories.";
      rule.Generator = true;
      this->WriteRule(*this->RulesFileStream, rule);
    }

    cmNinjaBuild phonyBuild("phony");
    phonyBuild.Comment = "Phony target to force glob verification run.";
    phonyBuild.Outputs.push_back(
      cmStrCat(cm->GetGlobVerifyScript(), "_force"));
    this->WriteBuild(os, phonyBuild);

    reBuild.Variables["restat"] = "1";
    std::string const verifyScriptFile =
      this->NinjaOutputPath(cm->GetGlobVerifyScript());
    std::string const verifyStampFile =
      this->NinjaOutputPath(cm->GetGlobVerifyStamp());
    {
      cmNinjaBuild vgBuild("VERIFY_GLOBS");
      vgBuild.Comment =
        "Re-run CMake to check if globbed directories changed.";
      vgBuild.Outputs.push_back(verifyStampFile);
      vgBuild.ImplicitDeps = phonyBuild.Outputs;
      vgBuild.Variables = reBuild.Variables;
      this->WriteBuild(os, vgBuild);
    }
    reBuild.Variables.erase("restat");
    reBuild.ImplicitDeps.push_back(verifyScriptFile);
    reBuild.ExplicitDeps.push_back(verifyStampFile);
  } else if (!this->SupportsManifestRestat() &&
             cm->DoWriteGlobVerifyTarget()) {
    this->GetCMakeInstance()->IssueDiagnostic(
      cmDiagnostics::CMD_AUTHOR,
      cmStrCat(
        "The detected version of Ninja:\n"
        "  ",
        this->NinjaVersion,
        "\n"
        "is less than the version of Ninja required by CMake for adding "
        "restat dependencies to the build.ninja manifest regeneration "
        "target:\n"
        "  ",
        cmGlobalNinjaGenerator::RequiredNinjaVersionForManifestRestat(),
        "\n"
        "Any pre-check scripts, such as those generated for file(GLOB "
        "CONFIGURE_DEPENDS), will not be run by Ninja."));
  }

  std::sort(reBuild.ImplicitDeps.begin(), reBuild.ImplicitDeps.end());
  reBuild.ImplicitDeps.erase(
    std::unique(reBuild.ImplicitDeps.begin(), reBuild.ImplicitDeps.end()),
    reBuild.ImplicitDeps.end());

  this->WriteBuild(os, reBuild);

  {
    cmNinjaBuild build("phony");
    build.Comment = "A missing CMake input file is not an error.";
    std::set_difference(std::make_move_iterator(reBuild.ImplicitDeps.begin()),
                        std::make_move_iterator(reBuild.ImplicitDeps.end()),
                        this->CustomCommandOutputs.begin(),
                        this->CustomCommandOutputs.end(),
                        std::back_inserter(build.Outputs));
    this->WriteBuild(os, build);
  }
}

std::string cmGlobalNinjaGenerator::CMakeCmd() const
{
  auto const& lgen = this->LocalGenerators.at(0);
  return lgen->ConvertToOutputFormat(cmSystemTools::GetCMakeCommand(),
                                     cmOutputConverter::SHELL);
}

std::string cmGlobalNinjaGenerator::NinjaCmd() const
{
  auto const& lgen = this->LocalGenerators[0];
  if (lgen) {
    return lgen->ConvertToOutputFormat(this->NinjaCommand,
                                       cmOutputConverter::SHELL);
  }
  return "ninja";
}

bool cmGlobalNinjaGenerator::SupportsDirectConsole() const
{
  return this->NinjaSupportsConsolePool;
}

bool cmGlobalNinjaGenerator::SupportsImplicitOuts() const
{
  return this->NinjaSupportsImplicitOuts;
}

bool cmGlobalNinjaGenerator::SupportsManifestRestat() const
{
  return this->NinjaSupportsManifestRestat;
}

bool cmGlobalNinjaGenerator::SupportsMultilineDepfile() const
{
  return this->NinjaSupportsMultilineDepfile;
}

bool cmGlobalNinjaGenerator::SupportsCWDDepend() const
{
  return this->NinjaSupportsCWDDepend;
}

bool cmGlobalNinjaGenerator::WriteTargetCleanAdditional(std::ostream& os)
{
  auto const& lgr = this->LocalGenerators.at(0);
  std::string cleanScriptRel = "CMakeFiles/clean_additional.cmake";
  std::string cleanScriptAbs =
    cmStrCat(lgr->GetBinaryDirectory(), '/', cleanScriptRel);
  std::vector<std::string> const& configs = this->GetConfigNames();

  // Check if there are additional files to clean
  bool empty = true;
  for (auto const& config : configs) {
    auto const it = this->Configs.find(config);
    if (it != this->Configs.end() &&
        !it->second.AdditionalCleanFiles.empty()) {
      empty = false;
      break;
    }
  }
  if (empty) {
    // Remove cmake clean script file if it exists
    cmSystemTools::RemoveFile(cleanScriptAbs);
    return false;
  }

  // Write cmake clean script file
  {
    cmGeneratedFileStream fout(cleanScriptAbs);
    if (!fout) {
      return false;
    }
    fout << "# Additional clean files\ncmake_minimum_required(VERSION 3.16)\n";
    for (auto const& config : configs) {
      auto const it = this->Configs.find(config);
      if (it != this->Configs.end() &&
          !it->second.AdditionalCleanFiles.empty()) {
        fout << "\nif(\"${CONFIG}\" STREQUAL \"\" OR \"${CONFIG}\" STREQUAL \""
             << config << "\")\n";
        fout << "  file(REMOVE_RECURSE\n";
        for (std::string const& acf : it->second.AdditionalCleanFiles) {
          fout << "  "
               << cmScriptGenerator::Quote(this->ConvertToNinjaPath(acf))
               << '\n';
        }
        fout << "  )\n";
        fout << "endif()\n";
      }
    }
  }
  // Register clean script file
  lgr->GetMakefile()->AddCMakeOutputFile(cleanScriptAbs);

  // Write rule
  {
    cmNinjaRule rule("CLEAN_ADDITIONAL");
    rule.Command = cmStrCat(
      this->CMakeCmd(), " -DCONFIG=$CONFIG -P ",
      lgr->ConvertToOutputFormat(this->NinjaOutputPath(cleanScriptRel),
                                 cmOutputConverter::SHELL));
    rule.Description = "Cleaning additional files...";
    rule.Comment = "Rule for cleaning additional files.";
    WriteRule(*this->RulesFileStream, rule);
  }

  // Write build
  {
    cmNinjaBuild build("CLEAN_ADDITIONAL");
    build.Comment = "Clean additional files.";
    build.Outputs.emplace_back();
    for (auto const& config : configs) {
      build.Outputs.front() = this->BuildAlias(
        this->NinjaOutputPath(this->GetAdditionalCleanTargetName()), config);
      build.Variables["CONFIG"] = config;
      this->WriteBuild(os, build);
    }
    if (this->IsMultiConfig()) {
      build.Outputs.front() =
        this->NinjaOutputPath(this->GetAdditionalCleanTargetName());
      build.Variables["CONFIG"] = "";
      this->WriteBuild(os, build);
    }
  }
  // Return success
  return true;
}

void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os)
{
  // -- Additional clean target
  bool additionalFiles = this->WriteTargetCleanAdditional(os);

  // -- Default clean target
  // Write rule
  {
    cmNinjaRule rule("CLEAN");
    rule.Command = cmStrCat(this->NinjaCmd(), " $FILE_ARG -t clean $TARGETS");
    rule.Description = "Cleaning all built files...";
    rule.Comment = "Rule for cleaning all built files.";
    WriteRule(*this->RulesFileStream, rule);
  }

  // Write build
  {
    cmNinjaBuild build("CLEAN");
    build.Comment = "Clean all the built files.";
    build.Outputs.emplace_back();

    for (std::string const& config : this->GetConfigNames()) {
      build.Outputs.front() = this->BuildAlias(
        this->NinjaOutputPath(this->GetCleanTargetName()), config);
      if (this->IsMultiConfig()) {
        build.Variables["TARGETS"] = cmStrCat(
          this->BuildAlias(
            this->NinjaOutputPath(GetByproductsForCleanTargetName()), config),
          ' ', this->NinjaOutputPath(GetByproductsForCleanTargetName()));
      }
      build.ExplicitDeps.clear();
      if (additionalFiles) {
        build.ExplicitDeps.push_back(this->BuildAlias(
          this->NinjaOutputPath(this->GetAdditionalCleanTargetName()),
          config));
      }
      for (std::string const& fileConfig : this->GetConfigNames()) {
        if (fileConfig != config && !this->EnableCrossConfigBuild()) {
          continue;
        }
        if (this->IsMultiConfig()) {
          build.Variables["FILE_ARG"] = cmStrCat(
            "-f ",
            this->NinjaOutputPath(
              cmGlobalNinjaMultiGenerator::GetNinjaImplFilename(fileConfig)));
        }
        this->WriteBuild(*this->GetImplFileStream(fileConfig), build);
      }
    }

    if (this->EnableCrossConfigBuild()) {
      build.Outputs.front() = this->BuildAlias(
        this->NinjaOutputPath(this->GetCleanTargetName()), "all");
      build.ExplicitDeps.clear();

      if (additionalFiles) {
        for (auto const& config : this->CrossConfigs) {
          build.ExplicitDeps.push_back(this->BuildAlias(
            this->NinjaOutputPath(this->GetAdditionalCleanTargetName()),
            config));
        }
      }

      std::vector<std::string> byproducts;
      byproducts.reserve(this->CrossConfigs.size());
      for (auto const& config : this->CrossConfigs) {
        byproducts.push_back(this->BuildAlias(
          this->NinjaOutputPath(GetByproductsForCleanTargetName()), config));
      }
      byproducts.emplace_back(GetByproductsForCleanTargetName());
      build.Variables["TARGETS"] = cmJoin(byproducts, " ");

      for (std::string const& fileConfig : this->GetConfigNames()) {
        build.Variables["FILE_ARG"] = cmStrCat(
          "-f ",
          this->NinjaOutputPath(
            cmGlobalNinjaMultiGenerator::GetNinjaImplFilename(fileConfig)));
        this->WriteBuild(*this->GetImplFileStream(fileConfig), build);
      }
    }
  }

  if (this->IsMultiConfig()) {
    cmNinjaBuild build("phony");
    build.Outputs.emplace_back(
      this->NinjaOutputPath(this->GetCleanTargetName()));
    build.ExplicitDeps.emplace_back();

    for (std::string const& config : this->GetConfigNames()) {
      build.ExplicitDeps.front() = this->BuildAlias(
        this->NinjaOutputPath(this->GetCleanTargetName()), config);
      this->WriteBuild(*this->GetConfigFileStream(config), build);
    }

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

  // Write byproducts
  if (this->IsMultiConfig()) {
    cmNinjaBuild build("phony");
    build.Comment = "Clean byproducts.";
    build.Outputs.emplace_back(
      this->ConvertToNinjaPath(GetByproductsForCleanTargetName()));
    build.ExplicitDeps = this->ByproductsForCleanTarget;
    this->WriteBuild(os, build);

    for (std::string const& config : this->GetConfigNames()) {
      build.Outputs.front() = this->BuildAlias(
        this->ConvertToNinjaPath(GetByproductsForCleanTargetName()), config);
      build.ExplicitDeps = this->Configs[config].ByproductsForCleanTarget;
      this->WriteBuild(os, build);
    }
  }
}

void cmGlobalNinjaGenerator::WriteTargetHelp(std::ostream& os)
{
  {
    cmNinjaRule rule("HELP");
    rule.Command = cmStrCat(this->NinjaCmd(), " -t targets");
    rule.Description = "All primary targets available:";
    rule.Comment = "Rule for printing all primary targets available.";
    WriteRule(*this->RulesFileStream, rule);
  }
  {
    cmNinjaBuild build("HELP");
    build.Comment = "Print all primary targets available.";
    build.Outputs.push_back(this->NinjaOutputPath("help"));
    this->WriteBuild(os, build);
  }
}

#ifndef CMAKE_BOOTSTRAP
void cmGlobalNinjaGenerator::WriteTargetInstrument(std::ostream& os)
{
  // Write rule
  {
    cmNinjaRule rule("START_INSTRUMENT");
    rule.Command = cmStrCat(
      '"', cmSystemTools::GetCTestCommand(), "\" --start-instrumentation \"",
      this->GetCMakeInstance()->GetHomeOutputDirectory(), '"');
#  ifndef _WIN32
    /*
     * On Unix systems, Ninja will prefix the command with `/bin/sh -c`.
     * Use exec so that Ninja is the parent process of the command.
     */
    rule.Command = cmStrCat("exec ", rule.Command);
#  endif
    rule.Description = "Collecting build metrics";
    rule.Comment = "Rule to initialize instrumentation daemon.";
    rule.Restat = "1";
    WriteRule(*this->RulesFileStream, rule);
  }

  // Write build
  {
    cmNinjaBuild phony("phony");
    phony.Comment = "Phony target to keep START_INSTRUMENTATION out of date.";
    phony.Outputs.push_back(this->NinjaOutputPath("CMakeFiles/instrument"));
    cmNinjaBuild instrument("START_INSTRUMENT");
    instrument.Comment = "Start instrumentation daemon.";
    instrument.Outputs.push_back(this->NinjaOutputPath("start_instrument"));
    instrument.ExplicitDeps.push_back(
      this->NinjaOutputPath("CMakeFiles/instrument"));
    WriteBuild(os, phony);
    WriteBuild(os, instrument);
  }
}
#endif

void cmGlobalNinjaGenerator::InitOutputPathPrefix()
{
  this->OutputPathPrefix =
    this->LocalGenerators[0]->GetMakefile()->GetSafeDefinition(
      "CMAKE_NINJA_OUTPUT_PATH_PREFIX");
  EnsureTrailingSlash(this->OutputPathPrefix);
}

std::string cmGlobalNinjaGenerator::NinjaOutputPath(
  std::string const& path) const
{
  if (!this->HasOutputPathPrefix() || cmSystemTools::FileIsFullPath(path)) {
    return path;
  }
  return cmStrCat(this->OutputPathPrefix, path);
}

void cmGlobalNinjaGenerator::EnsureDirectoryExists(std::string const& path)
{
  // The same object and PDB directories are requested for every source.
  if (this->ExistingDirectories.count(path)) {
    return;
  }
  if (cmSystemTools::MakeDirectory(path)) {
    this->ExistingDirectories.insert(path);
  }
}

void cmGlobalNinjaGenerator::StripNinjaOutputPathPrefixAsSuffix(
  std::string& path)
{
  if (path.empty()) {
    return;
  }
  EnsureTrailingSlash(path);
  cmStripSuffixIfExists(path, this->OutputPathPrefix);
}

#if !defined(CMAKE_BOOTSTRAP)

/*

We use the following approach to support Fortran.  Each target already
has an intermediate directory used to hold intermediate files for CMake.
For each target, a FortranDependInfo.json file is generated by CMake with
information about include directories, module directories, and the locations
the per-target directories for target dependencies.

Compilation of source files within a target is split into the following steps:

1. Preprocess all sources, scan preprocessed output for module dependencies.
   This step is done with independent build statements for each source,
   and can therefore be done in parallel.

    rule Fortran_PREPROCESS
      depfile = $DEP_FILE
      command = gfortran -cpp $DEFINES $INCLUDES $FLAGS -E $in -o $out &&
                cmake -E cmake_ninja_depends \
                  --tdi=FortranDependInfo.json --lang=Fortran \
                  --src=$out --out=$out --dep=$DEP_FILE --obj=$OBJ_FILE \
                  --ddi=$DYNDEP_INTERMEDIATE_FILE

    build src.f90-pp.f90 | src.f90.o.ddi: Fortran_PREPROCESS src.f90
      OBJ_FILE = src.f90.o
      DEP_FILE = src.f90.o.d
      DYNDEP_INTERMEDIATE_FILE = src.f90.o.ddi

   The ``cmake -E cmake_ninja_depends`` tool reads the preprocessed output
   and generates the ninja depfile for preprocessor dependencies.  It also
   generates a "ddi" file (in a format private to CMake) that lists the
   object file that compilation will produce along with the module names
   it provides and/or requires.  The "ddi" file is an implicit output
   because it should not appear in "$out" but is generated by the rule.

2. Consolidate the per-source module dependencies saved in the "ddi"
   files from all sources to produce a ninja "dyndep" file, ``Fortran.dd``.

    rule Fortran_DYNDEP
      command = cmake -E cmake_ninja_dyndep \
                  --tdi=FortranDependInfo.json --lang=Fortran --dd=$out $in

    build Fortran.dd: Fortran_DYNDEP src1.f90.o.ddi src2.f90.o.ddi

   The ``cmake -E cmake_ninja_dyndep`` tool reads the "ddi" files from all
   sources in the target and the ``FortranModules.json`` files from targets
   on which the target depends.  It computes dependency edges on compilations
   that require modules to those that provide the modules.  This information
   is placed in the ``Fortran.dd`` file for ninja to load later.  It also
   writes the expected location of modules provided by this target into
   ``FortranModules.json`` for use by dependent targets.

3. Compile all sources after loading dynamically discovered dependencies
   of the compilation build statements from their ``dyndep`` bindings.

    rule Fortran_COMPILE
      command = gfortran $INCLUDES $FLAGS -c $in -o $out

    build src1.f90.o: Fortran_COMPILE src1.f90-pp.f90 || Fortran.dd
      dyndep = Fortran.dd

   The "dyndep" binding tells ninja to load dynamically discovered
   dependency information from ``Fortran.dd``.  This adds information
   such as:

    build src1.f90.o | mod1.mod: dyndep
      restat = 1

   This tells ninja that ``mod1.mod`` is an implicit output of compiling
   the object file ``src1.f90.o``.  The ``restat`` binding tells it that
   the timestamp of the output may not always change.  Additionally:

    build src2.f90.o: dyndep | mod1.mod

   This tells ninja that ``mod1.mod`` is a dependency of compiling the
   object file ``src2.f90.o``.  This ensures that ``src1.f90.o`` and
   ``mod1.mod`` will always be up to date before ``src2.f90.o`` is built
   (because the latter consumes the module).
*/

namespace {

struct cmSourceInfo
{
  cmScanDepInfo ScanDep;
  std::vector<std::string> Includes;
};

cm::optional<cmSourceInfo> cmcmd_cmake_ninja_depends_fortran(
  std::string const& arg_tdi, std::string const& arg_src,
  std::string const& arg_src_orig);
}

int cmcmd_cmake_ninja_depends(std::vector<std::string>::const_iterator argBeg,
                              std::vector<std::string>::const_iterator argEnd)
{
  std::string arg_tdi;
  std::string arg_src;
  std::string arg_src_orig;
  std::string arg_out;
  std::string arg_dep;
  std::string arg_obj;
  std::string arg_ddi;
  std::string arg_lang;
  for (std::string const& arg : cmMakeRange(argBeg, argEnd)) {
    if (cmHasLiteralPrefix(arg, "--tdi=")) {
      arg_tdi = arg.substr(6);
    } else if (cmHasLiteralPrefix(arg, "--src=")) {
      arg_src = arg.substr(6);
    } else if (cmHasLiteralPrefix(arg, "--src-orig=")) {
      arg_src_orig = arg.substr(11);
    } else if (cmHasLiteralPrefix(arg, "--out=")) {
      arg_out = arg.substr(6);
    } else if (cmHasLiteralPrefix(arg, "--dep=")) {
      arg_dep = arg.substr(6);
    } else if (cmHasLiteralPrefix(arg, "--obj=")) {
      arg_obj = arg.substr(6);
    } else if (cmHasLiteralPrefix(arg, "--ddi=")) {
      arg_ddi = arg.substr(6);
    } else if (cmHasLiteralPrefix(arg, "--lang=")) {
      arg_lang = arg.substr(7);
    } else if (cmHasLiteralPrefix(arg, "--pp=")) {
      // CMake 3.26 and below used '--pp=' instead of '--src=' and '--out='.
      arg_src = arg.substr(5);
      arg_out = arg_src;
    } else {
      cmSystemTools::Error(
        cmStrCat("-E cmake_ninja_depends unknown argument: ", arg));
      return 1;
    }
  }
  if (arg_tdi.empty()) {
    cmSystemTools::Error("-E cmake_ninja_depends requires value for --tdi=");
    return 1;
  }
  if (arg_src.empty()) {
    cmSystemTools::Error("-E cmake_ninja_depends requires value for --src=");
    return 1;
  }
  if (arg_out.empty()) {
    cmSystemTools::Error("-E cmake_ninja_depends requires value for --out=");
    return 1;
  }
  if (arg_dep.empty()) {
    cmSystemTools::Error("-E cmake_ninja_depends requires value for --dep=");
    return 1;
  }
  if (arg_obj.empty()) {
    cmSystemTools::Error("-E cmake_ninja_depends requires value for --obj=");
    return 1;
  }
  if (arg_ddi.empty()) {
    cmSystemTools::Error("-E cmake_ninja_depends requires value for --ddi=");
    return 1;
  }
  if (arg_lang.empty()) {
    cmSystemTools::Error("-E cmake_ninja_depends requires value for --lang=");
    return 1;
  }

  cm::optional<cmSourceInfo> info;
  if (arg_lang == "Fortran") {
    info = cmcmd_cmake_ninja_depends_fortran(arg_tdi, arg_src, arg_src_orig);
  } else {
    cmSystemTools::Error(
      cmStrCat("-E cmake_ninja_depends does not understand the ", arg_lang,
               " language"));
    return 1;
  }

  if (!info) {
    // The error message is already expected to have been output.
    return 1;
  }

  info->ScanDep.PrimaryOutput = arg_obj;

  {
    cmGeneratedFileStream depfile(arg_dep);
    depfile << cmSystemTools::ConvertToUnixOutputPath(arg_out) << ":";
    for (std::string const& include : info->Includes) {
      depfile << " \\\n " << cmSystemTools::ConvertToUnixOutputPath(include);
    }
    depfile << "\n";
  }

  if (!cmScanDepFormat_P1689_Write(arg_ddi, info->ScanDep)) {
    cmSystemTools::Error(
      cmStrCat("-E cmake_ninja_depends failed to write ", arg_ddi));
    return 1;
  }
  return 0;
}

namespace {

cm::optional<cmSourceInfo> cmcmd_cmake_ninja_depends_fortran(
  std::string const& arg_tdi, std::string const& arg_src,
  std::string const& arg_src_orig)
{
  cm::optional<cmSourceInfo> info;
  cmFortranCompiler fc;
  std::vector<std::string> includes;
  std::string dir_top_bld;
  std::string module_dir;
  bool building_intrinsics = false;

  if (!arg_src_orig.empty()) {
    // Prepend the original source file's directory as an include directory
    // so Fortran INCLUDE statements can look for files in it.
    std::string src_orig_dir = cmSystemTools::GetParentDirectory(arg_src_orig);
    if (!src_orig_dir.empty()) {
      includes.push_back(src_orig_dir);
    }
  }

  {
    Json::Value tdio;
    Json::Value const& tdi = tdio;
    {
      cmJSONState parseState(arg_tdi, &tdio, cmJSONState::StrictMode::Relaxed);
      if (!parseState.errors.empty()) {
        cmSystemTools::Error(
          cmStrCat("-E cmake_ninja_depends failed to parse ", arg_tdi,
                   parseState.GetErrorMessage()));
        return info;
      }
    }

    dir_top_bld = tdi["dir-top-bld"].asString();
    if (!dir_top_bld.empty() && !cmHasSuffix(dir_top_bld, '/')) {
      dir_top_bld += '/';
    }

    Json::Value const& tdi_include_dirs = tdi["include-dirs"];
    if (tdi_include_dirs.isArray()) {
      for (auto const& tdi_include_dir : tdi_include_dirs) {
        includes.push_back(tdi_include_dir.asString());
      }
    }

    Json::Value const& tdi_module_dir = tdi["module-dir"];
    module_dir = tdi_module_dir.asString();
    if (!module_dir.empty() && !cmHasSuffix(module_dir, '/')) {
      module_dir += '/';
    }

    Json::Value const& tdi_compiler_id = tdi["compiler-id"];
    fc.Id = tdi_compiler_id.asString();

    Json::Value const& tdi_submodule_sep = tdi["submodule-sep"];
    fc.SModSep = tdi_submodule_sep.asString();

    Json::Value const& tdi_submodule_ext = tdi["submodule-ext"];
    fc.SModExt = tdi_submodule_ext.asString();

    Json::Value const& tdi_building_intrinsics =
      tdi["building-intrinsic-modules"];
    building_intrinsics = tdi_building_intrinsics.asBool();
  }

  cmFortranSourceInfo finfo;
  std::set<std::string> defines;
  cmFortranParser parser(fc, includes, defines, finfo);
  if (!cmFortranParser_FilePush(&parser, arg_src.c_str())) {
    cmSystemTools::Error(
      cmStrCat("-E cmake_ninja_depends failed to open ", arg_src));
    return info;
  }
  if (cmFortran_yyparse(parser.Scanner) != 0) {
    // Failed to parse the file.
    return info;
  }

  info = cmSourceInfo();
  for (std::string const& provide : finfo.Provides) {
    cmSourceReqInfo src_info;
    src_info.LogicalName = provide;
    if (!module_dir.empty()) {
      std::string mod = cmStrCat(module_dir, provide);
      if (!dir_top_bld.empty() && cmHasPrefix(mod, dir_top_bld)) {
        mod = mod.substr(dir_top_bld.size());
      }
      src_info.CompiledModulePath = std::move(mod);
    }
    info->ScanDep.Provides.emplace_back(src_info);
  }
  std::set<std::string> requiredModules = finfo.Requires;
  if (building_intrinsics) {
    requiredModules.insert(finfo.Intrinsics.begin(), finfo.Intrinsics.end());
  }
  for (std::string const& require : requiredModules) {
    // Require modules not provided in the same source.
    if (finfo.Provides.count(require)) {
      continue;
    }
    cmSourceReqInfo src_info;
    src_info.LogicalName = require;
    info->ScanDep.Requires.emplace_back(src_info);
  }
  for (std::string const& include : finfo.Includes) {
    info->Includes.push_back(include);
  }
  return info;
}
}

bool cmGlobalNinjaGenerator::WriteDyndepFile(
  std::string const& dir_top_src, std::string const& dir_top_bld,
  std::string const& dir_cur_src, std::string const& dir_cur_bld,
  std::string const& arg_dd, std::vector<std::string> const& arg_ddis,
  std::string const& module_dir,
  std::vector<std::string> const& linked_target_dirs,
  std::vector<std::string> const& forward_modules_from_target_dirs,
  std::string const& native_target_dir, std::string const& arg_lang,
  std::string const& arg_modmapfmt, cmCxxModuleExportInfo const& export_info,
  Json::Value const* cxx_interface_objects)
{
  // Setup path conversions.
  {
    cmStateSnapshot snapshot = this->GetCMakeInstance()->GetCurrentSnapshot();
    snapshot.GetDirectory().SetCurrentSource(dir_cur_src);
    snapshot.GetDirectory().SetCurrentBinary(dir_cur_bld);
    auto mfd = cm::make_unique<cmMakefile>(this, snapshot);
    auto lgd = this->CreateLocalGenerator(mfd.get());
    lgd->SetRelativePathTop(dir_top_src, dir_top_bld);
    this->Makefiles.push_back(std::move(mfd));
    this->LocalGenerators.push_back(std::move(lgd));
  }

  std::vector<cmScanDepInfo> objects;
  for (std::string const& arg_ddi : arg_ddis) {
    cmScanDepInfo info;
    if (!cmScanDepFormat_P1689_Parse(arg_ddi, &info)) {
      cmSystemTools::Error(
        cmStrCat("-E cmake_ninja_dyndep failed to parse ddi file ", arg_ddi));
      return false;
    }
    objects.push_back(std::move(info));
  }

  CxxModuleUsage usages;

  // Map from module name to module file path, if known.
  struct AvailableModuleInfo
  {
    std::string BmiPath;
    bool IsPrivate;
  };
  std::map<std::string, AvailableModuleInfo> mod_files;

  struct ImportErrorInfo
  {
    std::string Message;
    std::set<std::string> Modules;
  };
  std::vector<ImportErrorInfo> importErrors;
  Json::Value transitiveInterfaceObjects(Json::objectValue);

  // Populate the module map with those provided by linked targets first.
  for (std::string const& linked_target_dir : linked_target_dirs) {
    std::string const ltmn =
      cmStrCat(linked_target_dir, '/', arg_lang, "Modules.json");
    Json::Value ltm;
    cmJSONState parseState(ltmn, &ltm, cmJSONState::StrictMode::Relaxed);
    if (!parseState.errors.empty()) {
      cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ",
                                    linked_target_dir,
                                    parseState.GetErrorMessage()));
      return false;
    }
    if (ltm.isObject()) {
      Json::Value const& target_modules = ltm["modules"];
      if (target_modules.isObject()) {
        for (auto i = target_modules.begin(); i != target_modules.end(); ++i) {
          Json::Value const& visible_module = *i;
          if (visible_module.isObject()) {
            Json::Value const& bmi_path = visible_module["bmi"];
            Json::Value const& is_private = visible_module["is-private"];
            mod_files[i.key().asString()] = AvailableModuleInfo{
              bmi_path.asString(),
              is_private.asBool(),
            };
          }
        }
      }
      Json::Value const& target_modules_references = ltm["references"];
      if (target_modules_references.isObject()) {
        for (auto i = target_modules_references.begin();
             i != target_modules_references.end(); ++i) {
          if (i->isObject()) {
            Json::Value const& reference_path = (*i)["path"];
            CxxModuleReference module_reference;
            if (reference_path.isString()) {
              module_reference.Path = reference_path.asString();
            }
            Json::Value const& reference_method = (*i)["lookup-method"];
            if (reference_method.isString()) {
              std::string reference = reference_method.asString();
              if (reference == "by-name") {
                module_reference.Method = LookupMethod::ByName;
              } else if (reference == "include-angle") {
                module_reference.Method = LookupMethod::IncludeAngle;
              } else if (reference == "include-quote") {
                module_reference.Method = LookupMethod::IncludeQuote;
              }
            }
            usages.Reference[i.key().asString()] = module_reference;
          }
        }
      }
      Json::Value const& target_modules_usage = ltm["usages"];
      if (target_modules_usage.isObject()) {
        for (auto i = target_modules_usage.begin();
             i != target_modules_usage.end(); ++i) {
          if (i->isArray()) {
            for (auto j = i->begin(); j != i->end(); ++j) {
              usages.Usage[i.key().asString()].insert(j->asString());
            }
          }
        }
      }
      Json::Value const& import_error = ltm["import-error"];
      if (import_error.isObject()) {
        ImportErrorInfo info;
        info.Message = import_error["message"].asString();
        Json::Value const& errModules = import_error["modules"];
        if (errModules.isArray()) {
          for (auto const& m : errModules) {
            info.Modules.insert(m.asString());
          }
        }
        if (!info.Modules.empty()) {
          importErrors.push_back(std::move(info));
        }
      }
      Json::Value const& linked_interface_objects = ltm["interface-objects"];
      if (linked_interface_objects.isObject()) {
        for (auto i = linked_interface_objects.begin();
             i != linked_interface_objects.end(); ++i) {
          if (!transitiveInterfaceObjects.isMember(i.key().asString())) {
            transitiveInterfaceObjects[i.key().asString()] = *i;
          }
        }
      }
    }
  }

  if (!importErrors.empty()) {
    for (cmScanDepInfo const& object : objects) {
      for (auto const& r : object.Requires) {
        for (auto const& ie : importErrors) {
          if (ie.Modules.count(r.LogicalName)) {
            cmSystemTools::Error(ie.Message);
            return false;
          }
        }
      }
    }
  }

  cm::optional<CxxModuleMapFormat> modmap_fmt;
  if (arg_modmapfmt.empty()) {
    // nothing to do.
  } else if (arg_modmapfmt == "clang") {
    modmap_fmt = CxxModuleMapFormat::Clang;
  } else if (arg_modmapfmt == "gcc") {
    modmap_fmt = CxxModuleMapFormat::Gcc;
  } else if (arg_modmapfmt == "msvc") {
    modmap_fmt = CxxModuleMapFormat::Msvc;
  } else {
    cmSystemTools::Error(
      cmStrCat("-E cmake_ninja_dyndep does not understand the ", arg_modmapfmt,
               " module map format"));
    return false;
  }

  auto module_ext = CxxModuleMapExtension(modmap_fmt);

  // Extend the module map with those provided by this target.
  // We do this after loading the modules provided by linked targets
  // in case we have one of the same name that must be preferred.
  Json::Value target_modules = Json::objectValue;
  for (cmScanDepInfo const& object : objects) {
    for (auto const& p : object.Provides) {
      std::string mod;
      if (cmDyndepCollation::IsBmiOnly(export_info, object.PrimaryOutput)) {
        mod = object.PrimaryOutput;
      } else if (!p.CompiledModulePath.empty()) {
        // The scanner provided the path to the module file.
        mod = p.CompiledModulePath;
        if (!cmSystemTools::FileIsFullPath(mod)) {
          // Treat relative to work directory (top of build tree).
          mod = cmSystemTools::CollapseFullPath(mod, dir_top_bld);
        }
      } else {
        // Assume the module file path matches the logical module name.
        std::string safe_logical_name =
          p.LogicalName; // TODO: needs fixing for header units
        cmSystemTools::ReplaceString(safe_logical_name, ":", "-");
        mod = cmStrCat(module_dir, safe_logical_name, module_ext);
      }
      mod_files[p.LogicalName] = AvailableModuleInfo{
        mod,
        false, // Always visible within our own target.
      };
      Json::Value& module_info = target_modules[p.LogicalName] =
        Json::objectValue;
      module_info["bmi"] = mod;
      module_info["is-private"] =
        cmDyndepCollation::IsObjectPrivate(object.PrimaryOutput, export_info);
    }
  }

  // If this is a synthetic target for a non-imported target, read PRIVATE
  // module info from the native target
  if (!native_target_dir.empty()) {
    std::string const modules_info_path =
      cmStrCat(native_target_dir, '/', arg_lang, "Modules.json");
    Json::Value native_modules_info;
    cmJSONState parseState(modules_info_path, &native_modules_info,
                           cmJSONState::StrictMode::Relaxed);
    if (!parseState.errors.empty()) {
      cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ",
                                    modules_info_path,
                                    parseState.GetErrorMessage()));
      return false;
    }
    if (native_modules_info.isObject()) {
      Json::Value const& native_target_modules =
        native_modules_info["modules"];
      if (native_target_modules.isObject()) {
        for (auto i = native_target_modules.begin();
             i != native_target_modules.end(); ++i) {
          Json::Value const& visible_module = *i;
          if (visible_module.isObject()) {
            auto is_private = visible_module["is-private"].asBool();
            // Only add private modules since others are discovered by the
            // synthetic target's own scan rules
            if (is_private) {
              target_modules[i.key().asString()] = visible_module;
            }
          }
        }
      }
    }
  }

  cmGeneratedFileStream ddf(arg_dd);
  ddf << "ninja_dyndep_version = 1.0\n";

  {
    CxxModuleLocations locs;
    locs.RootDirectory = ".";
    locs.PathForGenerator = [this](std::string path) -> std::string {
      path = this->ConvertToNinjaPath(path);
#  ifdef _WIN32
      if (this->IsGCCOnWindows()) {
        std::replace(path.begin(), path.end(), '\\', '/');
      }
#  endif
      return path;
    };
    locs.BmiLocationForModule =
      [&mod_files](std::string const& logical) -> CxxBmiLocation {
      auto m = mod_files.find(logical);
      if (m != mod_files.end()) {
        if (m->second.IsPrivate) {
          return CxxBmiLocation::Private();
        }
        return CxxBmiLocation::Known(m->second.BmiPath);
      }
      return CxxBmiLocation::Unknown();
    };

    // Insert information about the current target's modules.
    if (modmap_fmt) {
      bool private_usage_found = false;
      auto cycle_modules =
        CxxModuleUsageSeed(locs, objects, usages, private_usage_found);
      if (!cycle_modules.empty()) {
        cmSystemTools::Error(
          cmStrCat("Circular dependency detected in the C++ module import "
                   "graph. See modules named: \"",
                   cmJoin(cycle_modules, R"(", ")"_s), '"'));
        return false;
      }
      if (private_usage_found) {
        // Already errored in the function.
        return false;
      }
    }

    cmNinjaBuild build("dyndep");
    build.Outputs.emplace_back("");
    for (cmScanDepInfo const& object : objects) {
      build.Outputs[0] = this->ConvertToNinjaPath(object.PrimaryOutput);
      build.ImplicitOuts.clear();
      for (auto const& p : object.Provides) {
        auto const implicitOut =
          this->ConvertToNinjaPath(mod_files[p.LogicalName].BmiPath);
        // Ignore the `provides` when the BMI is the output.
        if (implicitOut != build.Outputs[0]) {
          build.ImplicitOuts.emplace_back(implicitOut);
        }
      }
      build.ImplicitDeps.clear();
      for (auto const& r : object.Requires) {
        auto mit = mod_files.find(r.LogicalName);
        if (mit != mod_files.end()) {
          build.ImplicitDeps.push_back(
            this->ConvertToNinjaPath(mit->second.BmiPath));
        }
      }
      build.Variables.clear();
      if (!object.Provides.empty()) {
        build.Variables.emplace("restat", "1");
      }

      if (modmap_fmt) {
        auto mm = CxxModuleMapContent(*modmap_fmt, locs, object, usages);

        // XXX(modmap): If changing this path construction, change
        // `cmNinjaTargetGenerator::WriteObjectBuildStatements` and
        // `cmNinjaTargetGenerator::ExportObjectCompileCommand` to generate the
        // corresponding file path.
        cmGeneratedFileStream mmf;
        mmf.Open(cmStrCat(object.PrimaryOutput, ".modmap"), false,
                 CxxModuleMapOpenMode(*modmap_fmt) ==
                   CxxModuleMapMode::Binary);
        mmf.SetCopyIfDifferent(true);
        mmf << mm;
      }

      this->WriteBuild(ddf, build);
    }
  }

  Json::Value target_module_info = Json::objectValue;
  target_module_info["modules"] = target_modules;

  auto& target_usages = target_module_info["usages"] = Json::objectValue;
  for (auto const& u : usages.Usage) {
    auto& mod_usage = target_usages[u.first] = Json::arrayValue;
    for (auto const& v : u.second) {
      mod_usage.append(v);
    }
  }

  auto name_for_method = [](LookupMethod method) -> cm::static_string_view {
    switch (method) {
      case LookupMethod::ByName:
        return "by-name"_s;
      case LookupMethod::IncludeAngle:
        return "include-angle"_s;
      case LookupMethod::IncludeQuote:
        return "include-quote"_s;
    }
    CM_UNREACHABLE;
    return ""_s;
  };

  auto& target_references = target_module_info["references"] =
    Json::objectValue;
  for (auto const& r : usages.Reference) {
    auto& mod_ref = target_references[r.first] = Json::objectValue;
    mod_ref["path"] = r.second.Path;
    mod_ref["lookup-method"] = std::string(name_for_method(r.second.Method));
  }

  // Store the map of modules provided by this target in a file for
  // use by dependents that reference this target in linked-target-dirs.
  std::string const target_mods_file = cmStrCat(
    cmSystemTools::GetFilenamePath(arg_dd), '/', arg_lang, "Modules.json");

  // Populate the module map with those provided by linked targets first.
  for (std::string const& forward_modules_from_target_dir :
       forward_modules_from_target_dirs) {
    std::string const fmftn =
      cmStrCat(forward_modules_from_target_dir, '/', arg_lang, "Modules.json");
    Json::Value fmft;
    cmJSONState parseState(fmftn, &fmft, cmJSONState::StrictMode::Relaxed);
    if (!parseState.errors.empty()) {
      cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ",
                                    forward_modules_from_target_dir,
                                    parseState.GetErrorMessage()));
      return false;
    }
    if (!fmft.isObject()) {
      continue;
    }

    auto forward_info = [](Json::Value& target, Json::Value const& source) {
      if (!source.isObject()) {
        return;
      }

      for (auto i = source.begin(); i != source.end(); ++i) {
        std::string const key = i.key().asString();
        if (target.isMember(key)) {
          continue;
        }
        target[key] = *i;
      }
    };

    // Forward info from forwarding targets into our collation.
    Json::Value& tmi_target_modules = target_module_info["modules"];
    forward_info(tmi_target_modules, fmft["modules"]);
    forward_info(target_references, fmft["references"]);
    forward_info(target_usages, fmft["usages"]);
    forward_info(transitiveInterfaceObjects, fmft["interface-objects"]);
  }

  // Compute the set of modules imported directly or transitively by sources in
  // this target.
  std::set<std::string> usedModules;
  for (cmScanDepInfo const& object : objects) {
    for (auto const& r : object.Requires) {
      usedModules.insert(r.LogicalName);
      auto usage = usages.Usage.find(r.LogicalName);
      if (usage != usages.Usage.end()) {
        usedModules.insert(usage->second.begin(), usage->second.end());
      }
    }
  }

  // Merge interface objects into the accumulated set.
  // Objects are filtered: only keep those for modules that are imported
  // directly or transitively by sources in this target. Transitive objects
  // from linked targets were already filtered in their originating target.
  if (cxx_interface_objects && cxx_interface_objects->isObject()) {
    Json::Value const& directObjects =
      (*cxx_interface_objects)["module-objects"];
    if (directObjects.isObject()) {
      for (auto i = directObjects.begin(); i != directObjects.end(); ++i) {
        std::string moduleName = i.key().asString();
        if (usedModules.count(moduleName) &&
            !transitiveInterfaceObjects.isMember(moduleName)) {
          transitiveInterfaceObjects[i.key().asString()] = *i;
        }
      }
    }
  }

  target_module_info["interface-objects"] = transitiveInterfaceObjects;

  cmGeneratedFileStream tmf(target_mods_file);
  tmf.SetCopyIfDifferent(true);
  tmf << target_module_info;

  cmDyndepMetadataCallbacks cb;
  cb.ModuleFile =
    [mod_files](std::string const& name) -> cm::optional<std::string> {
    auto m = mod_files.find(name);
    if (m != mod_files.end()) {
      return m->second.BmiPath;
    }
    return {};
  };

  if (!cmDyndepCollation::WriteDyndepMetadata(arg_lang, objects, export_info,
                                              cb)) {
    return false;
  }

  // Write the interface objects response file if configured.
  if (cxx_interface_objects && cxx_interface_objects->isObject()) {
    Json::Value const& rspFile = (*cxx_interface_objects)["rsp-file"];
    if (rspFile.isString()) {
      cmGeneratedFileStream rsp(rspFile.asString());
      rsp.SetCopyIfDifferent(true);
      auto* lg = this->LocalGenerators.back().get();

      for (auto const& objPath : transitiveInterfaceObjects) {
        rsp << lg->ConvertToOutputFormat(
                 lg->MaybeRelativeToTopBinDir(objPath.asString()),
                 cmOutputConverter::RESPONSE)
            << "\n";
      }
    }
  }

  return true;
}

int cmcmd_cmake_ninja_dyndep(std::vector<std::string>::const_iterator argBeg,
                             std::vector<std::string>::const_iterator argEnd)
{
  std::vector<std::string> arg_full =
    cmSystemTools::HandleResponseFile(argBeg, argEnd);

  std::string arg_dd;
  std::string arg_lang;
  std::string arg_tdi;
  std::string arg_modmapfmt;
  std::vector<std::string> arg_ddis;
  for (std::string const& arg : arg_full) {
    if (cmHasLiteralPrefix(arg, "--tdi=")) {
      arg_tdi = arg.substr(6);
    } else if (cmHasLiteralPrefix(arg, "--lang=")) {
      arg_lang = arg.substr(7);
    } else if (cmHasLiteralPrefix(arg, "--dd=")) {
      arg_dd = arg.substr(5);
    } else if (cmHasLiteralPrefix(arg, "--modmapfmt=")) {
      arg_modmapfmt = arg.substr(12);
    } else if (!cmHasLiteralPrefix(arg, "--") &&
               cmHasLiteralSuffix(arg, ".ddi")) {
      arg_ddis.push_back(arg);
    } else {
      cmSystemTools::Error(
        cmStrCat("-E cmake_ninja_dyndep unknown argument: ", arg));
      return 1;
    }
  }
  if (arg_tdi.empty()) {
    cmSystemTools::Error("-E cmake_ninja_dyndep requires value for --tdi=");
    return 1;
  }
  if (arg_lang.empty()) {
    cmSystemTools::Error("-E cmake_ninja_dyndep requires value for --lang=");
    return 1;
  }
  if (arg_dd.empty()) {
    cmSystemTools::Error("-E cmake_ninja_dyndep requires value for --dd=");
    return 1;
  }

  Json::Value tdio;
  Json::Value const& tdi = tdio;
  {
    cmJSONState parseState(arg_tdi, &tdio, cmJSONState::StrictMode::Relaxed);
    if (!parseState.errors.empty()) {
      cmSystemTools::Error(cmStrCat("-E cmake_ninja_dyndep failed to parse ",
                                    arg_tdi, parseState.GetErrorMessage()));
      return 1;
    }
  }

  std::string const dir_cur_bld = tdi["dir-cur-bld"].asString();
  if (!cmSystemTools::FileIsFullPath(dir_cur_bld)) {
    cmSystemTools::Error(
      "-E cmake_ninja_dyndep --tdi= file has no absolute dir-cur-bld");
    return 1;
  }

  std::string const dir_cur_src = tdi["dir-cur-src"].asString();
  if (!cmSystemTools::FileIsFullPath(dir_cur_src)) {
    cmSystemTools::Error(
      "-E cmake_ninja_dyndep --tdi= file has no absolute dir-cur-src");
    return 1;
  }

  std::string const dir_top_bld = tdi["dir-top-bld"].asString();
  if (!cmSystemTools::FileIsFullPath(dir_top_bld)) {
    cmSystemTools::Error(
      "-E cmake_ninja_dyndep --tdi= file has no absolute dir-top-bld");
    return 1;
  }

  std::string const dir_top_src = tdi["dir-top-src"].asString();
  if (!cmSystemTools::FileIsFullPath(dir_top_src)) {
    cmSystemTools::Error(
      "-E cmake_ninja_dyndep --tdi= file has no absolute dir-top-src");
    return 1;
  }

  std::string module_dir = tdi["module-dir"].asString();
  if (!module_dir.empty() && !cmHasSuffix(module_dir, '/')) {
    module_dir += '/';
  }
  std::vector<std::string> linked_target_dirs;
  Json::Value const& tdi_linked_target_dirs = tdi["linked-target-dirs"];
  if (tdi_linked_target_dirs.isArray()) {
    for (auto const& tdi_linked_target_dir : tdi_linked_target_dirs) {
      linked_target_dirs.push_back(tdi_linked_target_dir.asString());
    }
  }
  std::vector<std::string> forward_modules_from_target_dirs;
  Json::Value const& tdi_forward_modules_from_target_dirs =
    tdi["forward-modules-from-target-dirs"];
  if (tdi_forward_modules_from_target_dirs.isArray()) {
    for (auto const& tdi_forward_modules_from_target_dir :
         tdi_forward_modules_from_target_dirs) {
      forward_modules_from_target_dirs.push_back(
        tdi_forward_modules_from_target_dir.asString());
    }
  }
  std::string const native_target_dir = tdi["native-target-dir"].asString();
  std::string const compilerId = tdi["compiler-id"].asString();
  std::string const simulateId = tdi["compiler-simulate-id"].asString();
  std::string const compilerFrontendVariant =
    tdi["compiler-frontend-variant"].asString();

  auto export_info = cmDyndepCollation::ParseExportInfo(tdi);

  Json::Value const* cxx_interface_objects = nullptr;
  if (tdi.isMember("cxx-interface-objects")) {
    cxx_interface_objects = &tdi["cxx-interface-objects"];
  }

  cmake cm(cmState::Role::Internal);
  cm.SetHomeDirectory(dir_top_src);
  cm.SetHomeOutputDirectory(dir_top_bld);
  auto ggd = cm.CreateGlobalGenerator("Ninja");
  if (!ggd) {
    return 1;
  }
  cmGlobalNinjaGenerator& gg =
    cm::static_reference_cast<cmGlobalNinjaGenerator>(ggd);
#  ifdef _WIN32
  if (DetectGCCOnWindows(compilerId, simulateId, compilerFrontendVariant)) {
    gg.MarkAsGCCOnWindows();
  }
#  endif
  return gg.WriteDyndepFile(dir_top_src, dir_top_bld, dir_cur_src, dir_cur_bld,
                            arg_dd, arg_ddis, module_dir, linked_target_dirs,
                            forward_modules_from_target_dirs,
                            native_target_dir, arg_lang, arg_modmapfmt,
                            *export_info, cxx_interface_objects)
    ? 0
    : 1;
}

#endif

bool cmGlobalNinjaGenerator::EnableCrossConfigBuild() const
{
  return !this->CrossConfigs.empty();
}

void cmGlobalNinjaGenerator::AppendDirectoryForConfig(
  std::string const& prefix, std::string const& config,
  std::string const& suffix, std::string& dir)
{
  if (!config.empty() && this->IsMultiConfig()) {
    dir = cmStrCat(std::move(dir), prefix, config, suffix);
  }
}

std::set<std::string> cmGlobalNinjaGenerator::GetCrossConfigs(
  std::string const& fileConfig) const
{
  auto result = this->CrossConfigs;
  result.insert(fileConfig);
  return result;
}

bool cmGlobalNinjaGenerator::IsSingleConfigUtility(
  cmGeneratorTarget const* target) const
{
  return target->GetType() == cm::TargetType::UTILITY &&
    !this->PerConfigUtilityTargets.count(target->GetName());
}

std::string cmGlobalNinjaGenerator::ConvertToOutputPath(std::string path) const
{
  return this->ConvertToNinjaPath(path);
}

char const* cmGlobalNinjaMultiGenerator::NINJA_COMMON_FILE =
  "CMakeFiles/common.ninja";
char const* cmGlobalNinjaMultiGenerator::NINJA_FILE_EXTENSION = ".ninja";

cmGlobalNinjaMultiGenerator::cmGlobalNinjaMultiGenerator(cmake* cm)
  : cmGlobalNinjaGenerator(cm)
{
  cm->GetState()->SetIsGeneratorMultiConfig(true);
  cm->GetState()->SetNinjaMulti(true);
}

cmDocumentationEntry cmGlobalNinjaMultiGenerator::GetDocumentation()
{
  return { cmGlobalNinjaMultiGenerator::GetActualName(),
           "Generates build-<Config>.ninja files." };
}

std::string cmGlobalNinjaMultiGenerator::ExpandCFGIntDir(
  std::string const& str, std::string const& config) const
{
  std::string result = str;
  cmSystemTools::ReplaceString(result, this->GetCMakeCFGIntDir(), config);
  return result;
}

bool cmGlobalNinjaMultiGenerator::OpenBuildFileStreams()
{
  if (!this->OpenFileStream(this->CommonFileStream,
                            cmGlobalNinjaMultiGenerator::NINJA_COMMON_FILE)) {
    return false;
  }

  if (!this->OpenFileStream(this->DefaultFileStream, NINJA_BUILD_FILE)) {
    return false;
  }
  *this->DefaultFileStream << "# Build using rules for '"
                           << this->DefaultFileConfig << "'.\n\n"
                           << "include "
                           << this->NinjaOutputPath(
                                GetNinjaImplFilename(this->DefaultFileConfig))
                           << "\n\n";

  // Write a comment about this file.
  *this->CommonFileStream
    << "# This file contains build statements common to all "
       "configurations.\n\n";

  std::vector<std::string> const& configs = this->GetConfigNames();
  return std::all_of(
    configs.begin(), configs.end(), [this](std::string const& config) -> bool {
      // Open impl file.
      if (!this->OpenFileStream(this->ImplFileStreams[config],
                                GetNinjaImplFilename(config))) {
        return false;
      }

      // Write a comment about this file.
      *this->ImplFileStreams[config]
        << "# This file contains build statements specific to the \"" << config
        << "\"\n# configuration.\n\n";

      // Open config file.
      if (!this->OpenFileStream(this->ConfigFileStreams[config],
                                GetNinjaConfigFilename(config))) {
        return false;
      }

      // Write a comment about this file.
      *this->ConfigFileStreams[config]
        << "# This file contains aliases specific to the \"" << config
        << "\"\n# configuration.\n\n"
        << "include " << this->NinjaOutputPath(GetNinjaImplFilename(config))
        << "\n\n";

      return true;
    });
}

void cmGlobalNinjaMultiGenerator::CloseBuildFileStreams()
{
  if (this->CommonFileStream) {
    this->CommonFileStream.reset();
  } else {
    cmSystemTools::Error("Common file stream was not open.");
  }

  if (this->DefaultFileStream) {
    this->DefaultFileStream.reset();
  } // No error if it wasn't open

  for (std::string const& config : this->GetConfigNames()) {
    if (this->ImplFileStreams[config]) {
      this->ImplFileStreams[config].reset();
    } else {
      cmSystemTools::Error(
        cmStrCat("Impl file stream for \"", config, "\" was not open."));
    }
    if (this->ConfigFileStreams[config]) {
      this->ConfigFileStreams[config].reset();
    } else {
      cmSystemTools::Error(
        cmStrCat("Config file stream for \"", config, "\" was not open."));
    }
  }
}

void cmGlobalNinjaMultiGenerator::AppendNinjaFileArgument(
  GeneratedMakeCommand& command, std::string const& config) const
{
  if (!config.empty()) {
    command.Add("-f");
    command.Add(GetNinjaConfigFilename(config));
  }
}

std::string cmGlobalNinjaMultiGenerator::GetNinjaImplFilename(
  std::string const& config)
{
  return cmStrCat("CMakeFiles/impl-", config,
                  cmGlobalNinjaMultiGenerator::NINJA_FILE_EXTENSION);
}

std::string cmGlobalNinjaMultiGenerator::GetNinjaConfigFilename(
  std::string const& config)
{
  return cmStrCat("build-", config,
                  cmGlobalNinjaMultiGenerator::NINJA_FILE_EXTENSION);
}

void cmGlobalNinjaMultiGenerator::AddRebuildManifestOutputs(
  cmNinjaDeps& outputs) const
{
  for (std::string const& config : this->GetConfigNames()) {
    outputs.push_back(this->NinjaOutputPath(GetNinjaImplFilename(config)));
    outputs.push_back(this->NinjaOutputPath(GetNinjaConfigFilename(config)));
  }
  if (!this->DefaultFileConfig.empty()) {
    outputs.push_back(this->NinjaOutputPath(NINJA_BUILD_FILE));
  }
  this->AddCMakeFilesToRebuild(outputs);
}

void cmGlobalNinjaMultiGenerator::GetQtAutoGenConfigs(
  std::vector<std::string>& configs) const
{
  std::vector<std::string> const& allConfigs = this->GetConfigNames();
  configs.insert(configs.end(), cm::cbegin(allConfigs), cm::cend(allConfigs));
}

bool cmGlobalNinjaMultiGenerator::InspectConfigTypeVariables()
{
  std::vector<std::string> configsList =
    this->Makefiles.front()->GetGeneratorConfigs(
      cmMakefile::IncludeEmptyConfig);
  std::set<std::string> configs(configsList.cbegin(), configsList.cend());

  this->DefaultFileConfig =
    this->Makefiles.front()->GetSafeDefinition("CMAKE_DEFAULT_BUILD_TYPE");
  if (this->DefaultFileConfig.empty()) {
    this->DefaultFileConfig = configsList.front();
  }
  if (!configs.count(this->DefaultFileConfig)) {
    this->GetCMakeInstance()->IssueMessage(
      MessageType::FATAL_ERROR,
      cmStrCat("The configuration specified by "
               "CMAKE_DEFAULT_BUILD_TYPE (",
               this->DefaultFileConfig,
               ") is not present in CMAKE_CONFIGURATION_TYPES"));
    return false;
  }

  cmList crossConfigsList{ this->Makefiles.front()->GetSafeDefinition(
    "CMAKE_CROSS_CONFIGS") };
  auto crossConfigs = ListSubsetWithAll(configs, configs, crossConfigsList);
  if (!crossConfigs) {
    this->GetCMakeInstance()->IssueMessage(
      MessageType::FATAL_ERROR,
      "CMAKE_CROSS_CONFIGS is not a subset of CMAKE_CONFIGURATION_TYPES");
    return false;
  }
  this->CrossConfigs = *crossConfigs;

  auto defaultConfigsString =
    this->Makefiles.front()->GetSafeDefinition("CMAKE_DEFAULT_CONFIGS");
  if (defaultConfigsString.empty()) {
    defaultConfigsString = this->DefaultFileConfig;
  }
  if (!defaultConfigsString.empty() &&
      defaultConfigsString != this->DefaultFileConfig &&
      (this->DefaultFileConfig.empty() || this->CrossConfigs.empty())) {
    this->GetCMakeInstance()->IssueMessage(
      MessageType::FATAL_ERROR,
      "CMAKE_DEFAULT_CONFIGS cannot be used without "
      "CMAKE_DEFAULT_BUILD_TYPE or CMAKE_CROSS_CONFIGS");
    return false;
  }

  cmList defaultConfigsList(defaultConfigsString);
  if (!this->DefaultFileConfig.empty()) {
    auto defaultConfigs =
      ListSubsetWithAll(this->GetCrossConfigs(this->DefaultFileConfig),
                        this->CrossConfigs, defaultConfigsList);
    if (!defaultConfigs) {
      this->GetCMakeInstance()->IssueMessage(
        MessageType::FATAL_ERROR,
        "CMAKE_DEFAULT_CONFIGS is not a subset of CMAKE_CROSS_CONFIGS");
      return false;
    }
    this->DefaultConfigs = *defaultConfigs;
  }

  return true;
}

std::string cmGlobalNinjaMultiGenerator::GetDefaultBuildConfig() const
{
  return "";
}

std::string cmGlobalNinjaMultiGenerator::OrderDependsTargetForTarget(
  cmGeneratorTarget const* target, std::string const& config) const
{
  return cmStrCat("cmake_object_order_depends_target_", target->GetName(), '_',
                  cmSystemTools::UpperCase(config));
}

Coverage Report

Created: 2026-10-28 06:38