Feature/merge upstream 20210212

clang-tools-extra/clang-include-fixer/SymbolIndexManager.cpp

@@ -149,6 +149,7 @@ SymbolIndexManager::search(llvm::StringRef Identifier,
   rank(MatchedSymbols, FileName);
   // Strip signals, they are no longer needed.
   std::vector<SymbolInfo> Res;
+  Res.reserve(MatchedSymbols.size());
   for (auto &SymAndSig : MatchedSymbols)
     Res.push_back(std::move(SymAndSig.Symbol));
   return Res;

clang-tools-extra/clang-tidy/bugprone/InfiniteLoopCheck.cpp

@@ -21,9 +21,9 @@ namespace bugprone {
 
 static internal::Matcher<Stmt>
 loopEndingStmt(internal::Matcher<Stmt> Internal) {
-  return stmt(anyOf(breakStmt(Internal), returnStmt(Internal),
-                    gotoStmt(Internal), cxxThrowExpr(Internal),
-                    callExpr(Internal, callee(functionDecl(isNoReturn())))));
+  return stmt(anyOf(
+      mapAnyOf(breakStmt, returnStmt, gotoStmt, cxxThrowExpr).with(Internal),
+      callExpr(Internal, callee(functionDecl(isNoReturn())))));
 }
 
 /// Return whether `Var` was changed in `LoopStmt`.
@@ -122,8 +122,8 @@ void InfiniteLoopCheck::registerMatchers(MatchFinder *Finder) {
       unless(hasBody(hasDescendant(
           loopEndingStmt(forFunction(equalsBoundNode("func")))))));
 
-  Finder->addMatcher(stmt(anyOf(whileStmt(LoopCondition), doStmt(LoopCondition),
-                                forStmt(LoopCondition)))
+  Finder->addMatcher(mapAnyOf(whileStmt, doStmt, forStmt)
+                         .with(LoopCondition)
                          .bind("loop-stmt"),
                      this);
 }

clang-tools-extra/clang-tidy/bugprone/SpuriouslyWakeUpFunctionsCheck.cpp

@@ -59,34 +59,20 @@ void SpuriouslyWakeUpFunctionsCheck::registerMatchers(MatchFinder *Finder) {
   if (getLangOpts().CPlusPlus) {
     // Check for `CON54-CPP`
     Finder->addMatcher(
-        ifStmt(
-            allOf(HasWaitDescendantCpp,
-                  unless(anyOf(hasDescendant(ifStmt(HasWaitDescendantCpp)),
-                               hasDescendant(whileStmt(HasWaitDescendantCpp)),
-                               hasDescendant(forStmt(HasWaitDescendantCpp)),
-                               hasDescendant(doStmt(HasWaitDescendantCpp)))))
-
-                ),
+        ifStmt(HasWaitDescendantCpp,
+               unless(hasDescendant(mapAnyOf(ifStmt, whileStmt, forStmt, doStmt)
+                                        .with(HasWaitDescendantCpp)))),
         this);
   } else {
     // Check for `CON36-C`
     Finder->addMatcher(
-        ifStmt(
-            allOf(HasWaitDescendantC,
-                  unless(anyOf(hasDescendant(ifStmt(HasWaitDescendantC)),
-                               hasDescendant(whileStmt(HasWaitDescendantC)),
-                               hasDescendant(forStmt(HasWaitDescendantC)),
-                               hasDescendant(doStmt(HasWaitDescendantC)),
-                               hasParent(whileStmt()),
-                               hasParent(compoundStmt(hasParent(whileStmt()))),
-                               hasParent(forStmt()),
-                               hasParent(compoundStmt(hasParent(forStmt()))),
-                               hasParent(doStmt()),
-                               hasParent(compoundStmt(hasParent(doStmt())))))
-
-                      ))
-
-            ,
+        ifStmt(HasWaitDescendantC,
+               unless(anyOf(
+                   hasDescendant(mapAnyOf(ifStmt, whileStmt, forStmt, doStmt)
+                                     .with(HasWaitDescendantC)),
+                   hasParent(mapAnyOf(whileStmt, forStmt, doStmt)),
+                   hasParent(compoundStmt(
+                       hasParent(mapAnyOf(whileStmt, forStmt, doStmt))))))),
         this);
   }
 }

clang-tools-extra/clang-tidy/bugprone/SuspiciousStringCompareCheck.cpp

@@ -113,10 +113,8 @@ void SuspiciousStringCompareCheck::registerMatchers(MatchFinder *Finder) {
     // Detect suspicious calls to string compare:
     //     'if (strcmp())'  ->  'if (strcmp() != 0)'
     Finder->addMatcher(
-        stmt(anyOf(ifStmt(hasCondition(StringCompareCallExpr)),
-                   whileStmt(hasCondition(StringCompareCallExpr)),
-                   doStmt(hasCondition(StringCompareCallExpr)),
-                   forStmt(hasCondition(StringCompareCallExpr)),
+        stmt(anyOf(mapAnyOf(ifStmt, whileStmt, doStmt, forStmt)
+                       .with(hasCondition(StringCompareCallExpr)),
                    binaryOperator(hasAnyOperatorName("&&", "||"),
                                   hasEitherOperand(StringCompareCallExpr))))
             .bind("missing-comparison"),

clang-tools-extra/clang-tidy/bugprone/UnhandledSelfAssignmentCheck.cpp

@@ -40,12 +40,9 @@ void UnhandledSelfAssignmentCheck::registerMatchers(MatchFinder *Finder) {
 
   // Self-check: Code compares something with 'this' pointer. We don't check
   // whether it is actually the parameter what we compare.
-  const auto HasNoSelfCheck = cxxMethodDecl(unless(anyOf(
-      hasDescendant(binaryOperator(hasAnyOperatorName("==", "!="),
-                                   has(ignoringParenCasts(cxxThisExpr())))),
-      hasDescendant(cxxOperatorCallExpr(
-          hasAnyOverloadedOperatorName("==", "!="), argumentCountIs(2),
-          has(ignoringParenCasts(cxxThisExpr())))))));
+  const auto HasNoSelfCheck = cxxMethodDecl(unless(hasDescendant(
+      binaryOperation(hasAnyOperatorName("==", "!="),
+                      hasEitherOperand(ignoringParenCasts(cxxThisExpr()))))));
 
   // Both copy-and-swap and copy-and-move method creates a copy first and
   // assign it to 'this' with swap or move.

clang-tools-extra/clang-tidy/bugprone/UseAfterMoveCheck.cpp

@@ -310,9 +310,7 @@ void UseAfterMoveFinder::getReinits(
                // Assignment. In addition to the overloaded assignment operator,
                // test for built-in assignment as well, since template functions
                // may be instantiated to use std::move() on built-in types.
-               binaryOperator(hasOperatorName("="), hasLHS(DeclRefMatcher)),
-               cxxOperatorCallExpr(hasOverloadedOperatorName("="),
-                                   hasArgument(0, DeclRefMatcher)),
+               binaryOperation(hasOperatorName("="), hasLHS(DeclRefMatcher)),
                // Declaration. We treat this as a type of reinitialization too,
                // so we don't need to treat it separately.
                declStmt(hasDescendant(equalsNode(MovedVariable))),

clang-tools-extra/clang-tidy/cert/MutatingCopyCheck.cpp

@@ -30,22 +30,16 @@ void MutatingCopyCheck::registerMatchers(MatchFinder *Finder) {
             MemberExprOrSourceObject);
 
   const auto IsSourceMutatingAssignment = traverse(
-      TK_AsIs,
-      expr(anyOf(binaryOperator(isAssignmentOperator(), hasLHS(IsPartOfSource))
-                     .bind(MutatingOperatorName),
-                 cxxOperatorCallExpr(isAssignmentOperator(),
-                                     hasArgument(0, IsPartOfSource))
-                     .bind(MutatingOperatorName))));
+      TK_AsIs, binaryOperation(hasOperatorName("="), hasLHS(IsPartOfSource))
+                   .bind(MutatingOperatorName));
 
   const auto MemberExprOrSelf = anyOf(memberExpr(), cxxThisExpr());
 
   const auto IsPartOfSelf = allOf(
       unless(hasDescendant(expr(unless(MemberExprOrSelf)))), MemberExprOrSelf);
 
   const auto IsSelfMutatingAssignment =
-      expr(anyOf(binaryOperator(isAssignmentOperator(), hasLHS(IsPartOfSelf)),
-                 cxxOperatorCallExpr(isAssignmentOperator(),
-                                     hasArgument(0, IsPartOfSelf))));
+      binaryOperation(isAssignmentOperator(), hasLHS(IsPartOfSelf));
 
   const auto IsSelfMutatingMemberFunction =
       functionDecl(hasBody(hasDescendant(IsSelfMutatingAssignment)));

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidGotoCheck.cpp

@@ -29,10 +29,8 @@ void AvoidGotoCheck::registerMatchers(MatchFinder *Finder) {
 
   // Check if the 'goto' is used for control flow other than jumping
   // out of a nested loop.
-  auto Loop = stmt(anyOf(forStmt(), cxxForRangeStmt(), whileStmt(), doStmt()));
-  auto NestedLoop =
-      stmt(anyOf(forStmt(hasAncestor(Loop)), cxxForRangeStmt(hasAncestor(Loop)),
-                 whileStmt(hasAncestor(Loop)), doStmt(hasAncestor(Loop))));
+  auto Loop = mapAnyOf(forStmt, cxxForRangeStmt, whileStmt, doStmt);
+  auto NestedLoop = Loop.with(hasAncestor(Loop));
 
   Finder->addMatcher(gotoStmt(anyOf(unless(hasAncestor(NestedLoop)),
                                     unless(isForwardJumping())))

clang-tools-extra/clang-tidy/google/AvoidUnderscoreInGoogletestNameCheck.h

@@ -17,7 +17,7 @@ namespace google {
 namespace readability {
 
 // Check for underscores in the names of googletest tests, per
-// https://github.com/google/googletest/blob/master/googletest/docs/faq.md#why-should-test-suite-names-and-test-names-not-contain-underscore
+// https://github.com/google/googletest/blob/master/docs/faq.md#why-should-test-suite-names-and-test-names-not-contain-underscore
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/google-readability-avoid-underscore-in-googletest-name.html

clang-tools-extra/clang-tidy/llvm/PreferIsaOrDynCastInConditionalsCheck.cpp

@@ -47,8 +47,9 @@ void PreferIsaOrDynCastInConditionalsCheck::registerMatchers(
               allOf(callee(namedDecl(hasAnyName("isa", "cast", "cast_or_null",
                                                 "dyn_cast", "dyn_cast_or_null"))
                                .bind("func")),
-                    hasArgument(0, anyOf(declRefExpr().bind("arg"),
-                                         cxxMemberCallExpr().bind("arg"))))))
+                    hasArgument(
+                        0,
+                        mapAnyOf(declRefExpr, cxxMemberCallExpr).bind("arg")))))
           .bind("rhs");
 
   Finder->addMatcher(

clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp

@@ -188,11 +188,6 @@ StatementMatcher makeIteratorLoopMatcher(bool IsReverse) {
   StatementMatcher IteratorComparisonMatcher = expr(
       ignoringParenImpCasts(declRefExpr(to(varDecl().bind(ConditionVarName)))));
 
-  auto OverloadedNEQMatcher = ignoringImplicit(
-      cxxOperatorCallExpr(hasOverloadedOperatorName("!="), argumentCountIs(2),
-                          hasArgument(0, IteratorComparisonMatcher),
-                          hasArgument(1, IteratorBoundMatcher)));
-
   // This matcher tests that a declaration is a CXXRecordDecl that has an
   // overloaded operator*(). If the operator*() returns by value instead of by
   // reference then the return type is tagged with DerefByValueResultName.
@@ -216,14 +211,9 @@ StatementMatcher makeIteratorLoopMatcher(bool IsReverse) {
                                         containsDeclaration(0, InitDeclMatcher),
                                         containsDeclaration(1, EndDeclMatcher)),
                                declStmt(hasSingleDecl(InitDeclMatcher)))),
-             hasCondition(
-                 anyOf(binaryOperator(hasOperatorName("!="),
-                                      hasLHS(IteratorComparisonMatcher),
-                                      hasRHS(IteratorBoundMatcher)),
-                       binaryOperator(hasOperatorName("!="),
-                                      hasLHS(IteratorBoundMatcher),
-                                      hasRHS(IteratorComparisonMatcher)),
-                       OverloadedNEQMatcher)),
+             hasCondition(ignoringImplicit(binaryOperation(
+                 hasOperatorName("!="), hasOperands(IteratorComparisonMatcher,
+                                                    IteratorBoundMatcher)))),
              hasIncrement(anyOf(
                  unaryOperator(hasOperatorName("++"),
                                hasUnaryOperand(declRefExpr(
@@ -722,10 +712,11 @@ StringRef LoopConvertCheck::getContainerString(ASTContext *Context,
   if (isa<CXXThisExpr>(ContainerExpr)) {
     ContainerString = "this";
   } else {
-    // For CXXOperatorCallExpr (e.g. vector_ptr->size()), its first argument is
-    // the class object (vector_ptr) we are targeting.
+    // For CXXOperatorCallExpr such as vector_ptr->size() we want the class
+    // object vector_ptr, but for vector[2] we need the whole expression.
     if (const auto* E = dyn_cast<CXXOperatorCallExpr>(ContainerExpr))
-      ContainerExpr = E->getArg(0);
+      if (E->getOperator() != OO_Subscript)
+        ContainerExpr = E->getArg(0);
     ContainerString =
         getStringFromRange(Context->getSourceManager(), Context->getLangOpts(),
                            ContainerExpr->getSourceRange());

clang-tools-extra/clang-tidy/modernize/UseEqualsDefaultCheck.cpp

@@ -183,15 +183,10 @@ static bool isCopyAssignmentAndCanBeDefaulted(ASTContext *Context,
     auto LHS = memberExpr(hasObjectExpression(cxxThisExpr()),
                           member(fieldDecl(equalsNode(Field))));
     auto RHS = accessToFieldInVar(Field, Param);
-    if (match(
-            traverse(TK_AsIs,
-                     compoundStmt(has(ignoringParenImpCasts(stmt(anyOf(
-                         binaryOperator(hasOperatorName("="), hasLHS(LHS),
-                                        hasRHS(RHS)),
-                         cxxOperatorCallExpr(
-                             hasOverloadedOperatorName("="), argumentCountIs(2),
-                             hasArgument(0, LHS), hasArgument(1, RHS)))))))),
-            *Compound, *Context)
+    if (match(traverse(TK_AsIs,
+                       compoundStmt(has(ignoringParenImpCasts(binaryOperation(
+                           hasOperatorName("="), hasLHS(LHS), hasRHS(RHS)))))),
+              *Compound, *Context)
             .empty())
       return false;
   }

clang-tools-extra/clang-tidy/modernize/UseNullptrCheck.cpp

@@ -41,12 +41,28 @@ StatementMatcher makeCastSequenceMatcher() {
       unless(hasImplicitDestinationType(qualType(substTemplateTypeParmType()))),
       unless(hasSourceExpression(hasType(sugaredNullptrType()))));
 
+  auto IsOrHasDescendant = [](auto InnerMatcher) {
+    return anyOf(InnerMatcher, hasDescendant(InnerMatcher));
+  };
+
   return traverse(
       TK_AsIs,
-      castExpr(anyOf(ImplicitCastToNull,
-                     explicitCastExpr(hasDescendant(ImplicitCastToNull))),
-               unless(hasAncestor(explicitCastExpr())))
-          .bind(CastSequence));
+      anyOf(castExpr(anyOf(ImplicitCastToNull,
+                           explicitCastExpr(hasDescendant(ImplicitCastToNull))),
+                     unless(hasAncestor(explicitCastExpr())),
+                     unless(hasAncestor(cxxRewrittenBinaryOperator())))
+                .bind(CastSequence),
+            cxxRewrittenBinaryOperator(
+                // Match rewritten operators, but verify (in the check method)
+                // that if an implicit cast is found, it is not from another
+                // nested rewritten operator.
+                expr().bind("matchBinopOperands"),
+                hasEitherOperand(IsOrHasDescendant(
+                    implicitCastExpr(
+                        ImplicitCastToNull,
+                        hasAncestor(cxxRewrittenBinaryOperator().bind(
+                            "checkBinopOperands")))
+                        .bind(CastSequence))))));
 }
 
 bool isReplaceableRange(SourceLocation StartLoc, SourceLocation EndLoc,
@@ -480,6 +496,11 @@ void UseNullptrCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *NullCast = Result.Nodes.getNodeAs<CastExpr>(CastSequence);
   assert(NullCast && "Bad Callback. No node provided");
 
+  if (Result.Nodes.getNodeAs<CXXRewrittenBinaryOperator>(
+          "matchBinopOperands") !=
+      Result.Nodes.getNodeAs<CXXRewrittenBinaryOperator>("checkBinopOperands"))
+    return;
+
   // Given an implicit null-ptr cast or an explicit cast with an implicit
   // null-to-pointer cast within use CastSequenceVisitor to identify sequences
   // of explicit casts that can be converted into 'nullptr'.

clang-tools-extra/clang-tidy/mpi/TypeMismatchCheck.cpp

@@ -228,7 +228,7 @@ static bool isTypedefTypeMatching(const TypedefType *const Typedef,
 /// Get the unqualified, dereferenced type of an argument.
 ///
 /// \param CE call expression
-/// \param idx argument index
+/// \param Idx argument index
 ///
 /// \returns type of the argument
 static const Type *argumentType(const CallExpr *const CE, const size_t Idx) {

clang-tools-extra/clang-tidy/performance/MoveConstArgCheck.cpp

@@ -47,13 +47,11 @@ void MoveConstArgCheck::registerMatchers(MatchFinder *Finder) {
 
   Finder->addMatcher(MoveCallMatcher, this);
 
-  auto ConstParamMatcher = forEachArgumentWithParam(
-      MoveCallMatcher, parmVarDecl(hasType(references(isConstQualified()))));
-
-  Finder->addMatcher(callExpr(ConstParamMatcher).bind("receiving-expr"), this);
   Finder->addMatcher(
-      traverse(TK_AsIs,
-               cxxConstructExpr(ConstParamMatcher).bind("receiving-expr")),
+      invocation(forEachArgumentWithParam(
+                     MoveCallMatcher,
+                     parmVarDecl(hasType(references(isConstQualified())))))
+          .bind("receiving-expr"),
       this);
 }