blob: 57a836567df4934b01c015097ba64d5e65c7df43 [file] [log] [blame]
//===--- Transformer.cpp - Transformer library implementation ---*- C++ -*-===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#include "clang/Tooling/Refactoring/Transformer.h"
#include "clang/AST/Expr.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Rewrite/Core/Rewriter.h"
#include "clang/Tooling/Refactoring/AtomicChange.h"
#include "clang/Tooling/Refactoring/SourceCode.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/Error.h"
#include <deque>
#include <string>
#include <utility>
#include <vector>
using namespace clang;
using namespace tooling;
using ast_matchers::MatchFinder;
using ast_type_traits::ASTNodeKind;
using ast_type_traits::DynTypedNode;
using llvm::Error;
using llvm::Expected;
using llvm::Optional;
using llvm::StringError;
using llvm::StringRef;
using llvm::Twine;
using MatchResult = MatchFinder::MatchResult;
// Did the text at this location originate in a macro definition (aka. body)?
// For example,
// #define NESTED(x) x
// #define MACRO(y) { int y = NESTED(3); }
// if (true) MACRO(foo)
// The if statement expands to
// if (true) { int foo = 3; }
// ^ ^
// Loc1 Loc2
// For SourceManager SM, SM.isMacroArgExpansion(Loc1) and
// SM.isMacroArgExpansion(Loc2) are both true, but isOriginMacroBody(sm, Loc1)
// is false, because "foo" originated in the source file (as an argument to a
// macro), whereas isOriginMacroBody(SM, Loc2) is true, because "3" originated
// in the definition of MACRO.
static bool isOriginMacroBody(const clang::SourceManager &SM,
clang::SourceLocation Loc) {
while (Loc.isMacroID()) {
if (SM.isMacroBodyExpansion(Loc))
return true;
// Otherwise, it must be in an argument, so we continue searching up the
// invocation stack. getImmediateMacroCallerLoc() gives the location of the
// argument text, inside the call text.
Loc = SM.getImmediateMacroCallerLoc(Loc);
return false;
static llvm::Error invalidArgumentError(Twine Message) {
return llvm::make_error<StringError>(llvm::errc::invalid_argument, Message);
static llvm::Error typeError(StringRef Id, const ASTNodeKind &Kind,
Twine Message) {
return invalidArgumentError(
Message + " (node id=" + Id + " kind=" + Kind.asStringRef() + ")");
static llvm::Error missingPropertyError(StringRef Id, Twine Description,
StringRef Property) {
return invalidArgumentError(Description + " requires property '" + Property +
"' (node id=" + Id + ")");
static Expected<CharSourceRange>
getTargetRange(StringRef Target, const DynTypedNode &Node, ASTNodeKind Kind,
NodePart TargetPart, ASTContext &Context) {
switch (TargetPart) {
case NodePart::Node: {
// For non-expression statements, associate any trailing semicolon with the
// statement text. However, if the target was intended as an expression (as
// indicated by its kind) then we do not associate any trailing semicolon
// with it. We only associate the exact expression text.
if (Node.get<Stmt>() != nullptr) {
auto ExprKind = ASTNodeKind::getFromNodeKind<clang::Expr>();
if (!ExprKind.isBaseOf(Kind))
return getExtendedRange(Node, tok::TokenKind::semi, Context);
return CharSourceRange::getTokenRange(Node.getSourceRange());
case NodePart::Member:
if (auto *M = Node.get<clang::MemberExpr>())
return CharSourceRange::getTokenRange(
return typeError(Target, Node.getNodeKind(),
"NodePart::Member applied to non-MemberExpr");
case NodePart::Name:
if (const auto *D = Node.get<clang::NamedDecl>()) {
if (!D->getDeclName().isIdentifier())
return missingPropertyError(Target, "NodePart::Name", "identifier");
SourceLocation L = D->getLocation();
auto R = CharSourceRange::getTokenRange(L, L);
// Verify that the range covers exactly the name.
// FIXME: extend this code to support cases like `operator +` or
// `foo<int>` for which this range will be too short. Doing so will
// require subcasing `NamedDecl`, because it doesn't provide virtual
// access to the \c DeclarationNameInfo.
if (getText(R, Context) != D->getName())
return CharSourceRange();
return R;
if (const auto *E = Node.get<clang::DeclRefExpr>()) {
if (!E->getNameInfo().getName().isIdentifier())
return missingPropertyError(Target, "NodePart::Name", "identifier");
SourceLocation L = E->getLocation();
return CharSourceRange::getTokenRange(L, L);
if (const auto *I = Node.get<clang::CXXCtorInitializer>()) {
if (!I->isMemberInitializer() && I->isWritten())
return missingPropertyError(Target, "NodePart::Name",
"explicit member initializer");
SourceLocation L = I->getMemberLocation();
return CharSourceRange::getTokenRange(L, L);
return typeError(
Target, Node.getNodeKind(),
"NodePart::Name applied to neither DeclRefExpr, NamedDecl nor "
llvm_unreachable("Unexpected case in NodePart type.");
Expected<SmallVector<Transformation, 1>>
tooling::translateEdits(const MatchResult &Result,
llvm::ArrayRef<ASTEdit> Edits) {
SmallVector<Transformation, 1> Transformations;
auto &NodesMap = Result.Nodes.getMap();
for (const auto &Edit : Edits) {
auto It = NodesMap.find(Edit.Target);
assert(It != NodesMap.end() && "Edit target must be bound in the match.");
Expected<CharSourceRange> Range = getTargetRange(
Edit.Target, It->second, Edit.Kind, Edit.Part, *Result.Context);
if (!Range)
return Range.takeError();
if (Range->isInvalid() ||
isOriginMacroBody(*Result.SourceManager, Range->getBegin()))
return SmallVector<Transformation, 0>();
auto Replacement = Edit.Replacement(Result);
if (!Replacement)
return Replacement.takeError();
Transformation T;
T.Range = *Range;
T.Replacement = std::move(*Replacement);
return Transformations;
RewriteRule tooling::makeRule(ast_matchers::internal::DynTypedMatcher M,
SmallVector<ASTEdit, 1> Edits) {
// `tryBind` is guaranteed to succeed, because `AllowBind` was set to true.
return RewriteRule{*M.tryBind(RewriteRule::RootId), std::move(Edits),
constexpr llvm::StringLiteral RewriteRule::RootId;
void Transformer::registerMatchers(MatchFinder *MatchFinder) {
MatchFinder->addDynamicMatcher(Rule.Matcher, this);
void Transformer::run(const MatchResult &Result) {
if (Result.Context->getDiagnostics().hasErrorOccurred())
// Verify the existence and validity of the AST node that roots this rule.
auto &NodesMap = Result.Nodes.getMap();
auto Root = NodesMap.find(RewriteRule::RootId);
assert(Root != NodesMap.end() && "Transformation failed: missing root node.");
SourceLocation RootLoc = Result.SourceManager->getExpansionLoc(
assert(RootLoc.isValid() && "Invalid location for Root node of match.");
auto Transformations = translateEdits(Result, Rule.Edits);
if (!Transformations) {
if (Transformations->empty()) {
// No rewrite applied (but no error encountered either).
RootLoc.print(llvm::errs() << "note: skipping match at loc ",
llvm::errs() << "\n";
// Record the results in the AtomicChange.
AtomicChange AC(*Result.SourceManager, RootLoc);
for (const auto &T : *Transformations) {
if (auto Err = AC.replace(*Result.SourceManager, T.Range, T.Replacement)) {