llvm/clang/lib/Tooling/RefactoringCallbacks.cpp

//===--- RefactoringCallbacks.cpp - Structural query framework ------------===//
//
// 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/Tooling/RefactoringCallbacks.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Lex/Lexer.h"

StringError;
make_error;

namespace clang {
namespace tooling {

RefactoringCallback::RefactoringCallback() { … }
tooling::Replacements &RefactoringCallback::getReplacements() { … }

ASTMatchRefactorer::ASTMatchRefactorer(
    std::map<std::string, Replacements> &FileToReplaces)
    : … { … }

void ASTMatchRefactorer::addDynamicMatcher(
    const ast_matchers::internal::DynTypedMatcher &Matcher,
    RefactoringCallback *Callback) { … }

class RefactoringASTConsumer : public ASTConsumer { … };

std::unique_ptr<ASTConsumer> ASTMatchRefactorer::newASTConsumer() { … }

static Replacement replaceStmtWithText(SourceManager &Sources, const Stmt &From,
                                       StringRef Text) { … }
static Replacement replaceStmtWithStmt(SourceManager &Sources, const Stmt &From,
                                       const Stmt &To) { … }

ReplaceStmtWithText::ReplaceStmtWithText(StringRef FromId, StringRef ToText)
    : … { … }

void ReplaceStmtWithText::run(
    const ast_matchers::MatchFinder::MatchResult &Result) { … }

ReplaceStmtWithStmt::ReplaceStmtWithStmt(StringRef FromId, StringRef ToId)
    : … { … }

void ReplaceStmtWithStmt::run(
    const ast_matchers::MatchFinder::MatchResult &Result) { … }

ReplaceIfStmtWithItsBody::ReplaceIfStmtWithItsBody(StringRef Id,
                                                   bool PickTrueBranch)
    : … { … }

void ReplaceIfStmtWithItsBody::run(
    const ast_matchers::MatchFinder::MatchResult &Result) { … }

ReplaceNodeWithTemplate::ReplaceNodeWithTemplate(
    llvm::StringRef FromId, std::vector<TemplateElement> Template)
    : … { … }

llvm::Expected<std::unique_ptr<ReplaceNodeWithTemplate>>
ReplaceNodeWithTemplate::create(StringRef FromId, StringRef ToTemplate) { … }

void ReplaceNodeWithTemplate::run(
    const ast_matchers::MatchFinder::MatchResult &Result) { … }

} // end namespace tooling
} // end namespace clang