In the following snippet I've defined a basic assertion macro and an enum, with an external function that returns a value typed by that enum. I wish to verify that the returned value is a valid enumerated value.

Firstly, if we remove both assertions below then there are no warnings generated, despite the fact that an out of bounds access on the printf is possible.

If you add both assertions then the warning described inline occur: a warning on the first assertion claims that the result can be predetermined. If we assume that enums can only take their enumerated values then this could be a reasonable claim, albeit unsafe in my opinion.

However, if you remove the first assertion then a warning is generated on the printf line indicating that a possible out-of-range access at position -2147483648 occurs. In this case, Lint assumes that enums can take any possible value. In my opinion this is the desired result, however it conflicts with the previous paragraph.

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>

typedef enum MyEnum_e
{
  ENUM_VAL_0 = 0,
  ENUM_VAL_1 = 1,
  ENUM_VAL_COUNT
} MyEnum_t;

MyEnum_t f(void);

#define MY_ASSERT(cond) if (!(cond)) exit(0)
int main()
{
    static int32_t the_array[(uint32_t)ENUM_VAL_COUNT] = { 0, 1 };
    MyEnum_t the_value = f(); //some function call, perhaps external. consider f() could return (MyEnum_t)(-1);
    MY_ASSERT(the_value >= ENUM_VAL_0); //causes warnings 2650 and 587, incorrectly claims predicate '>=' can be pre-determined and always evaluates to true.
    MY_ASSERT(the_value < ENUM_VAL_COUNT);
    (void)printf("%i", the_array[the_value]); //If you comment out the first assertion above then this line triggers "warning 676: possibly indexing before the beginning of an allocation, inference yields -2147483648"

    return 0;
}