Add warnings for casting ptr -> smaller int for C++ in Microsoft mode

[aeubanks]

Summary

Adds warnings to groups recently added in https://reviews.llvm.org/D72231.

[rnk]

Looks good, but we should add a test.

I can push this for you and even give attribution (hooray, git!), but I think you have enough uploaded code reviews that you could request push access as described here:
https://llvm.org/docs/DeveloperPolicy.html#new-contributors
Link to all the phab issues you have opened to show contributions.

clang/test/SemaCXX/MicrosoftExtensions.cpp

228

Can you please add a test for the void* diagnostic to exercise the other side of the ternary?

[aeubanks]

• Add tests for void *

[aeubanks]

I can push this for you and even give attribution (hooray, git!), but I think you have enough uploaded code reviews that you could request push access as described here:
https://llvm.org/docs/DeveloperPolicy.html#new-contributors
Link to all the phab issues you have opened to show contributions.

Sounds good, I'll send an email to request push access.

[aeubanks]

• Format

[rnk]

Thanks, looks good! I'll push it in a sec.

clang/lib/Sema/SemaCast.cpp

if (!destIsPtr && !srcIsPtr) {
     return TC_NotApplicable;
   }
 
   if (DestType->isIntegralType(Self.Context)) {
     assert(srcIsPtr && "One type must be a pointer");
     // C++ 5.2.10p4: A pointer can be explicitly converted to any integral
     //   type large enough to hold it; except in Microsoft mode, where the
     //   integral type size doesn't matter (except we don't allow bool).
-    bool MicrosoftException = Self.getLangOpts().MicrosoftExt &&
-                              !DestType->isBooleanType();
     if ((Self.Context.getTypeSize(SrcType) >
-         Self.Context.getTypeSize(DestType)) &&
-         !MicrosoftException) {
+         Self.Context.getTypeSize(DestType))) {
+      bool MicrosoftException =
+          Self.getLangOpts().MicrosoftExt && !DestType->isBooleanType();
+      if (MicrosoftException) {
+        unsigned Diag = SrcType->isVoidPointerType()
+                            ? diag::warn_void_pointer_to_int_cast
+                            : diag::warn_pointer_to_int_cast;
+        Self.Diag(OpRange.getBegin(), Diag) << SrcType << DestType << OpRange;
+      } else {
         msg = diag::err_bad_reinterpret_cast_small_int;
         return TC_Failed;
       }
+    }
     Kind = CK_PointerToIntegral;
     return TC_Success;
   }
 
   if (SrcType->isIntegralOrEnumerationType()) {
     assert(destIsPtr && "One type must be a pointer");
     checkIntToPointerCast(CStyle, OpRange, SrcExpr.get(), DestType, Self);
     // C++ 5.2.10p5: A value of integral or enumeration type can be explicitly

clang/test/SemaCXX/MicrosoftExtensions.cpp

 {
 
 }
 
 extern const int static_var; // expected-note {{previous declaration is here}}
 static const int static_var = 3; // expected-warning {{redeclaring non-static 'static_var' as static is a Microsoft extension}}
 
 void pointer_to_integral_type_conv(char* ptr) {
-   char ch = (char)ptr;
-   short sh = (short)ptr;
-   ch = (char)ptr;
-   sh = (short)ptr;
+  char ch = (char)ptr;   // expected-warning {{cast to smaller integer type 'char' from 'char *'}}
+  short sh = (short)ptr; // expected-warning {{cast to smaller integer type 'short' from 'char *'}}
+  ch = (char)ptr;        // expected-warning {{cast to smaller integer type 'char' from 'char *'}}
+  sh = (short)ptr;       // expected-warning {{cast to smaller integer type 'short' from 'char *'}}
+
+  // These are valid C++.
+  bool b = (bool)ptr;
+  b = static_cast<bool>(ptr);
+
+  // This is bad.
+  b = reinterpret_cast<bool>(ptr); // expected-error {{cast from pointer to smaller type 'bool' loses information}}
+}
+
+void void_pointer_to_integral_type_conv(void *ptr) {
+  char ch = (char)ptr;   // expected-warning {{cast to smaller integer type 'char' from 'void *'}}
+  short sh = (short)ptr; // expected-warning {{cast to smaller integer type 'short' from 'void *'}}
+  ch = (char)ptr;        // expected-warning {{cast to smaller integer type 'char' from 'void *'}}
+  sh = (short)ptr;       // expected-warning {{cast to smaller integer type 'short' from 'void *'}}
 
-   // These are valid C++.
-   bool b = (bool)ptr;
-   b = static_cast<bool>(ptr);
 
-   // This is bad.
-   b = reinterpret_cast<bool>(ptr); // expected-error {{cast from pointer to smaller type 'bool' loses information}}
 }
 
 struct PR11150 {
   class X {
     virtual void f() = 0;
   };
 
   int array[__is_abstract(X)? 1 : -1];
 };