//===--- Refactoring.cpp - Framework for clang refactoring tools ----------===//

//

// 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

//

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

//

//  Implements tools to support refactorings.

//

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

#include "clang/Tooling/Refactoring.h"

#include "clang/Basic/DiagnosticOptions.h"

#include "clang/Basic/FileManager.h"

#include "clang/Basic/SourceManager.h"

#include "clang/Format/Format.h"

#include "clang/Frontend/TextDiagnosticPrinter.h"

#include "clang/Lex/Lexer.h"

#include "clang/Rewrite/Core/Rewriter.h"

#include "llvm/Support/Path.h"

#include "llvm/Support/raw_os_ostream.h"

namespace clang {

namespace tooling {

RefactoringTool::RefactoringTool(

    const CompilationDatabase &Compilations, ArrayRef<std::string> SourcePaths,

    std::shared_ptr<PCHContainerOperations> PCHContainerOps)

    : ClangTool(Compilations, SourcePaths, std::move(PCHContainerOps)) {}

std::map<std::string, Replacements> &RefactoringTool::getReplacements() {

  return FileToReplaces;

}

int RefactoringTool::runAndSave(FrontendActionFactory *ActionFactory) {

  if (int Result = run(ActionFactory)) {

    return Result;

  }

  LangOptions DefaultLangOptions;

  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();

  TextDiagnosticPrinter DiagnosticPrinter(llvm::errs(), &*DiagOpts);

  DiagnosticsEngine Diagnostics(

      IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()),

      &*DiagOpts, &DiagnosticPrinter, false);

  SourceManager Sources(Diagnostics, getFiles());

  Rewriter Rewrite(Sources, DefaultLangOptions);

  if (!applyAllReplacements(Rewrite)) {

    llvm::errs() << "Skipped some replacements.\n";

  }

  return saveRewrittenFiles(Rewrite);

}

bool RefactoringTool::applyAllReplacements(Rewriter &Rewrite) {

  bool Result = true;

  for (const auto &Entry : groupReplacementsByFile(

           Rewrite.getSourceMgr().getFileManager(), FileToReplaces))

    Result = tooling::applyAllReplacements(Entry.second, Rewrite) && Result;

  return Result;

}

int RefactoringTool::saveRewrittenFiles(Rewriter &Rewrite) {

  return Rewrite.overwriteChangedFiles() ? 1 : 0;

}

bool formatAndApplyAllReplacements(

    const std::map<std::string, Replacements> &FileToReplaces,

    Rewriter &Rewrite, StringRef Style) {

  SourceManager &SM = Rewrite.getSourceMgr();

  FileManager &Files = SM.getFileManager();

  bool Result = true;

  for (const auto &FileAndReplaces : groupReplacementsByFile(

           Rewrite.getSourceMgr().getFileManager(), FileToReplaces)) {

    const std::string &FilePath = FileAndReplaces.first;

    auto &CurReplaces = FileAndReplaces.second;

    const FileEntry *Entry = nullptr;

    if (auto File = Files.getFile(FilePath))

      Entry = *File;

    FileID ID = SM.getOrCreateFileID(Entry, SrcMgr::C_User);

    StringRef Code = SM.getBufferData(ID);

    auto CurStyle = format::getStyle(Style, FilePath, "LLVM");

    if (!CurStyle) {

      llvm::errs() << llvm::toString(CurStyle.takeError()) << "\n";

      return false;

    }

    auto NewReplacements =

        format::formatReplacements(Code, CurReplaces, *CurStyle);

    if (!NewReplacements) {

      llvm::errs() << llvm::toString(NewReplacements.takeError()) << "\n";

      return false;

    }

    Result = applyAllReplacements(*NewReplacements, Rewrite) && Result;

  }

  return Result;

}

} // end namespace tooling

} // end namespace clang