[LLDB] Fix crash when printing a struct with a static signed char member

[DavidSpickett]

Summary

As with static bool for whatever reason printing them on their own
worked fine but wasn't handled when you printed the whole type.

I don't see a good way to test this from clang's side so our existing
tests will have to do.

We can now print all of the struct "A", so there's no need for a separate
one for static bool testing. I've not checked the output, just that it
succeeds. This saves us having to handle different min/max between systems.

Depends on D135169

[DavidSpickett]

Rebase

[shafik]

LGTM

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

39

We use signed char for the max case but char for the min case. Maybe we need a max using char and a min using signed char.

[DavidSpickett]

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

39

I'll look into this.

clang/lib/AST/StmtPrinter.cpp

 //===- StmtPrinter.cpp - Printing implementation for Stmt ASTs ------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
void StmtPrinter::VisitIntegerLiteral(IntegerLiteral *Node) {
   }
 
   // Emit suffixes.  Integer literals are always a builtin integer type.
   switch (Node->getType()->castAs<BuiltinType>()->getKind()) {
   default: llvm_unreachable("Unexpected type for integer literal!");
   case BuiltinType::Char_S:
   case BuiltinType::Char_U:    OS << "i8"; break;
   case BuiltinType::UChar:     OS << "Ui8"; break;
+  case BuiltinType::SChar:     OS << "i8"; break;
   case BuiltinType::Short:     OS << "i16"; break;
   case BuiltinType::UShort:    OS << "Ui16"; break;
   case BuiltinType::Int:       break; // no suffix.
   case BuiltinType::UInt:      OS << 'U'; break;
   case BuiltinType::Long:      OS << 'L'; break;
   case BuiltinType::ULong:     OS << "UL"; break;
   case BuiltinType::LongLong:  OS << "LL"; break;
   case BuiltinType::ULongLong: OS << "ULL"; break;

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

def test(self):
 
         # Test a simple integer member that was also defined in a namespace
         # scope and has an address.
         self.expect_expr("A::int_val_with_address", result_value="2")
 
         # Test a bool member.
         self.expect_expr("A::bool_val", result_value="true")
 
-        # Test a bool member when printing the struct it is a member of.
-        # TODO: replace this with printing struct A, once doing so doesn't crash lldb.
-        self.expect("image lookup -t StaticBoolStruct",
-                    substrs=["static const bool value = false;"])
-
         # Test that minimum and maximum values for each data type are right.
         self.expect_expr("A::char_max == char_max", result_value="true")
         self.expect_expr("A::uchar_max == uchar_max", result_value="true")
         self.expect_expr("A::int_max == int_max", result_value="true")
         self.expect_expr("A::uint_max == uint_max", result_value="true")
         self.expect_expr("A::long_max == long_max", result_value="true")
         self.expect_expr("A::ulong_max == ulong_max", result_value="true")
         self.expect_expr("A::longlong_max == longlong_max", result_value="true")
def test(self):
             # a linker error.
             self.expect("expr const int *i = &A::int_val; *i", error=True,
                         substrs=["Couldn't lookup symbols:"])
 
         # This should work on all platforms.
         self.expect_expr("const int *i = &A::int_val_with_address; *i",
                          result_value="2")
 
+        # Printing the whole type takes a slightly different code path. Check that
+        # it does not crash.
+        self.expect("image lookup -t A")
+
     # dsymutil strips the debug info for classes that only have const static
     # data members without a definition namespace scope.
     @expectedFailureAll(debug_info=["dsym"])
     def test_class_with_only_const_static(self):
         self.build()
         lldbutil.run_to_source_breakpoint(self, "// break here", lldb.SBFileSpec("main.cpp"))
 
         self.expect_expr("ClassWithOnlyConstStatic::member", result_value="3")

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

 #include <limits>
 
 enum Enum {
   enum_case1 = 1,
   enum_case2 = 2,
 };
 
 enum class ScopedEnum {
struct A {
   const static auto int_max = std::numeric_limits<int>::max();
   const static auto uint_max = std::numeric_limits<unsigned>::max();
   const static auto long_max = std::numeric_limits<long>::max();
   const static auto ulong_max = std::numeric_limits<unsigned long>::max();
   const static auto longlong_max = std::numeric_limits<long long>::max();
   const static auto ulonglong_max =
       std::numeric_limits<unsigned long long>::max();
 
   const static auto char_min = std::numeric_limits<char>::min();
   const static auto uchar_min = std::numeric_limits<unsigned char>::min();
   const static auto int_min = std::numeric_limits<int>::min();
   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();
struct ClassWithEnumAlias {
   using EnumAlias = ScopedEnum;
   static constexpr EnumAlias enum_alias = ScopedEnum::scoped_enum_case2;
 
   using EnumAliasAlias = EnumAlias;
   static constexpr EnumAliasAlias enum_alias_alias =
       ScopedEnum::scoped_enum_case1;
 };
 
-struct StaticBoolStruct {
-  static const bool value = false;
-};
-
 int main() {
   A a;
-  StaticBoolStruct sbs;
 
   auto char_max = A::char_max;
   auto uchar_max = A::uchar_max;
   auto int_max = A::int_max;
   auto uint_max = A::uint_max;
   auto long_max = A::long_max;
   auto ulong_max = A::ulong_max;
   auto longlong_max = A::longlong_max;