[clang-tidy] Add bugprone-non-zero-enum-to-bool-conversion check

[PiotrZSL]

Summary

Detect implicit and explicit conversions of enum to bool,
when enum doesn't have a enumerator with value equal to 0.
In theory such conversion should always return TRUE.

[PiotrZSL]

Removed "Offers fixes" from list.rst

[Eugene.Zelenko]

clang-tools-extra/clang-tidy/bugprone/EnumToBoolConversionCheck.h

28 ↗

(On Diff #497408)

Should language be checked for C++?

clang-tools-extra/docs/clang-tidy/checks/bugprone/enum-to-bool-conversion.rst

6 ↗

(On Diff #497408)

Please synchronize first statement with statement in Release Notes. Please use double back-ticks for language constructs.

49 ↗

(On Diff #497408)

Please use single back-ticks for option values. Default value is usually placed after option description.

[PiotrZSL]

Correct copyrights and commit author

[PiotrZSL]

Ready for review

[PiotrZSL]

Corrected issues mentioned in review

[PiotrZSL]

Fixed

[PiotrZSL]

Documentation to be updated, option need to be changed to list

[PiotrZSL]

Ping, Rebase, Changed Option from Regexp to List, Improved documentation, Removed usage of deprecated API

[carlosgalvezp]

Such a great check, thanks! I have very minor comments, the most debatable one about the name of the check (but no strong opinion).

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

107

I think the name is a bit generic, do we foresee risk of conflict with other similar checks in the future? I wonder if we should narrow it down to something like bugprone-non-zero-enum-to-bool-conversion. WDYT?

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

23 ↗

(On Diff #502752)

Use explicit type

24 ↗

(On Diff #502752)

The convention in the LLVM repo is to use traditional operators, please keep consistency.

27 ↗

(On Diff #502752)

Use explicit type

72 ↗

(On Diff #502752)

Unnecessary empty line

clang-tools-extra/docs/ReleaseNotes.rst

123

Keep alphabetical order.

clang-tools-extra/docs/clang-tidy/checks/bugprone/enum-to-bool-conversion.rst

12–13 ↗

(On Diff #502752)

I can't think of a case where this could happen, might be worth adding an example below.

14 ↗

(On Diff #502752)

Nit: Add space between // and NOLINT

38 ↗

(On Diff #502752)

Nit: use 2 chars indentation

39 ↗

(On Diff #502752)

Use traditional operators for consistency.

41 ↗

(On Diff #502752)

won't

41 ↗

(On Diff #502752)

Remove?

clang-tools-extra/test/clang-tidy/checkers/bugprone/enum-to-bool-conversion-cpp11.cpp

9 ↗

(On Diff #502752)

Indent with 2 chars instead of 4.

16 ↗

(On Diff #502752)

Nit: Add 2 chars indentation to align with the code.

20 ↗

(On Diff #502752)

Maybe test also "int", since it's the most common default? Also test one enum class without explicit underlying type.

[PiotrZSL]

Thank you for review, I will correct comments in this week.

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

107

I'm fine with name change....

clang-tools-extra/docs/clang-tidy/checks/bugprone/enum-to-bool-conversion.rst

41 ↗

(On Diff #502752)

enums are ints, you can assign them any value by using static casts or when reading data from external message, so thats why in theory, but in this example you right, there is no "in theory"

[PiotrZSL]

TODO: Fix review comments, rename check.

[PiotrZSL]

clang-tools-extra/docs/clang-tidy/checks/bugprone/enum-to-bool-conversion.rst

12–13 ↗

(On Diff #502752)

I thinkg that in STL we got some enums (flags) used as bitmasks... Just wanted to mention that there could be some known false-positives.

[PiotrZSL]

Review fixes + check rename

[carlosgalvezp]

LGTM, thanks! Would be good to fix the last nit before landing.

clang-tools-extra/clang-tidy/bugprone/NonZeroEnumToBoolConversionCheck.h

18

Nit remove excessive whitespace

[PiotrZSL]

Fix check description in source file (white spaces, sync it with release notes)

[PiotrZSL]

Rebase due to broken baseline

[PiotrZSL]

Rebase

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

 #include "MacroParenthesesCheck.h"
 #include "MacroRepeatedSideEffectsCheck.h"
 #include "MisplacedOperatorInStrlenInAllocCheck.h"
 #include "MisplacedPointerArithmeticInAllocCheck.h"
 #include "MisplacedWideningCastCheck.h"
 #include "MoveForwardingReferenceCheck.h"
 #include "MultipleStatementMacroCheck.h"
 #include "NoEscapeCheck.h"
+#include "NonZeroEnumToBoolConversionCheck.h"
 #include "NotNullTerminatedResultCheck.h"
 #include "ParentVirtualCallCheck.h"
 #include "PosixReturnCheck.h"
 #include "RedundantBranchConditionCheck.h"
 #include "ReservedIdentifierCheck.h"
 #include "SharedPtrArrayMismatchCheck.h"
 #include "SignalHandlerCheck.h"
 #include "SignedCharMisuseCheck.h"
CheckFactories.registerCheck<CopyConstructorInitCheck>(
         "bugprone-copy-constructor-init");
     CheckFactories.registerCheck<DanglingHandleCheck>(
         "bugprone-dangling-handle");
     CheckFactories.registerCheck<DynamicStaticInitializersCheck>(
         "bugprone-dynamic-static-initializers");
     CheckFactories.registerCheck<EasilySwappableParametersCheck>(
         "bugprone-easily-swappable-parameters");
     CheckFactories.registerCheck<ExceptionEscapeCheck>(
         "bugprone-exception-escape");
     CheckFactories.registerCheck<FoldInitTypeCheck>("bugprone-fold-init-type");
     CheckFactories.registerCheck<ForwardDeclarationNamespaceCheck>(
         "bugprone-forward-declaration-namespace");
     CheckFactories.registerCheck<ForwardingReferenceOverloadCheck>(
         "bugprone-forwarding-reference-overload");
     CheckFactories.registerCheck<ImplicitWideningOfMultiplicationResultCheck>(
         "bugprone-implicit-widening-of-multiplication-result");
     CheckFactories.registerCheck<InaccurateEraseCheck>(
CheckFactories.registerCheck<MoveForwardingReferenceCheck>(
         "bugprone-move-forwarding-reference");
     CheckFactories.registerCheck<MultipleStatementMacroCheck>(
         "bugprone-multiple-statement-macro");
     CheckFactories.registerCheck<RedundantBranchConditionCheck>(
         "bugprone-redundant-branch-condition");
     CheckFactories.registerCheck<cppcoreguidelines::NarrowingConversionsCheck>(
         "bugprone-narrowing-conversions");
     CheckFactories.registerCheck<NoEscapeCheck>("bugprone-no-escape");
+    CheckFactories.registerCheck<NonZeroEnumToBoolConversionCheck>(
+        "bugprone-non-zero-enum-to-bool-conversion");
     CheckFactories.registerCheck<NotNullTerminatedResultCheck>(
         "bugprone-not-null-terminated-result");
     CheckFactories.registerCheck<ParentVirtualCallCheck>(
         "bugprone-parent-virtual-call");
     CheckFactories.registerCheck<PosixReturnCheck>("bugprone-posix-return");
     CheckFactories.registerCheck<ReservedIdentifierCheck>(
         "bugprone-reserved-identifier");
     CheckFactories.registerCheck<SharedPtrArrayMismatchCheck>(

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

add_clang_library(clangTidyBugproneModule
   MacroParenthesesCheck.cpp
   MacroRepeatedSideEffectsCheck.cpp
   MisplacedOperatorInStrlenInAllocCheck.cpp
   MisplacedPointerArithmeticInAllocCheck.cpp
   MisplacedWideningCastCheck.cpp
   MoveForwardingReferenceCheck.cpp
   MultipleStatementMacroCheck.cpp
   NoEscapeCheck.cpp
+  NonZeroEnumToBoolConversionCheck.cpp
   NotNullTerminatedResultCheck.cpp
   ParentVirtualCallCheck.cpp
   PosixReturnCheck.cpp
   RedundantBranchConditionCheck.cpp
   ReservedIdentifierCheck.cpp
   SharedPtrArrayMismatchCheck.cpp
-  SmartPtrArrayMismatchCheck.cpp
   SignalHandlerCheck.cpp
   SignedCharMisuseCheck.cpp
   SizeofContainerCheck.cpp
   SizeofExpressionCheck.cpp
+  SmartPtrArrayMismatchCheck.cpp
   SpuriouslyWakeUpFunctionsCheck.cpp
   StandaloneEmptyCheck.cpp
   StringConstructorCheck.cpp
   StringIntegerAssignmentCheck.cpp
   StringLiteralWithEmbeddedNulCheck.cpp
   StringviewNullptrCheck.cpp
   SuspiciousEnumUsageCheck.cpp
   SuspiciousIncludeCheck.cpp

clang-tools-extra/clang-tidy/bugprone/NonZeroEnumToBoolConversionCheck.h

+//===--- NonZeroNonZeroEnumToBoolConversionCheck.h - clang-tidy -*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_NONZEROENUMTOBOOLCONVERSIONCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_NONZEROENUMTOBOOLCONVERSIONCHECK_H
+
+#include "../ClangTidyCheck.h"
+#include <vector>
+
+namespace clang::tidy::bugprone {
+
+/// Detect implicit and explicit casts of `enum` type into `bool` where
+/// `enum` type doesn't have a zero-value enumerator.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone/non-zero-enum-to-bool-conversion.html
+class NonZeroEnumToBoolConversionCheck : public ClangTidyCheck {
+public:
+  NonZeroEnumToBoolConversionCheck(StringRef Name, ClangTidyContext *Context);
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
+
+private:
+  const std::vector<StringRef> EnumIgnoreList;
+};
+
+} // namespace clang::tidy::bugprone
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_NONZEROENUMTOBOOLCONVERSIONCHECK_H

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

+//===--- NonZeroEnumToBoolConversionCheck.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 "NonZeroEnumToBoolConversionCheck.h"
+#include "../utils/Matchers.h"
+#include "../utils/OptionsUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include <algorithm>
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::bugprone {
+
+namespace {
+
+AST_MATCHER(EnumDecl, isCompleteAndHasNoZeroValue) {
+  const EnumDecl *Definition = Node.getDefinition();
+  return Definition && Node.isComplete() &&
+         std::none_of(Definition->enumerator_begin(),
+                      Definition->enumerator_end(),
+                      [](const EnumConstantDecl *Value) {
+                        return Value->getInitVal().isZero();
+                      });
+}
+
+} // namespace
+
+NonZeroEnumToBoolConversionCheck::NonZeroEnumToBoolConversionCheck(
+    StringRef Name, ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      EnumIgnoreList(
+          utils::options::parseStringList(Options.get("EnumIgnoreList", ""))) {}
+
+void NonZeroEnumToBoolConversionCheck::storeOptions(
+    ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "EnumIgnoreList",
+                utils::options::serializeStringList(EnumIgnoreList));
+}
+
+bool NonZeroEnumToBoolConversionCheck::isLanguageVersionSupported(
+    const LangOptions &LangOpts) const {
+  return LangOpts.CPlusPlus;
+}
+
+void NonZeroEnumToBoolConversionCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(
+      castExpr(hasCastKind(CK_IntegralToBoolean),
+               unless(isExpansionInSystemHeader()), hasType(booleanType()),
+               hasSourceExpression(
+                   expr(hasType(qualType(hasCanonicalType(hasDeclaration(
+                            enumDecl(isCompleteAndHasNoZeroValue(),
+                                     unless(matchers::matchesAnyListedName(
+                                         EnumIgnoreList)))
+                                .bind("enum"))))),
+                        unless(declRefExpr(to(enumConstantDecl()))))),
+               unless(hasAncestor(staticAssertDecl())))
+          .bind("cast"),
+      this);
+}
+
+void NonZeroEnumToBoolConversionCheck::check(
+    const MatchFinder::MatchResult &Result) {
+  const auto *Cast = Result.Nodes.getNodeAs<CastExpr>("cast");
+  const auto *Enum = Result.Nodes.getNodeAs<EnumDecl>("enum");
+
+  diag(Cast->getExprLoc(), "conversion of %0 into 'bool' will always return "
+                           "'true', enum doesn't have a zero-value enumerator")
+      << Enum;
+  diag(Enum->getLocation(), "enum is defined here", DiagnosticIDs::Note);
+}
+
+} // namespace clang::tidy::bugprone

clang-tools-extra/docs/ReleaseNotes.rst

 - Support specifying `Checks` as a YAML list in the `.clang-tidy` configuration
   file.
 
 - Fix a potential crash when using the `--dump-config` option.
 
 New checks
 ^^^^^^^^^^
 
+- New :doc:`bugprone-non-zero-enum-to-bool-conversion
+  <clang-tidy/checks/bugprone/non-zero-enum-to-bool-conversion>` check.
+
+  Detect implicit and explicit casts of ``enum`` type into ``bool`` where ``enum`` type
+  doesn't have a zero-value enumerator.
+
 - New :doc:`bugprone-unsafe-functions
   <clang-tidy/checks/bugprone/unsafe-functions>` check.
 
   Checks for functions that have safer, more secure replacements available, or
   are considered deprecated due to design flaws.
   This check relies heavily on, but is not exclusive to, the functions from
   the *Annex K. "Bounds-checking interfaces"* of C11.
 
 - New :doc:`cppcoreguidelines-avoid-capturing-lambda-coroutines
   <clang-tidy/checks/cppcoreguidelines/avoid-capturing-lambda-coroutines>` check.
 
   Flags C++20 coroutine lambdas with non-empty capture lists that may cause
   use-after-free errors and suggests avoiding captures or ensuring the lambda
   closure object has a guaranteed lifetime.
 
 - New :doc:`cppcoreguidelines-misleading-capture-default-by-value
   <clang-tidy/checks/cppcoreguidelines/misleading-capture-default-by-value>` check.

clang-tools-extra/docs/clang-tidy/checks/bugprone/non-zero-enum-to-bool-conversion.rst

+.. title:: clang-tidy - bugprone-non-zero-enum-to-bool-conversion
+
+bugprone-non-zero-enum-to-bool-conversion
+=========================================
+
+Detect implicit and explicit casts of ``enum`` type into ``bool`` where ``enum``
+type doesn't have a zero-value enumerator. If the ``enum`` is used only to hold
+values equal to its enumerators, then conversion to ``bool`` will always result
+in ``true`` value. This can lead to unnecessary code that reduces readability
+and maintainability and can result in bugs.
+
+May produce false positives if the ``enum`` is used to store other values
+(used as a bit-mask or zero-initialized on purpose). To deal with them,
+``// NOLINT`` or casting first to the underlying type before casting to ``bool``
+can be used.
+
+It is important to note that this check will not generate warnings if the
+definition of the enumeration type is not available.
+Additionally, C++11 enumeration classes are supported by this check.
+
+Overall, this check serves to improve code quality and readability by identifying
+and flagging instances where implicit or explicit casts from enumeration types to
+boolean could cause potential issues.
+
+Example
+-------
+
+.. code-block:: c++
+
+  enum EStatus {
+    OK = 1,
+    NOT_OK,
+    UNKNOWN
+  };
+
+  void process(EStatus status) {
+    if (!status) {
+      // this true-branch won't be executed
+      return;
+    }
+    // proceed with "valid data"
+  }
+
+Options
+-------
+
+.. option:: EnumIgnoreList
+
+  Option is used to ignore certain enum types when checking for
+  implicit/explicit casts to bool. It accepts a semicolon-separated list of
+  (fully qualified) enum type names or regular expressions that match the enum
+  type names.
+  The default value is an empty string, which means no enums will be ignored.

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

.. csv-table::
    `bugprone-macro-parentheses <bugprone/macro-parentheses.html>`_, "Yes"
    `bugprone-macro-repeated-side-effects <bugprone/macro-repeated-side-effects.html>`_,
    `bugprone-misplaced-operator-in-strlen-in-alloc <bugprone/misplaced-operator-in-strlen-in-alloc.html>`_, "Yes"
    `bugprone-misplaced-pointer-arithmetic-in-alloc <bugprone/misplaced-pointer-arithmetic-in-alloc.html>`_, "Yes"
    `bugprone-misplaced-widening-cast <bugprone/misplaced-widening-cast.html>`_,
    `bugprone-move-forwarding-reference <bugprone/move-forwarding-reference.html>`_, "Yes"
    `bugprone-multiple-statement-macro <bugprone/multiple-statement-macro.html>`_,
    `bugprone-no-escape <bugprone/no-escape.html>`_,
+   `bugprone-non-zero-enum-to-bool-conversion <bugprone/non-zero-enum-to-bool-conversion.html>`_,
    `bugprone-not-null-terminated-result <bugprone/not-null-terminated-result.html>`_, "Yes"
    `bugprone-parent-virtual-call <bugprone/parent-virtual-call.html>`_, "Yes"
    `bugprone-posix-return <bugprone/posix-return.html>`_, "Yes"
    `bugprone-redundant-branch-condition <bugprone/redundant-branch-condition.html>`_, "Yes"
    `bugprone-reserved-identifier <bugprone/reserved-identifier.html>`_, "Yes"
    `bugprone-shared-ptr-array-mismatch <bugprone/shared-ptr-array-mismatch.html>`_, "Yes"
    `bugprone-signal-handler <bugprone/signal-handler.html>`_,
    `bugprone-signed-char-misuse <bugprone/signed-char-misuse.html>`_,

clang-tools-extra/test/clang-tidy/checkers/bugprone/non-zero-enum-to-bool-conversion-cpp11.cpp

+// RUN: %check_clang_tidy -std=c++11-or-later %s bugprone-non-zero-enum-to-bool-conversion %t
+
+namespace with::issue {
+
+enum class EStatusC : char {
+  SUCCESS       = 1,
+  FAILURE       = 2,
+  INVALID_PARAM = 3,
+  UNKNOWN       = 4
+};
+
+bool testEnumConversion(EStatusC value) {
+  // CHECK-MESSAGES: :[[@LINE+1]]:10: warning: conversion of 'EStatusC' into 'bool' will always return 'true', enum doesn't have a zero-value enumerator [bugprone-non-zero-enum-to-bool-conversion]
+  return static_cast<bool>(value);
+}
+
+enum class EStatusS : short {
+  SUCCESS       = 1,
+  FAILURE       = 2,
+  INVALID_PARAM = 3,
+  UNKNOWN       = 4
+};
+
+bool testEnumConversion(EStatusS value) {
+  // CHECK-MESSAGES: :[[@LINE+1]]:10: warning: conversion of 'EStatusS' into 'bool' will always return 'true', enum doesn't have a zero-value enumerator [bugprone-non-zero-enum-to-bool-conversion]
+  return static_cast<bool>(value);
+}
+
+
+enum class EStatusI : int {
+  SUCCESS       = 1,
+  FAILURE       = 2,
+  INVALID_PARAM = 3,
+  UNKNOWN       = 4
+};
+
+bool testEnumConversion(EStatusI value) {
+  // CHECK-MESSAGES: :[[@LINE+1]]:10: warning: conversion of 'EStatusI' into 'bool' will always return 'true', enum doesn't have a zero-value enumerator [bugprone-non-zero-enum-to-bool-conversion]
+  return static_cast<bool>(value);
+}
+
+enum class EStatus {
+  SUCCESS       = 1,
+  FAILURE       = 2,
+  INVALID_PARAM = 3,
+  UNKNOWN       = 4
+};
+
+bool testEnumConversion(EStatus value) {
+  // CHECK-MESSAGES: :[[@LINE+1]]:10: warning: conversion of 'EStatus' into 'bool' will always return 'true', enum doesn't have a zero-value enumerator [bugprone-non-zero-enum-to-bool-conversion]
+  return static_cast<bool>(value);
+}
+
+namespace enum_int {
+
+enum EResult : int {
+  OK = 1,
+  NOT_OK
+};
+
+bool testEnumConversion(const EResult& value) {
+  // CHECK-MESSAGES: :[[@LINE+1]]:10: warning: conversion of 'EResult' into 'bool' will always return 'true', enum doesn't have a zero-value enumerator [bugprone-non-zero-enum-to-bool-conversion]
+  return value;
+}
+
+}
+
+namespace enum_short {
+
+enum EResult : short {
+  OK = 1,
+  NOT_OK
+};
+
+bool testEnumConversion(const EResult& value) {
+  // CHECK-MESSAGES: :[[@LINE+1]]:10: warning: conversion of 'EResult' into 'bool' will always return 'true', enum doesn't have a zero-value enumerator [bugprone-non-zero-enum-to-bool-conversion]
+  return value;
+}
+
+}
+
+namespace enum_char {
+
+enum EResult : char {
+  OK = 1,
+  NOT_OK
+};
+
+bool testEnumConversion(const EResult& value) {
+  // CHECK-MESSAGES: :[[@LINE+1]]:10: warning: conversion of 'EResult' into 'bool' will always return 'true', enum doesn't have a zero-value enumerator [bugprone-non-zero-enum-to-bool-conversion]
+  return value;
+}
+
+}
+
+namespace enum_default {
+
+enum EResult {
+  OK = 1,
+  NOT_OK
+};
+
+bool testEnumConversion(const EResult& value) {
+  // CHECK-MESSAGES: :[[@LINE+1]]:10: warning: conversion of 'EResult' into 'bool' will always return 'true', enum doesn't have a zero-value enumerator [bugprone-non-zero-enum-to-bool-conversion]
+  return value;
+}
+
+}
+
+}

clang-tools-extra/test/clang-tidy/checkers/bugprone/non-zero-enum-to-bool-conversion.cpp

+// RUN: %check_clang_tidy -std=c++98-or-later %s bugprone-non-zero-enum-to-bool-conversion %t -- \
+// RUN:   -config="{CheckOptions: [{key: bugprone-non-zero-enum-to-bool-conversion.EnumIgnoreList, value: '::without::issue::IgnoredEnum;IgnoredSecondEnum'}]}"
+
+namespace with::issue {
+
+typedef enum EStatus {
+  SUCCESS       = 1,
+  FAILURE       = 2,
+  INVALID_PARAM = 3,
+  UNKNOWN       = 4
+} Status;
+
+bool testEnumConversion(EStatus value) {
+  // CHECK-MESSAGES: :[[@LINE+1]]:10: warning: conversion of 'EStatus' into 'bool' will always return 'true', enum doesn't have a zero-value enumerator [bugprone-non-zero-enum-to-bool-conversion]
+  return value;
+}
+
+bool testTypedefConversion(Status value) {
+  // CHECK-MESSAGES: :[[@LINE+1]]:10: warning: conversion of 'EStatus' into 'bool' will always return 'true', enum doesn't have a zero-value enumerator [bugprone-non-zero-enum-to-bool-conversion]
+  return value;
+}
+
+bool testExplicitConversion(EStatus value) {
+  // CHECK-MESSAGES: :[[@LINE+1]]:28: warning: conversion of 'EStatus' into 'bool' will always return 'true', enum doesn't have a zero-value enumerator [bugprone-non-zero-enum-to-bool-conversion]
+  return static_cast<bool>(value);
+}
+
+bool testInIfConversion(EStatus value) {
+  // CHECK-MESSAGES: :[[@LINE+1]]:7: warning: conversion of 'EStatus' into 'bool' will always return 'true', enum doesn't have a zero-value enumerator [bugprone-non-zero-enum-to-bool-conversion]
+  if (value) {
+    return false;
+  }
+  return true;
+}
+
+bool testWithNegation(EStatus value) {
+  // CHECK-MESSAGES: :[[@LINE+1]]:14: warning: conversion of 'EStatus' into 'bool' will always return 'true', enum doesn't have a zero-value enumerator [bugprone-non-zero-enum-to-bool-conversion]
+  return not value;
+}
+
+}
+
+namespace without::issue {
+
+enum StatusWithZero {
+  UNK  = 0,
+  OK   = 1,
+  NOT_OK = 2
+};
+
+bool testEnumConversion(StatusWithZero value) {
+  return value;
+}
+
+enum WithDefault {
+  Value0,
+  Value1
+};
+
+bool testEnumConversion(WithDefault value) {
+  return value;
+}
+
+enum WithNegative : int {
+  Nen2 = -2,
+  Nen1,
+  Nen0
+};
+
+bool testEnumConversion(WithNegative value) {
+  return value;
+}
+
+enum EStatus {
+  SUCCESS = 1,
+  FAILURE,
+  INVALID_PARAM,
+  UNKNOWN
+};
+
+bool explicitCompare(EStatus value) {
+  return value == SUCCESS;
+}
+
+bool testEnumeratorCompare() {
+  return SUCCESS;
+}
+
+enum IgnoredEnum {
+  IGNORED_VALUE_1 = 1,
+  IGNORED_VALUE_2
+};
+
+enum IgnoredSecondEnum {
+  IGNORED_SECOND_VALUE_1 = 1,
+  IGNORED_SECOND_VALUE_2
+};
+
+bool testIgnored(IgnoredEnum value) {
+  return value;
+}
+
+bool testIgnored(IgnoredSecondEnum value) {
+  return value;
+}
+
+}