[clang-tidy] add new check readability-use-anyofallof

[mgehre]

Summary

Finds range-based for loops that can be replaced by a call to std::any_of` or
std::all_of. In C++ 20 mode, suggests std::ranges::any_of or
std::ranges::all_of.
For now, no fixits are produced.

[Eugene.Zelenko]

clang-tools-extra/clang-tidy/readability/UseAnyOfAllOfCheck.cpp

27

Please don't use auto unless type is spelled in same statement or iterator.

56

Must be in isLanguageVersionSupported() method.

111

Unnecessary empty line.

clang-tools-extra/docs/ReleaseNotes.rst

135

Please enclose std::any_of and std::all_of in double back-ticks.

[njames93]

As no FixIts are made the IncludeInserter can be removed.

I'm struggling to see the value of this check though. If it was reworked to check for loop in the middle of a function it would have a lot more value.

bool all_of = true;
for (auto X : V) {
  if (!X) {
    all_of = false;
    break;
  }
}

Being able to identify those and possibly even transform them would have much more value

bool all_of = std::all_of(std::begin(V), std::end(V), [](const auto &X) { return static_cast<bool>(X) });

I'm guessing you'd want to check for compound statements that have a bool VarDecl with an init just before the range for loop and a condition in the loop that flips the value and then breaks after.

clang-tools-extra/clang-tidy/readability/UseAnyOfAllOfCheck.cpp

22–42

This should be in an anonymous namespace as it doesn't need external linkage. Probably shouldn't be in the ast_matchers namespace either

35

nit: const auto *I = llvm::find(C->body(), &Node);

[Eugene.Zelenko]

See also suggestion for more generic loop-to-algorithm transformations.

[mgehre]

In D77572#1965143, @njames93 wrote:

I'm struggling to see the value of this check though. If it was reworked to check for loop in the middle of a function it would have a lot more value.

This is (just) a first step. The next step is to detect the local variable case as you also described it. Note that this also catches functions
that do some preprocessing and end with a any_of-style loop.
I also have a local branch that generates fixits, but they add quite some code, so I wanted to put them in a separate PR.

In LLVM & clang, the check in this PR already emits 370 unique warnings.

readability-use-anyofallof.log3 MBDownload

[mgehre]

Review comments

[mgehre]

Review comments

[njames93]

In D77572#1967956, @mgehre wrote:

In D77572#1965143, @njames93 wrote:

I'm struggling to see the value of this check though. If it was reworked to check for loop in the middle of a function it would have a lot more value.

This is (just) a first step. The next step is to detect the local variable case as you also described it. Note that this also catches functions
that do some preprocessing and end with a any_of-style loop.
I also have a local branch that generates fixits, but they add quite some code, so I wanted to put them in a separate PR.

In LLVM & clang, the check in this PR already emits 370 unique warnings.

Take this example from TableGen/Record.cpp:

bool CondOpInit::isConcrete() const {
  for (const Init *Case : getConds())
    if (!Case->isConcrete())
      return false;

  for (const Init *Val : getVals())
    if (!Val->isConcrete())
      return false;

  return true;
}

Firstly, the warning is only emitted on the second loop.
Secondly how does your fix it code handle temporaries?
Would it transform to

bool CondOpInit::isConcrete() const {
  for (const Init *Case : getConds())
    if (!Case->isConcrete())
      return false;

  return std::all_of(getVals().begin(), getVals().end(),
                     [](const Init *Val) { return Val->isConcrete(); });
}

I'd argue that it actually makes the code less readable as there are 2 different constructs for the same thing.

[mgehre]

Thanks @njames93, this is a good examples which I did not consider yet. I agree that only transforming
the second loop would make the code worse.

I would argue that a human seeing a warning on the second loop might also realize
that the first loop can be transformed in a similar way, and possibly combine them into

return llvm::all_of(getConds(), [](const Init *Cond) { return Val->isConcrete(); }) && llvm::all_of(getVals(), [](const Init *Val) { return Val->isConcrete(); });

or

auto IsConcrete = [](auto Init* I) { return I->isConcrete(); };
return llvm::all_of(getConds(), IsConcrete) && llvm::all_of(getVals(), IsConcrete);

(I was wondering whether the check should have an option to suggest llvm::all_of (or boost::algorithm::all_of, ...) instead of std::all_of, but
I thought that this could go into another PR.)

I have the feeling that extracting code into algorithms is generally a hard topic,
and automatic fixits would possible give a false sense of automatism (at least at the current point).
Your example is a good reminder of that.

Personally, clang-tidy has been a good source of learning C++ best practices. And I hope that this clang-tidy check would help
me and my coworkers to remember using those algorithms.

Are you saying that this check should not land unless its scope is extended? What would be the minimal scope making this check
worth-while to land?

[njames93]

Right now it would be a great candidate for this - http://lists.llvm.org/pipermail/cfe-dev/2020-March/064980.html, however in its current state I wouldn't say its ready to get the green light right now.
No point worrying about the fix-its yet, but when it is time, could add options for RangeAllOfName, RangeAnyOfName, RangeNoneOfName, AlgorithmHeader.
Gonna throw it out there that generating that templated lambda automatically... just don't :)

[mgehre]

Thanks for the comments so far.
I'm a bit lost now. Which changes that cannot wait for the next PR do you see necessary to get this check merged?

[mgehre]

Ping :-)
I'm looking for directions on what the next steps are.

[aaron.ballman]

In D77572#1981871, @mgehre wrote:

Thanks for the comments so far.
I'm a bit lost now. Which changes that cannot wait for the next PR do you see necessary to get this check merged?

I'd be curious to know what @njames93 thinks -- I spot-checked the diagnostics you attached earlier (thank you for those!) and all of them seemed reasonable to me, which suggests there's not an extraordinary amount of false positives. The functionality seems useful in its current state, though as you point out, there are improvements you want to make in follow-up patches. That seems reasonable to me.

clang-tools-extra/clang-tidy/readability/UseAnyOfAllOfCheck.cpp

23–25

It looks like these comments got formatted a bit strangely -- probably should re-flow them.

37

I think the comment should turn into a string literal that's part of the assertion.

62

Should we reject other ways to break out of the loop, like goto or throw?

99

clang-tidy diagnostics don't start with a capital letter, and I'd probably drop the from <algorithm> part under the assumption the user can figure out the header pretty easily from the diagnostic wording. Also, you should put single quotes around the std%0::any_of(). Similar below.

[mgehre]

Aaron, thank you very much for taking the time to review this PR.

clang-tools-extra/clang-tidy/readability/UseAnyOfAllOfCheck.cpp

62

I think throw statements still can be transformed. We cannot transform break because the loop is gone and we cannot transform goto because we cannot jump from the lambda into its caller.
But we can keep throw statements because exceptions can propagate from the lambda through the algorithm back into the original caller. If we could not allow throw statements, we would also have to disallow any other kind of call statements.

[mgehre]

Fix comments

[aaron.ballman]

LGTM, though please wait a bit for @njames93 to speak up if they still have concerns.

clang-tools-extra/clang-tidy/readability/UseAnyOfAllOfCheck.cpp

62

Ah, good point on throw, thank you!

[njames93]

LGMT, just a few minor nits though.

clang-tools-extra/clang-tidy/readability/UseAnyOfAllOfCheck.cpp

15–16

Fairly certain these headers aren't used

clang-tools-extra/clang-tidy/readability/UseAnyOfAllOfCheck.h

30

std::all_of, std::any_of and std::none_of were only introduced in c++11, maybe CPlusPlus11 should be the minimum requirement.

clang-tools-extra/docs/ReleaseNotes.rst

202

This removed line in unrelated and should be added back

[mgehre]

Implemented njames93's comments

[gribozavr2]

This change broke the build: http://lab.llvm.org:8011/builders/clang-x86_64-debian-fast/builds/29716. The build is already fixed by https://github.com/llvm/llvm-project/commit/fd2740143e626ca32432aac0b51b2880a3b1e0bc.

Please always run ninja check-all before pushing commits. Thanks!

[RKSimon]

@mgehre Please can you take at the remaining buildbot failures here : http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-ubuntu-fast/builds/68662

[njames93]

In D77572#2071045, @RKSimon wrote:

@mgehre Please can you take at the remaining buildbot failures here : http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-ubuntu-fast/builds/68662

Pushed a fix for that too. https://github.com/llvm/llvm-project/commit/6780be4c63e582466a35d7644c35e09ba85d4f67

[mgehre]

Sorry for breaking the build and thanks for the fixes!

clang-tools-extra/clang-tidy/readability/CMakeLists.txt

add_clang_library(clangTidyReadabilityModule
   RedundantStringInitCheck.cpp
   SimplifyBooleanExprCheck.cpp
   SimplifySubscriptExprCheck.cpp
   StaticAccessedThroughInstanceCheck.cpp
   StaticDefinitionInAnonymousNamespaceCheck.cpp
   StringCompareCheck.cpp
   UniqueptrDeleteReleaseCheck.cpp
   UppercaseLiteralSuffixCheck.cpp
+  UseAnyOfAllOfCheck.cpp
 
   LINK_LIBS
+  clangAnalysis
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTidyUtils
   clangTooling
   )

clang-tools-extra/clang-tidy/readability/ReadabilityTidyModule.cpp

 //===--- ReadabilityTidyModule.cpp - clang-tidy ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 

 #include "RedundantStringInitCheck.h"
 #include "SimplifyBooleanExprCheck.h"
 #include "SimplifySubscriptExprCheck.h"
 #include "StaticAccessedThroughInstanceCheck.h"
 #include "StaticDefinitionInAnonymousNamespaceCheck.h"
 #include "StringCompareCheck.h"
 #include "UniqueptrDeleteReleaseCheck.h"
 #include "UppercaseLiteralSuffixCheck.h"
+#include "UseAnyOfAllOfCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
 class ReadabilityModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<RedundantStringInitCheck>(
         "readability-redundant-string-init");
     CheckFactories.registerCheck<SimplifyBooleanExprCheck>(
         "readability-simplify-boolean-expr");
     CheckFactories.registerCheck<UniqueptrDeleteReleaseCheck>(
         "readability-uniqueptr-delete-release");
     CheckFactories.registerCheck<UppercaseLiteralSuffixCheck>(
         "readability-uppercase-literal-suffix");
+    CheckFactories.registerCheck<UseAnyOfAllOfCheck>(
+        "readability-use-anyofallof");
   }
 };
 
 // Register the ReadabilityModule using this statically initialized variable.
 static ClangTidyModuleRegistry::Add<ReadabilityModule>
     X("readability-module", "Adds readability-related checks.");
 
 } // namespace readability
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the ReadabilityModule.
 volatile int ReadabilityModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/readability/UseAnyOfAllOfCheck.h

+//===--- UseAnyOfAllOfCheck.h - clang-tidy-----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_USEALGORITHMCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_USEALGORITHMCHECK_H
+
+#include "../ClangTidy.h"
+#include "../utils/IncludeInserter.h"
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+/// Finds ranged-based for loops that can be replaced by a call to std::any_of
+/// or std::all_of.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/readability-use-anyofallof.html
+class UseAnyOfAllOfCheck : public ClangTidyCheck {
+public:
+  using ClangTidyCheck::ClangTidyCheck;
+
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
+    return LangOpts.CPlusPlus;
+  }
+
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_USEALGORITHMCHECK_H

clang-tools-extra/clang-tidy/readability/UseAnyOfAllOfCheck.cpp

+//===--- UseAnyOfAllOfCheck.cpp - clang-tidy-------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "UseAnyOfAllOfCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Analysis/Analyses/ExprMutationAnalyzer.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include <algorithm>
+#include <string>
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace {
+/// Matches a Stmt whose parent is a CompoundStmt, and which is directly
+/// followed by a Stmt matching the inner matcher.
+AST_MATCHER_P(Stmt, nextStmt, ast_matchers::internal::Matcher<Stmt>,
+              InnerMatcher) {
+  DynTypedNodeList Parents = Finder->getASTContext().getParents(Node);
+  if (Parents.size() != 1)
+    return false;
+
+  auto *C = Parents[0].get<CompoundStmt>();
+  if (!C)
+    return false;
+
+  const auto *I = llvm::find(C->body(), &Node);
+  assert(I != C->body_end() && "C is parent of Node");
+  if (++I == C->body_end())
+    return false; // Node is last statement.
+
+  return InnerMatcher.matches(**I, Finder, Builder);
+}
+} // namespace
+
+namespace tidy {
+namespace readability {
+
+void UseAnyOfAllOfCheck::registerMatchers(MatchFinder *Finder) {
+  auto returns = [](bool V) {
+    return returnStmt(hasReturnValue(cxxBoolLiteral(equals(V))));
+  };
+
+  auto returnsButNotTrue =
+      returnStmt(hasReturnValue(unless(cxxBoolLiteral(equals(true)))));
+  auto returnsButNotFalse =
+      returnStmt(hasReturnValue(unless(cxxBoolLiteral(equals(false)))));
+
+  Finder->addMatcher(
+      cxxForRangeStmt(
+          nextStmt(returns(false).bind("final_return")),
+          hasBody(allOf(hasDescendant(returns(true)),
+                        unless(anyOf(hasDescendant(breakStmt()),
+                                     hasDescendant(gotoStmt()),
+                                     hasDescendant(returnsButNotTrue))))))
+          .bind("any_of_loop"),
+      this);
+
+  Finder->addMatcher(
+      cxxForRangeStmt(
+          nextStmt(returns(true).bind("final_return")),
+          hasBody(allOf(hasDescendant(returns(false)),
+                        unless(anyOf(hasDescendant(breakStmt()),
+                                     hasDescendant(gotoStmt()),
+                                     hasDescendant(returnsButNotFalse))))))
+          .bind("all_of_loop"),
+      this);
+}
+
+static bool isViableLoop(const CXXForRangeStmt &S, ASTContext &Context) {
+
+  ExprMutationAnalyzer Mutations(*S.getBody(), Context);
+  if (Mutations.isMutated(S.getLoopVariable()))
+    return false;
+  const auto Matches =
+      match(findAll(declRefExpr().bind("decl_ref")), *S.getBody(), Context);
+
+  return llvm::none_of(Matches, [&Mutations](auto &DeclRef) {
+    // TODO: allow modifications of loop-local variables
+    return Mutations.isMutated(
+        DeclRef.template getNodeAs<DeclRefExpr>("decl_ref")->getDecl());
+  });
+}
+
+void UseAnyOfAllOfCheck::check(const MatchFinder::MatchResult &Result) {
+  StringRef Ranges = getLangOpts().CPlusPlus2a ? "::ranges" : "";
+
+  if (const auto *S = Result.Nodes.getNodeAs<CXXForRangeStmt>("any_of_loop")) {
+    if (!isViableLoop(*S, *Result.Context))
+      return;
+
+    diag(S->getForLoc(), "replace loop by 'std%0::any_of()'") << Ranges;
+  } else if (const auto *S =
+                 Result.Nodes.getNodeAs<CXXForRangeStmt>("all_of_loop")) {
+    if (!isViableLoop(*S, *Result.Context))
+      return;
+
+    diag(S->getForLoc(), "replace loop by 'std%0::all_of()'") << Ranges;
+  }
+}
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang

clang-tools-extra/docs/ReleaseNotes.rst

- New :doc:`bugprone-misplaced-pointer-arithmetic-in-alloc
   result of a memory allocation function (``malloc()``, ``calloc()``,
   ``realloc()``, ``alloca()``) instead of its argument.
 
 - New :doc:`bugprone-spuriously-wake-up-functions
   <clang-tidy/checks/bugprone-spuriously-wake-up-functions>` check.
 
   Finds ``cnd_wait``, ``cnd_timedwait``, ``wait``, ``wait_for``, or
   ``wait_until`` function calls when the function is not invoked from a loop
-  that checks whether a condition predicate holds or the function has a 
+  that checks whether a condition predicate holds or the function has a
   condition parameter.
 
 - New :doc:`bugprone-reserved-identifier
   <clang-tidy/checks/bugprone-reserved-identifier>` check.
 
   Checks for usages of identifiers reserved for use by the implementation.
 
 - New :doc:`bugprone-suspicious-include
- New :doc:`objc-dealloc-in-category
 
   Finds implementations of -dealloc in Objective-C categories.
 
 - New :doc:`misc-no-recursion
   <clang-tidy/checks/misc-no-recursion>` check.
 
   Finds recursive functions and diagnoses them.
 
+- New :doc:`readability-use-anyofallof
+  <clang-tidy/checks/readability-use-anyofallof>` check.
+
+  Finds range-based for loops that can be replaced by a call to ``std::any_of``
+  or ``std::all_of``.
+
 New check aliases
 ^^^^^^^^^^^^^^^^^
 
 - New alias :doc:`cert-con36-c
   <clang-tidy/checks/cert-con36-c>` to
   :doc:`bugprone-spuriously-wake-up-functions
   <clang-tidy/checks/bugprone-spuriously-wake-up-functions>` was added.
 
- New alias :doc:`cert-dcl51-cpp
   <clang-tidy/checks/cert-dcl51-cpp>` to
   :doc:`bugprone-reserved-identifier
   <clang-tidy/checks/bugprone-reserved-identifier>` was added.
 
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - Improved :doc:`readability-qualified-auto
-  <clang-tidy/checks/readability-qualified-auto>` check now supports a 
+  <clang-tidy/checks/readability-qualified-auto>` check now supports a
   `AddConstToQualified` to enable adding ``const`` qualifiers to variables
   typed with ``auto *`` and ``auto &``.
 
 - Improved :doc:`readability-redundant-string-init
   <clang-tidy/checks/readability-redundant-string-init>` check now supports a
   `StringNames` option enabling its application to custom string classes. The
   check now detects in class initializers and constructor initializers which
   are deemed to be redundant.

 
 Improvements to pp-trace
 ------------------------
 
 The improvements are...
 
 Clang-tidy visual studio plugin
 -------------------------------
-

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. csv-table::
    `readability-redundant-string-init <readability-redundant-string-init.html>`_, "Yes"
    `readability-simplify-boolean-expr <readability-simplify-boolean-expr.html>`_, "Yes"
    `readability-simplify-subscript-expr <readability-simplify-subscript-expr.html>`_, "Yes"
    `readability-static-accessed-through-instance <readability-static-accessed-through-instance.html>`_, "Yes"
    `readability-static-definition-in-anonymous-namespace <readability-static-definition-in-anonymous-namespace.html>`_, "Yes"
    `readability-string-compare <readability-string-compare.html>`_, "Yes"
    `readability-uniqueptr-delete-release <readability-uniqueptr-delete-release.html>`_, "Yes"
    `readability-uppercase-literal-suffix <readability-uppercase-literal-suffix.html>`_, "Yes"
+   `readability-use-anyofallof`_, "No"
    `zircon-temporary-objects <zircon-temporary-objects.html>`_,
 
 
 .. csv-table:: Aliases..
    :header: "Name", "Redirect", "Offers fixes"
 
    `cert-con36-c <cert-con36-c.html>`_, `bugprone-spuriously-wake-up-functions <bugprone-spuriously-wake-up-functions.html>`_,
    `cert-con54-cpp <cert-con54-cpp.html>`_, `bugprone-spuriously-wake-up-functions <bugprone-spuriously-wake-up-functions.html>`_,

clang-tools-extra/docs/clang-tidy/checks/readability-use-anyofallof.rst

+.. title:: clang-tidy - readability-use-anyofallof
+
+readability-use-anyofallof
+==========================
+
+Finds range-based for loops that can be replaced by a call to ``std::any_of`` or
+``std::all_of``. In C++ 20 mode, suggests ``std::ranges::any_of`` or
+``std::ranges::all_of``.
+
+Example:
+
+.. code-block:: c++
+
+  bool all_even(std::vector<int> V) {
+    for (int I : V) {
+      if (I % 2)
+        return false;
+    }
+    return true;
+    // Replace loop by
+    // return std::ranges::all_of(V, [](int I) { return I % 2 == 0; });
+  }

clang-tools-extra/test/clang-tidy/checkers/readability-use-anyofallof-cpp20.cpp

+// RUN: %check_clang_tidy -std=c++2a-or-later %s readability-use-anyofallof %t
+
+bool good_any_of() {
+  int v[] = {1, 2, 3};
+  // CHECK-MESSAGES: :[[@LINE+1]]:3: warning: replace loop by 'std::ranges::any_of()'
+  for (int i : v)
+    if (i)
+      return true;
+  return false;
+}
+
+bool good_all_of() {
+  int v[] = {1, 2, 3};
+  // CHECK-MESSAGES: :[[@LINE+1]]:3: warning: replace loop by 'std::ranges::all_of()'
+  for (int i : v)
+    if (i)
+      return false;
+  return true;
+}

clang-tools-extra/test/clang-tidy/checkers/readability-use-anyofallof.cpp

+// RUN: %check_clang_tidy -std=c++14,c++17 %s readability-use-anyofallof %t
+
+bool good_any_of() {
+  int v[] = {1, 2, 3};
+  // CHECK-MESSAGES: :[[@LINE+1]]:3: warning: replace loop by 'std::any_of()' [readability-use-anyofallof]
+  for (int i : v)
+    if (i)
+      return true;
+  return false;
+}
+
+bool cond(int i);
+
+bool good_any_of2() {
+  int v[] = {1, 2, 3};
+  for (int i : v) {
+    // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: replace loop by 'std::any_of()'
+    int k = i / 2;
+    if (cond(k))
+      return true;
+  }
+  return false;
+}
+
+bool good_any_of3() {
+  int v[] = {1, 2, 3};
+  for (int i : v) {
+    // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: replace loop by 'std::any_of()'
+    if (i == 3)
+      continue;
+    if (i)
+      return true;
+  }
+
+  return false;
+}
+
+bool good_any_of_use_external(int comp) {
+  int v[] = {1, 2, 3};
+  for (int i : v) {
+    // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: replace loop by 'std::any_of()'
+    if (i == comp)
+      return true;
+  }
+
+  return false;
+}
+
+bool good_any_of_no_cond() {
+  int v[] = {1, 2, 3};
+  for (int i : v) {
+    // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: replace loop by 'std::any_of()'
+    return true; // Not a real loop, but technically can become any_of.
+  }
+
+  return false;
+}
+
+bool good_any_of_local_modification() {
+  int v[] = {1, 2, 3};
+  for (int i : v) {
+    int j = i;
+    j++; // FIXME: Any non-const use disables check.
+    if (j > 3)
+      return true;
+  }
+
+  return false;
+}
+
+bool good_any_of_throw() {
+  int v[] = {1, 2, 3};
+  for (int i : v) {
+    // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: replace loop by 'std::any_of()'
+    if (i > 3)
+      return true;
+    if (i == 42)
+      throw 0;
+  }
+
+  return false;
+}
+
+bool bad_any_of1() {
+  int v[] = {1, 2, 3};
+  for (int i : v) {
+    if (i)
+      return false; // bad constant
+  }
+  return false;
+}
+
+bool bad_any_of2() {
+  int v[] = {1, 2, 3};
+  for (int i : v)
+    if (i)
+      return true;
+
+  return true; // bad return
+}
+
+bool bad_any_of3() {
+  int v[] = {1, 2, 3};
+  for (int i : v)
+    if (i)
+      return true;
+    else
+      return i / 2; // bad return
+
+  return false;
+}
+
+bool bad_any_of_control_flow1() {
+  int v[] = {1, 2, 3};
+  for (int i : v) {
+    break; // bad control flow
+    if (i)
+      return true;
+  }
+
+  return false;
+}
+
+bool bad_any_of_control_flow2() {
+  int v[] = {1, 2, 3};
+  for (int i : v) {
+    goto end; // bad control flow
+    if (i)
+      return true;
+  }
+
+  end:
+  return false;
+}
+
+bool bad_any_of4() {
+  return false; // wrong order
+
+  int v[] = {1, 2, 3};
+  for (int i : v) {
+    if (i)
+      return true;
+  }
+}
+
+bool bad_any_of5() {
+  int v[] = {1, 2, 3};
+  int j = 0;
+  for (int i : v) {
+    j++; // modifications
+    if (i)
+      return true;
+  }
+  return false;
+}
+
+bool bad_any_of6() {
+  int v[] = {1, 2, 3};
+  for (int i : v) {
+    if (i)
+      return true;
+  }
+  int j = 0; // Statements between loop and return
+  j++;
+  return false;
+}
+
+bool bad_any_of7() {
+  int v[] = {1, 2, 3};
+  for (int i : v) {
+    i; // No 'return true' in body.
+  }
+  return false;
+}
+
+bool good_all_of() {
+  int v[] = {1, 2, 3};
+  // CHECK-MESSAGES: :[[@LINE+1]]:3: warning: replace loop by 'std::all_of()' [readability-use-anyofallof]
+  for (int i : v)
+    if (i)
+      return false;
+  return true;
+}