[clang] Do not crash on pointer wchar_t pointer assignment.

[adamcz]

Summary

wchar_t can be signed (thus hasSignedIntegerRepresentation() returns
true), but it doesn't have an unsigned type, which would lead to a crash
when trying to get it.

With this fix, we special-case WideChar types in the pointer assignment
code.

[adamcz]

rebase

[hokein]

clang/lib/Sema/SemaExpr.cpp

8726

I'm wondering whether the fix is in ASTContext::getCorrespondingUnsignedType()

if my reading of the standard is right:

• there exists a corresponding standard (or extended) unsigned integer type for each of standard (or extended) signed integer types, http://eel.is/c++draft/basic.fundamental#2
• wchar_t is an integer type, http://eel.is/c++draft/basic.fundamental#11, and has an implementation-defined signed or unsigned integer type as its underlying type, http://eel.is/c++draft/basic.fundamental#8

I think the rule also applies on wchar_t, the fix seems to handle WChar_S case (return ASTContext::getUnsignedWCharType()) in ASTContext::getCorrespondingUnsignedType(). What do you think?

[adamcz]

addressed review comment

clang/lib/Sema/SemaExpr.cpp

8726

http://eel.is/c++draft/basic.fundamental#11 - wchar_t is not a signed or unsigned integer type. It is an integer type, but not signed integer type. Therefore it's underlying type might have an matching signed/unsigned version, but wchar_t does not.

I initially wanted to fix ASTContext::getCorrespondingUnsignedType(), but switched to this version with the idea that calling getCorrespondingUnsignedType() on wchar_t is most likely a bug in the first place and returning something there might just hide the issue.

However, based on your comment and the fact that, for char, we already return underlying type too, I think maybe this is a better approach after all. Updated. Thanks!

[hokein]

Thanks!

clang/lib/Sema/SemaExpr.cpp

checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType) {
   // unqualified versions of compatible types, ...
   QualType ltrans = QualType(lhptee, 0), rtrans = QualType(rhptee, 0);
   if (!S.Context.typesAreCompatible(ltrans, rtrans)) {
     // Check if the pointee types are compatible ignoring the sign.
     // We explicitly check for char so that we catch "char" vs
     // "unsigned char" on systems where "char" is unsigned.
     if (lhptee->isCharType())
       ltrans = S.Context.UnsignedCharTy;
-    else if (lhptee->hasSignedIntegerRepresentation())
+    else if (!lhptee->isWideCharType() &&
+             lhptee->hasSignedIntegerRepresentation())
       ltrans = S.Context.getCorrespondingUnsignedType(ltrans);
 
     if (rhptee->isCharType())
       rtrans = S.Context.UnsignedCharTy;
-    else if (rhptee->hasSignedIntegerRepresentation())
+    else if (!rhptee->isWideCharType() &&
+             rhptee->hasSignedIntegerRepresentation())
       rtrans = S.Context.getCorrespondingUnsignedType(rtrans);
 
     if (ltrans == rtrans) {
       // Types are compatible ignoring the sign. Qualifier incompatibility
       // takes priority over sign incompatibility because the sign
       // warning can be disabled.
       if (ConvTy != Sema::Compatible)
         return ConvTy;

clang/test/SemaCXX/wchar_t.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
-// RUN: %clang_cc1 -fsyntax-only -Wno-signed-unsigned-wchar -verify=allow-signed %s
+// RUN: %clang_cc1 -fsyntax-only -Wno-signed-unsigned-wchar -verify=allow-signed -DSKIP_ERROR_TESTS %s
 // allow-signed-no-diagnostics
 wchar_t x;
 
 void f(wchar_t p) {
   wchar_t x;
   unsigned wchar_t y; // expected-error {{'wchar_t' cannot be signed or unsigned}}
   signed wchar_t z; // expected-error {{'wchar_t' cannot be signed or unsigned}}
   ++x;
int t(void) {
   basic_string<wchar_t>() + L'-';
   return (0);
 }
 
 
 // rdar://8040728
 wchar_t in[] = L"\x434" "\x434";  // No warning
 
+#ifndef SKIP_ERROR_TESTS
+// Verify that we do not crash when assigning wchar_t* to another pointer type.
+void assignment(wchar_t *x) {
+  char *y;
+  y = x; // expected-error {{incompatible pointer types assigning to 'char *' from 'wchar_t *'}}
+}
+#endif