CMake/Source/cmGeneratorTarget_Wrappers.cxx

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

#include <algorithm>
#include <map>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>

#include <cmext/algorithm>

#include "cmEvaluatedTargetProperty.h"
#include "cmGenExContext.h"
#include "cmGeneratorExpressionDAGChecker.h"
#include "cmList.h"
#include "cmListFileCache.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmStringAlgorithms.h"
#include "cmUnreachable.h"
#include "cmValue.h"
#include "cmake.h"

namespace {

enum class WrapperType
{
  Compile,
  Link,
};

std::string WrapperTypeToString(WrapperType type)
{
  switch (type) {
    case WrapperType::Compile:
      return "compile";
    case WrapperType::Link:
      return "link";
  }
  CM_UNREACHABLE;
}

void ProcessWrappers(cmGeneratorTarget const* tgt,
                     cm::EvaluatedTargetPropertyEntries const& entries,
                     std::vector<BT<std::string>>& wrappers,
                     std::unordered_set<std::string>& uniqueWrappers,
                     WrapperType wrapperType, bool debugWrapper)
{
  for (cm::EvaluatedTargetPropertyEntry const& entry : entries.Entries) {
    std::string usedOptions;
    for (std::string const& entryOption : entry.Values) {
      if (uniqueWrappers.insert(entryOption).second) {
        wrappers.emplace_back(entryOption, entry.Backtrace);
        if (debugWrapper) {
          usedOptions =
            cmStrCat(std::move(usedOptions), " * ", entryOption, '\n');
        }
      }
    }
    if (!usedOptions.empty()) {
      tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(
        MessageType::LOG,
        cmStrCat("Used ", WrapperTypeToString(wrapperType),
                 " wrappers for target ", tgt->GetName(), ":\n", usedOptions),
        entry.Backtrace);
    }
  }

  // Order wrappers lexicographically based on their name.
  std::sort(wrappers.begin(), wrappers.end(),
            [](BT<std::string> const& a, BT<std::string> const& b) {
              return a.Value < b.Value;
            });
}
} // namespace

std::vector<BT<std::string>> cmGeneratorTarget::GetLinkWrappers(
  std::string const& config, std::string const& lang) const
{
  ConfigAndLanguage cacheKey(config, lang);
  {
    auto it = this->LinkWrappersCache.find(cacheKey);
    if (it != this->LinkWrappersCache.end()) {
      return it->second;
    }
  }

  std::vector<BT<std::string>> wrappers;
  std::unordered_set<std::string> uniqueWrappers;
  cm::GenEx::Context context(this->LocalGenerator, config, lang);
  cmGeneratorExpressionDAGChecker dagChecker{
    this, "LINK_WRAPPERS", nullptr, nullptr, context,
  };

  cmList debugProperties{ this->Makefile->GetDefinition(
    "CMAKE_DEBUG_TARGET_PROPERTIES") };
  bool debugWrappers = !this->DebugLinkWrappersDone &&
    cm::contains(debugProperties, "LINK_WRAPPERS");
  this->DebugLinkWrappersDone = true;

  cm::EvaluatedTargetPropertyEntries entries =
    cm::EvaluateTargetPropertyEntries(this, context, &dagChecker,
                                      this->LinkWrappersEntries);
  AddInterfaceEntries(this, "INTERFACE_LINK_WRAPPERS", context, &dagChecker,
                      entries, cm::IncludeRuntimeInterface::Yes, UseTo::Link);

  ProcessWrappers(this, entries, wrappers, uniqueWrappers, WrapperType::Link,
                  debugWrappers);

  this->LinkWrappersCache.emplace(cacheKey, wrappers);
  return wrappers;
}

std::vector<BT<std::string>> cmGeneratorTarget::GetCompileWrappers(
  std::string const& config, std::string const& lang) const
{
  ConfigAndLanguage cacheKey(config, lang);
  {
    auto it = this->CompileWrappersCache.find(cacheKey);
    if (it != this->CompileWrappersCache.end()) {
      return it->second;
    }
  }

  std::vector<BT<std::string>> wrappers;
  std::unordered_set<std::string> uniqueWrappers;
  cm::GenEx::Context context(this->LocalGenerator, config, lang);
  cmGeneratorExpressionDAGChecker dagChecker{
    this, "COMPILE_WRAPPERS", nullptr, nullptr, context,
  };

  cmList debugProperties{ this->Makefile->GetDefinition(
    "CMAKE_DEBUG_TARGET_PROPERTIES") };
  bool debugWrappers = !this->DebugCompileWrappersDone &&
    cm::contains(debugProperties, "COMPILE_WRAPPERS");
  this->DebugCompileWrappersDone = true;

  cm::EvaluatedTargetPropertyEntries entries =
    cm::EvaluateTargetPropertyEntries(this, context, &dagChecker,
                                      this->CompileWrappersEntries);
  AddInterfaceEntries(this, "INTERFACE_COMPILE_WRAPPERS", context, &dagChecker,
                      entries, cm::IncludeRuntimeInterface::Yes,
                      UseTo::Compile);

  ProcessWrappers(this, entries, wrappers, uniqueWrappers,
                  WrapperType::Compile, debugWrappers);

  this->CompileWrappersCache.emplace(cacheKey, wrappers);
  return wrappers;
}