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

[aeubanks]

Summary

Similar to D135170.

[DavidSpickett]

You need to update the python file for the test as well.

What does the output look like, do we actually print the character itself or it's value? (just curious, which one we do is probably out of scope for this change)

clang/lib/AST/StmtPrinter.cpp

1298

Is there any reason to have a suffix here?

I admit this function is puzzling to me anyway given that char has a prefix and this won't. Perhaps this is because char here is not "character" it's an integer of a certain size. Where wide char is more about, well, being an actual character.

And reading https://en.cppreference.com/w/cpp/language/character_literal the suffix would be "L" which we've already used.

As long as it prints in a way that's useful for the developer that's fine.

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

39

Is there a specific signed wchar_t and unsigned wchar_t like for char?

[aeubanks]

update python test, although those changes don't actually test the code path changed here, the code path here is tested via the existing self.expect("image lookup -t A")

clang/lib/AST/StmtPrinter.cpp

1298

https://en.cppreference.com/w/cpp/language/character_literal is about char literal prefixes, which is not what this is

e.g.

$ lldb a.out
(lldb) im loo -t A
...
static const unsigned char uchar_max = 255Ui8;

this output isn't valid C++, I believe it's just more clarification for the user on the exact type of the integer literal. I could make this output something like "UW"/"SW"?

with and without this change, we already have

(lldb) print A::wchar_min
(const wchar_t) $0 = L'\U0000fffd'

this change makes the following not crash

$ lldb a.out
(lldb) im loo -t A
...
static const wchar_t wchar_max = 2147483647;

any suffix we choose here is appended to the 2147483647

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

39

/tmp/a.cc:1:7: error: 'wchar_t' cannot be signed or unsigned [-Wsigned-unsigned-wchar]
const unsigned wchar_t a = 0;

https://en.cppreference.com/w/cpp/language/types

wchar_t - type for wide character representation (see wide strings). It has the same size, signedness, and alignment as one of the integer types, but is a distinct type.

so it sounds like under the hood the signedness is platform dependent, but there's only one wchar_t type

[DavidSpickett]

although those changes don't actually test the code path changed here

Yeah I'm just cargo culting on that one so it doesn't look strange that a few are missing.

If we're going to change the suffix that can be done elsewhere and reviewed by someone who understands them better than me :)

Not crashing is an improvement in itself, LGTM.

clang/lib/AST/StmtPrinter.cpp

void StmtPrinter::VisitIntegerLiteral(IntegerLiteral *Node) {
   case BuiltinType::Long:      OS << 'L'; break;
   case BuiltinType::ULong:     OS << "UL"; break;
   case BuiltinType::LongLong:  OS << "LL"; break;
   case BuiltinType::ULongLong: OS << "ULL"; break;
   case BuiltinType::Int128:
     break; // no suffix.
   case BuiltinType::UInt128:
     break; // no suffix.
+  case BuiltinType::WChar_S:
+  case BuiltinType::WChar_U:
+    break; // no suffix
   }
 }
 
 void StmtPrinter::VisitFixedPointLiteral(FixedPointLiteral *Node) {
   if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context))
     return;
   OS << Node->getValueAsString(/*Radix=*/10);
 

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

def test(self):
         self.expect_expr("A::schar_max == schar_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")
         self.expect_expr("A::ulonglong_max == ulonglong_max", result_value="true")
+        self.expect_expr("A::wchar_max == wchar_max", result_value="true")
 
         self.expect_expr("A::char_min == char_min", result_value="true")
         self.expect_expr("A::schar_min == schar_min", result_value="true")
         self.expect_expr("A::uchar_min == uchar_min", result_value="true")
         self.expect_expr("A::int_min == int_min", result_value="true")
         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")
+        self.expect_expr("A::wchar_min == wchar_min", result_value="true")
 
         # Test an unscoped enum.
         self.expect_expr("A::enum_val", result_value="enum_case2")
 
         # Test a scoped enum.
         self.expect_expr("A::scoped_enum_val", result_value="scoped_enum_case2")
         # Test an scoped enum with a value that isn't an enumerator.
         self.expect_expr("A::not_enumerator_scoped_enum_val", result_value="scoped_enum_case1 | 0x4")

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

struct A {
   const static auto uchar_max = std::numeric_limits<unsigned char>::max();
   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 wchar_max = std::numeric_limits<wchar_t>::max();
 
   const static auto char_min = std::numeric_limits<char>::min();
   const static auto schar_min = std::numeric_limits<signed 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();
+  const static auto wchar_min = std::numeric_limits<wchar_t>::min();
 
   const static Enum enum_val = enum_case2;
   const static ScopedEnum scoped_enum_val = ScopedEnum::scoped_enum_case2;
   const static ScopedEnum not_enumerator_scoped_enum_val = static_cast<ScopedEnum>(5);
   const static ScopedEnum not_enumerator_scoped_enum_val_2 =
       static_cast<ScopedEnum>(7);
   const static ScopedCharEnum scoped_char_enum_val = ScopedCharEnum::case2;
   const static ScopedLongLongEnum scoped_ll_enum_val_neg =
int main() {
   auto schar_max = A::schar_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;
   auto ulonglong_max = A::ulonglong_max;
+  auto wchar_max = A::wchar_max;
 
   auto char_min = A::char_min;
   auto schar_min = A::schar_min;
   auto uchar_min = A::uchar_min;
   auto int_min = A::int_min;
   auto uint_min = A::uint_min;
   auto long_min = A::long_min;
   auto ulong_min = A::ulong_min;
   auto longlong_min = A::longlong_min;
   auto ulonglong_min = A::ulonglong_min;
+  auto wchar_min = A::wchar_min;
 
   int member_copy = ClassWithOnlyConstStatic::member;
 
   Enum e = A::enum_val;
   ScopedEnum se = A::scoped_enum_val;
   se = A::not_enumerator_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
 }