diff options
Diffstat (limited to 'lib/Tooling/Refactoring/Transformer.cpp')
-rw-r--r-- | lib/Tooling/Refactoring/Transformer.cpp | 224 |
1 files changed, 224 insertions, 0 deletions
diff --git a/lib/Tooling/Refactoring/Transformer.cpp b/lib/Tooling/Refactoring/Transformer.cpp new file mode 100644 index 0000000000..57a836567d --- /dev/null +++ b/lib/Tooling/Refactoring/Transformer.cpp @@ -0,0 +1,224 @@ +//===--- Transformer.cpp - Transformer library implementation ---*- C++ -*-===// +// +// 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/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( + M->getMemberNameInfo().getSourceRange()); + 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 " + "CXXCtorInitializer"); + } + 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); + Transformations.push_back(std::move(T)); + } + return Transformations; +} + +RewriteRule tooling::makeRule(ast_matchers::internal::DynTypedMatcher M, + SmallVector<ASTEdit, 1> Edits) { + M.setAllowBind(true); + // `tryBind` is guaranteed to succeed, because `AllowBind` was set to true. + return RewriteRule{*M.tryBind(RewriteRule::RootId), std::move(Edits), + nullptr}; +} + +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()) + return; + + // 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( + Root->second.getSourceRange().getBegin()); + assert(RootLoc.isValid() && "Invalid location for Root node of match."); + + auto Transformations = translateEdits(Result, Rule.Edits); + if (!Transformations) { + Consumer(Transformations.takeError()); + return; + } + + if (Transformations->empty()) { + // No rewrite applied (but no error encountered either). + RootLoc.print(llvm::errs() << "note: skipping match at loc ", + *Result.SourceManager); + llvm::errs() << "\n"; + return; + } + + // 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)) { + Consumer(std::move(Err)); + return; + } + } + + Consumer(std::move(AC)); +} |