[LLDB] Remove undefined behavior in TestConstStaticIntegralMember.py

[shafik]

Summary

Setting an enum without a fixed underlying type to a value which is outside the value range is undefined behavior.

The initializer needs to be a constant expression and therefore this was always ill-formed we just were not diagnosing it before.

See D130058 and D131307 for more details.

[shafik]

I will probably land this soon since this is being reported by several built bots and I this should bring the builds back to green. I just wanted the interested parties to see this in case there is some functionality this is testing that I am missing and some additions are needed to cover what you want.

[DavidSpickett]

Just looking at the test I think the main thing this removes is checking that we can show an enum as a combination of more than one value plus some extra number (invalid_scoped_enum_val is only one valid name plus extra).

Thanks for bringing this to our attention. I'm guessing that the formatting code is the same for scoped/non scoped or non typed so I'll add an extra test for the typed enum to cover the multiple values case.

[DavidSpickett]

https://reviews.llvm.org/D131472

lldb/test/API/lang/cpp/const_static_integral_member/TestConstStaticIntegralMember.py

def test(self):
         self.expect_expr("A::uint_min == uint_min", result_value="true")
         self.expect_expr("A::long_min == long_min", result_value="true")
         self.expect_expr("A::ulong_min == ulong_min", result_value="true")
         self.expect_expr("A::longlong_min == longlong_min", result_value="true")
         self.expect_expr("A::ulonglong_min == ulonglong_min", result_value="true")
 
         # Test an unscoped enum.
         self.expect_expr("A::enum_val", result_value="enum_case2")
-        # Test an unscoped enum with an invalid enum case.
-        self.expect_expr("A::invalid_enum_val", result_value="enum_case1 | enum_case2 | 0x4")
 
         # Test a scoped enum.
         self.expect_expr("A::scoped_enum_val", result_value="scoped_enum_case2")
         # Test an scoped enum with an invalid enum case.
         self.expect_expr("A::invalid_scoped_enum_val", result_value="scoped_enum_case1 | 0x4")
 
         # Test an enum with fixed underlying type.
         self.expect_expr("A::scoped_char_enum_val", result_value="case2")

lldb/test/API/lang/cpp/const_static_integral_member/main.cpp

struct A {
   const static auto uint_min = std::numeric_limits<unsigned>::min();
   const static auto long_min = std::numeric_limits<long>::min();
   const static auto ulong_min = std::numeric_limits<unsigned long>::min();
   const static auto longlong_min = std::numeric_limits<long long>::min();
   const static auto ulonglong_min =
       std::numeric_limits<unsigned long long>::min();
 
   const static Enum enum_val = enum_case2;
-  const static Enum invalid_enum_val = static_cast<Enum>(enum_case2 + 5);
   const static ScopedEnum scoped_enum_val = ScopedEnum::scoped_enum_case2;
   const static ScopedEnum invalid_scoped_enum_val = static_cast<ScopedEnum>(5);
   const static ScopedCharEnum scoped_char_enum_val = ScopedCharEnum::case2;
   const static ScopedLongLongEnum scoped_ll_enum_val_neg =
       ScopedLongLongEnum::case0;
   const static ScopedLongLongEnum scoped_ll_enum_val =
       ScopedLongLongEnum::case2;
 };
int main() {
   auto long_min = A::long_min;
   auto ulong_min = A::ulong_min;
   auto longlong_min = A::longlong_min;
   auto ulonglong_min = A::ulonglong_min;
 
   int member_copy = ClassWithOnlyConstStatic::member;
 
   Enum e = A::enum_val;
-  e = A::invalid_enum_val;
   ScopedEnum se = A::scoped_enum_val;
   se = A::invalid_scoped_enum_val;
   ScopedCharEnum sce = A::scoped_char_enum_val;
   ScopedLongLongEnum sle = A::scoped_ll_enum_val;
 
   auto enum_alias_val = ClassWithEnumAlias::enum_alias;
   auto enum_alias_alias_val = ClassWithEnumAlias::enum_alias_alias;
 
   return 0; // break here
 }