[clang][analyzer] Fix empty enum handling in EnumCastOutOfRange checker

[gamesh411]

Summary

The alpha.cplusplus.EnumCastOutOfRange checker previously gave many
false positives because a warning was given if the initializer value
did not appear in the enumerator list.
The strict handling caused std::byte to always give a warning, as it
is implemented as an enum class without any declarators.

[shafik]

I did not look at this in detail but I don't think this approach is correct. I fixed this for constant evaluation the other day and you can find the details here: D130058

The test suite I wrote should be sufficient for you to validate your approach against.

[donat.nagy]

I think the old "report when the value stored in an enum type is not equal to one of the enumerators" behavior would be useful as an opt-in checker that could be adopted by some projects; while the new "relaxed" version is too bland to be really useful. I'd suggest keeping the old behavior in the general case, eliminating the "obvious" false positives like std::byte (don't report types that have no enumerators) and moving this checker towards the optin group.

[steakhal]

In D153954#4480103, @donat.nagy wrote:

I think the old "report when the value stored in an enum type is not equal to one of the enumerators" behavior would be useful as an opt-in checker that could be adopted by some projects; while the new "relaxed" version is too bland to be really useful. I'd suggest keeping the old behavior in the general case, eliminating the "obvious" false positives like std::byte (don't report types that have no enumerators) and moving this checker towards the optin group.

I would agree that after ignoring the obvious cases (like no enumerators), a checker like this could be useful as an "optin" checker, however, I'd not recommend moving the actual implementation anywhere.
You can create "virtual" checkers like it's done in many cases, eg. MismatchedDeallocatorChecker.

FYI I haven't checked the actual implementation thoroughly, because I had higher-level remarks inline.

clang/lib/StaticAnalyzer/Checkers/EnumCastOutOfRangeChecker.cpp

42

I can see llvm::APSInt used a few places. Consider using namespace llvm;

65–69

Why do you fold the "Pred" ExplodedNode?
I'd say, you probably didn't want to use addTransition here.
Why don't you assume the subsequent assumptions and transition only once?

Anyway, I think it's better to have the addTransition closer to the outer scope (where the error reporting is done), so that we can easily see how many ways we branch off, etc.

clang/test/Analysis/enum-cast-out-of-range.cpp

44

void sink(...); would have achieved the same and I'd say it's less complex.
sink(unscoped, scoped);

[donat.nagy]

In D153954#4480296, @steakhal wrote:

[...] I'd not recommend moving the actual implementation anywhere.

I agree, I mostly spoke figuratively, suggesting that this checker could end up in the optin group when it's eventually brought out of alpha.

clang/test/Analysis/enum-cast-out-of-range.cpp

44

Or just (void)unscoped; (void)scoped; if we're bikeshedding this test...

[gamesh411]

The checker now retains the original detection logic, but only whitelists empty
enums.

As a future step the checker is moved into the optin package.

[gamesh411]

In D153954#4456713, @shafik wrote:

I did not look at this in detail but I don't think this approach is correct. I fixed this for constant evaluation the other day and you can find the details here: D130058

The test suite I wrote should be sufficient for you to validate your approach against.

@shafik, @donat.nagy Thanks for looking at this patch.
I have checked the linked improvements in Sema, and this initial modification would only lead to a ClangSA implementation of the same error-detection logic.
Due to symbolic execution, the set of potentially detectable errors is bigger, but this is maybe not the right place for this checker.

My goal is to improve the checker and eventually bring it out of alpha.

I see one main problem with this checker:

It does not support enums with fixed underlying type, namely std::byte, which is implemented like this:

enum class byte: unsigned char {};

As std::byte has no enumerators, the checker would say any otherwise allowed non-default initialization of a std::byte instance is bad, i.e.:

std::byte b {42}; // the checker gives a warning for this

Aside from this, in the optin package, there is a place for the current state of the checker (namely that only the value mentioned in the enumerator list are OK).
I will create a separate patch to move it out of alpha and into optin package.

clang/lib/StaticAnalyzer/Checkers/EnumCastOutOfRangeChecker.cpp

42

Again, good point, I just abandoned the direction where many APSInt mentions are introduced, and the original only has 2 mentions of APSInt.

65–69

Thanks! This is a very good point; I just changed the general direction of the checker, and this implementation is no longer touched by the change.

[donat.nagy]

LGTM, with a little bikeshedding ;-)

clang/test/Analysis/enum-cast-out-of-range.cpp

49

Consider using "specified" and "unspecified" instead of "fixed" and "unfixed", because the rest of the test file uses them and in my opinion "unfixed" looks strange in this context. (I know that e.g. https://en.cppreference.com/w/cpp/language/enum speaks about "fixed" underlying context, but it doesn't use "unfixed".)

[steakhal]

LGTM

clang/test/Analysis/enum-cast-out-of-range.cpp

49

How about calling it "plain" or "common"?

58–60

[donat.nagy]

clang/test/Analysis/enum-cast-out-of-range.cpp

49

"plain" is also a good alternative for "unfixed" (although it would still be inconsistent with the earlier cases); but "common" is confusing, because in addition to the "plain, regular, normal" meaning it can also mean "mutual; shared by more than one <something>".

[gamesh411]

minor review fixups

clang/lib/StaticAnalyzer/Checkers/EnumCastOutOfRangeChecker.cpp

 //   of casting an integer value that is out of range
 // SEI CERT C++ Coding Standard, INT50-CPP. Do not cast to an out-of-range
 //   enumeration value
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "llvm/ADT/APSInt.h"
 #include <optional>
 
 using namespace clang;
 using namespace ento;
 
 namespace {
-// This evaluator checks two SVals for equality. The first SVal is provided via
-// the constructor, the second is the parameter of the overloaded () operator.
-// It uses the in-built ConstraintManager to resolve the equlity to possible or
-// not possible ProgramStates.
-class ConstraintBasedEQEvaluator {
-  const DefinedOrUnknownSVal CompareValue;
-  const ProgramStateRef PS;
-  SValBuilder &SVB;
+class ValueMatchEvaluator {
+protected:
+  CheckerContext &C;
+  SValBuilder &SVB = C.getSValBuilder();
+  const ProgramStateRef PS = C.getState();
+  ValueMatchEvaluator(CheckerContext &C)
+      : C(C), SVB(C.getSValBuilder()), PS(C.getState()) {}
+};
+
+class RangeBasedValueMatchEvaluator : ValueMatchEvaluator {
+  llvm::APSInt Min, Max;
 
 public:
-  ConstraintBasedEQEvaluator(CheckerContext &C,
-                             const DefinedOrUnknownSVal CompareValue)
-      : CompareValue(CompareValue), PS(C.getState()), SVB(C.getSValBuilder()) {}
-
-  bool operator()(const llvm::APSInt &EnumDeclInitValue) {
-    DefinedOrUnknownSVal EnumDeclValue = SVB.makeIntVal(EnumDeclInitValue);
-    DefinedOrUnknownSVal ElemEqualsValueToCast =
-        SVB.evalEQ(PS, EnumDeclValue, CompareValue);
+  RangeBasedValueMatchEvaluator(CheckerContext &C, const llvm::APSInt &Min,
+                                const llvm::APSInt &Max)
+      : ValueMatchEvaluator(C), Min(Min), Max(Max) {}
+  bool possiblyContains(const DefinedOrUnknownSVal &CompareValue) {
+    // Check if there is a possibility of CompareValue between the min and max
+    // values of the underlying type's range.
+
+    // Build the ExplodedGraph to incrementally model valid assumptions.
+    ExplodedNode *Pred = C.getPredecessor();
+
+    auto CheckAssumption =
+        [this, &Pred](
+            SVal Assumption) -> std::pair<ProgramStateRef, ProgramStateRef> {
+      if (Assumption.isUndef())
+        return {nullptr, nullptr};
+
+      const auto DefinedOrUnknownAssumption =
+          Assumption.castAs<DefinedOrUnknownSVal>();
+      const auto [TrueState, FalseState] =
+          C.getState()->assume(DefinedOrUnknownAssumption);
+      if (TrueState && !FalseState) {
+        Pred = C.addTransition(TrueState, Pred);
+      } else if (FalseState && !TrueState) {
+        Pred = C.addTransition(FalseState, Pred);
+      }
+      return {TrueState, FalseState};
+    };
 
-    return static_cast<bool>(PS->assume(ElemEqualsValueToCast, true));
+    // Check lower bound, i.e.: CompareValue >= Min.
+    const SVal LowerBound = SVB.makeIntVal(Min);
+    const SVal CompareValueAtLeastMin =
+        SVB.evalBinOp(C.getState(), BinaryOperator::Opcode::BO_GE, CompareValue,
+                      LowerBound, SVB.getConditionType());
+    const auto [AtLeastMin, NotAtLeastMin] =
+        CheckAssumption(CompareValueAtLeastMin);
+
+    // Check upper bound, i.e.: CompareValue <= Max.
+    const SVal UpperBound = SVB.makeIntVal(Max);
+    SVal CompareValueAtMostMax =
+        SVB.evalBinOp(C.getState(), BinaryOperator::Opcode::BO_LE, CompareValue,
+                      UpperBound, SVB.getConditionType());
+    const auto [AtMostMax, NotAtMostMax] =
+        CheckAssumption(CompareValueAtMostMax);
+
+    const bool DefinitelyLowerThanMin = NotAtLeastMin && !AtLeastMin;
+    const bool DefinitelyHigherThanMax = NotAtMostMax && !AtMostMax;
+    const bool DefinitelyOutOfRange =
+        DefinitelyLowerThanMin || DefinitelyHigherThanMax;
+    const bool PossiblyInRange = !DefinitelyOutOfRange;
+    return PossiblyInRange;
   }
 };
 
 // This checker checks CastExpr statements.
 // If the value provided to the cast is one of the values the enumeration can
 // represent, the said value matches the enumeration. If the checker can
 // establish the impossibility of matching it gives a warning.
 // Being conservative, it does not warn if there is slight possibility the
 // value can be matching.
 class EnumCastOutOfRangeChecker : public Checker<check::PreStmt<CastExpr>> {
   mutable std::unique_ptr<BuiltinBug> EnumValueCastOutOfRange;
   void reportWarning(CheckerContext &C) const;
 
 public:
   void checkPreStmt(const CastExpr *CE, CheckerContext &C) const;
 };
-
-using EnumValueVector = llvm::SmallVector<llvm::APSInt, 6>;
-
-// Collects all of the values an enum can represent (as SVals).
-EnumValueVector getDeclValuesForEnum(const EnumDecl *ED) {
-  EnumValueVector DeclValues(
-      std::distance(ED->enumerator_begin(), ED->enumerator_end()));
-  llvm::transform(ED->enumerators(), DeclValues.begin(),
-                 [](const EnumConstantDecl *D) { return D->getInitVal(); });
-  return DeclValues;
-}
 } // namespace
 
 void EnumCastOutOfRangeChecker::reportWarning(CheckerContext &C) const {
   if (const ExplodedNode *N = C.generateNonFatalErrorNode()) {
     if (!EnumValueCastOutOfRange)
       EnumValueCastOutOfRange.reset(
           new BuiltinBug(this, "Enum cast out of range",
                          "The value provided to the cast expression is not in "
if (!T->isEnumeralType())
     return;
 
   // If the cast is an enum, get its declaration.
   // If the isEnumeralType() returned true, then the declaration must exist
   // even if it is a stub declaration. It is up to the getDeclValuesForEnum()
   // function to handle this.
   const EnumDecl *ED = T->castAs<EnumType>()->getDecl();
 
-  EnumValueVector DeclValues = getDeclValuesForEnum(ED);
-  // Check if any of the enum values possibly match.
-  bool PossibleValueMatch = llvm::any_of(
-      DeclValues, ConstraintBasedEQEvaluator(C, *ValueToCast));
+  const bool IsFixed = ED->isFixed();
+
+  bool PossibleValueMatch = false;
+
+  if (IsFixed) {
+    QualType UnderlyingType = ED->getIntegerType();
+    const unsigned Bitwidth = C.getASTContext().getIntWidth(UnderlyingType);
+    const bool isUnsigned = UnderlyingType->isUnsignedIntegerType();
+    llvm::APSInt UnderlyingTypeMin =
+        llvm::APSInt::getMinValue(Bitwidth, isUnsigned);
+    llvm::APSInt UnderlyingTypeMax =
+        llvm::APSInt::getMaxValue(Bitwidth, isUnsigned);
+
+    PossibleValueMatch =
+        RangeBasedValueMatchEvaluator(C, UnderlyingTypeMin, UnderlyingTypeMax)
+            .possiblyContains(*ValueToCast);
+  } else {
+    llvm::APSInt RepresentationMin, RepresentationMax;
+    ED->getValueRange(RepresentationMax, RepresentationMin);
+
+    PossibleValueMatch =
+        RangeBasedValueMatchEvaluator(C, RepresentationMin, RepresentationMax)
+            .possiblyContains(*ValueToCast);
+  }
 
   // If there is no value that can possibly match any of the enum values, then
   // warn.
   if (!PossibleValueMatch)
     reportWarning(C);
 }
 
 void ento::registerEnumCastOutOfRangeChecker(CheckerManager &mgr) {
   mgr.registerChecker<EnumCastOutOfRangeChecker>();
 }
 
 bool ento::shouldRegisterEnumCastOutOfRangeChecker(const CheckerManager &mgr) {
   return true;
 }

clang/test/Analysis/enum-cast-out-of-range.c

 // RUN: %clang_analyze_cc1 \
 // RUN:   -analyzer-checker=core,alpha.cplusplus.EnumCastOutOfRange \
 // RUN:   -verify %s
 
-enum En_t {
-  En_0 = -4,
-  En_1,
-  En_2 = 1,
-  En_3,
-  En_4 = 4
+#define UINT_MAX (~0U)
+#define INT_MAX (int)(UINT_MAX & (UINT_MAX >> 1))
+#define INT_MIN (int)(UINT_MAX & ~(UINT_MAX >> 1))
+
+// Enum with enumeration values only non-negative and max value smaller than
+// INT_MAX
+// this allows a signed or unsigned underlying type as well, but the max value
+// of this type is definitely smaller than INT_MAX.
+enum Nonneg_t {
+  Small_nonneg_0 = 0,
+  Small_nonneg_1, // 1
+  Small_nonneg_2 = 4
+};
+
+// Enum with enumeration values close to 0 (so having small absolute value).
+// this forces a signed representation.
+enum Small_abs_t {
+  Small_abs_0 = -1,
+  Small_abs_1, // 0
+  Small_abs_2 = 4
+};
+
+// Enum with big enumeration values.
+enum Big_abs_t {
+  Big_abs_0 = (long long)INT_MIN - 1,
+  Big_abs_1 = (long long)INT_MAX + 1
 };
 
-void unscopedUnspecifiedCStyle(void) {
-  enum En_t Below = (enum En_t)(-5);    // expected-warning {{not in the valid range}}
-  enum En_t NegVal1 = (enum En_t)(-4);  // OK.
-  enum En_t NegVal2 = (enum En_t)(-3);  // OK.
-  enum En_t InRange1 = (enum En_t)(-2); // expected-warning {{not in the valid range}}
-  enum En_t InRange2 = (enum En_t)(-1); // expected-warning {{not in the valid range}}
-  enum En_t InRange3 = (enum En_t)(0);  // expected-warning {{not in the valid range}}
-  enum En_t PosVal1 = (enum En_t)(1);   // OK.
-  enum En_t PosVal2 = (enum En_t)(2);   // OK.
-  enum En_t InRange4 = (enum En_t)(3);  // expected-warning {{not in the valid range}}
-  enum En_t PosVal3 = (enum En_t)(4);   // OK.
-  enum En_t Above = (enum En_t)(5);     // expected-warning {{not in the valid range}}
+void unscopedUnspecifiedNonnegEnumCStyle(void) {
+  // the underlying type may be unsigned
+  enum Nonneg_t NegVal = (enum Nonneg_t)(-1);    // expected-warning {{not in the valid range}}
+  // enum Nonneg_t ZeroVal = (enum Nonneg_t)(0);    // OK
+  // enum Nonneg_t NonMentionedVal = (enum Nonneg_t)(2);    // OK as the underlying type should be able to represent [0..4]
+  // the underlying type is not wider than int
+  enum Nonneg_t BigVal = (enum Nonneg_t)((long long)INT_MAX + 1);  //expected-warning {{not in the valid range}}
+}
+
+void unscopedUnspecifiedSmallEnumCStyle(void) {
+  enum Small_abs_t NegVal = (enum Small_abs_t)(-1);    // OK
+  enum Small_abs_t ZeroVal = (enum Small_abs_t)(0);    // OK
+  enum Small_abs_t NonMentionedVal = (enum Small_abs_t)(2);    // OK as the underlying type should be able to represent [-1..4]
+  // the underlying type is not wider than int
+  enum Small_abs_t BigVal = (enum Small_abs_t)((long long)INT_MAX + 1);  //expected-warning {{not in the valid range}}
+}
+
+void unscopedUnspecifiedBigEnumCStyle(void) {
+  enum Big_abs_t NegVal = (enum Big_abs_t)((long long)INT_MIN - 1);    // OK
+  enum Big_abs_t ZeroVal = (enum Big_abs_t)(0);    // OK
+  enum Big_abs_t BigVal = (enum Big_abs_t)((long long)INT_MAX + 1);  // OK
 }
 
-enum En_t unused;
+enum Unused_t { Unused_enum_val } unused;
 void unusedExpr(void) {
   // Following line is not something that EnumCastOutOfRangeChecker should
   // evaluate.  Checker should either ignore this line or process it without
   // producing any warnings.  However, compilation will (and should) still
   // generate a warning having nothing to do with this checker.
   unused; // expected-warning {{expression result unused}}
 }

clang/test/Analysis/enum-cast-out-of-range.cpp

 // RUN: %clang_analyze_cc1 \
 // RUN:   -analyzer-checker=core,alpha.cplusplus.EnumCastOutOfRange \
 // RUN:   -std=c++11 -verify %s
 
-enum unscoped_unspecified_t {
-  unscoped_unspecified_0 = -4,
-  unscoped_unspecified_1,
-  unscoped_unspecified_2 = 1,
-  unscoped_unspecified_3,
-  unscoped_unspecified_4 = 4
-};
-
-enum unscoped_specified_t : int {
-  unscoped_specified_0 = -4,
-  unscoped_specified_1,
-  unscoped_specified_2 = 1,
-  unscoped_specified_3,
-  unscoped_specified_4 = 4
-};
-
-enum class scoped_unspecified_t {
-  scoped_unspecified_0 = -4,
-  scoped_unspecified_1,
-  scoped_unspecified_2 = 1,
-  scoped_unspecified_3,
-  scoped_unspecified_4 = 4
-};
-
-enum class scoped_specified_t : int {
-  scoped_specified_0 = -4,
-  scoped_specified_1,
-  scoped_specified_2 = 1,
-  scoped_specified_3,
-  scoped_specified_4 = 4
-};
-
-struct S {
-  unscoped_unspecified_t E : 5;
-};
-
-void unscopedUnspecified() {
-  unscoped_unspecified_t InvalidBeforeRangeBegin = static_cast<unscoped_unspecified_t>(-5); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_unspecified_t ValidNegativeValue1 = static_cast<unscoped_unspecified_t>(-4); // OK.
-  unscoped_unspecified_t ValidNegativeValue2 = static_cast<unscoped_unspecified_t>(-3); // OK.
-  unscoped_unspecified_t InvalidInsideRange1 = static_cast<unscoped_unspecified_t>(-2); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_unspecified_t InvalidInsideRange2 = static_cast<unscoped_unspecified_t>(-1); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_unspecified_t InvalidInsideRange3 = static_cast<unscoped_unspecified_t>(0); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_unspecified_t ValidPositiveValue1 = static_cast<unscoped_unspecified_t>(1); // OK.
-  unscoped_unspecified_t ValidPositiveValue2 = static_cast<unscoped_unspecified_t>(2); // OK.
-  unscoped_unspecified_t InvalidInsideRange4 = static_cast<unscoped_unspecified_t>(3); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_unspecified_t ValidPositiveValue3 = static_cast<unscoped_unspecified_t>(4); // OK.
-  unscoped_unspecified_t InvalidAfterRangeEnd = static_cast<unscoped_unspecified_t>(5); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-}
-
-void unscopedSpecified() {
-  unscoped_specified_t InvalidBeforeRangeBegin = static_cast<unscoped_specified_t>(-5); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_specified_t ValidNegativeValue1 = static_cast<unscoped_specified_t>(-4); // OK.
-  unscoped_specified_t ValidNegativeValue2 = static_cast<unscoped_specified_t>(-3); // OK.
-  unscoped_specified_t InvalidInsideRange1 = static_cast<unscoped_specified_t>(-2); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_specified_t InvalidInsideRange2 = static_cast<unscoped_specified_t>(-1); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_specified_t InvalidInsideRange3 = static_cast<unscoped_specified_t>(0); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_specified_t ValidPositiveValue1 = static_cast<unscoped_specified_t>(1); // OK.
-  unscoped_specified_t ValidPositiveValue2 = static_cast<unscoped_specified_t>(2); // OK.
-  unscoped_specified_t InvalidInsideRange4 = static_cast<unscoped_specified_t>(3); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_specified_t ValidPositiveValue3 = static_cast<unscoped_specified_t>(4); // OK.
-  unscoped_specified_t InvalidAfterRangeEnd = static_cast<unscoped_specified_t>(5); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-}
+#define UINT_MAX (~0U)
+#define INT_MAX (int)(UINT_MAX & (UINT_MAX >> 1))
 
-void scopedUnspecified() {
-  scoped_unspecified_t InvalidBeforeRangeBegin = static_cast<scoped_unspecified_t>(-5); // expected-warning{{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_unspecified_t ValidNegativeValue1 = static_cast<scoped_unspecified_t>(-4); // OK.
-  scoped_unspecified_t ValidNegativeValue2 = static_cast<scoped_unspecified_t>(-3); // OK.
-  scoped_unspecified_t InvalidInsideRange1 = static_cast<scoped_unspecified_t>(-2); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_unspecified_t InvalidInsideRange2 = static_cast<scoped_unspecified_t>(-1); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_unspecified_t InvalidInsideRange3 = static_cast<scoped_unspecified_t>(0); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_unspecified_t ValidPositiveValue1 = static_cast<scoped_unspecified_t>(1); // OK.
-  scoped_unspecified_t ValidPositiveValue2 = static_cast<scoped_unspecified_t>(2); // OK.
-  scoped_unspecified_t InvalidInsideRange4 = static_cast<scoped_unspecified_t>(3); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_unspecified_t ValidPositiveValue3 = static_cast<scoped_unspecified_t>(4); // OK.
-  scoped_unspecified_t InvalidAfterRangeEnd = static_cast<scoped_unspecified_t>(5); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-}
+enum unscoped_specified_t : unsigned char;
 
-void scopedSpecified() {
-  scoped_specified_t InvalidBeforeRangeBegin = static_cast<scoped_specified_t>(-5); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_specified_t ValidNegativeValue1 = static_cast<scoped_specified_t>(-4); // OK.
-  scoped_specified_t ValidNegativeValue2 = static_cast<scoped_specified_t>(-3); // OK.
-  scoped_specified_t InvalidInsideRange1 = static_cast<scoped_specified_t>(-2); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_specified_t InvalidInsideRange2 = static_cast<scoped_specified_t>(-1); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_specified_t InvalidInsideRange3 = static_cast<scoped_specified_t>(0); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_specified_t ValidPositiveValue1 = static_cast<scoped_specified_t>(1); // OK.
-  scoped_specified_t ValidPositiveValue2 = static_cast<scoped_specified_t>(2); // OK.
-  scoped_specified_t InvalidInsideRange4 = static_cast<scoped_specified_t>(3); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_specified_t ValidPositiveValue3 = static_cast<scoped_specified_t>(4); // OK.
-  scoped_specified_t InvalidAfterRangeEnd = static_cast<scoped_specified_t>(5); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-}
+enum class scoped_specified_t : unsigned char;
 
-void unscopedUnspecifiedCStyle() {
-  unscoped_unspecified_t InvalidBeforeRangeBegin = (unscoped_unspecified_t)(-5); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_unspecified_t ValidNegativeValue1 = (unscoped_unspecified_t)(-4); // OK.
-  unscoped_unspecified_t ValidNegativeValue2 = (unscoped_unspecified_t)(-3); // OK.
-  unscoped_unspecified_t InvalidInsideRange1 = (unscoped_unspecified_t)(-2); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_unspecified_t InvalidInsideRange2 = (unscoped_unspecified_t)(-1); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_unspecified_t InvalidInsideRange3 = (unscoped_unspecified_t)(0); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_unspecified_t ValidPositiveValue1 = (unscoped_unspecified_t)(1); // OK.
-  unscoped_unspecified_t ValidPositiveValue2 = (unscoped_unspecified_t)(2); // OK.
-  unscoped_unspecified_t InvalidInsideRange4 = (unscoped_unspecified_t)(3); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_unspecified_t ValidPositiveValue3 = (unscoped_unspecified_t)(4); // OK.
-  unscoped_unspecified_t InvalidAfterRangeEnd = (unscoped_unspecified_t)(5); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-}
+void unscopedSpecified() {
+  auto InvalidBeforeRangeBegin = static_cast<unscoped_specified_t>(-1); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
+  auto Zero = static_cast<unscoped_specified_t>(0); // OK.
+  auto VeryBigValueForEnum = static_cast<unscoped_specified_t>(INT_MAX); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
 
-void unscopedSpecifiedCStyle() {
-  unscoped_specified_t InvalidBeforeRangeBegin = (unscoped_specified_t)(-5); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_specified_t ValidNegativeValue1 = (unscoped_specified_t)(-4); // OK.
-  unscoped_specified_t ValidNegativeValue2 = (unscoped_specified_t)(-3); // OK.
-  unscoped_specified_t InvalidInsideRange1 = (unscoped_specified_t)(-2); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_specified_t InvalidInsideRange2 = (unscoped_specified_t)(-1); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_specified_t InvalidInsideRange3 = (unscoped_specified_t)(0); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_specified_t ValidPositiveValue1 = (unscoped_specified_t)(1); // OK.
-  unscoped_specified_t ValidPositiveValue2 = (unscoped_specified_t)(2); // OK.
-  unscoped_specified_t InvalidInsideRange4 = (unscoped_specified_t)(3); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  unscoped_specified_t ValidPositiveValue3 = (unscoped_specified_t)(4); // OK.
-  unscoped_specified_t InvalidAfterRangeEnd = (unscoped_specified_t)(5); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
+  // Suppress unused warnings
+  [](...){}(InvalidBeforeRangeBegin,Zero,VeryBigValueForEnum);
 }
 
-void scopedUnspecifiedCStyle() {
-  scoped_unspecified_t InvalidBeforeRangeBegin = (scoped_unspecified_t)(-5); // expected-warning{{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_unspecified_t ValidNegativeValue1 = (scoped_unspecified_t)(-4); // OK.
-  scoped_unspecified_t ValidNegativeValue2 = (scoped_unspecified_t)(-3); // OK.
-  scoped_unspecified_t InvalidInsideRange1 = (scoped_unspecified_t)(-2); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_unspecified_t InvalidInsideRange2 = (scoped_unspecified_t)(-1); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_unspecified_t InvalidInsideRange3 = (scoped_unspecified_t)(0); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_unspecified_t ValidPositiveValue1 = (scoped_unspecified_t)(1); // OK.
-  scoped_unspecified_t ValidPositiveValue2 = (scoped_unspecified_t)(2); // OK.
-  scoped_unspecified_t InvalidInsideRange4 = (scoped_unspecified_t)(3); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_unspecified_t ValidPositiveValue3 = (scoped_unspecified_t)(4); // OK.
-  scoped_unspecified_t InvalidAfterRangeEnd = (scoped_unspecified_t)(5); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
+void scopedSpecified() {
+  auto InvalidBeforeRangeBegin = static_cast<scoped_specified_t>(-1); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
+  auto Zero = static_cast<scoped_specified_t>(0); // OK.
+  auto VeryBigValueForEnum = static_cast<scoped_specified_t>(INT_MAX); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
+                                                                        //
+  // Suppress unused warnings
+  [](...){}(InvalidBeforeRangeBegin,Zero,VeryBigValueForEnum);
 }
 
-void scopedSpecifiedCStyle() {
-  scoped_specified_t InvalidBeforeRangeBegin = (scoped_specified_t)(-5); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_specified_t ValidNegativeValue1 = (scoped_specified_t)(-4); // OK.
-  scoped_specified_t ValidNegativeValue2 = (scoped_specified_t)(-3); // OK.
-  scoped_specified_t InvalidInsideRange1 = (scoped_specified_t)(-2); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_specified_t InvalidInsideRange2 = (scoped_specified_t)(-1); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_specified_t InvalidInsideRange3 = (scoped_specified_t)(0); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_specified_t ValidPositiveValue1 = (scoped_specified_t)(1); // OK.
-  scoped_specified_t ValidPositiveValue2 = (scoped_specified_t)(2); // OK.
-  scoped_specified_t InvalidInsideRange4 = (scoped_specified_t)(3); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-  scoped_specified_t ValidPositiveValue3 = (scoped_specified_t)(4); // OK.
-  scoped_specified_t InvalidAfterRangeEnd = (scoped_specified_t)(5); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-}
+void undefinedInput(int input) {
+  auto unscoped  = static_cast<unscoped_specified_t>(input); // OK.
+  auto scoped  = static_cast<scoped_specified_t>(input); // OK.
 
-unscoped_unspecified_t unused;
-void unusedExpr() {
-  // following line is not something that EnumCastOutOfRangeChecker should evaluate.  checker should either ignore this line
-  // or process it without producing any warnings.  However, compilation will (and should) still generate a warning having
-  // nothing to do with this checker.
-  unused; // expected-warning {{expression result unused}}
-}
-
-void rangeConstrained1(int input) {
-  if (input > -5 && input < 5)
-    auto value = static_cast<scoped_specified_t>(input); // OK. Being conservative, this is a possibly good value.
+   // Suppress unused warnings
+  [](...){}(unscoped, scoped);
 }
 
 void rangeConstrained2(int input) {
-  if (input < -5)
-    auto value = static_cast<scoped_specified_t>(input); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-}
-
-void rangeConstrained3(int input) {
-  if (input >= -2 && input <= -1)
-    auto value = static_cast<scoped_specified_t>(input); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-}
-
-void rangeConstrained4(int input) {
-  if (input >= -2 && input <= 1)
-    auto value = static_cast<scoped_specified_t>(input); // OK. Possibly 1.
-}
+  if (input < 0) {
+    auto unscoped = static_cast<unscoped_specified_t>(input); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
+    auto scoped = static_cast<scoped_specified_t>(input); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
 
-void rangeConstrained5(int input) {
-  if (input >= 1 && input <= 2)
-    auto value = static_cast<scoped_specified_t>(input); // OK. Strict inner matching.
+    // Suppress unused warnings
+    [](...){}(unscoped, scoped);
   }
-
-void rangeConstrained6(int input) {
-  if (input >= 2 && input <= 4)
-    auto value = static_cast<scoped_specified_t>(input); // OK. The value is possibly 2 or 4, dont warn.
-}
-
-void rangeConstrained7(int input) {
-  if (input >= 3 && input <= 3)
-    auto value = static_cast<scoped_specified_t>(input); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
-}
-
-void enumBitFieldAssignment() {
-  S s;
-  s.E = static_cast<unscoped_unspecified_t>(4); // OK.
-  s.E = static_cast<unscoped_unspecified_t>(5); // expected-warning {{The value provided to the cast expression is not in the valid range of values for the enum}}
 }