clang  3.7.0
Registry.cpp
Go to the documentation of this file.
1 //===--- Registry.cpp - Matcher registry -------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===------------------------------------------------------------===//
9 ///
10 /// \file
11 /// \brief Registry map populated at static initialization time.
12 ///
13 //===------------------------------------------------------------===//
14 
16 #include "Marshallers.h"
18 #include "llvm/ADT/StringMap.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/Support/ManagedStatic.h"
21 #include <set>
22 #include <utility>
23 
24 using namespace clang::ast_type_traits;
25 
26 namespace clang {
27 namespace ast_matchers {
28 namespace dynamic {
29 namespace {
30 
31 using internal::MatcherDescriptor;
32 
33 typedef llvm::StringMap<const MatcherDescriptor *> ConstructorMap;
34 class RegistryMaps {
35 public:
36  RegistryMaps();
37  ~RegistryMaps();
38 
39  const ConstructorMap &constructors() const { return Constructors; }
40 
41 private:
42  void registerMatcher(StringRef MatcherName, MatcherDescriptor *Callback);
43  ConstructorMap Constructors;
44 };
45 
46 void RegistryMaps::registerMatcher(StringRef MatcherName,
47  MatcherDescriptor *Callback) {
48  assert(Constructors.find(MatcherName) == Constructors.end());
49  Constructors[MatcherName] = Callback;
50 }
51 
52 #define REGISTER_MATCHER(name) \
53  registerMatcher(#name, internal::makeMatcherAutoMarshall( \
54  ::clang::ast_matchers::name, #name));
55 
56 #define SPECIFIC_MATCHER_OVERLOAD(name, Id) \
57  static_cast< ::clang::ast_matchers::name##_Type##Id>( \
58  ::clang::ast_matchers::name)
59 
60 #define REGISTER_OVERLOADED_2(name) \
61  do { \
62  MatcherDescriptor *Callbacks[] = { \
63  internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 0), \
64  #name), \
65  internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 1), \
66  #name) \
67  }; \
68  registerMatcher(#name, \
69  new internal::OverloadedMatcherDescriptor(Callbacks)); \
70  } while (0)
71 
72 /// \brief Generate a registry map with all the known matchers.
73 RegistryMaps::RegistryMaps() {
74  // TODO: Here is the list of the missing matchers, grouped by reason.
75  //
76  // Need Variant/Parser fixes:
77  // ofKind
78  //
79  // Polymorphic + argument overload:
80  // findAll
81  //
82  // Other:
83  // equals
84  // equalsNode
85 
86  REGISTER_OVERLOADED_2(callee);
87  REGISTER_OVERLOADED_2(hasPrefix);
88  REGISTER_OVERLOADED_2(hasType);
89  REGISTER_OVERLOADED_2(isDerivedFrom);
90  REGISTER_OVERLOADED_2(isSameOrDerivedFrom);
92  REGISTER_OVERLOADED_2(pointsTo);
93  REGISTER_OVERLOADED_2(references);
94  REGISTER_OVERLOADED_2(thisPointerType);
95 
101  REGISTER_MATCHER(argumentCountIs);
103  REGISTER_MATCHER(arrayType);
105  REGISTER_MATCHER(asString);
106  REGISTER_MATCHER(atomicType);
107  REGISTER_MATCHER(autoType);
110  REGISTER_MATCHER(blockPointerType);
113  REGISTER_MATCHER(builtinType);
121  REGISTER_MATCHER(complexType);
125  REGISTER_MATCHER(constantArrayType);
129  REGISTER_MATCHER(containsDeclaration);
137  REGISTER_MATCHER(declCountIs);
143  REGISTER_MATCHER(dependentSizedArrayType);
148  REGISTER_MATCHER(elaboratedType);
151  REGISTER_MATCHER(equalsBoundNode);
152  REGISTER_MATCHER(equalsIntegralValue);
159  REGISTER_MATCHER(forEachConstructorInitializer);
161  REGISTER_MATCHER(forEachSwitchCase);
162  REGISTER_MATCHER(forField);
169  REGISTER_MATCHER(functionType);
173  REGISTER_MATCHER(hasAnyArgument);
174  REGISTER_MATCHER(hasAnyConstructorInitializer);
175  REGISTER_MATCHER(hasAnyParameter);
176  REGISTER_MATCHER(hasAnySubstatement);
177  REGISTER_MATCHER(hasAnyTemplateArgument);
178  REGISTER_MATCHER(hasAnyUsingShadowDecl);
179  REGISTER_MATCHER(hasArgument);
180  REGISTER_MATCHER(hasArgumentOfType);
181  REGISTER_MATCHER(hasAttr);
182  REGISTER_MATCHER(hasBase);
183  REGISTER_MATCHER(hasBody);
184  REGISTER_MATCHER(hasCanonicalType);
185  REGISTER_MATCHER(hasCaseConstant);
186  REGISTER_MATCHER(hasCondition);
187  REGISTER_MATCHER(hasConditionVariableStatement);
189  REGISTER_MATCHER(hasDeclContext);
190  REGISTER_MATCHER(hasDeducedType);
192  REGISTER_MATCHER(hasDestinationType);
194  REGISTER_MATCHER(hasElementType);
195  REGISTER_MATCHER(hasElse);
196  REGISTER_MATCHER(hasFalseExpression);
197  REGISTER_MATCHER(hasGlobalStorage);
198  REGISTER_MATCHER(hasImplicitDestinationType);
199  REGISTER_MATCHER(hasIncrement);
200  REGISTER_MATCHER(hasIndex);
201  REGISTER_MATCHER(hasInitializer);
202  REGISTER_MATCHER(hasKeywordSelector);
203  REGISTER_MATCHER(hasLHS);
204  REGISTER_MATCHER(hasLocalQualifiers);
205  REGISTER_MATCHER(hasLocalStorage);
206  REGISTER_MATCHER(hasLoopInit);
207  REGISTER_MATCHER(hasLoopVariable);
208  REGISTER_MATCHER(hasMethod);
210  REGISTER_MATCHER(hasNullSelector);
211  REGISTER_MATCHER(hasObjectExpression);
212  REGISTER_MATCHER(hasOperatorName);
214  REGISTER_MATCHER(hasParameter);
216  REGISTER_MATCHER(hasQualifier);
217  REGISTER_MATCHER(hasRangeInit);
218  REGISTER_MATCHER(hasReceiverType);
219  REGISTER_MATCHER(hasRHS);
220  REGISTER_MATCHER(hasSelector);
221  REGISTER_MATCHER(hasSingleDecl);
222  REGISTER_MATCHER(hasSize);
223  REGISTER_MATCHER(hasSizeExpr);
224  REGISTER_MATCHER(hasSourceExpression);
225  REGISTER_MATCHER(hasTargetDecl);
226  REGISTER_MATCHER(hasTemplateArgument);
227  REGISTER_MATCHER(hasThen);
228  REGISTER_MATCHER(hasTrueExpression);
229  REGISTER_MATCHER(hasTypeLoc);
230  REGISTER_MATCHER(hasUnaryOperand);
231  REGISTER_MATCHER(hasUnarySelector);
232  REGISTER_MATCHER(hasValueType);
234  REGISTER_MATCHER(ignoringImpCasts);
235  REGISTER_MATCHER(ignoringParenCasts);
236  REGISTER_MATCHER(ignoringParenImpCasts);
238  REGISTER_MATCHER(incompleteArrayType);
240  REGISTER_MATCHER(innerType);
242  REGISTER_MATCHER(isArrow);
243  REGISTER_MATCHER(isCatchAll);
244  REGISTER_MATCHER(isConst);
245  REGISTER_MATCHER(isConstQualified);
246  REGISTER_MATCHER(isDefinition);
247  REGISTER_MATCHER(isDeleted);
248  REGISTER_MATCHER(isExplicitTemplateSpecialization);
249  REGISTER_MATCHER(isExpr);
251  REGISTER_MATCHER(isImplicit);
252  REGISTER_MATCHER(isExpansionInFileMatching);
253  REGISTER_MATCHER(isExpansionInMainFile);
254  REGISTER_MATCHER(isInstantiated);
255  REGISTER_MATCHER(isExpansionInSystemHeader);
256  REGISTER_MATCHER(isInteger);
257  REGISTER_MATCHER(isIntegral);
258  REGISTER_MATCHER(isInTemplateInstantiation);
259  REGISTER_MATCHER(isListInitialization);
260  REGISTER_MATCHER(isOverride);
261  REGISTER_MATCHER(isPrivate);
262  REGISTER_MATCHER(isProtected);
263  REGISTER_MATCHER(isPublic);
264  REGISTER_MATCHER(isPure);
266  REGISTER_MATCHER(isVirtual);
267  REGISTER_MATCHER(isWritten);
270  REGISTER_MATCHER(lValueReferenceType);
271  REGISTER_MATCHER(matchesName);
272  REGISTER_MATCHER(matchesSelector);
274  REGISTER_MATCHER(member);
277  REGISTER_MATCHER(memberPointerType);
281  REGISTER_MATCHER(namesType);
287  REGISTER_MATCHER(numSelectorArgs);
288  REGISTER_MATCHER(ofClass);
290  REGISTER_MATCHER(on);
291  REGISTER_MATCHER(onImplicitObjectArgument);
293  REGISTER_MATCHER(parameterCountIs);
294  REGISTER_MATCHER(parenType);
296  REGISTER_MATCHER(pointee);
297  REGISTER_MATCHER(pointerType);
300  REGISTER_MATCHER(recordType);
301  REGISTER_MATCHER(referenceType);
302  REGISTER_MATCHER(refersToDeclaration);
303  REGISTER_MATCHER(refersToIntegralType);
304  REGISTER_MATCHER(refersToType);
306  REGISTER_MATCHER(returns);
308  REGISTER_MATCHER(rValueReferenceType);
310  REGISTER_MATCHER(specifiesNamespace);
311  REGISTER_MATCHER(specifiesType);
312  REGISTER_MATCHER(specifiesTypeLoc);
313  REGISTER_MATCHER(statementCountIs);
322  REGISTER_MATCHER(templateArgumentCountIs);
323  REGISTER_MATCHER(templateSpecializationType);
326  REGISTER_MATCHER(throughUsingDecl);
328  REGISTER_MATCHER(to);
333  REGISTER_MATCHER(typedefType);
337  REGISTER_MATCHER(unaryTransformType);
346  REGISTER_MATCHER(variableArrayType);
347  REGISTER_MATCHER(voidType);
349  REGISTER_MATCHER(withInitializer);
350 }
351 
352 RegistryMaps::~RegistryMaps() {
353  for (ConstructorMap::iterator it = Constructors.begin(),
354  end = Constructors.end();
355  it != end; ++it) {
356  delete it->second;
357  }
358 }
359 
360 static llvm::ManagedStatic<RegistryMaps> RegistryData;
361 
362 } // anonymous namespace
363 
364 // static
365 llvm::Optional<MatcherCtor> Registry::lookupMatcherCtor(StringRef MatcherName) {
366  ConstructorMap::const_iterator it =
367  RegistryData->constructors().find(MatcherName);
368  return it == RegistryData->constructors().end()
370  : it->second;
371 }
372 
373 namespace {
374 
375 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
376  const std::set<ASTNodeKind> &KS) {
377  unsigned Count = 0;
378  for (std::set<ASTNodeKind>::const_iterator I = KS.begin(), E = KS.end();
379  I != E; ++I) {
380  if (I != KS.begin())
381  OS << "|";
382  if (Count++ == 3) {
383  OS << "...";
384  break;
385  }
386  OS << *I;
387  }
388  return OS;
389 }
390 
391 } // namespace
392 
393 std::vector<ArgKind> Registry::getAcceptedCompletionTypes(
394  ArrayRef<std::pair<MatcherCtor, unsigned>> Context) {
395  ASTNodeKind InitialTypes[] = {
396  ASTNodeKind::getFromNodeKind<Decl>(),
397  ASTNodeKind::getFromNodeKind<QualType>(),
398  ASTNodeKind::getFromNodeKind<Type>(),
399  ASTNodeKind::getFromNodeKind<Stmt>(),
400  ASTNodeKind::getFromNodeKind<NestedNameSpecifier>(),
401  ASTNodeKind::getFromNodeKind<NestedNameSpecifierLoc>(),
402  ASTNodeKind::getFromNodeKind<TypeLoc>()};
403 
404  // Starting with the above seed of acceptable top-level matcher types, compute
405  // the acceptable type set for the argument indicated by each context element.
406  std::set<ArgKind> TypeSet(std::begin(InitialTypes), std::end(InitialTypes));
407  for (const auto &CtxEntry : Context) {
408  MatcherCtor Ctor = CtxEntry.first;
409  unsigned ArgNumber = CtxEntry.second;
410  std::vector<ArgKind> NextTypeSet;
411  for (const ArgKind &Kind : TypeSet) {
412  if (Kind.getArgKind() == Kind.AK_Matcher &&
413  Ctor->isConvertibleTo(Kind.getMatcherKind()) &&
414  (Ctor->isVariadic() || ArgNumber < Ctor->getNumArgs()))
415  Ctor->getArgKinds(Kind.getMatcherKind(), ArgNumber, NextTypeSet);
416  }
417  TypeSet.clear();
418  TypeSet.insert(NextTypeSet.begin(), NextTypeSet.end());
419  }
420  return std::vector<ArgKind>(TypeSet.begin(), TypeSet.end());
421 }
422 
423 std::vector<MatcherCompletion>
424 Registry::getMatcherCompletions(ArrayRef<ArgKind> AcceptedTypes) {
425  std::vector<MatcherCompletion> Completions;
426 
427  // Search the registry for acceptable matchers.
428  for (ConstructorMap::const_iterator I = RegistryData->constructors().begin(),
429  E = RegistryData->constructors().end();
430  I != E; ++I) {
431  std::set<ASTNodeKind> RetKinds;
432  unsigned NumArgs = I->second->isVariadic() ? 1 : I->second->getNumArgs();
433  bool IsPolymorphic = I->second->isPolymorphic();
434  std::vector<std::vector<ArgKind>> ArgsKinds(NumArgs);
435  unsigned MaxSpecificity = 0;
436  for (const ArgKind& Kind : AcceptedTypes) {
437  if (Kind.getArgKind() != Kind.AK_Matcher)
438  continue;
439  unsigned Specificity;
440  ASTNodeKind LeastDerivedKind;
441  if (I->second->isConvertibleTo(Kind.getMatcherKind(), &Specificity,
442  &LeastDerivedKind)) {
443  if (MaxSpecificity < Specificity)
444  MaxSpecificity = Specificity;
445  RetKinds.insert(LeastDerivedKind);
446  for (unsigned Arg = 0; Arg != NumArgs; ++Arg)
447  I->second->getArgKinds(Kind.getMatcherKind(), Arg, ArgsKinds[Arg]);
448  if (IsPolymorphic)
449  break;
450  }
451  }
452 
453  if (!RetKinds.empty() && MaxSpecificity > 0) {
454  std::string Decl;
455  llvm::raw_string_ostream OS(Decl);
456 
457  if (IsPolymorphic) {
458  OS << "Matcher<T> " << I->first() << "(Matcher<T>";
459  } else {
460  OS << "Matcher<" << RetKinds << "> " << I->first() << "(";
461  for (const std::vector<ArgKind> &Arg : ArgsKinds) {
462  if (&Arg != &ArgsKinds[0])
463  OS << ", ";
464 
465  bool FirstArgKind = true;
466  std::set<ASTNodeKind> MatcherKinds;
467  // Two steps. First all non-matchers, then matchers only.
468  for (const ArgKind &AK : Arg) {
469  if (AK.getArgKind() == ArgKind::AK_Matcher) {
470  MatcherKinds.insert(AK.getMatcherKind());
471  } else {
472  if (!FirstArgKind) OS << "|";
473  FirstArgKind = false;
474  OS << AK.asString();
475  }
476  }
477  if (!MatcherKinds.empty()) {
478  if (!FirstArgKind) OS << "|";
479  OS << "Matcher<" << MatcherKinds << ">";
480  }
481  }
482  }
483  if (I->second->isVariadic())
484  OS << "...";
485  OS << ")";
486 
487  std::string TypedText = I->first();
488  TypedText += "(";
489  if (ArgsKinds.empty())
490  TypedText += ")";
491  else if (ArgsKinds[0][0].getArgKind() == ArgKind::AK_String)
492  TypedText += "\"";
493 
494  Completions.emplace_back(TypedText, OS.str(), MaxSpecificity);
495  }
496  }
497 
498  return Completions;
499 }
500 
501 // static
502 VariantMatcher Registry::constructMatcher(MatcherCtor Ctor,
503  const SourceRange &NameRange,
505  Diagnostics *Error) {
506  return Ctor->create(NameRange, Args, Error);
507 }
508 
509 // static
510 VariantMatcher Registry::constructBoundMatcher(MatcherCtor Ctor,
511  const SourceRange &NameRange,
512  StringRef BindID,
514  Diagnostics *Error) {
515  VariantMatcher Out = constructMatcher(Ctor, NameRange, Args, Error);
516  if (Out.isNull()) return Out;
517 
519  if (Result.hasValue()) {
520  llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID);
521  if (Bound.hasValue()) {
522  return VariantMatcher::SingleMatcher(*Bound);
523  }
524  }
525  Error->addError(NameRange, Error->ET_RegistryNotBindable);
526  return VariantMatcher();
527 }
528 
529 } // namespace dynamic
530 } // namespace ast_matchers
531 } // namespace clang
internal::TrueMatcher anything()
Matches any node.
Definition: ASTMatchers.h:145
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
Definition: ASTMatchers.h:1110
const internal::VariadicDynCastAllOfMatcher< Stmt, BreakStmt > breakStmt
Matches break statements.
Definition: ASTMatchers.h:1232
const internal::ArgumentAdaptingMatcherFunc< internal::HasParentMatcher, internal::TypeList< Decl, Stmt >, internal::TypeList< Decl, Stmt > > LLVM_ATTRIBUTE_UNUSED hasParent
Matches AST nodes that have a parent that matches the provided matcher.
Definition: ASTMatchers.h:1982
const internal::VariadicDynCastAllOfMatcher< Stmt, DoStmt > doStmt
Matches do statements.
Definition: ASTMatchers.h:1222
const internal::ArgumentAdaptingMatcherFunc< internal::HasDescendantMatcher > LLVM_ATTRIBUTE_UNUSED hasDescendant
Matches AST nodes that have descendant AST nodes that match the provided matcher. ...
Definition: ASTMatchers.h:1902
const internal::VariadicAllOfMatcher< Stmt > stmt
Matches statements.
Definition: ASTMatchers.h:826
Registry of all known matchers.
internal::PolymorphicMatcherWithParam1< internal::HasDeclarationMatcher, internal::Matcher< Decl >, void(internal::HasDeclarationSupportedTypes)> hasDeclaration(const internal::Matcher< Decl > &InnerMatcher)
Matches a node if the declaration associated with that node matches the given matcher.
Definition: ASTMatchers.h:2033
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXBindTemporaryExpr > bindTemporaryExpr
Matches nodes where temporaries are created.
Definition: ASTMatchers.h:1017
const internal::ArgumentAdaptingMatcherFunc< internal::ForEachMatcher > LLVM_ATTRIBUTE_UNUSED forEach
Matches AST nodes that have child AST nodes that match the provided matcher.
Definition: ASTMatchers.h:1921
ArgStream addError(const SourceRange &Range, ErrorType Error)
Add an error to the diagnostics.
Definition: Diagnostics.cpp:66
const internal::VariadicDynCastAllOfMatcher< Stmt, LabelStmt > labelStmt
Matches label statements.
Definition: ASTMatchers.h:1274
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXThisExpr > thisExpr
Matches implicit and explicit this expressions.
Definition: ASTMatchers.h:1005
const internal::VariadicDynCastAllOfMatcher< Decl, UsingDecl > usingDecl
Matches using declarations.
Definition: ASTMatchers.h:940
const internal::VariadicDynCastAllOfMatcher< Decl, ValueDecl > valueDecl
Matches any value declaration.
Definition: ASTMatchers.h:700
const internal::VariadicDynCastAllOfMatcher< Decl, ClassTemplateDecl > classTemplateDecl
Matches C++ class template declarations.
Definition: ASTMatchers.h:314
const internal::VariadicDynCastAllOfMatcher< Decl, EnumConstantDecl > enumConstantDecl
Matches enum constants.
Definition: ASTMatchers.h:750
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXForRangeStmt > forRangeStmt
Matches range-based for statements.
Definition: ASTMatchers.h:1174
const internal::VariadicDynCastAllOfMatcher< Decl, VarDecl > varDecl
Matches variable declarations.
Definition: ASTMatchers.h:778
const internal::VariadicDynCastAllOfMatcher< Stmt, AsmStmt > asmStmt
Matches asm statements.
Definition: ASTMatchers.h:1368
const internal::VariadicDynCastAllOfMatcher< Stmt, ConditionalOperator > conditionalOperator
Matches conditional operator expressions.
Definition: ASTMatchers.h:1477
const internal::VariadicDynCastAllOfMatcher< Stmt, UnaryExprOrTypeTraitExpr > unaryExprOrTypeTraitExpr
Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
Definition: ASTMatchers.h:1692
const internal::VariadicAllOfMatcher< QualType > qualType
Matches QualTypes in the clang AST.
Definition: ASTMatchers.h:1636
const internal::VariadicDynCastAllOfMatcher< Stmt, CaseStmt > caseStmt
Matches case statements inside switch statements.
Definition: ASTMatchers.h:1304
#define REGISTER_OVERLOADED_2(name)
Definition: Registry.cpp:60
const internal::VariadicDynCastAllOfMatcher< Decl, CXXConversionDecl > conversionDecl
Matches conversion operator declarations.
Definition: ASTMatchers.h:767
const internal::VariadicDynCastAllOfMatcher< Decl, UsingDirectiveDecl > usingDirectiveDecl
Matches using namespace declarations.
Definition: ASTMatchers.h:952
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchers.h:258
const internal::VariadicDynCastAllOfMatcher< Stmt, ObjCMessageExpr > objcMessageExpr
Matches ObjectiveC Message invocation expressions.
Definition: ASTMatchers.h:893
const internal::VariadicDynCastAllOfMatcher< Stmt, WhileStmt > whileStmt
Matches while statements.
Definition: ASTMatchers.h:1212
const internal::VariadicDynCastAllOfMatcher< Stmt, CompoundLiteralExpr > compoundLiteralExpr
Matches compound (i.e. non-scalar) literals.
Definition: ASTMatchers.h:1437
const internal::VariadicDynCastAllOfMatcher< Stmt, NullStmt > nullStmt
Matches null statements.
Definition: ASTMatchers.h:1358
const internal::VariadicDynCastAllOfMatcher< Decl, NamedDecl > namedDecl
Matches a declaration of anything that could have a name.
Definition: ASTMatchers.h:282
const internal::VariadicDynCastAllOfMatcher< Decl, TypedefDecl > typedefDecl
Matches typedef declarations.
Definition: ASTMatchers.h:169
const internal::VariadicOperatorMatcherFunc< 2, UINT_MAX > eachOf
Matches if any of the given matchers matches.
Definition: ASTMatchers.h:1663
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXReinterpretCastExpr > reinterpretCastExpr
Matches a reinterpret_cast expression.
Definition: ASTMatchers.h:1508
const internal::VariadicDynCastAllOfMatcher< Stmt, DefaultStmt > defaultStmt
Matches default statements inside switch statements.
Definition: ASTMatchers.h:1314
const internal::VariadicDynCastAllOfMatcher< Decl, CXXRecordDecl > recordDecl
Matches C++ class declarations.
Definition: ASTMatchers.h:304
const internal::VariadicDynCastAllOfMatcher< Stmt, CompoundStmt > compoundStmt
Matches compound statements.
Definition: ASTMatchers.h:1322
const internal::VariadicDynCastAllOfMatcher< Decl, ParmVarDecl > parmVarDecl
Matches parameter variable declarations.
Definition: ASTMatchers.h:350
const internal::VariadicDynCastAllOfMatcher< Stmt, ReturnStmt > returnStmt
Matches return statements.
Definition: ASTMatchers.h:1252
const internal::VariadicDynCastAllOfMatcher< Decl, TranslationUnitDecl > translationUnitDecl
Matches the top declaration context.
Definition: ASTMatchers.h:159
const internal::VariadicDynCastAllOfMatcher< Decl, FriendDecl > friendDecl
Matches friend declarations.
Definition: ASTMatchers.h:816
internal::Matcher< Stmt > sizeOfExpr(const internal::Matcher< UnaryExprOrTypeTraitExpr > &InnerMatcher)
Same as unaryExprOrTypeTraitExpr, but only matching sizeof.
Definition: ASTMatchers.h:1731
Functions templates and classes to wrap matcher construct functions.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXTemporaryObjectExpr > temporaryObjectExpr
Matches functional cast expressions having N != 1 arguments.
Definition: ASTMatchers.h:1633
const internal::VariadicDynCastAllOfMatcher< Decl, StaticAssertDecl > staticAssertDecl
Matches a C++ static_assert declaration.
Definition: ASTMatchers.h:1494
const internal::VariadicDynCastAllOfMatcher< Stmt, DeclStmt > declStmt
Matches declaration statements.
Definition: ASTMatchers.h:838
internal::PolymorphicMatcherWithParam1< internal::HasOverloadedOperatorNameMatcher, StringRef, AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl)> hasOverloadedOperatorName(StringRef Name)
Matches overloaded operator names.
Definition: ASTMatchers.h:1800
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXConstCastExpr > constCastExpr
Matches a const_cast expression.
Definition: ASTMatchers.h:1553
const internal::VariadicDynCastAllOfMatcher< Stmt, UnaryOperator > unaryOperator
Matches unary operator expressions.
Definition: ASTMatchers.h:1467
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXStaticCastExpr > staticCastExpr
Matches a C++ static_cast expression.
Definition: ASTMatchers.h:1525
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXOperatorCallExpr > operatorCallExpr
Matches overloaded operator calls.
Definition: ASTMatchers.h:1102
const internal::VariadicDynCastAllOfMatcher< Stmt, MemberExpr > memberExpr
Matches member expressions.
Definition: ASTMatchers.h:851
bool isNull() const
Whether the matcher is null.
Definition: VariantValue.h:158
const internal::VariadicDynCastAllOfMatcher< Stmt, InitListExpr > initListExpr
Matches init list expressions.
Definition: ASTMatchers.h:916
const internal::VariadicOperatorMatcherFunc< 2, UINT_MAX > allOf
Matches if all given matchers match.
Definition: ASTMatchers.h:1677
const internal::VariadicDynCastAllOfMatcher< Stmt, ArraySubscriptExpr > arraySubscriptExpr
Matches array subscript expressions.
Definition: ASTMatchers.h:1071
ASTContext * Context
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXNewExpr > newExpr
Matches new expressions.
Definition: ASTMatchers.h:1049
const internal::VariadicDynCastAllOfMatcher< Stmt, LambdaExpr > lambdaExpr
Matches lambda expressions.
Definition: ASTMatchers.h:869
const internal::VariadicDynCastAllOfMatcher< Stmt, BinaryOperator > binaryOperator
Matches binary operator expressions.
Definition: ASTMatchers.h:1457
const internal::VariadicAllOfMatcher< NestedNameSpecifier > nestedNameSpecifier
Matches record types (e.g. structs, classes).
Definition: ASTMatchers.h:3896
const internal::ArgumentAdaptingMatcherFunc< internal::ForEachDescendantMatcher > LLVM_ATTRIBUTE_UNUSED forEachDescendant
Matches AST nodes that have descendant AST nodes that match the provided matcher. ...
Definition: ASTMatchers.h:1948
const internal::VariadicDynCastAllOfMatcher< Stmt, IntegerLiteral > integerLiteral
Matches integer literals of all sizes / encodings, e.g. 1, 1L, 0x1 and 1U.
Definition: ASTMatchers.h:1409
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXThrowExpr > throwExpr
Matches throw expressions.
Definition: ASTMatchers.h:1349
const internal::VariadicDynCastAllOfMatcher< Stmt, ForStmt > forStmt
Matches for statements.
Definition: ASTMatchers.h:1136
MatchFinder::MatchCallback * Callback
const internal::VariadicOperatorMatcherFunc< 1, 1 > unless
Matches if the provided matcher does not match.
Definition: ASTMatchers.h:2008
const internal::VariadicAllOfMatcher< NestedNameSpecifierLoc > nestedNameSpecifierLoc
Same as nestedNameSpecifier but matches NestedNameSpecifierLoc.
Definition: ASTMatchers.h:3900
const internal::VariadicDynCastAllOfMatcher< Stmt, GotoStmt > gotoStmt
Matches goto statements.
Definition: ASTMatchers.h:1263
#define REGISTER_MATCHER(name)
Definition: Registry.cpp:52
const internal::VariadicDynCastAllOfMatcher< Stmt, MaterializeTemporaryExpr > materializeTemporaryExpr
Matches nodes where temporaries are materialized.
Definition: ASTMatchers.h:1039
The result type of a method or function.
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:155
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXNullPtrLiteralExpr > nullPtrLiteralExpr
Matches nullptr literal.
Definition: ASTMatchers.h:1442
const internal::VariadicDynCastAllOfMatcher< Stmt, SwitchCase > switchCase
Matches case and default statements inside switch statements.
Definition: ASTMatchers.h:1294
Helper class to manage error messages.
Definition: Diagnostics.h:51
const internal::ArgumentAdaptingMatcherFunc< internal::HasAncestorMatcher, internal::TypeList< Decl, Stmt >, internal::TypeList< Decl, Stmt > > LLVM_ATTRIBUTE_UNUSED hasAncestor
Matches AST nodes that have an ancestor that matches the provided matcher.
Definition: ASTMatchers.h:1997
const internal::VariadicAllOfMatcher< TypeLoc > typeLoc
Matches TypeLocs in the clang AST.
Definition: ASTMatchers.h:1642
const internal::VariadicDynCastAllOfMatcher< Decl, CXXMethodDecl > methodDecl
Matches method declarations.
Definition: ASTMatchers.h:758
const internal::VariadicDynCastAllOfMatcher< Decl, UnresolvedUsingValueDecl > unresolvedUsingValueDecl
Matches unresolved using value declarations.
Definition: ASTMatchers.h:967
Kind
const internal::VariadicDynCastAllOfMatcher< Stmt, CharacterLiteral > characterLiteral
Matches character literals (also matches wchar_t).
Definition: ASTMatchers.h:1401
const internal::VariadicDynCastAllOfMatcher< Stmt, DeclRefExpr > declRefExpr
Matches expressions that refer to declarations.
Definition: ASTMatchers.h:1119
const internal::VariadicDynCastAllOfMatcher< Stmt, ImplicitCastExpr > implicitCastExpr
Matches the implicit cast nodes of Clang's AST.
Definition: ASTMatchers.h:1596
const internal::ArgumentAdaptingMatcherFunc< internal::HasMatcher > LLVM_ATTRIBUTE_UNUSED has
Matches the first method of a class or struct that satisfies InnerMatcher.
Definition: ASTMatchers.h:1885
const internal::VariadicDynCastAllOfMatcher< Decl, CXXDestructorDecl > destructorDecl
Matches explicit C++ destructor declarations.
Definition: ASTMatchers.h:728
const internal::VariadicDynCastAllOfMatcher< Decl, ClassTemplateSpecializationDecl > classTemplateSpecializationDecl
Matches C++ class template specializations.
Definition: ASTMatchers.h:328
internal::Matcher< Stmt > alignOfExpr(const internal::Matcher< UnaryExprOrTypeTraitExpr > &InnerMatcher)
Same as unaryExprOrTypeTraitExpr, but only matching alignof.
Definition: ASTMatchers.h:1723
const internal::VariadicDynCastAllOfMatcher< Decl, FunctionDecl > functionDecl
Matches function declarations.
Definition: ASTMatchers.h:796
const internal::VariadicDynCastAllOfMatcher< Stmt, ExprWithCleanups > exprWithCleanups
Matches expressions that introduce cleanups to be run at the end of the sub-expression's evaluation...
Definition: ASTMatchers.h:904
const internal::VariadicDynCastAllOfMatcher< Decl, AccessSpecDecl > accessSpecDecl
Matches C++ access specifier declarations.
Definition: ASTMatchers.h:365
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXDefaultArgExpr > defaultArgExpr
Matches the value of a default argument at the call site.
Definition: ASTMatchers.h:1084
const internal::VariadicDynCastAllOfMatcher< Stmt, ExplicitCastExpr > explicitCastExpr
Matches explicit cast expressions.
Definition: ASTMatchers.h:1588
const internal::VariadicDynCastAllOfMatcher< Decl, CXXConstructorDecl > constructorDecl
Matches C++ constructor declarations.
Definition: ASTMatchers.h:715
virtual unsigned getNumArgs() const =0
Returns the number of arguments accepted by the matcher if not variadic.
const internal::VariadicDynCastAllOfMatcher< Stmt, StringLiteral > stringLiteral
Matches string literals (also matches wide string literals).
Definition: ASTMatchers.h:1388
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXUnresolvedConstructExpr > unresolvedConstructExpr
Matches unresolved constructor call expressions.
Definition: ASTMatchers.h:993
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXCatchStmt > catchStmt
Matches catch statements.
Definition: ASTMatchers.h:1331
const internal::VariadicDynCastAllOfMatcher< Decl, FunctionTemplateDecl > functionTemplateDecl
Matches C++ function template declarations.
Definition: ASTMatchers.h:806
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXFunctionalCastExpr > functionalCastExpr
Matches functional cast expressions.
Definition: ASTMatchers.h:1623
const internal::VariadicDynCastAllOfMatcher< Decl, EnumDecl > enumDecl
Matches enum declarations.
Definition: ASTMatchers.h:738
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1639
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXDynamicCastExpr > dynamicCastExpr
Matches a dynamic_cast expression.
Definition: ASTMatchers.h:1541
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXBoolLiteralExpr > boolLiteral
Matches bool literals.
Definition: ASTMatchers.h:1378
const internal::VariadicDynCastAllOfMatcher< Stmt, CUDAKernelCallExpr > CUDAKernelCallExpr
Matches CUDA kernel call expression.
Definition: ASTMatchers.h:4113
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXConstructExpr > constructExpr
Matches constructor call expressions (including implicit ones).
Definition: ASTMatchers.h:981
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXMemberCallExpr > memberCallExpr
Matches member call expressions.
Definition: ASTMatchers.h:880
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXTryStmt > tryStmt
Matches try statements.
Definition: ASTMatchers.h:1340
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXDeleteExpr > deleteExpr
Matches delete expressions.
Definition: ASTMatchers.h:1059
const internal::VariadicDynCastAllOfMatcher< Stmt, CStyleCastExpr > cStyleCastExpr
Matches a C-style cast expression.
Definition: ASTMatchers.h:1563
const internal::VariadicDynCastAllOfMatcher< Stmt, FloatingLiteral > floatLiteral
Matches float literals of all sizes / encodings, e.g. 1.0, 1.0f, 1.0L and 1e10.
Definition: ASTMatchers.h:1420
const internal::VariadicDynCastAllOfMatcher< Stmt, IfStmt > ifStmt
Matches if statements.
Definition: ASTMatchers.h:1127
const internal::VariadicDynCastAllOfMatcher< Stmt, CallExpr > callExpr
Matches call expressions.
Definition: ASTMatchers.h:861
internal::Matcher< BinaryOperator > hasEitherOperand(const internal::Matcher< Expr > &InnerMatcher)
Matches if either the left hand side or the right hand side of a binary operator matches.
Definition: ASTMatchers.h:3001
const internal::VariadicOperatorMatcherFunc< 2, UINT_MAX > anyOf
Matches if any of the given matchers matches.
Definition: ASTMatchers.h:1670
const internal::VariadicDynCastAllOfMatcher< Stmt, ContinueStmt > continueStmt
Matches continue statements.
Definition: ASTMatchers.h:1242
const internal::VariadicAllOfMatcher< TemplateArgument > templateArgument
Matches template arguments.
Definition: ASTMatchers.h:387
const internal::VariadicDynCastAllOfMatcher< Stmt, CastExpr > castExpr
Matches any cast nodes of Clang's AST.
Definition: ASTMatchers.h:1611
internal::Matcher< NamedDecl > hasName(const std::string &Name)
Matches NamedDecl nodes that have the specified name.
Definition: ASTMatchers.h:1752
raw_ostream & operator<<(raw_ostream &OS, ASTNodeKind K)
const internal::VariadicDynCastAllOfMatcher< Decl, NamespaceDecl > namespaceDecl
Matches a declaration of a namespace.
Definition: ASTMatchers.h:293
const internal::VariadicDynCastAllOfMatcher< Stmt, UserDefinedLiteral > userDefinedLiteral
Matches user defined literal operator call.
Definition: ASTMatchers.h:1427
const internal::VariadicAllOfMatcher< CXXCtorInitializer > ctorInitializer
Matches constructor initializers.
Definition: ASTMatchers.h:376
const internal::VariadicDynCastAllOfMatcher< Stmt, SwitchStmt > switchStmt
Matches switch statements.
Definition: ASTMatchers.h:1284
const internal::VariadicDynCastAllOfMatcher< Stmt, SubstNonTypeTemplateParmExpr > substNonTypeTemplateParmExpr
Matches substitutions of non-type template parameters.
Definition: ASTMatchers.h:929
const internal::VariadicDynCastAllOfMatcher< Decl, FieldDecl > fieldDecl
Matches field declarations.
Definition: ASTMatchers.h:788
ConstructorMap Constructors
Definition: Registry.cpp:43
virtual VariantMatcher create(const SourceRange &NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) const =0
virtual void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo, std::vector< ArgKind > &ArgKinds) const =0
virtual bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity=nullptr, ast_type_traits::ASTNodeKind *LeastDerivedKind=nullptr) const =0
const internal::VariadicDynCastAllOfMatcher< Decl, DeclaratorDecl > declaratorDecl
Matches declarator declarations (field, variable, function and non-type template parameter declaratio...
Definition: ASTMatchers.h:340
llvm::Optional< DynTypedMatcher > getSingleMatcher() const
Return a single matcher, if there is no ambiguity.
static bool isExternC(const NamedDecl *ND)
Definition: Mangle.cpp:59