Source code
Revision control
Copy as Markdown
Other Tools
#define MOZ_ENUM_SERIALIZER_ALLOW_SENTINEL_UPPER_BOUND \
__attribute__((annotate("moz_enum_serializer_allow_sentinel_upper_bound")))
#define MOZ_ENUM_SERIALIZER_ALLOW_MIN_MISMATCH \
__attribute__((annotate("moz_enum_serializer_allow_min_mismatch")))
// Minimal definitions matching ipc/glue/EnumSerializer.h
template <typename E, typename EnumValidator> struct EnumSerializer {};
template <typename E, E MinLegal, E HighBound>
class ContiguousEnumValidator {};
template <typename E, E MinLegal, E MaxLegal>
class ContiguousEnumValidatorInclusive {};
template <typename E, E MinLegal, E HighBound>
struct ContiguousEnumSerializer
: EnumSerializer<E, ContiguousEnumValidator<E, MinLegal, HighBound>> {};
template <typename E, E MinLegal, E MaxLegal>
struct ContiguousEnumSerializerInclusive
: EnumSerializer<E,
ContiguousEnumValidatorInclusive<E, MinLegal, MaxLegal>> {};
template <typename E, E AllBits>
struct BitFlagsEnumSerializer {};
template <class P> struct ParamTraits;
// --- Test: Inclusive with sentinel value ---
enum class WithCount { A, B, C, OP_COUNT };
template <>
struct ParamTraits<WithCount> // expected-warning {{ContiguousEnumSerializerInclusive includes sentinel value 'OP_COUNT' as valid; use ContiguousEnumSerializer with an exclusive upper bound instead}}
: ContiguousEnumSerializerInclusive<
WithCount, WithCount::A, WithCount::OP_COUNT> {};
enum class WithMax { None, Partial, Full, MAX };
template <>
struct ParamTraits<WithMax> // expected-warning {{ContiguousEnumSerializerInclusive includes sentinel value 'MAX' as valid; use ContiguousEnumSerializer with an exclusive upper bound instead}}
: ContiguousEnumSerializerInclusive<
WithMax, WithMax::None, WithMax::MAX> {};
enum class WithInvalid { Default, Verbose, Invalid };
template <>
struct ParamTraits<WithInvalid> // expected-warning {{ContiguousEnumSerializerInclusive includes sentinel value 'Invalid' as valid; use ContiguousEnumSerializer with an exclusive upper bound instead}}
: ContiguousEnumSerializerInclusive<
WithInvalid, WithInvalid::Default, WithInvalid::Invalid> {};
// --- Test: Min value doesn't match first enumerator ---
enum class SkippedFirst { First = 0, Second = 1, Third = 2, NUM };
template <>
struct ParamTraits<SkippedFirst> // expected-warning {{ContiguousEnumSerializer min value 'Second' does not match the first enumerator 'First' (value 0); the range excludes valid enum values}}
: ContiguousEnumSerializer<
SkippedFirst, SkippedFirst::Second, SkippedFirst::NUM> {};
// --- Test: Non-contiguous enum (gaps) ---
enum class Rotation { R0 = 0, R90 = 90, R180 = 180, R270 = 270, SENTINEL };
template <>
struct ParamTraits<Rotation> // expected-error {{ContiguousEnumSerializer used with non-contiguous enum; range accepts 271 values but only 4 enumerators exist (267 invalid values accepted)}}
: ContiguousEnumSerializer<
Rotation, Rotation::R0, Rotation::SENTINEL> {};
// Non-contiguous (duplication)
enum class Duplicate { First = 1, Second = 2, AlsoSecond = 2, Fourth = 4, Count };
template <>
struct ParamTraits<Duplicate> // expected-error {{ContiguousEnumSerializer used with non-contiguous enum; range accepts 4 values but only 3 enumerators exist (1 invalid values accepted)}}
: ContiguousEnumSerializer<
Duplicate, Duplicate::First, Duplicate::Count> {};
// --- Test: Bit-flag enum ---
enum class Flags {
NONE = 0,
A = 1 << 0,
B = 1 << 1,
C = 1 << 2,
D = 1 << 3,
SENTINEL
};
template <>
struct ParamTraits<Flags> // expected-error {{ContiguousEnumSerializer used with non-contiguous enum; range accepts 9 values but only 5 enumerators exist (4 invalid values accepted)}}
: ContiguousEnumSerializer<
Flags, Flags::NONE, Flags::SENTINEL> {};
// --- Test: Correct usage (should not warn) ---
enum class Good { First, Second, Third, NUM };
template <>
struct ParamTraits<Good>
: ContiguousEnumSerializer<Good, Good::First, Good::NUM> {};
enum class GoodInclusive { First, Second, Third };
template <>
struct ParamTraits<GoodInclusive>
: ContiguousEnumSerializerInclusive<GoodInclusive, GoodInclusive::First,
GoodInclusive::Third> {};
// --- Test: Inclusive + sentinel AND skipped first (multiple errors) ---
enum class ComboIssue { Clear = 0, Over = 1, Xor = 2, OP_COUNT };
template <>
struct ParamTraits<ComboIssue> // expected-warning {{ContiguousEnumSerializerInclusive includes sentinel value 'OP_COUNT' as valid; use ContiguousEnumSerializer with an exclusive upper bound instead}} expected-warning {{ContiguousEnumSerializerInclusive min value 'Over' does not match the first enumerator 'Clear' (value 0); the range excludes valid enum values}}
: ContiguousEnumSerializerInclusive<
ComboIssue, ComboIssue::Over, ComboIssue::OP_COUNT> {};
// --- Test: Non-contiguous with small gap ---
enum class StorageAccess { Deny = -2, Default = -1, Allow = 0, Prompt = 1, Grant = 3 };
template <>
struct ParamTraits<StorageAccess> // expected-error {{ContiguousEnumSerializerInclusive used with non-contiguous enum; range accepts 6 values but only 5 enumerators exist (1 invalid values accepted)}}
: ContiguousEnumSerializerInclusive<
StorageAccess, StorageAccess::Deny, StorageAccess::Grant> {};
// --- Test: Upper bound doesn't match last enumerator (inclusive) ---
enum class MissedHigh { A = 0, B = 1, C = 2, D = 3 };
template <>
struct ParamTraits<MissedHigh> // expected-warning {{ContiguousEnumSerializerInclusive upper bound does not match the last enumerator 'D' (value 3); the range may exclude valid enum values}}
: ContiguousEnumSerializerInclusive<
MissedHigh, MissedHigh::A, MissedHigh::B> {};
// --- Test: Upper bound doesn't match last enumerator (exclusive) ---
enum class MissedHighExcl { A = 0, B = 1, C = 2, D = 3, Count };
template <>
struct ParamTraits<MissedHighExcl> // expected-warning {{ContiguousEnumSerializer upper bound does not match the last enumerator 'Count' (value 4); the range may exclude valid enum values}}
: ContiguousEnumSerializer<
MissedHighExcl, MissedHighExcl::A, MissedHighExcl::C> {};
// --- Test: Attribute suppresses sentinel-upper-bound warning ---
enum class AllowedSentinel { A, B, C, END };
template <>
struct MOZ_ENUM_SERIALIZER_ALLOW_SENTINEL_UPPER_BOUND ParamTraits<AllowedSentinel>
: ContiguousEnumSerializerInclusive<AllowedSentinel, AllowedSentinel::A,
AllowedSentinel::END> {};
// --- Test: Attribute suppresses min-mismatch warning ---
enum class AllowedMinMismatch { First = 0, Second = 1, Third = 2, NUM };
template <>
struct MOZ_ENUM_SERIALIZER_ALLOW_MIN_MISMATCH ParamTraits<AllowedMinMismatch>
: ContiguousEnumSerializer<AllowedMinMismatch, AllowedMinMismatch::Second,
AllowedMinMismatch::NUM> {};