clang/lib/Tooling/Transformer/RangeSelector.cpp

   1 //===--- RangeSelector.cpp - RangeSelector implementations ------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "clang/Tooling/Transformer/RangeSelector.h"
  10 #include "clang/AST/Expr.h"
  11 #include "clang/AST/TypeLoc.h"
  12 #include "clang/ASTMatchers/ASTMatchFinder.h"
  13 #include "clang/Basic/SourceLocation.h"
  14 #include "clang/Lex/Lexer.h"
  15 #include "clang/Tooling/Transformer/SourceCode.h"
  16 #include "llvm/ADT/StringRef.h"
  17 #include "llvm/Support/Errc.h"
  18 #include "llvm/Support/Error.h"
  19 #include <string>
  20 #include <utility>
  21 #include <vector>
  22
  23 using namespace clang;
  24 using namespace transformer;
  25
  26 using ast_matchers::MatchFinder;
  27 using llvm::Error;
  28 using llvm::StringError;
  29
  30 using MatchResult = MatchFinder::MatchResult;
  31
  32 static Error invalidArgumentError(Twine Message) {
  33   return llvm::make_error<StringError>(llvm::errc::invalid_argument, Message);
  34 }
  35
  36 static Error typeError(StringRef ID, const ASTNodeKind &Kind) {
  37   return invalidArgumentError("mismatched type (node id=" + ID +
  38                               " kind=" + Kind.asStringRef() + ")");
  39 }
  40
  41 static Error typeError(StringRef ID, const ASTNodeKind &Kind,
  42                        Twine ExpectedType) {
  43   return invalidArgumentError("mismatched type: expected one of " +
  44                               ExpectedType + " (node id=" + ID +
  45                               " kind=" + Kind.asStringRef() + ")");
  46 }
  47
  48 static Error missingPropertyError(StringRef ID, Twine Description,
  49                                   StringRef Property) {
  50   return invalidArgumentError(Description + " requires property '" + Property +
  51                               "' (node id=" + ID + ")");
  52 }
  53
  54 static Expected<DynTypedNode> getNode(const ast_matchers::BoundNodes &Nodes,
  55                                       StringRef ID) {
  56   auto &NodesMap = Nodes.getMap();
  57   auto It = NodesMap.find(ID);
  58   if (It == NodesMap.end())
  59     return invalidArgumentError("ID not bound: " + ID);
  60   return It->second;
  61 }
  62
  63 // FIXME: handling of macros should be configurable.
  64 static SourceLocation findPreviousTokenStart(SourceLocation Start,
  65                                              const SourceManager &SM,
  66                                              const LangOptions &LangOpts) {
  67   if (Start.isInvalid() || Start.isMacroID())
  68     return SourceLocation();
  69
  70   SourceLocation BeforeStart = Start.getLocWithOffset(-1);
  71   if (BeforeStart.isInvalid() || BeforeStart.isMacroID())
  72     return SourceLocation();
  73
  74   return Lexer::GetBeginningOfToken(BeforeStart, SM, LangOpts);
  75 }
  76
  77 // Finds the start location of the previous token of kind \p TK.
  78 // FIXME: handling of macros should be configurable.
  79 static SourceLocation findPreviousTokenKind(SourceLocation Start,
  80                                             const SourceManager &SM,
  81                                             const LangOptions &LangOpts,
  82                                             tok::TokenKind TK) {
  83   while (true) {
  84     SourceLocation L = findPreviousTokenStart(Start, SM, LangOpts);
  85     if (L.isInvalid() || L.isMacroID())
  86       return SourceLocation();
  87
  88     Token T;
  89     if (Lexer::getRawToken(L, T, SM, LangOpts, /*IgnoreWhiteSpace=*/true))
  90       return SourceLocation();
  91
  92     if (T.is(TK))
  93       return T.getLocation();
  94
  95     Start = L;
  96   }
  97 }
  98
  99 static SourceLocation findOpenParen(const CallExpr &E, const SourceManager &SM,
 100                                     const LangOptions &LangOpts) {
 101   SourceLocation EndLoc =
 102       E.getNumArgs() == 0 ? E.getRParenLoc() : E.getArg(0)->getBeginLoc();
 103   return findPreviousTokenKind(EndLoc, SM, LangOpts, tok::TokenKind::l_paren);
 104 }
 105
 106 RangeSelector transformer::before(RangeSelector Selector) {
 107   return [Selector](const MatchResult &Result) -> Expected<CharSourceRange> {
 108     Expected<CharSourceRange> SelectedRange = Selector(Result);
 109     if (!SelectedRange)
 110       return SelectedRange.takeError();
 111     return CharSourceRange::getCharRange(SelectedRange->getBegin());
 112   };
 113 }
 114
 115 RangeSelector transformer::after(RangeSelector Selector) {
 116   return [Selector](const MatchResult &Result) -> Expected<CharSourceRange> {
 117     Expected<CharSourceRange> SelectedRange = Selector(Result);
 118     if (!SelectedRange)
 119       return SelectedRange.takeError();
 120     SourceLocation End = SelectedRange->getEnd();
 121     if (SelectedRange->isTokenRange()) {
 122       // We need to find the actual (exclusive) end location from which to
 123       // create a new source range. However, that's not guaranteed to be valid,
 124       // even if the token location itself is valid. So, we create a token range
 125       // consisting only of the last token, then map that range back to the
 126       // source file. If that succeeds, we have a valid location for the end of
 127       // the generated range.
 128       CharSourceRange Range = Lexer::makeFileCharRange(
 129           CharSourceRange::getTokenRange(SelectedRange->getEnd()),
 130           *Result.SourceManager, Result.Context->getLangOpts());
 131       if (Range.isInvalid())
 132         return invalidArgumentError(
 133             "after: can't resolve sub-range to valid source range");
 134       End = Range.getEnd();
 135     }
 136
 137     return CharSourceRange::getCharRange(End);
 138   };
 139 }
 140
 141 RangeSelector transformer::node(std::string ID) {
 142   return [ID](const MatchResult &Result) -> Expected<CharSourceRange> {
 143     Expected<DynTypedNode> Node = getNode(Result.Nodes, ID);
 144     if (!Node)
 145       return Node.takeError();
 146     return (Node->get<Decl>() != nullptr ||
 147             (Node->get<Stmt>() != nullptr && Node->get<Expr>() == nullptr))
 148                ? tooling::getExtendedRange(*Node, tok::TokenKind::semi,
 149                                            *Result.Context)
 150                : CharSourceRange::getTokenRange(Node->getSourceRange());
 151   };
 152 }
 153
 154 RangeSelector transformer::statement(std::string ID) {
 155   return [ID](const MatchResult &Result) -> Expected<CharSourceRange> {
 156     Expected<DynTypedNode> Node = getNode(Result.Nodes, ID);
 157     if (!Node)
 158       return Node.takeError();
 159     return tooling::getExtendedRange(*Node, tok::TokenKind::semi,
 160                                      *Result.Context);
 161   };
 162 }
 163
 164 RangeSelector transformer::enclose(RangeSelector Begin, RangeSelector End) {
 165   return [Begin, End](const MatchResult &Result) -> Expected<CharSourceRange> {
 166     Expected<CharSourceRange> BeginRange = Begin(Result);
 167     if (!BeginRange)
 168       return BeginRange.takeError();
 169     Expected<CharSourceRange> EndRange = End(Result);
 170     if (!EndRange)
 171       return EndRange.takeError();
 172     SourceLocation B = BeginRange->getBegin();
 173     SourceLocation E = EndRange->getEnd();
 174     // Note: we are precluding the possibility of sub-token ranges in the case
 175     // that EndRange is a token range.
 176     if (Result.SourceManager->isBeforeInTranslationUnit(E, B)) {
 177       return invalidArgumentError("Bad range: out of order");
 178     }
 179     return CharSourceRange(SourceRange(B, E), EndRange->isTokenRange());
 180   };
 181 }
 182
 183 RangeSelector transformer::encloseNodes(std::string BeginID,
 184                                         std::string EndID) {
 185   return transformer::enclose(node(std::move(BeginID)), node(std::move(EndID)));
 186 }
 187
 188 RangeSelector transformer::member(std::string ID) {
 189   return [ID](const MatchResult &Result) -> Expected<CharSourceRange> {
 190     Expected<DynTypedNode> Node = getNode(Result.Nodes, ID);
 191     if (!Node)
 192       return Node.takeError();
 193     if (auto *M = Node->get<clang::MemberExpr>())
 194       return CharSourceRange::getTokenRange(
 195           M->getMemberNameInfo().getSourceRange());
 196     return typeError(ID, Node->getNodeKind(), "MemberExpr");
 197   };
 198 }
 199
 200 RangeSelector transformer::name(std::string ID) {
 201   return [ID](const MatchResult &Result) -> Expected<CharSourceRange> {
 202     Expected<DynTypedNode> N = getNode(Result.Nodes, ID);
 203     if (!N)
 204       return N.takeError();
 205     auto &Node = *N;
 206     if (const auto *D = Node.get<NamedDecl>()) {
 207       if (!D->getDeclName().isIdentifier())
 208         return missingPropertyError(ID, "name", "identifier");
 209       SourceLocation L = D->getLocation();
 210       auto R = CharSourceRange::getTokenRange(L, L);
 211       // Verify that the range covers exactly the name.
 212       // FIXME: extend this code to support cases like `operator +` or
 213       // `foo<int>` for which this range will be too short.  Doing so will
 214       // require subcasing `NamedDecl`, because it doesn't provide virtual
 215       // access to the \c DeclarationNameInfo.
 216       if (tooling::getText(R, *Result.Context) != D->getName())
 217         return CharSourceRange();
 218       return R;
 219     }
 220     if (const auto *E = Node.get<DeclRefExpr>()) {
 221       if (!E->getNameInfo().getName().isIdentifier())
 222         return missingPropertyError(ID, "name", "identifier");
 223       SourceLocation L = E->getLocation();
 224       return CharSourceRange::getTokenRange(L, L);
 225     }
 226     if (const auto *I = Node.get<CXXCtorInitializer>()) {
 227       if (!I->isMemberInitializer() && I->isWritten())
 228         return missingPropertyError(ID, "name", "explicit member initializer");
 229       SourceLocation L = I->getMemberLocation();
 230       return CharSourceRange::getTokenRange(L, L);
 231     }
 232     if (const auto *T = Node.get<TypeLoc>()) {
 233       TypeLoc Loc = *T;
 234       auto ET = Loc.getAs<ElaboratedTypeLoc>();
 235       if (!ET.isNull())
 236         Loc = ET.getNamedTypeLoc();
 237       if (auto SpecLoc = Loc.getAs<TemplateSpecializationTypeLoc>();
 238           !SpecLoc.isNull())
 239         return CharSourceRange::getTokenRange(SpecLoc.getTemplateNameLoc());
 240       return CharSourceRange::getTokenRange(Loc.getSourceRange());
 241     }
 242     return typeError(ID, Node.getNodeKind(),
 243                      "DeclRefExpr, NamedDecl, CXXCtorInitializer, TypeLoc");
 244   };
 245 }
 246
 247 namespace {
 248 // FIXME: make this available in the public API for users to easily create their
 249 // own selectors.
 250
 251 // Creates a selector from a range-selection function \p Func, which selects a
 252 // range that is relative to a bound node id.  \c T is the node type expected by
 253 // \p Func.
 254 template <typename T, CharSourceRange (*Func)(const MatchResult &, const T &)>
 255 class RelativeSelector {
 256   std::string ID;
 257
 258 public:
 259   RelativeSelector(std::string ID) : ID(std::move(ID)) {}
 260
 261   Expected<CharSourceRange> operator()(const MatchResult &Result) {
 262     Expected<DynTypedNode> N = getNode(Result.Nodes, ID);
 263     if (!N)
 264       return N.takeError();
 265     if (const auto *Arg = N->get<T>())
 266       return Func(Result, *Arg);
 267     return typeError(ID, N->getNodeKind());
 268   }
 269 };
 270 } // namespace
 271
 272 // FIXME: Change the following functions from being in an anonymous namespace
 273 // to static functions, after the minimum Visual C++ has _MSC_VER >= 1915
 274 // (equivalent to Visual Studio 2017 v15.8 or higher). Using the anonymous
 275 // namespace works around a bug in earlier versions.
 276 namespace {
 277 // Returns the range of the statements (all source between the braces).
 278 CharSourceRange getStatementsRange(const MatchResult &,
 279                                    const CompoundStmt &CS) {
 280   return CharSourceRange::getCharRange(CS.getLBracLoc().getLocWithOffset(1),
 281                                        CS.getRBracLoc());
 282 }
 283 } // namespace
 284
 285 RangeSelector transformer::statements(std::string ID) {
 286   return RelativeSelector<CompoundStmt, getStatementsRange>(std::move(ID));
 287 }
 288
 289 namespace {
 290 // Returns the range of the source between the call's parentheses.
 291 CharSourceRange getCallArgumentsRange(const MatchResult &Result,
 292                                       const CallExpr &CE) {
 293   return CharSourceRange::getCharRange(
 294       findOpenParen(CE, *Result.SourceManager, Result.Context->getLangOpts())
 295           .getLocWithOffset(1),
 296       CE.getRParenLoc());
 297 }
 298 } // namespace
 299
 300 RangeSelector transformer::callArgs(std::string ID) {
 301   return RelativeSelector<CallExpr, getCallArgumentsRange>(std::move(ID));
 302 }
 303
 304 namespace {
 305 // Returns the range of the elements of the initializer list. Includes all
 306 // source between the braces.
 307 CharSourceRange getElementsRange(const MatchResult &,
 308                                  const InitListExpr &E) {
 309   return CharSourceRange::getCharRange(E.getLBraceLoc().getLocWithOffset(1),
 310                                        E.getRBraceLoc());
 311 }
 312 } // namespace
 313
 314 RangeSelector transformer::initListElements(std::string ID) {
 315   return RelativeSelector<InitListExpr, getElementsRange>(std::move(ID));
 316 }
 317
 318 namespace {
 319 // Returns the range of the else branch, including the `else` keyword.
 320 CharSourceRange getElseRange(const MatchResult &Result, const IfStmt &S) {
 321   return tooling::maybeExtendRange(
 322       CharSourceRange::getTokenRange(S.getElseLoc(), S.getEndLoc()),
 323       tok::TokenKind::semi, *Result.Context);
 324 }
 325 } // namespace
 326
 327 RangeSelector transformer::elseBranch(std::string ID) {
 328   return RelativeSelector<IfStmt, getElseRange>(std::move(ID));
 329 }
 330
 331 RangeSelector transformer::expansion(RangeSelector S) {
 332   return [S](const MatchResult &Result) -> Expected<CharSourceRange> {
 333     Expected<CharSourceRange> SRange = S(Result);
 334     if (!SRange)
 335       return SRange.takeError();
 336     return Result.SourceManager->getExpansionRange(*SRange);
 337   };
 338 }