自学教程：C++ unless函数代码示例

void StrCatAppendCheck::registerMatchers(MatchFinder *Finder) {  if (!getLangOpts().CPlusPlus)  	return;  const auto StrCat = functionDecl(hasName("::absl::StrCat"));  // The arguments of absl::StrCat are implicitly converted to AlphaNum. This   // matches to the arguments because of that behavior.   const auto AlphaNum = IgnoringTemporaries(cxxConstructExpr(      argumentCountIs(1), hasType(cxxRecordDecl(hasName("::absl::AlphaNum"))),      hasArgument(0, ignoringImpCasts(declRefExpr(to(equalsBoundNode("LHS")),                                                  expr().bind("Arg0"))))));  const auto HasAnotherReferenceToLhs =      callExpr(hasAnyArgument(expr(hasDescendant(declRefExpr(          to(equalsBoundNode("LHS")), unless(equalsBoundNode("Arg0")))))));  // Now look for calls to operator= with an object on the LHS and a call to  // StrCat on the RHS. The first argument of the StrCat call should be the same  // as the LHS. Ignore calls from template instantiations.  Finder->addMatcher(      cxxOperatorCallExpr(          unless(isInTemplateInstantiation()), hasOverloadedOperatorName("="),          hasArgument(0, declRefExpr(to(decl().bind("LHS")))),          hasArgument(1, IgnoringTemporaries(                             callExpr(callee(StrCat), hasArgument(0, AlphaNum),                                      unless(HasAnotherReferenceToLhs))                                 .bind("Call"))))          .bind("Op"),      this);}

void PassByValueCheck::registerMatchers(MatchFinder *Finder) {  // Only register the matchers for C++; the functionality currently does not  // provide any benefit to other languages, despite being benign.  if (!getLangOpts().CPlusPlus)    return;  Finder->addMatcher(      cxxConstructorDecl(          forEachConstructorInitializer(              cxxCtorInitializer(                  // Clang builds a CXXConstructExpr only whin it knows which                  // constructor will be called. In dependent contexts a                  // ParenListExpr is generated instead of a CXXConstructExpr,                  // filtering out templates automatically for us.                  withInitializer(cxxConstructExpr(                      has(ignoringParenImpCasts(declRefExpr(to(                          parmVarDecl(                              hasType(qualType(                                  // Match only const-ref or a non-const value                                  // parameters. Rvalues and const-values                                  // shouldn't be modified.                                  anyOf(constRefType(), nonConstValueType()))))                              .bind("Param"))))),                      hasDeclaration(cxxConstructorDecl(                          isCopyConstructor(), unless(isDeleted()),                          hasDeclContext(                              cxxRecordDecl(isMoveConstructible())))))))                  .bind("Initializer")))          .bind("Ctor"),      this);}

void InaccurateEraseCheck::registerMatchers(MatchFinder *Finder) {  // Only register the matchers for C++; the functionality currently does not  // provide any benefit to other languages, despite being benign.  if (!getLangOpts().CPlusPlus)    return;  const auto CheckForEndCall = hasArgument(      1, anyOf(cxxConstructExpr(has(ignoringParenImpCasts(                   cxxMemberCallExpr(callee(cxxMethodDecl(hasName("end"))))                       .bind("InaccEndCall")))),               anything()));  Finder->addMatcher(      cxxMemberCallExpr(          on(hasType(namedDecl(matchesName("^::std::")))),          callee(cxxMethodDecl(hasName("erase"))), argumentCountIs(1),          hasArgument(0, has(ignoringParenImpCasts(                             callExpr(callee(functionDecl(matchesName(                                          "^::std::(remove(_if)?|unique)$"))),                                      CheckForEndCall)                                 .bind("InaccAlgCall")))),          unless(isInTemplateInstantiation()))          .bind("InaccErase"),      this);}

void InaccurateEraseCheck::registerMatchers(MatchFinder *Finder) {  // Only register the matchers for C++; the functionality currently does not  // provide any benefit to other languages, despite being benign.  if (!getLangOpts().CPlusPlus)    return;  const auto EndCall =      callExpr(          callee(functionDecl(hasAnyName("remove", "remove_if", "unique"))),          hasArgument(              1,              anyOf(cxxConstructExpr(has(ignoringImplicit(                        cxxMemberCallExpr(callee(cxxMethodDecl(hasName("end"))))                            .bind("end")))),                    anything())))          .bind("alg");  const auto DeclInStd = type(hasUnqualifiedDesugaredType(      tagType(hasDeclaration(decl(isInStdNamespace())))));  Finder->addMatcher(      cxxMemberCallExpr(          on(anyOf(hasType(DeclInStd), hasType(pointsTo(DeclInStd)))),          callee(cxxMethodDecl(hasName("erase"))), argumentCountIs(1),          hasArgument(0, has(ignoringImplicit(                             anyOf(EndCall, has(ignoringImplicit(EndCall)))))),          unless(isInTemplateInstantiation()))          .bind("erase"),      this);}

void MakeSmartPtrCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {  if (!isLanguageVersionSupported(getLangOpts()))    return;  // Calling make_smart_ptr from within a member function of a type with a  // private or protected constructor would be ill-formed.  auto CanCallCtor = unless(has(ignoringImpCasts(      cxxConstructExpr(hasDeclaration(decl(unless(isPublic())))))));  Finder->addMatcher(      cxxBindTemporaryExpr(has(ignoringParenImpCasts(          cxxConstructExpr(              hasType(getSmartPointerTypeMatcher()), argumentCountIs(1),              hasArgument(0,                          cxxNewExpr(hasType(pointsTo(qualType(hasCanonicalType(                                         equalsBoundNode(PointerType))))),                                     CanCallCtor)                              .bind(NewExpression)),              unless(isInTemplateInstantiation()))              .bind(ConstructorCall)))),      this);  Finder->addMatcher(      cxxMemberCallExpr(          thisPointerType(getSmartPointerTypeMatcher()),          callee(cxxMethodDecl(hasName("reset"))),          hasArgument(0, cxxNewExpr(CanCallCtor).bind(NewExpression)),          unless(isInTemplateInstantiation()))          .bind(ResetCall),      this);}

void ForwardingReferenceOverloadCheck::registerMatchers(MatchFinder *Finder) {  // Forwarding references require C++11 or later.  if (!getLangOpts().CPlusPlus11)    return;  auto ForwardingRefParm =      parmVarDecl(          hasType(qualType(rValueReferenceType(),                           references(templateTypeParmType(hasDeclaration(                               templateTypeParmDecl().bind("type-parm-decl")))),                           unless(references(isConstQualified())))))          .bind("parm-var");  DeclarationMatcher findOverload =      cxxConstructorDecl(          hasParameter(0, ForwardingRefParm),          unless(hasAnyParameter(              // No warning: enable_if as constructor parameter.              parmVarDecl(hasType(isEnableIf())))),          unless(hasParent(functionTemplateDecl(has(templateTypeParmDecl(              // No warning: enable_if as type parameter.              hasDefaultArgument(isEnableIf())))))))          .bind("ctor");  Finder->addMatcher(findOverload, this);}

void NonPrivateMemberVariablesInClassesCheck::registerMatchers(    MatchFinder *Finder) {  if (!getLangOpts().CPlusPlus)    return;  // We can ignore structs/classes with all member variables being public.  auto ShouldIgnoreRecord =      allOf(boolean(IgnoreClassesWithAllMemberVariablesBeingPublic),            unless(hasNonPublicMemberVariable()));  // There are three visibility types: public, protected, private.  // If we are ok with public fields, then we only want to complain about  // protected fields, else we want to complain about all non-private fields.  // We can ignore public member variables in structs/classes, in unions.  auto InterestingField = fieldDecl(      IgnorePublicMemberVariables ? isProtected() : unless(isPrivate()));  // We only want the records that not only contain the mutable data (non-static  // member variables), but also have some logic (non-static member functions).  // We may optionally ignore records where all the member variables are public.  Finder->addMatcher(cxxRecordDecl(anyOf(isStruct(), isClass()), hasMethods(),                                   hasNonStaticMethod(),                                   unless(ShouldIgnoreRecord),                                   forEach(InterestingField.bind("field")))                         .bind("record"),                     this);}

void MultiwayPathsCoveredCheck::registerMatchers(MatchFinder *Finder) {  Finder->addMatcher(      switchStmt(          hasCondition(allOf(              // Match on switch statements that have either a bit-field or              // an integer condition. The ordering in 'anyOf()' is              // important because the last condition is the most general.              anyOf(ignoringImpCasts(memberExpr(hasDeclaration(                        fieldDecl(isBitField()).bind("bitfield")))),                    ignoringImpCasts(declRefExpr().bind("non-enum-condition"))),              // 'unless()' must be the last match here and must be bound,              // otherwise the matcher does not work correctly, because it              // will not explicitly ignore enum conditions.              unless(ignoringImpCasts(                  declRefExpr(hasType(enumType())).bind("enum-condition"))))))          .bind("switch"),      this);  // This option is noisy, therefore matching is configurable.  if (WarnOnMissingElse) {    Finder->addMatcher(        ifStmt(allOf(hasParent(ifStmt()), unless(hasElse(anything()))))            .bind("else-if"),        this);  }}

void NoexceptMoveConstructorCheck::registerMatchers(MatchFinder *Finder) {    Finder->addMatcher(        methodDecl(anyOf(constructorDecl(), hasOverloadedOperatorName("=")),                   unless(isImplicit()), unless(isDeleted()))        .bind("decl"),        this);}

void RedundantVoidArgCheck::registerMatchers(MatchFinder *Finder) {  Finder->addMatcher(functionDecl(parameterCountIs(0), unless(isImplicit()),                                  unless(isExternC()))                         .bind(FunctionId),                     this);  Finder->addMatcher(typedefNameDecl().bind(TypedefId), this);  auto ParenFunctionType = parenType(innerType(functionType()));  auto PointerToFunctionType = pointee(ParenFunctionType);  auto FunctionOrMemberPointer =      anyOf(hasType(pointerType(PointerToFunctionType)),            hasType(memberPointerType(PointerToFunctionType)));  Finder->addMatcher(fieldDecl(FunctionOrMemberPointer).bind(FieldId), this);  Finder->addMatcher(varDecl(FunctionOrMemberPointer).bind(VarId), this);  auto CastDestinationIsFunction =      hasDestinationType(pointsTo(ParenFunctionType));  Finder->addMatcher(      cStyleCastExpr(CastDestinationIsFunction).bind(CStyleCastId), this);  Finder->addMatcher(      cxxStaticCastExpr(CastDestinationIsFunction).bind(NamedCastId), this);  Finder->addMatcher(      cxxReinterpretCastExpr(CastDestinationIsFunction).bind(NamedCastId),      this);  Finder->addMatcher(      cxxConstCastExpr(CastDestinationIsFunction).bind(NamedCastId), this);  Finder->addMatcher(lambdaExpr().bind(LambdaId), this);}

void AssignOperatorSignatureCheck::registerMatchers(    ast_matchers::MatchFinder *Finder) {  // Only register the matchers for C++; the functionality currently does not  // provide any benefit to other languages, despite being benign.  if (getLangOpts().CPlusPlus) {    const auto HasGoodReturnType = methodDecl(returns(lValueReferenceType(        pointee(unless(isConstQualified()),                hasDeclaration(equalsBoundNode("class"))))));    const auto IsSelf = qualType(anyOf(        hasDeclaration(equalsBoundNode("class")),        referenceType(pointee(hasDeclaration(equalsBoundNode("class"))))));    const auto IsSelfAssign =        methodDecl(unless(anyOf(isDeleted(), isPrivate(), isImplicit())),                   hasName("operator="), ofClass(recordDecl().bind("class")),                   hasParameter(0, parmVarDecl(hasType(IsSelf))))            .bind("method");    Finder->addMatcher(        methodDecl(IsSelfAssign, unless(HasGoodReturnType)).bind("ReturnType"),        this);    const auto BadSelf = referenceType(        anyOf(lValueReferenceType(pointee(unless(isConstQualified()))),              rValueReferenceType(pointee(isConstQualified()))));    Finder->addMatcher(        methodDecl(IsSelfAssign, hasParameter(0, parmVarDecl(hasType(BadSelf))))            .bind("ArgumentType"),        this);    Finder->addMatcher(methodDecl(IsSelfAssign, isConst()).bind("Const"), this);  }}

void UseUncaughtExceptionsCheck::registerMatchers(MatchFinder *Finder) {  if (!getLangOpts().CPlusPlus17)    return;  std::string MatchText = "::std::uncaught_exception";  // Using declaration: warning and fix-it.  Finder->addMatcher(      usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(hasName(MatchText))))          .bind("using_decl"),      this);  // DeclRefExpr: warning, no fix-it.  Finder->addMatcher(declRefExpr(allOf(to(functionDecl(hasName(MatchText))),                                       unless(callExpr())))                         .bind("decl_ref_expr"),                     this);  // CallExpr: warning, fix-it.  Finder->addMatcher(      callExpr(allOf(hasDeclaration(functionDecl(hasName(MatchText))),                     unless(hasAncestor(initListExpr()))))          .bind("call_expr"),      this);  // CallExpr in initialisation list: warning, fix-it with avoiding narrowing  // conversions.  Finder->addMatcher(      callExpr(allOf(hasAncestor(initListExpr()),                     hasDeclaration(functionDecl(hasName(MatchText)))))          .bind("init_call_expr"),      this);}

void SuspiciousEnumUsageCheck::registerMatchers(MatchFinder *Finder) {  const auto enumExpr = [](StringRef RefName, StringRef DeclName) {    return allOf(ignoringImpCasts(expr().bind(RefName)),                 ignoringImpCasts(hasType(enumDecl().bind(DeclName))));  };  Finder->addMatcher(      binaryOperator(hasOperatorName("|"), hasLHS(enumExpr("", "enumDecl")),                     hasRHS(allOf(enumExpr("", "otherEnumDecl"),                                  ignoringImpCasts(hasType(enumDecl(                                      unless(equalsBoundNode("enumDecl"))))))))          .bind("diffEnumOp"),      this);  Finder->addMatcher(      binaryOperator(anyOf(hasOperatorName("+"), hasOperatorName("|")),                     hasLHS(enumExpr("lhsExpr", "enumDecl")),                     hasRHS(allOf(enumExpr("rhsExpr", ""),                                  ignoringImpCasts(hasType(enumDecl(                                      equalsBoundNode("enumDecl"))))))),      this);  Finder->addMatcher(      binaryOperator(anyOf(hasOperatorName("+"), hasOperatorName("|")),                     hasEitherOperand(                         allOf(hasType(isInteger()), unless(enumExpr("", "")))),                     hasEitherOperand(enumExpr("enumExpr", "enumDecl"))),      this);  Finder->addMatcher(      binaryOperator(anyOf(hasOperatorName("|="), hasOperatorName("+=")),                     hasRHS(enumExpr("enumExpr", "enumDecl"))),      this);}

void UseEqualsDeleteCheck::registerMatchers(MatchFinder *Finder) {  auto PrivateSpecialFn = cxxMethodDecl(      isPrivate(),      anyOf(cxxConstructorDecl(anyOf(isDefaultConstructor(),                                     isCopyConstructor(), isMoveConstructor())),            cxxMethodDecl(                anyOf(isCopyAssignmentOperator(), isMoveAssignmentOperator())),            cxxDestructorDecl()));  Finder->addMatcher(      cxxMethodDecl(          PrivateSpecialFn,          unless(anyOf(hasBody(stmt()), isDefaulted(), isDeleted(),                       ast_matchers::isTemplateInstantiation(),                       // Ensure that all methods except private special member                       // functions are defined.                       hasParent(cxxRecordDecl(hasMethod(unless(                           anyOf(PrivateSpecialFn, hasBody(stmt()), isPure(),                                 isDefaulted(), isDeleted()))))))))          .bind(SpecialFunction),      this);  Finder->addMatcher(      cxxMethodDecl(isDeleted(), unless(isPublic())).bind(DeletedNotPublic),      this);}

void NonConstReferences::registerMatchers(MatchFinder *Finder) {  Finder->addMatcher(      parmVarDecl(          unless(isInstantiated()),          hasType(references(              qualType(unless(isConstQualified())).bind("referenced_type"))),          unless(hasType(rValueReferenceType())))          .bind("param"),      this);}

void FunctionSizeCheck::registerMatchers(MatchFinder *Finder) {  Finder->addMatcher(      functionDecl(          unless(isInstantiated()),          forEachDescendant(              stmt(unless(compoundStmt()),                   hasParent(stmt(anyOf(compoundStmt(), ifStmt(),                                        anyOf(whileStmt(), doStmt(),                                              forRangeStmt(), forStmt())))))                  .bind("stmt"))).bind("func"),      this);}

voidAvoidCStyleCastsCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {  Finder->addMatcher(      cStyleCastExpr(          // Filter out (EnumType)IntegerLiteral construct, which is generated          // for non-type template arguments of enum types.          // FIXME: Remove this once this is fixed in the AST.          unless(hasParent(substNonTypeTemplateParmExpr())),          // Avoid matches in template instantiations.          unless(isInTemplateInstantiation())).bind("cast"),      this);}

void UnnecessaryValueParamCheck::registerMatchers(MatchFinder *Finder) {  const auto ExpensiveValueParamDecl =      parmVarDecl(hasType(hasCanonicalType(allOf(matchers::isExpensiveToCopy(),                                                 unless(referenceType())))),                  decl().bind("param"));  Finder->addMatcher(      functionDecl(isDefinition(), unless(cxxMethodDecl(isOverride())),                   unless(isInstantiated()),                   has(typeLoc(forEach(ExpensiveValueParamDecl))),                   decl().bind("functionDecl")),      this);}

void NoexceptMoveConstructorCheck::registerMatchers(MatchFinder *Finder) {  // Only register the matchers for C++11; the functionality currently does not  // provide any benefit to other languages, despite being benign.  if (!getLangOpts().CPlusPlus11)    return;  Finder->addMatcher(      cxxMethodDecl(anyOf(cxxConstructorDecl(), hasOverloadedOperatorName("=")),                    unless(isImplicit()), unless(isDeleted()))          .bind("decl"),      this);}

void UnconventionalAssignOperatorCheck::registerMatchers(    ast_matchers::MatchFinder *Finder) {  // Only register the matchers for C++; the functionality currently does not  // provide any benefit to other languages, despite being benign.  if (!getLangOpts().CPlusPlus)    return;  const auto HasGoodReturnType = cxxMethodDecl(returns(lValueReferenceType(      pointee(unless(isConstQualified()),              anyOf(autoType(), hasDeclaration(equalsBoundNode("class")))))));  const auto IsSelf = qualType(      anyOf(hasDeclaration(equalsBoundNode("class")),            referenceType(pointee(hasDeclaration(equalsBoundNode("class"))))));  const auto IsAssign =      cxxMethodDecl(unless(anyOf(isDeleted(), isPrivate(), isImplicit())),                    hasName("operator="), ofClass(recordDecl().bind("class")))          .bind("method");  const auto IsSelfAssign =      cxxMethodDecl(IsAssign, hasParameter(0, parmVarDecl(hasType(IsSelf))))          .bind("method");  Finder->addMatcher(      cxxMethodDecl(IsAssign, unless(HasGoodReturnType)).bind("ReturnType"),      this);  const auto BadSelf = referenceType(      anyOf(lValueReferenceType(pointee(unless(isConstQualified()))),            rValueReferenceType(pointee(isConstQualified()))));  Finder->addMatcher(      cxxMethodDecl(IsSelfAssign,                    hasParameter(0, parmVarDecl(hasType(BadSelf))))          .bind("ArgumentType"),      this);  Finder->addMatcher(      cxxMethodDecl(IsSelfAssign, anyOf(isConst(), isVirtual())).bind("cv"),      this);  const auto IsBadReturnStatement = returnStmt(unless(has(ignoringParenImpCasts(      anyOf(unaryOperator(hasOperatorName("*"), hasUnaryOperand(cxxThisExpr())),            cxxOperatorCallExpr(argumentCountIs(1),                                callee(unresolvedLookupExpr()),                                hasArgument(0, cxxThisExpr())))))));  const auto IsGoodAssign = cxxMethodDecl(IsAssign, HasGoodReturnType);  Finder->addMatcher(returnStmt(IsBadReturnStatement, forFunction(IsGoodAssign))                         .bind("returnStmt"),                     this);}

void ExceptionBaseclassCheck::registerMatchers(MatchFinder *Finder) {  if (!getLangOpts().CPlusPlus)    return;  Finder->addMatcher(      cxxThrowExpr(allOf(has(expr(unless(hasType(qualType(hasCanonicalType(                             hasDeclaration(cxxRecordDecl(isSameOrDerivedFrom(                                 hasName("std::exception")))))))))),                         has(expr(unless(cxxUnresolvedConstructExpr()))),                         eachOf(has(expr(hasType(namedDecl().bind("decl")))),                                anything())))          .bind("bad_throw"),      this);}

/*{{{  start link threads */static void start_link_threads(int index, char *argv){ int	linkno, channel;  unless (sscanf(argv, "%d.%d", &linkno, &channel) == 2)   Fatal("invalid link specification %s", argv);  NumberThreads++;  unless(Fork(StackSize, &link_receiver, 3 * sizeof(int), index, linkno, channel))   Fatal("out of memory starting receiver for link %d", linkno);  NumberThreads++;  unless(Fork(StackSize, &link_sender, 3 * sizeof(int), index, linkno, channel+1))   Fatal("out of memory starting sender for link %d", linkno);}

void InefficientAlgorithmCheck::registerMatchers(MatchFinder *Finder) {  // Only register the matchers for C++; the functionality currently does not  // provide any benefit to other languages, despite being benign.  if (!getLangOpts().CPlusPlus)    return;  const std::string Algorithms =      "^::std::(find|count|equal_range|lower_bound|upper_bound)$";  const auto ContainerMatcher = classTemplateSpecializationDecl(      matchesName("^::std::(unordered_)?(multi)?(set|map)$"));  const auto Matcher =      callExpr(          callee(functionDecl(matchesName(Algorithms))),          hasArgument(              0, constructExpr(has(memberCallExpr(                     callee(methodDecl(hasName("begin"))),                     on(declRefExpr(                            hasDeclaration(decl().bind("IneffContObj")),                            anyOf(hasType(ContainerMatcher.bind("IneffCont")),                                  hasType(pointsTo(                                      ContainerMatcher.bind("IneffContPtr")))))                            .bind("IneffContExpr")))))),          hasArgument(1, constructExpr(has(memberCallExpr(                             callee(methodDecl(hasName("end"))),                             on(declRefExpr(hasDeclaration(                                 equalsBoundNode("IneffContObj")))))))),          hasArgument(2, expr().bind("AlgParam")),          unless(isInTemplateInstantiation()))          .bind("IneffAlg");  Finder->addMatcher(Matcher, this);}

void ExplicitConstructorCheck::registerMatchers(MatchFinder *Finder) {  // Only register the matchers for C++; the functionality currently does not  // provide any benefit to other languages, despite being benign.  if (getLangOpts().CPlusPlus)    Finder->addMatcher(        cxxConstructorDecl(unless(isInstantiated())).bind("ctor"), this);}

void ProBoundsArrayToPointerDecayCheck::registerMatchers(MatchFinder *Finder) {  if (!getLangOpts().CPlusPlus)    return;  // The only allowed array to pointer decay  // 1) just before array subscription  // 2) inside a range-for over an array  // 3) if it converts a string literal to a pointer  Finder->addMatcher(      implicitCastExpr(unless(hasParent(arraySubscriptExpr())),                       unless(hasParentIgnoringImpCasts(explicitCastExpr())),                       unless(isInsideOfRangeBeginEndStmt()),                       unless(hasSourceExpression(stringLiteral())))          .bind("cast"),      this);}

void ShrinkToFitCheck::registerMatchers(MatchFinder *Finder) {  // Swap as a function need not to be considered, because rvalue can not  // be bound to a non-const reference.  const auto ShrinkableAsMember =      memberExpr(member(valueDecl().bind("ContainerDecl")));  const auto ShrinkableAsDecl =      declRefExpr(hasDeclaration(valueDecl().bind("ContainerDecl")));  const auto CopyCtorCall = constructExpr(      hasArgument(0, anyOf(ShrinkableAsMember, ShrinkableAsDecl,                           unaryOperator(has(ShrinkableAsMember)),                           unaryOperator(has(ShrinkableAsDecl)))));  const auto SwapParam = expr(anyOf(      memberExpr(member(equalsBoundNode("ContainerDecl"))),      declRefExpr(hasDeclaration(equalsBoundNode("ContainerDecl"))),      unaryOperator(has(memberExpr(member(equalsBoundNode("ContainerDecl"))))),      unaryOperator(          has(declRefExpr(hasDeclaration(equalsBoundNode("ContainerDecl")))))));  Finder->addMatcher(      memberCallExpr(on(hasType(namedDecl(stlShrinkableContainer()))),                     callee(methodDecl(hasName("swap"))),                     has(memberExpr(hasDescendant(CopyCtorCall))),                     hasArgument(0, SwapParam.bind("ContainerToShrink")),                     unless(isInTemplateInstantiation()))          .bind("CopyAndSwapTrick"),      this);}

void ProBoundsPointerArithmeticCheck::registerMatchers(MatchFinder *Finder) {  if (!getLangOpts().CPlusPlus)    return;  // Flag all operators +, -, +=, -=, ++, -- that result in a pointer  Finder->addMatcher(      binaryOperator(          anyOf(hasOperatorName("+"), hasOperatorName("-"),                hasOperatorName("+="), hasOperatorName("-=")),          hasType(pointerType()),          unless(hasLHS(ignoringImpCasts(declRefExpr(to(isImplicit()))))))          .bind("expr"),      this);  Finder->addMatcher(      unaryOperator(anyOf(hasOperatorName("++"), hasOperatorName("--")),                    hasType(pointerType()))          .bind("expr"),      this);  // Array subscript on a pointer (not an array) is also pointer arithmetic  Finder->addMatcher(      arraySubscriptExpr(          hasBase(ignoringImpCasts(              anyOf(hasType(pointerType()),                    hasType(decayedType(hasDecayedType(pointerType())))))))          .bind("expr"),      this);}

void FasterStringFindCheck::registerMatchers(MatchFinder *Finder) {  if (!getLangOpts().CPlusPlus)    return;  const auto SingleChar =      expr(ignoringParenCasts(stringLiteral(hasSize(1)).bind("literal")));  const auto StringFindFunctions =      anyOf(hasName("find"), hasName("rfind"), hasName("find_first_of"),            hasName("find_first_not_of"), hasName("find_last_of"),            hasName("find_last_not_of"));  llvm::Optional<ast_matchers::internal::Matcher<NamedDecl>> IsStringClass;  for (const auto &ClassName : StringLikeClasses) {    const auto HasName = hasName(ClassName);    IsStringClass = IsStringClass ? anyOf(*IsStringClass, HasName) : HasName;  }  if (IsStringClass) {    Finder->addMatcher(        cxxMemberCallExpr(            callee(functionDecl(StringFindFunctions).bind("func")),            anyOf(argumentCountIs(1), argumentCountIs(2)),            hasArgument(0, SingleChar),            on(expr(hasType(recordDecl(*IsStringClass)),                    unless(hasSubstitutedType())))),        this);  }}

void UseNodiscardCheck::registerMatchers(MatchFinder *Finder) {  // If we use ``[[nodiscard]]`` attribute, we require at least C++17. Use a  // macro or ``__attribute__`` with pre c++17 compilers by using  // ReplacementString option.  if ((NoDiscardMacro == "[[nodiscard]]" && !getLangOpts().CPlusPlus17) ||      !getLangOpts().CPlusPlus)    return;  auto FunctionObj =      cxxRecordDecl(hasAnyName("::std::function", "::boost::function"));  // Find all non-void const methods which have not already been marked to  // warn on unused result.  Finder->addMatcher(      cxxMethodDecl(          allOf(isConst(), isDefinitionOrInline(),                unless(anyOf(                    returns(voidType()), isNoReturn(), isOverloadedOperator(),                    isVariadic(), hasTemplateReturnType(),                    hasClassMutableFields(), isConversionOperator(),                    hasAttr(clang::attr::WarnUnusedResult),                    hasType(isInstantiationDependentType()),                    hasAnyParameter(anyOf(                        parmVarDecl(anyOf(hasType(FunctionObj),                                          hasType(references(FunctionObj)))),                        hasType(isNonConstReferenceOrPointer()),                        hasParameterPack()))))))          .bind("no_discard"),      this);}

void ProTypeCstyleCastCheck::registerMatchers(MatchFinder *Finder) {  if (!getLangOpts().CPlusPlus)    return;  Finder->addMatcher(      cStyleCastExpr(unless(isInTemplateInstantiation())).bind("cast"), this);}