[Sema][ObjC] Allow conversions between pointers to ObjC pointers and pointers to structs

[ahatanak]

Summary

clang was just being conservative and trying to prevent users from messing up the qualifier on the inner pointer type. Lifting this restriction enables using some of the libc++ templates with ObjC pointer arguments, which clang currently rejects.

rdar://79018677

[ahatanak]

I don't think there is any reason conversions between ACTC_none and ACTC_indirectRetainable (for example, conversions between struct S ** and __strong id *x or int * and __strong id *x) should be disallowed. I just made the minimal change needed to enable using ObjC ARC pointers as the libc++ functions' template arguments.

[ahatanak]

Rebase and ping.

[rjmccall]

Alright, LGTM.

clang/lib/Sema/SemaExprObjC.cpp

Sema::CheckObjCConversion(SourceRange castRange, QualType castType,
   // Allow all of these types to be cast to integer types (but not
   // vice-versa).
   if (castACTC == ACTC_none && castType->isIntegralType(Context))
     return ACR_okay;
 
   // Allow casts between pointers to lifetime types (e.g., __strong id*)
   // and pointers to void (e.g., cv void *). Casting from void* to lifetime*
   // must be explicit.
-  if (exprACTC == ACTC_indirectRetainable && castACTC == ACTC_voidPtr)
+  // Allow conversions between pointers to lifetime types and coreFoundation
+  // pointers too, but only when the conversions are explicit.
+  if (exprACTC == ACTC_indirectRetainable &&
+      (castACTC == ACTC_voidPtr ||
+       (castACTC == ACTC_coreFoundation && isCast(CCK))))
     return ACR_okay;
-  if (castACTC == ACTC_indirectRetainable && exprACTC == ACTC_voidPtr &&
+  if (castACTC == ACTC_indirectRetainable &&
+      (exprACTC == ACTC_voidPtr || exprACTC == ACTC_coreFoundation) &&
       isCast(CCK))
     return ACR_okay;
 
   switch (ARCCastChecker(Context, exprACTC, castACTC, false).Visit(castExpr)) {
   // For invalid casts, fall through.
   case ACC_invalid:
     break;
 

clang/test/SemaObjC/arc-type-conversion.m

-// RUN: %clang_cc1 -fsyntax-only -fobjc-arc -fobjc-runtime-has-weak -verify -fblocks %s
+// RUN: %clang_cc1 -fsyntax-only -fobjc-arc -fobjc-runtime-has-weak -verify -fblocks -Wno-incompatible-pointer-types %s
 
 typedef const void * CFTypeRef;
 CFTypeRef CFBridgingRetain(id X);
 id CFBridgingRelease(CFTypeRef);
 
 void * cvt(id arg)
 {
   void* voidp_val;
void ownership_transfer_in_cast(void *vp, Block *pblk) {
   (void)(Block*)lv; // expected-error {{cast of an Objective-C pointer to '__strong Block *'}}
 }
 
 // <rdar://problem/10486347>
 void conversion_in_conditional(id a, void* b) {
   id c = 1 ? a : b; // expected-error {{operands to conditional of types 'id' and 'void *' are incompatible in ARC mode}}
   id d = 1 ? b : a; // expected-error {{operands to conditional of types 'void *' and 'id' are incompatible in ARC mode}}
 }
+
+void conversion_pointer_to_id(__strong id *x) {
+  struct S {
+    int a[2];
+  } s, *p;
+
+  x = (__strong id *)&s;
+  x = &s; // expected-error {{implicit conversion of a non-Objective-C pointer type 'struct S *' to '__strong id *' is disallowed with ARC}}
+  p = (struct S *)x;
+  p = x; // expected-error {{implicit conversion of an indirect pointer to an Objective-C pointer to 'struct S *' is disallowed with ARC}}
+}