//===--- FileRemapper.cpp - File Remapping Helper -------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

#include "clang/ARCMigrate/FileRemapper.h"

#include "clang/Basic/Diagnostic.h"

#include "clang/Basic/FileManager.h"

#include "clang/Lex/PreprocessorOptions.h"

#include "llvm/Support/FileSystem.h"

#include "llvm/Support/MemoryBuffer.h"

#include "llvm/Support/Path.h"

#include "llvm/Support/raw_ostream.h"

#include <fstream>

using namespace clang;

using namespace arcmt;

FileRemapper::FileRemapper() {

  FileMgr.reset(new FileManager(FileSystemOptions()));

}

FileRemapper::~FileRemapper() {

  clear();

}

void FileRemapper::clear(StringRef outputDir) {

  for (MappingsTy::iterator

         I = FromToMappings.begin(), E = FromToMappings.end(); I != E; 
++I95
)

    resetTarget(I->second);

  FromToMappings.clear();

  assert(ToFromMappings.empty());

  if (!outputDir.empty()) {

    std::string infoFile = getRemapInfoFile(outputDir);

    llvm::sys::fs::remove(infoFile);

  }

}

std::string FileRemapper::getRemapInfoFile(StringRef outputDir) {

  assert(!outputDir.empty());

  SmallString<128> InfoFile = outputDir;

  llvm::sys::path::append(InfoFile, "remap");

  return std::string(InfoFile.str());

}

bool FileRemapper::initFromDisk(StringRef outputDir, DiagnosticsEngine &Diag,

                                bool ignoreIfFilesChanged) {

  std::string infoFile = getRemapInfoFile(outputDir);

  return initFromFile(infoFile, Diag, ignoreIfFilesChanged);

}

bool FileRemapper::initFromFile(StringRef filePath, DiagnosticsEngine &Diag,

                                bool ignoreIfFilesChanged) {

  assert(FromToMappings.empty() &&

         "initFromDisk should be called before any remap calls");

  std::string infoFile = std::string(filePath);

  if (!llvm::sys::fs::exists(infoFile))

    return false;

  std::vector<std::pair<FileEntryRef, FileEntryRef>> pairs;

  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileBuf =

      llvm::MemoryBuffer::getFile(infoFile, /*IsText=*/true);

  if (!fileBuf)

    return report("Error opening file: " + infoFile, Diag);

  SmallVector<StringRef, 64> lines;

  fileBuf.get()->getBuffer().split(lines, "\n");

  for (unsigned idx = 0; idx+3 <= lines.size(); 
idx += 336
) {

    StringRef fromFilename = lines[idx];

    unsigned long long timeModified;

    if (lines[idx+1].getAsInteger(10, timeModified))

      return report("Invalid file data: '" + lines[idx+1] + "' not a number",

                    Diag);

    StringRef toFilename = lines[idx+2];

    auto origFE = FileMgr->getOptionalFileRef(fromFilename);

    if (!origFE) {

      if (ignoreIfFilesChanged)

        continue;

      return report("File does not exist: " + fromFilename, Diag);

    }

    auto newFE = FileMgr->getOptionalFileRef(toFilename);

    if (!newFE) {

      if (ignoreIfFilesChanged)

        continue;

      return report("File does not exist: " + toFilename, Diag);

    }

    if ((uint64_t)origFE->getModificationTime() != timeModified) {

      if (ignoreIfFilesChanged)

        continue;

      return report("File was modified: " + fromFilename, Diag);

    }

    pairs.push_back(std::make_pair(*origFE, *newFE));

  }

  
for (unsigned i = 0, e = pairs.size(); 27
i != e; 
++i36
)

    remap(pairs[i].first, pairs[i].second);

  return false;

}

bool FileRemapper::flushToDisk(StringRef outputDir, DiagnosticsEngine &Diag) {

  using namespace llvm::sys;

  if (fs::create_directory(outputDir))

    return report("Could not create directory: " + outputDir, Diag);

  std::string infoFile = getRemapInfoFile(outputDir);

  return flushToFile(infoFile, Diag);

}

bool FileRemapper::flushToFile(StringRef outputPath, DiagnosticsEngine &Diag) {

  using namespace llvm::sys;

  std::error_code EC;

  std::string infoFile = std::string(outputPath);

  llvm::raw_fd_ostream infoOut(infoFile, EC, llvm::sys::fs::OF_Text);

  if (EC)

    return report(EC.message(), Diag);

  for (MappingsTy::iterator

         I = FromToMappings.begin(), E = FromToMappings.end(); I != E; 
++I38
) {

    FileEntryRef origFE = I->first;

    SmallString<200> origPath = StringRef(origFE.getName());

    fs::make_absolute(origPath);

    infoOut << origPath << '\n';

    infoOut << (uint64_t)origFE.getModificationTime() << '\n';

    if (I->second.is<FileEntryRef>()) {

      auto FE = I->second.get<FileEntryRef>();

      SmallString<200> newPath = StringRef(FE.getName());

      fs::make_absolute(newPath);

      infoOut << newPath << '\n';

    } else {

      SmallString<64> tempPath;

      int fd;

      if (fs::createTemporaryFile(

              path::filename(origFE.getName()),

              path::extension(origFE.getName()).drop_front(), fd, tempPath,

              llvm::sys::fs::OF_Text))

        return report("Could not create file: " + tempPath.str(), Diag);

      llvm::raw_fd_ostream newOut(fd, /*shouldClose=*/true);

      llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();

      newOut.write(mem->getBufferStart(), mem->getBufferSize());

      newOut.close();

      auto newE = FileMgr->getOptionalFileRef(tempPath);

      if (newE) {

        remap(origFE, *newE);

        infoOut << newE->getName() << '\n';

      }

    }

  }

  infoOut.close();

  return false;

}

bool FileRemapper::overwriteOriginal(DiagnosticsEngine &Diag,

                                     StringRef outputDir) {

  using namespace llvm::sys;

  for (MappingsTy::iterator

         I = FromToMappings.begin(), E = FromToMappings.end(); I != E; 
++I2
) {

    FileEntryRef origFE = I->first;

    assert(I->second.is<llvm::MemoryBuffer *>());

    if (!fs::exists(origFE.getName()))

      return report(StringRef("File does not exist: ") + origFE.getName(),

                    Diag);

    std::error_code EC;

    llvm::raw_fd_ostream Out(origFE.getName(), EC, llvm::sys::fs::OF_None);

    if (EC)

      return report(EC.message(), Diag);

    llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();

    Out.write(mem->getBufferStart(), mem->getBufferSize());

    Out.close();

  }

  clear(outputDir);

  return false;

}

void FileRemapper::forEachMapping(

    llvm::function_ref<void(StringRef, StringRef)> CaptureFile,

    llvm::function_ref<void(StringRef, const llvm::MemoryBufferRef &)>

        CaptureBuffer) const {

  for (auto &Mapping : FromToMappings) {

    if (Mapping.second.is<FileEntryRef>()) {

      auto FE = Mapping.second.get<FileEntryRef>();

      CaptureFile(Mapping.first.getName(), FE.getName());

      continue;

    }

    CaptureBuffer(

        Mapping.first.getName(),

        Mapping.second.get<llvm::MemoryBuffer *>()->getMemBufferRef());

  }

}

void FileRemapper::applyMappings(PreprocessorOptions &PPOpts) const {

  for (MappingsTy::const_iterator

         I = FromToMappings.begin(), E = FromToMappings.end(); I != E; 
++I52
) {

    if (I->second.is<FileEntryRef>()) {

      auto FE = I->second.get<FileEntryRef>();

      PPOpts.addRemappedFile(I->first.getName(), FE.getName());

    } else {

      llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();

      PPOpts.addRemappedFile(I->first.getName(), mem);

    }

  }

  PPOpts.RetainRemappedFileBuffers = true;

}

void FileRemapper::remap(StringRef filePath,

                         std::unique_ptr<llvm::MemoryBuffer> memBuf) {

  OptionalFileEntryRef File = getOriginalFile(filePath);

  assert(File);

  remap(*File, std::move(memBuf));

}

void FileRemapper::remap(FileEntryRef file,

                         std::unique_ptr<llvm::MemoryBuffer> memBuf) {

  Target &targ = FromToMappings[file];

  resetTarget(targ);

  targ = memBuf.release();

}

void FileRemapper::remap(FileEntryRef file, FileEntryRef newfile) {

  Target &targ = FromToMappings[file];

  resetTarget(targ);

  targ = newfile;

  ToFromMappings.insert({newfile, file});

}

OptionalFileEntryRef FileRemapper::getOriginalFile(StringRef filePath) {

  OptionalFileEntryRef File = FileMgr->getOptionalFileRef(filePath);

  if (!File)

    return std::nullopt;

  // If we are updating a file that overridden an original file,

  // actually update the original file.

  auto I = ToFromMappings.find(*File);

  if (I != ToFromMappings.end()) {

    *File = I->second;

    assert(FromToMappings.contains(*File) && "Original file not in mappings!");

  }

  return File;

}

void FileRemapper::resetTarget(Target &targ) {

  if (!targ)

    return;

  if (llvm::MemoryBuffer *oldmem = targ.dyn_cast<llvm::MemoryBuffer *>()) {

    delete oldmem;

  } else {

    FileEntryRef toFE = targ.get<FileEntryRef>();

    ToFromMappings.erase(toFE);

  }

}

bool FileRemapper::report(const Twine &err, DiagnosticsEngine &Diag) {

  Diag.Report(Diag.getCustomDiagID(DiagnosticsEngine::Error, "%0"))

      << err.str();

  return true;

}