Merge pull request #35 from sx-aurora-dev/feature/merge-upstream-20210212

Feature/merge upstream 20210212

Author: kaz7

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(