[Sema][ObjC] Allow declaring ObjC pointer members in C++ unions under ARC

[ahatanak]

Summary

ObjC pointer members are currently not allowed in unions in either C or C++ mode. This patch lifts the restriction in C++ mode.

This patch essentially treats ObjC pointer members the same way a non-static data member of a class type that has non-trivial special functions is treated. The ObjC pointer member causes all of the defaulted special functions of the union that directly contains the member to be defined as deleted, except when the member has an in-class initializer, the default constructor isn't defined as deleted.

rdar://problem/34213306

[ahatanak]

test/SemaObjCXX/arc-0x.mm

164

The diagnostic message here should say the special function is deleted because the anonymous union's corresponding special function is deleted, but when diagnosing a deleted copy assignment operator, it says the anonymous union's special function is non-trivial. I'm not sure this is a bug, but I see the same diagnostic message when I compile the following non-ObjC code:

struct S0 {
  S0(const S0 &);
  S0 &operator=(const S0 &);
  int *p;
};

struct S1 {
  union {
    union { // copy assignment operator of 'S1' is implicitly deleted because variant field '' has a non-trivial copy assignment operator
      S0 s10;
      int b;
    };
    int c;
  };
  ~S1();
};

S1 *x0;

void testC1(S1 *a0) {
  *a0 = *x0; // error: object of type 'S1' cannot be assigned because its copy assignment operator is implicitly deleted
  *a0 = static_cast<S1&&>(*x0); // error: object of type 'S1' cannot be assigned because its copy assignment operator is implicitly deleted
}

It seems that this happens because the following code in Sema::ShouldDeleteSpecialMember is preventing the method declaration from being marked as deleted:

// For an anonymous struct or union, the copy and assignment special members
// will never be used, so skip the check. For an anonymous union declared at
// namespace scope, the constructor and destructor are used.
if (CSM != CXXDefaultConstructor && CSM != CXXDestructor &&
    RD->isAnonymousStructOrUnion())
  return false;

[rjmccall]

lib/Sema/SemaDeclCXX.cpp

7030

This comment should be talking about non-trivial ownership rather than just general ObjC pointer-ish-ness.

7033

I feel like this would be clearer as separate if statements; you can put separate comments on each.

7085

I believe the right check for variant-ness is inUnion(), not FD->getParent()->isUnion(), since the latter can miss cases with e.g. anonymous structs.

test/SemaObjCXX/arc-0x.mm

164

Well, if it's not different from the ordinary C++ treatment, I think we can justify just improving QoI there separately.

[ahatanak]

Address review comments.

test/SemaObjCXX/arc-0x.mm

164

I filed PR40555 to fix the C++ case.

[rjmccall]

lib/Sema/SemaDeclCXX.cpp

7085

Can you try adding a test case here for an anonymous struct nested within an anonymous union?

[ahatanak]

lib/Sema/SemaDeclCXX.cpp

7085

Added a test case for an anonymous struct nested within an anonymous union (struct S2 in arc-0x.mm).

I found out that the diagnostic messages clang prints for arc-0x.mm are the same whether inUnion() or FD->getParent()->isUnion() is called. This is what I discovered:

SpecialMemberDeletionInfo is used in two cases:

1. To find the deletedness of the special functions in the AST after a class is parsed.

2. When a deleted special function is used, provide more details on why the function is deleted and print note diagnostics.

Since the nested classes are parsed before the enclosing classes, we have all the information we need about the members that are directly contained to correctly infer the deletedness of a class' special functions. So the first case should work fine regardless of which method is called.

It doesn't make a difference for the second case either because SpecialMemberDeletionInfo doesn't try to find out which member of an anonymous struct is causing the special function to be deleted; it only does so for anonymous unions (which happens inside the if statement near comment "// Some additional restrictions exist on the variant members." at line 7140).

[ahatanak]

Add a test case for an anonymous struct nested inside an anonymous union.

[rjmccall]

Asking for a minor tweak, but feel free to commit with that.

lib/Sema/SemaDeclCXX.cpp

7085

Alright. Another place where we could generally improve diagnostics, then.

test/SemaObjCXX/arc-0x.mm

174

Worth adding a FIXME saying that this note should go on f1?

include/clang/Basic/DiagnosticSemaKinds.td

 
 def note_deleted_dtor_no_operator_delete : Note<
   "virtual destructor requires an unambiguous, accessible 'operator delete'">;
 def note_deleted_special_member_class_subobject : Note<
   "%select{default constructor of|copy constructor of|move constructor of|"
   "copy assignment operator of|move assignment operator of|destructor of|"
   "constructor inherited by}0 "
   "%1 is implicitly deleted because "
-  "%select{base class %3|%select{||||variant }4field %3}2 has "
+  "%select{base class %3|%select{||||variant }4field %3}2 "
+  "%select{has "
   "%select{no|a deleted|multiple|an inaccessible|a non-trivial}4 "
   "%select{%select{default constructor|copy constructor|move constructor|copy "
   "assignment operator|move assignment operator|destructor|"
   "%select{default|corresponding|default|default|default}4 constructor}0|"
   "destructor}5"
-  "%select{||s||}4">;
+  "%select{||s||}4"
+  "|is an ObjC pointer}6">;
 def note_deleted_default_ctor_uninit_field : Note<
   "%select{default constructor of|constructor inherited by}0 "
   "%1 is implicitly deleted because field %2 of "
   "%select{reference|const-qualified}4 type %3 would not be initialized">;
 def note_deleted_default_ctor_all_const : Note<
   "%select{default constructor of|constructor inherited by}0 "
   "%1 is implicitly deleted because all "
   "%select{data members|data members of an anonymous union member}2"

lib/AST/DeclCXX.cpp

if (T->isObjCRetainableType() || T.isObjCGCStrong()) {
         if (LT != Qualifiers::OCL_Strong && LT != Qualifiers::OCL_Weak)
           data().HasTrivialSpecialMembersForCall = 0;
 
         // Structs with __weak fields should never be passed directly.
         if (LT == Qualifiers::OCL_Weak)
           setArgPassingRestrictions(RecordDecl::APK_CanNeverPassInRegs);
 
         Data.HasIrrelevantDestructor = false;
+
+        if (isUnion()) {
+          data().DefaultedCopyConstructorIsDeleted = true;
+          data().DefaultedMoveConstructorIsDeleted = true;
+          data().DefaultedMoveAssignmentIsDeleted = true;
+          data().DefaultedDestructorIsDeleted = true;
+          data().NeedOverloadResolutionForCopyConstructor = true;
+          data().NeedOverloadResolutionForMoveConstructor = true;
+          data().NeedOverloadResolutionForMoveAssignment = true;
+          data().NeedOverloadResolutionForDestructor = true;
+        }
       } else if (!Context.getLangOpts().ObjCAutoRefCount) {
         setHasObjectMember(true);
       }
     } else if (!T.isCXX98PODType(Context))
       data().PlainOldData = false;
 
     if (T->isReferenceType()) {
       if (!Field->hasInClassInitializer())

lib/Sema/SemaDecl.cpp

if (FDTy->isFunctionType()) {
         Record->setHasVolatileMember(true);
     } else if (FDTy->isObjCObjectType()) {
       /// A field cannot be an Objective-c object
       Diag(FD->getLocation(), diag::err_statically_allocated_object)
         << FixItHint::CreateInsertion(FD->getLocation(), "*");
       QualType T = Context.getObjCObjectPointerType(FD->getType());
       FD->setType(T);
     } else if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
-               Record && !ObjCFieldLifetimeErrReported && Record->isUnion()) {
+               Record && !ObjCFieldLifetimeErrReported && Record->isUnion() &&
+               !getLangOpts().CPlusPlus) {
       // It's an error in ARC or Weak if a field has lifetime.
       // We don't want to report this in a system header, though,
       // so we just make the field unavailable.
       // FIXME: that's really not sufficient; we need to make the type
       // itself invalid to, say, initialize or copy.
       QualType T = FD->getType();
       if (T.hasNonTrivialObjCLifetime()) {
         SourceLocation loc = FD->getLocation();

lib/Sema/SemaDeclCXX.cpp

SpecialMemberDeletionInfo(Sema &S, CXXMethodDecl *MD,
         Loc(MD->getLocation()), AllFieldsAreConst(true) {}
 
   bool inUnion() const { return MD->getParent()->isUnion(); }
 
   Sema::CXXSpecialMember getEffectiveCSM() {
     return ICI ? Sema::CXXInvalid : CSM;
   }
 
+  bool shouldDeleteForVariantObjCPtrMember(FieldDecl *FD, QualType FieldType);
+
   bool visitBase(CXXBaseSpecifier *Base) { return shouldDeleteForBase(Base); }
   bool visitField(FieldDecl *Field) { return shouldDeleteForField(Field); }
 
   bool shouldDeleteForBase(CXXBaseSpecifier *Base);
   bool shouldDeleteForField(FieldDecl *FD);
   bool shouldDeleteForAllConstMembers();
 
   bool shouldDeleteForClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
   if (DiagKind == -1)
     return false;
 
   if (Diagnose) {
     if (Field) {
       S.Diag(Field->getLocation(),
              diag::note_deleted_special_member_class_subobject)
         << getEffectiveCSM() << MD->getParent() << /*IsField*/true
-        << Field << DiagKind << IsDtorCallInCtor;
+        << Field << DiagKind << IsDtorCallInCtor << /*IsObjCPtr*/false;
     } else {
       CXXBaseSpecifier *Base = Subobj.get<CXXBaseSpecifier*>();
       S.Diag(Base->getBeginLoc(),
              diag::note_deleted_special_member_class_subobject)
           << getEffectiveCSM() << MD->getParent() << /*IsField*/ false
-          << Base->getType() << DiagKind << IsDtorCallInCtor;
+          << Base->getType() << DiagKind << IsDtorCallInCtor
+          << /*IsObjCPtr*/false;
     }
 
     if (DiagKind == 1)
       S.NoteDeletedFunction(Decl);
     // FIXME: Explain inaccessibility if DiagKind == 3.
   }
 
   return true;
Sema::SpecialMemberOverloadResult SMOR =
                               false, false, false, false, false);
     if (shouldDeleteForSubobjectCall(Subobj, SMOR, true))
       return true;
   }
 
   return false;
 }
 
+bool SpecialMemberDeletionInfo::shouldDeleteForVariantObjCPtrMember(
+    FieldDecl *FD, QualType FieldType) {
+  // The defaulted special functions are defined as deleted if this is a variant
+  // member with a non-trivial ownership type, e.g., ObjC __strong or __weak
+  // type under ARC.
+  if (!FieldType.hasNonTrivialObjCLifetime())
+    return false;
+
+  // Don't make the defaulted default constructor defined as deleted if the
+  // member has an in-class initializer.
+  if (CSM == Sema::CXXDefaultConstructor && FD->hasInClassInitializer())
+    return false;
+
+  if (Diagnose) {
+    auto *ParentClass = cast<CXXRecordDecl>(FD->getParent());
+    S.Diag(FD->getLocation(),
+           diag::note_deleted_special_member_class_subobject)
+        << getEffectiveCSM() << ParentClass << /*IsField*/true
+        << FD << 4 << /*IsDtorCallInCtor*/false << /*IsObjCPtr*/true;
+  }
+
+  return true;
+}
+
 /// Check whether we should delete a special member function due to the class
 /// having a particular direct or virtual base class.
 bool SpecialMemberDeletionInfo::shouldDeleteForBase(CXXBaseSpecifier *Base) {
   CXXRecordDecl *BaseClass = Base->getType()->getAsCXXRecordDecl();
   // If program is correct, BaseClass cannot be null, but if it is, the error
   // must be reported elsewhere.
   if (!BaseClass)
     return false;
   // If we have an inheriting constructor, check whether we're calling an
   // inherited constructor instead of a default constructor.
   Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(BaseClass);
   if (auto *BaseCtor = SMOR.getMethod()) {
     // Note that we do not check access along this path; other than that,
     // this is the same as shouldDeleteForSubobjectCall(Base, BaseCtor, false);
     // FIXME: Check that the base has a usable destructor! Sink this into
     // shouldDeleteForClassSubobject.
     if (BaseCtor->isDeleted() && Diagnose) {
       S.Diag(Base->getBeginLoc(),
              diag::note_deleted_special_member_class_subobject)
           << getEffectiveCSM() << MD->getParent() << /*IsField*/ false
-          << Base->getType() << /*Deleted*/ 1 << /*IsDtorCallInCtor*/ false;
+          << Base->getType() << /*Deleted*/ 1 << /*IsDtorCallInCtor*/ false
+          << /*IsObjCPtr*/false;
       S.NoteDeletedFunction(BaseCtor);
     }
     return BaseCtor->isDeleted();
   }
   return shouldDeleteForClassSubobject(BaseClass, Base, 0);
 }
 
 /// Check whether we should delete a special member function due to the class
 /// having a particular non-static data member.
 bool SpecialMemberDeletionInfo::shouldDeleteForField(FieldDecl *FD) {
   QualType FieldType = S.Context.getBaseElementType(FD->getType());
   CXXRecordDecl *FieldRecord = FieldType->getAsCXXRecordDecl();
 
+  if (inUnion() && shouldDeleteForVariantObjCPtrMember(FD, FieldType))
+    return true;
+
   if (CSM == Sema::CXXDefaultConstructor) {
     // For a default constructor, all references must be initialized in-class
     // and, if a union, it must have a non-const member.
     if (FieldType->isReferenceType() && !FD->hasInClassInitializer()) {
       if (Diagnose)
         S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
           << !!ICI << MD->getParent() << FD << FieldType << /*Reference*/0;
       return true;
if (FieldRecord) {
     if (!inUnion() && FieldRecord->isUnion() &&
         FieldRecord->isAnonymousStructOrUnion()) {
       bool AllVariantFieldsAreConst = true;
 
       // FIXME: Handle anonymous unions declared within anonymous unions.
       for (auto *UI : FieldRecord->fields()) {
         QualType UnionFieldType = S.Context.getBaseElementType(UI->getType());
 
+        if (shouldDeleteForVariantObjCPtrMember(&*UI, UnionFieldType))
+          return true;
+
         if (!UnionFieldType.isConstQualified())
           AllVariantFieldsAreConst = false;
 
         CXXRecordDecl *UnionFieldRecord = UnionFieldType->getAsCXXRecordDecl();
         if (UnionFieldRecord &&
             shouldDeleteForClassSubobject(UnionFieldRecord, UI,
                                           UnionFieldType.getCVRQualifiers()))
           return true;

test/SemaObjCXX/arc-0x.mm

-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fobjc-arc -verify -fblocks -fobjc-exceptions %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fobjc-arc -fobjc-runtime-has-weak -fobjc-weak -verify -fblocks -fobjc-exceptions %s
 
 // "Move" semantics, trivial version.
 void move_it(__strong id &&from) {
   id to = static_cast<__strong id&&>(from);
 }
 
 // Deduction with 'auto'.
 @interface A
namespace test_err_arc_array_param_no_ownership {
   template <class T>
   void func(T a) {}
 
   void test() {
     func([](A *a[]){}); // expected-error{{must explicitly describe intended ownership of an object array parameter}}
     func(^(A *a[]){}); // expected-error{{must explicitly describe intended ownership of an object array parameter}}
   }
 }
+
+namespace test_union {
+  // Implicitly-declared special functions of a union are deleted by default if
+  // ARC is enabled and the union has an ObjC pointer field.
+  union U0 {
+    id f0; // expected-note 6 {{'U0' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
+  };
+
+  union U1 {
+    __weak id f0; // expected-note 12 {{'U1' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
+    U1() = default; // expected-warning {{explicitly defaulted default constructor is implicitly deleted}} expected-note {{explicitly defaulted function was implicitly deleted here}}
+    ~U1() = default; // expected-warning {{explicitly defaulted destructor is implicitly deleted}} expected-note {{explicitly defaulted function was implicitly deleted here}}
+    U1(const U1 &) = default; // expected-warning {{explicitly defaulted copy constructor is implicitly deleted}} expected-note 2 {{explicitly defaulted function was implicitly deleted here}}
+    U1(U1 &&) = default; // expected-warning {{explicitly defaulted move constructor is implicitly deleted}}
+    U1 & operator=(const U1 &) = default; // expected-warning {{explicitly defaulted copy assignment operator is implicitly deleted}} expected-note 2 {{explicitly defaulted function was implicitly deleted here}}
+    U1 & operator=(U1 &&) = default; // expected-warning {{explicitly defaulted move assignment operator is implicitly deleted}}
+  };
+
+  id getStrong();
+
+  // If the ObjC pointer field of a union has a default member initializer, the
+  // implicitly-declared default constructor of the union is not deleted by
+  // default.
+  union U2 {
+    id f0 = getStrong(); // expected-note 4 {{'U2' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
+    ~U2();
+  };
+
+  // It's fine if the user has explicitly defined the special functions.
+  union U3 {
+    id f0;
+    U3();
+    ~U3();
+    U3(const U3 &);
+    U3(U3 &&);
+    U3 & operator=(const U3 &);
+    U3 & operator=(U3 &&);
+  };
+
+  // ObjC pointer fields in anonymous union fields delete the defaulted special
+  // functions of the containing class.
+  struct S0 {
+    union {
+      id f0; // expected-note 6 {{'' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
+      char f1;
+    };
+  };
+
+  struct S1 {
+    union {
+      union { // expected-note 2 {{'S1' is implicitly deleted because variant field '' has a non-trivial}} expected-note 4 {{'S1' is implicitly deleted because field '' has a deleted}}
+        id f0; // expected-note 2 {{'' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
+        char f1;
+      };
+      int f2;
+    };
+  };
+
+  struct S2 {
+    union {
+      // FIXME: the note should say 'f0' is causing the special functions to be deleted.
+      struct { // expected-note 6 {{'S2' is implicitly deleted because variant field '' has a non-trivial}}
+        id f0;
+        int f1;
+      };
+      int f2;
+    };
+    int f3;
+  };
+
+  U0 *x0;
+  U1 *x1;
+  U2 *x2;
+  U3 *x3;
+  S0 *x4;
+  S1 *x5;
+  S2 *x6;
+
+  static union { // expected-error {{call to implicitly-deleted default constructor of}}
+    id g0; // expected-note {{default constructor of '' is implicitly deleted because variant field 'g0' is an ObjC pointer}}
+  };
+
+  static union { // expected-error {{call to implicitly-deleted default constructor of}}
+    union { // expected-note {{default constructor of '' is implicitly deleted because field '' has a deleted default constructor}}
+      union { // expected-note {{default constructor of '' is implicitly deleted because field '' has a deleted default constructor}}
+        __weak id g1; // expected-note {{default constructor of '' is implicitly deleted because variant field 'g1' is an ObjC pointer}}
+        int g2;
+      };
+      int g3;
+    };
+    int g4;
+  };
+
+  void testDefaultConstructor() {
+    U0 t0; // expected-error {{call to implicitly-deleted default constructor}}
+    U1 t1; // expected-error {{call to implicitly-deleted default constructor}}
+    U2 t2;
+    U3 t3;
+    S0 t4; // expected-error {{call to implicitly-deleted default constructor}}
+    S1 t5; // expected-error {{call to implicitly-deleted default constructor}}
+    S2 t6; // expected-error {{call to implicitly-deleted default constructor}}
+  }
+
+  void testDestructor(U0 *u0, U1 *u1, U2 *u2, U3 *u3, S0 *s0, S1 *s1, S2 *s2) {
+    delete u0; // expected-error {{attempt to use a deleted function}}
+    delete u1; // expected-error {{attempt to use a deleted function}}
+    delete u2;
+    delete u3;
+    delete s0; // expected-error {{attempt to use a deleted function}}
+    delete s1; // expected-error {{attempt to use a deleted function}}
+    delete s2; // expected-error {{attempt to use a deleted function}}
+  }
+
+  void testCopyConstructor(U0 *u0, U1 *u1, U2 *u2, U3 *u3, S0 *s0, S1 *s1, S2 *s2) {
+    U0 t0(*u0); // expected-error {{call to implicitly-deleted copy constructor}}
+    U1 t1(*u1); // expected-error {{call to implicitly-deleted copy constructor}}
+    U2 t2(*u2); // expected-error {{call to implicitly-deleted copy constructor}}
+    U3 t3(*u3);
+    S0 t4(*s0); // expected-error {{call to implicitly-deleted copy constructor}}
+    S1 t5(*s1); // expected-error {{call to implicitly-deleted copy constructor}}
+    S2 t6(*s2); // expected-error {{call to implicitly-deleted copy constructor}}
+  }
+
+  void testCopyAssignment(U0 *u0, U1 *u1, U2 *u2, U3 *u3, S0 *s0, S1 *s1, S2 *s2) {
+    *x0 = *u0; // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
+    *x1 = *u1; // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
+    *x2 = *u2; // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
+    *x3 = *u3;
+    *x4 = *s0; // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
+    *x5 = *s1; // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
+    *x6 = *s2; // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
+  }
+
+  // The diagnostics below refer to the deleted copy constructors and assignment
+  // operators since defaulted move constructors and assignment operators that are
+  // defined as deleted are ignored by overload resolution.
+
+  void testMoveConstructor(U0 *u0, U1 *u1, U2 *u2, U3 *u3, S0 *s0, S1 *s1, S2 *s2) {
+    U0 t0(static_cast<U0 &&>(*u0)); // expected-error {{call to implicitly-deleted copy constructor}}
+    U1 t1(static_cast<U1 &&>(*u1)); // expected-error {{call to implicitly-deleted copy constructor}}
+    U2 t2(static_cast<U2 &&>(*u2)); // expected-error {{call to implicitly-deleted copy constructor}}
+    U3 t3(static_cast<U3 &&>(*u3));
+    S0 t4(static_cast<S0 &&>(*s0)); // expected-error {{call to implicitly-deleted copy constructor}}
+    S1 t5(static_cast<S1 &&>(*s1)); // expected-error {{call to implicitly-deleted copy constructor}}
+    S2 t6(static_cast<S2 &&>(*s2)); // expected-error {{call to implicitly-deleted copy constructor}}
+  }
+
+  void testMoveAssignment(U0 *u0, U1 *u1, U2 *u2, U3 *u3, S0 *s0, S1 *s1, S2 *s2) {
+    *x0 = static_cast<U0 &&>(*u0); // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
+    *x1 = static_cast<U1 &&>(*u1); // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
+    *x2 = static_cast<U2 &&>(*u2); // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
+    *x3 = static_cast<U3 &&>(*u3);
+    *x4 = static_cast<S0 &&>(*s0); // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
+    *x5 = static_cast<S1 &&>(*s1); // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
+    *x6 = static_cast<S2 &&>(*s2); // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
+  }
+}

test/SemaObjCXX/objc-weak.mm

 // RUN: %clang_cc1 -fsyntax-only -fobjc-runtime-has-weak -fobjc-weak -fblocks -Wno-objc-root-class -std=c++98 -Wno-c++0x-extensions -verify %s
 
 @interface AnObject
 @property(weak) id value;
 @end
 
 __attribute__((objc_arc_weak_reference_unavailable))
 @interface NOWEAK : AnObject // expected-note 2 {{class is declared here}}
 @end
 
 struct S {
   __weak id a; // expected-note {{because type 'S' has a member with __weak ownership}}
 };
 
 union U {
-  __weak id a; // expected-error {{ARC forbids Objective-C objects in union}}
+  __weak id a;
   S b;         // expected-error {{union member 'b' has a non-trivial copy constructor}}
 };
 
 void testCast(AnObject *o) {
   __weak id a = reinterpret_cast<__weak NOWEAK *>(o); // expected-error {{class is incompatible with __weak references}} \
                                                       // expected-error {{explicit ownership qualifier on cast result has no effect}} \
                                                       // expected-error {{assignment of a weak-unavailable object to a __weak object}}
 
   __weak id b = static_cast<__weak NOWEAK *>(o); // expected-error {{class is incompatible with __weak references}} \
                                                  // expected-error {{explicit ownership qualifier on cast result has no effect}} \
                                                  // expected-error {{assignment of a weak-unavailable object to a __weak object}}
 }