cmake/Source/cmGeneratorFileSet.cxx

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

#include <algorithm>
#include <map>
#include <sstream>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

#include <cm/memory>
#include <cm/optional>

#include "cmFileSet.h"
#include "cmGenExContext.h"
#include "cmGeneratorExpression.h"
#include "cmList.h"
#include "cmListFileCache.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include "cmake.h"

class cmLinkItem;

class FileSetPropertyEntry : public cm::TargetPropertyEntry
{
public:
  FileSetPropertyEntry(
    std::vector<std::string> dirs, bool contextSensitiveDirs,
    std::unique_ptr<cmCompiledGeneratorExpression> const& cge,
    cmGeneratorFileSet const* fileSet, cmLinkItem const& item = NoLinkItem)
    : cm::TargetPropertyEntry(item)
    , BaseDirs(std::move(dirs))
    , ContextSensitiveDirs(contextSensitiveDirs)
    , Cge(cge)
    , FileSet(fileSet)
  {
  }

  static std::unique_ptr<cm::TargetPropertyEntry> CreateFileSetEntry(
    std::vector<std::string> dirs, bool contextSensitiveDirs,
    std::unique_ptr<cmCompiledGeneratorExpression> const& cge,
    cmGeneratorFileSet const* fileSet, cmLinkItem const& item = NoLinkItem)
  {
    return cm::make_unique<FileSetPropertyEntry>(
      std::move(dirs), contextSensitiveDirs, cge, fileSet, item);
  }

  std::string const& Evaluate(
    cm::GenEx::Context const& context, cmGeneratorTarget const* headTarget,
    cmGeneratorExpressionDAGChecker* dagChecker) const override
  {
    std::map<std::string, std::vector<std::string>> filesPerDir;
    this->FileSet->EvaluateFileEntry(this->BaseDirs, filesPerDir, this->Cge,
                                     context, headTarget, dagChecker);

    std::vector<std::string> files;
    for (auto const& it : filesPerDir) {
      files.insert(files.end(), it.second.begin(), it.second.end());
    }

    this->Value = cmList::to_string(files);
    return Value;
  }

  cmListFileBacktrace GetBacktrace() const override
  {
    return this->Cge->GetBacktrace();
  }

  std::string const& GetInput() const override
  {
    return this->Cge->GetInput();
  }

  bool GetHadContextSensitiveCondition() const override
  {
    return this->ContextSensitiveDirs ||
      this->Cge->GetHadContextSensitiveCondition();
  }

private:
  std::vector<std::string> const BaseDirs;
  bool const ContextSensitiveDirs;
  std::unique_ptr<cmCompiledGeneratorExpression> const& Cge;
  cmGeneratorFileSet const* FileSet;
  mutable std::string Value;
};

//
// Class cmGeneratorFileSet
//
cmGeneratorFileSet::cmGeneratorFileSet(cmFileSet const* fileSet)
  : FileSet(fileSet)
{
}

std::string const& cmGeneratorFileSet::GetName() const
{
  return this->FileSet->GetName();
}
std::string const& cmGeneratorFileSet::GetType() const
{
  return this->FileSet->GetType();
}
cm::FileSetMetadata::Visibility cmGeneratorFileSet::GetVisibility() const
{
  return this->FileSet->GetVisibility();
}

bool cmGeneratorFileSet::IsForSelf() const
{
  return this->FileSet->IsForSelf();
}
bool cmGeneratorFileSet::IsForInterface() const
{
  return this->FileSet->IsForInterface();
}
bool cmGeneratorFileSet::CanBeIncluded() const
{
  return this->FileSet->CanBeIncluded();
}

cmValue cmGeneratorFileSet::GetProperty(std::string const& prop) const
{
  return this->FileSet->GetProperty(prop);
}

std::vector<BT<std::string>> const& cmGeneratorFileSet::GetDirectoryEntries()
  const
{
  return this->FileSet->GetDirectoryEntries();
}

std::vector<BT<std::string>> const& cmGeneratorFileSet::GetFileEntries() const
{
  return this->FileSet->GetFileEntries();
}

std::vector<std::unique_ptr<cmCompiledGeneratorExpression>> const&
cmGeneratorFileSet::CompileFileEntries() const
{
  std::unordered_set<std::string> uniqueSrcs;

  if (this->CompiledFileEntries.empty() &&
      !this->FileSet->GetFileEntries().empty()) {
    for (auto const& entry : this->FileSet->GetFileEntries()) {
      for (auto const& ex : cmList{ entry.Value }) {
        if (uniqueSrcs.insert(ex).second) {
          cmGeneratorExpression ge(
            *this->FileSet->GetMakefile()->GetCMakeInstance(),
            entry.Backtrace);
          auto cge = ge.Parse(ex);
          this->CompiledFileEntries.push_back(std::move(cge));
        }
      }
    }
  }

  return this->CompiledFileEntries;
}

std::vector<std::unique_ptr<cmCompiledGeneratorExpression>> const&
cmGeneratorFileSet::CompileDirectoryEntries() const
{
  if (this->CompiledDirectoryEntries.empty() &&
      !this->FileSet->GetDirectoryEntries().empty()) {
    for (auto const& entry : this->FileSet->GetDirectoryEntries()) {
      for (auto const& ex : cmList{ entry.Value }) {
        cmGeneratorExpression ge(
          *this->FileSet->GetMakefile()->GetCMakeInstance(), entry.Backtrace);
        auto cge = ge.Parse(ex);
        this->CompiledDirectoryEntries.push_back(std::move(cge));
      }
    }
  }

  return this->CompiledDirectoryEntries;
}

std::vector<std::string> cmGeneratorFileSet::EvaluateDirectoryEntries(
  std::vector<std::unique_ptr<cmCompiledGeneratorExpression>> const& cges,
  cm::GenEx::Context const& context, cmGeneratorTarget const* target,
  cmGeneratorExpressionDAGChecker* dagChecker) const
{
  struct DirCacheEntry
  {
    std::string collapsedDir;
    cm::optional<cmSystemTools::FileId> fileId;
  };

  std::unordered_map<std::string, DirCacheEntry> dirCache;
  std::vector<std::string> result;
  for (auto const& cge : cges) {
    auto entry = cge->Evaluate(context, dagChecker, target);
    cmList dirs{ entry };
    for (std::string dir : dirs) {
      if (!cmSystemTools::FileIsFullPath(dir)) {
        dir = cmStrCat(context.LG->GetCurrentSourceDirectory(), '/', dir);
      }

      auto dirCacheResult = dirCache.emplace(dir, DirCacheEntry());
      auto& dirCacheEntry = dirCacheResult.first->second;
      auto const isNewCacheEntry = dirCacheResult.second;

      if (isNewCacheEntry) {
        cmSystemTools::FileId fileId;
        auto isFileIdValid = cmSystemTools::GetFileId(dir, fileId);
        dirCacheEntry.collapsedDir = cmSystemTools::CollapseFullPath(dir);
        dirCacheEntry.fileId =
          isFileIdValid ? cm::optional<decltype(fileId)>(fileId) : cm::nullopt;
      }

      for (auto const& priorDir : result) {
        auto priorDirCacheEntry = dirCache.at(priorDir);
        bool sameFile = dirCacheEntry.fileId.has_value() &&
          priorDirCacheEntry.fileId.has_value() &&
          (*dirCacheEntry.fileId == *priorDirCacheEntry.fileId);
        if (!sameFile &&
            (cmSystemTools::IsSubDirectory(dirCacheEntry.collapsedDir,
                                           priorDirCacheEntry.collapsedDir) ||
             cmSystemTools::IsSubDirectory(priorDirCacheEntry.collapsedDir,
                                           dirCacheEntry.collapsedDir))) {
          context.LG->GetCMakeInstance()->IssueMessage(
            MessageType::FATAL_ERROR,
            cmStrCat(
              "Base directories in file set cannot be subdirectories of each "
              "other:\n  ",
              priorDir, "\n  ", dir),
            cge->GetBacktrace());
          return {};
        }
      }
      result.push_back(dir);
    }
  }
  return result;
}

void cmGeneratorFileSet::EvaluateFileEntry(
  std::vector<std::string> const& dirs,
  std::map<std::string, std::vector<std::string>>& filesPerDir,
  std::unique_ptr<cmCompiledGeneratorExpression> const& cge,
  cm::GenEx::Context const& context, cmGeneratorTarget const* target,
  cmGeneratorExpressionDAGChecker* dagChecker) const
{
  auto files = cge->Evaluate(context, dagChecker, target);
  for (std::string file : cmList{ files }) {
    if (!cmSystemTools::FileIsFullPath(file)) {
      file = cmStrCat(context.LG->GetCurrentSourceDirectory(), '/', file);
    }
    auto collapsedFile = cmSystemTools::CollapseFullPath(file);
    bool found = false;
    std::string relDir;
    for (auto const& dir : dirs) {
      auto collapsedDir = cmSystemTools::CollapseFullPath(dir);
      if (cmSystemTools::IsSubDirectory(collapsedFile, collapsedDir)) {
        found = true;
        relDir = cmSystemTools::GetParentDirectory(
          cmSystemTools::RelativePath(collapsedDir, collapsedFile));
        break;
      }
    }
    if (!found) {
      std::ostringstream e;
      e << "File:\n  " << file
        << "\nmust be in one of the file set's base directories:";
      for (auto const& dir : dirs) {
        e << "\n  " << dir;
      }
      context.LG->GetCMakeInstance()->IssueMessage(
        MessageType::FATAL_ERROR, e.str(), cge->GetBacktrace());
      return;
    }

    filesPerDir[relDir].push_back(file);
  }
}

namespace {
bool EntryIsContextSensitive(
  std::unique_ptr<cmCompiledGeneratorExpression> const& cge)
{
  return cge->GetHadContextSensitiveCondition();
}
}

std::vector<std::unique_ptr<cm::TargetPropertyEntry>>
cmGeneratorFileSet::GetSources(
  cm::GenEx::Context const& context, cmGeneratorTarget const* target,
  cmGeneratorExpressionDAGChecker* dagChecker) const
{
  std::vector<std::unique_ptr<TargetPropertyEntry>> entries;

  auto directories = this->GetDirectories(context, target, dagChecker);
  bool contextSensitive = directories.second;

  for (auto const& entry : this->CompileFileEntries()) {
    auto propEntry = FileSetPropertyEntry::CreateFileSetEntry(
      directories.first, contextSensitive, entry, this);
    entries.push_back(std::move(propEntry));
  }

  return entries;
}

std::pair<std::vector<std::string>, bool> cmGeneratorFileSet::GetDirectories(
  cm::GenEx::Context const& context, cmGeneratorTarget const* target,
  cmGeneratorExpressionDAGChecker* dagChecker) const
{
  auto const& directoryEntries = this->CompileDirectoryEntries();
  auto directories = this->EvaluateDirectoryEntries(directoryEntries, context,
                                                    target, dagChecker);
  bool contextSensitive = std::any_of(
    directoryEntries.begin(), directoryEntries.end(), EntryIsContextSensitive);

  return std::make_pair(std::move(directories), contextSensitive);
}

std::pair<std::map<std::string, std::vector<std::string>>, bool>
cmGeneratorFileSet::GetFiles(cm::GenEx::Context const& context,
                             cmGeneratorTarget const* target,
                             cmGeneratorExpressionDAGChecker* dagChecker) const
{
  auto directories = this->GetDirectories(context, target, dagChecker);

  auto const& fileEntries = this->CompileFileEntries();
  std::map<std::string, std::vector<std::string>> files;
  for (auto const& entry : fileEntries) {
    this->EvaluateFileEntry(directories.first, files, entry, context, target,
                            dagChecker);
  }
  bool contextSensitive = directories.second ||
    std::any_of(fileEntries.begin(), fileEntries.end(),
                EntryIsContextSensitive);

  return std::make_pair(std::move(files), contextSensitive);
}