[AST] Dont invalidate VarDecl even the default initializaiton is failed.

[hokein]

Summary

This patch would cause clang emit more diagnostics, but it is much better than https://reviews.llvm.org/D76831

cpp
struct A {
  A(int);
  ~A() = delete;
};
void k() {
  A a;
}

before the patch:

/tmp/t3.cpp:24:5: error: no matching constructor for initialization of 'A'
  A a;
    ^
/tmp/t3.cpp:20:3: note: candidate constructor not viable: requires 1 argument, but 0 were provided
  A(int);
  ^
/tmp/t3.cpp:19:8: note: candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 0 were provided
struct A {

After the patch:

/tmp/t3.cpp:24:5: error: no matching constructor for initialization of 'A'
  A a;
    ^
/tmp/t3.cpp:20:3: note: candidate constructor not viable: requires 1 argument, but 0 were provided
  A(int);
  ^
/tmp/t3.cpp:19:8: note: candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 0 were provided
struct A {
       ^
/tmp/t3.cpp:24:5: error: attempt to use a deleted function
  A a;
    ^
/tmp/t3.cpp:21:3: note: '~A' has been explicitly marked deleted here
  ~A() = delete;

[sammccall]

the attempt to use a deleted function diagnostic is a bit spammy, because the default-constructor and destructor are often deleted for similar reasons. But I guess this is probably OK, unless you can see an easy way to suppress it.

clang/lib/Sema/SemaDecl.cpp

12559

Tempting as it is, I'm not sure we should leave a big comment around describing code that isn't here.
Maybe just a minimal If default-init fails, leave var uninitialized but valid, for recovery.

clang/test/AST/ast-dump-invalid-initialized.cpp

7

may be worth testing the other existing behavior we're being consistent with here too: A a1 = garbage(); etc

clang/test/CodeCompletion/invalid-initialized-class.cpp

8

Again, may want Foo bar = garbage(); bar.^

clang/test/SemaCXX/cxx0x-deleted-default-ctor.cpp

11

nit: extra //

[hokein]

rebase and address review comments

[hokein]

In D77395#1972666, @sammccall wrote:

the attempt to use a deleted function diagnostic is a bit spammy, because the default-constructor and destructor are often deleted for similar reasons. But I guess this is probably OK, unless you can see an easy way to suppress it.

didn't see a trivial way to suppress this diagnostic, as we don't have enough information to distinguish the VarDecl (valid bit is true, no init-expr) has an ill-formed default initialization. I think we could build a recovery-expr and use it as the init-expr for the VarDecl, and suppress this diagnostic.

clang/lib/Sema/SemaDecl.cpp

if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
     //   If no initializer is specified for an object, the object is
     //   default-initialized; [...].
     InitializedEntity Entity = InitializedEntity::InitializeVariable(Var);
     InitializationKind Kind
       = InitializationKind::CreateDefault(Var->getLocation());
 
     InitializationSequence InitSeq(*this, Entity, Kind, None);
     ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None);
-    if (Init.isInvalid())
-      Var->setInvalidDecl();
-    else if (Init.get()) {
+
+    // If default-init fails, leave var uninitialized but valid, for recovery.
+
+    if (Init.get()) {
       Var->setInit(MaybeCreateExprWithCleanups(Init.get()));
       // This is important for template substitution.
       Var->setInitStyle(VarDecl::CallInit);
     }
 
     CheckCompleteVariableDeclaration(Var);
   }
 }

clang/test/AST/ast-dump-invalid-initialized.cpp

+// RUN: not %clang_cc1 -triple x86_64-unknown-unknown -Wno-unused-value -fcxx-exceptions -std=gnu++17 -ast-dump %s | FileCheck -strict-whitespace %s
+
+struct A { A(int, int) {} };
+class ForwardDecl;
+
+void test() {
+  // CHECK: `-VarDecl {{.*}} a1 'A'
+  A a1;
+  // CHECK: `-VarDecl {{.*}} a2 'const A'
+  const A a2;
+  // CHECK: `-VarDecl {{.*}} a3 'A'
+  A a3 = garbage();
+
+
+  // CHECK: `-VarDecl {{.*}} invalid b1 'const A &'
+  const A& b1;
+  // CHECK: `-VarDecl {{.*}} invalid b2 'ForwardDecl'
+  ForwardDecl b2;
+}
 No newline at end of file

clang/test/CXX/class.access/p4.cpp

class Derived2 : // expected-error {{inherited virtual base class 'Base<2>' has private destructor}} \
     virtual Base<1>, // expected-error {{base class 'Base<1>' has private destructor}}
     Base2, // expected-error {{base class 'test3::Base2' has private destructor}}
     virtual Base3
   {
     ~Derived2() {}
   };
 
   class Derived3 :
-    Base<0>, // expected-note {{deleted because base class 'Base<0>' has an inaccessible destructor}}
+    Base<0>, // expected-note 2{{deleted because base class 'Base<0>' has an inaccessible destructor}}
     virtual Base<1>,
     Base2,
     virtual Base3
   {};
-  Derived3 d3; // expected-error {{implicitly-deleted default constructor}}
+  Derived3 d3; // expected-error {{implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
 #elif __cplusplus >= 201103L && defined(_MSC_VER)
-  template <unsigned N> class Base { ~Base(); }; // expected-note 6{{declared private here}}
+  template <unsigned N> class Base { ~Base(); }; // expected-note 9{{declared private here}}
   // expected-error@+1 {{inherited virtual base class 'Base<2>' has private destructor}}
   class Base2 : virtual Base<2> { ~Base2(); }; // expected-note 1{{declared private here}}
   // expected-error@+1 {{inherited virtual base class 'Base<3>' has private destructor}}
   class Base3 : virtual Base<3> { public: ~Base3(); };
 
   // These don't cause diagnostics because we don't need the destructor.
   class Derived0 : Base<0> { ~Derived0(); };
   class Derived1 : Base<1> { };
 
   class Derived2 : // expected-error {{inherited virtual base class 'Base<2>' has private destructor}} \
                    // expected-error {{inherited virtual base class 'Base<3>' has private destructor}}
     Base<0>,  // expected-error {{base class 'Base<0>' has private destructor}}
     virtual Base<1>, // expected-error {{base class 'Base<1>' has private destructor}}
     Base2, // expected-error {{base class 'test3::Base2' has private destructor}}
     virtual Base3
   {
     // expected-note@+2 {{in implicit destructor for 'test3::Base2' first required here}}
     // expected-note@+1 {{in implicit destructor for 'test3::Base3' first required here}}
     ~Derived2() {}
   };
 
-  class Derived3 :
+  class Derived3 : // expected-error 3{{has private destructor}}
     Base<0>, // expected-note {{deleted because base class 'Base<0>' has an inaccessible destructor}}
+             // expected-note@-1 {{destructor of 'Derived3' is implicitly deleted}}
     virtual Base<1>,
     Base2,
     virtual Base3
   {};
-  Derived3 d3; // expected-error {{implicitly-deleted default constructor}}
+  Derived3 d3; // expected-error {{implicitly-deleted default constructor}} expected-error {{use a deleted function}}
+               // expected-note@-1 {{implicit destructor for}}
 #else
 #error "missing case of MSVC cross C++ versions"
 #endif
 }
 
 // Conversion functions.
 namespace test4 {
   class Base {

clang/test/CXX/drs/dr3xx.cpp

void f(A *a) {
       (void) reinterpret_cast<B3*>(a); // expected-error {{casts away qualifiers}}
       (void) reinterpret_cast<B4*>(a);
     }
   }
 }
 
 namespace dr331 { // dr331: yes
   struct A {
-    A(volatile A&); // expected-note {{candidate}}
-  } const a, b(a); // expected-error {{no matching constructor}}
+    A(volatile A&); // expected-note 2{{candidate}}
+  } const a, b(a); // expected-error 2{{no matching constructor}}
 }
 
 namespace dr332 { // dr332: dup 577
   void f(volatile void); // expected-error {{'void' as parameter must not have type qualifiers}}
   void g(const void); // expected-error {{'void' as parameter must not have type qualifiers}}
   void h(int n, volatile void); // expected-error {{'void' must be the first and only parameter}}
 }
 

clang/test/CXX/special/class.ctor/p5-0x.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -Wno-defaulted-function-deleted
 
 struct DefaultedDefCtor1 {};
 struct DefaultedDefCtor2 { DefaultedDefCtor2() = default; };
 struct DeletedDefCtor { DeletedDefCtor() = delete; DeletedDefCtor(int); }; // expected-note {{explicitly marked deleted here}}
 class PrivateDefCtor { PrivateDefCtor() = default; public: PrivateDefCtor(int); };
-struct DeletedDtor { ~DeletedDtor() = delete; }; // expected-note 4{{explicitly marked deleted here}}
+struct DeletedDtor { ~DeletedDtor() = delete; }; // expected-note 8{{explicitly marked deleted here}}
 class PrivateDtor { ~PrivateDtor() = default; };
 class Friend {
   Friend() = default; ~Friend() = default;
   friend struct NotDeleted6c;
   friend struct NotDeleted7i;
   friend struct NotDeleted7j;
   friend struct NotDeleted7k;
 };

 struct NotDeleted6b { PrivateDefCtor a = 0; };
 NotDeleted6b nd6b;
 struct NotDeleted6c { Friend a; };
 NotDeleted6c nd6c;
 
 // - any direct or virtual base class or non-static data member has a type with
 // a destructor that is deleted or inaccessible from the defaulted default
 // constructor.
-struct Deleted7a : DeletedDtor {}; // expected-note {{because base class 'DeletedDtor' has a deleted destructor}}
-Deleted7a d7a; // expected-error {{implicitly-deleted default constructor}}
-struct Deleted7b : virtual DeletedDtor {}; // expected-note {{because base class 'DeletedDtor' has a deleted destructor}}
-Deleted7b d7b; // expected-error {{implicitly-deleted default constructor}}
-struct Deleted7c { DeletedDtor a; }; // expected-note {{because field 'a' has a deleted destructor}}
-Deleted7c d7c; // expected-error {{implicitly-deleted default constructor}}
-struct Deleted7d { DeletedDtor a = {}; }; // expected-note {{because field 'a' has a deleted destructor}}
-Deleted7d d7d; // expected-error {{implicitly-deleted default constructor}}
-struct Deleted7e : PrivateDtor {}; // expected-note {{base class 'PrivateDtor' has an inaccessible destructor}}
-Deleted7e d7e; // expected-error {{implicitly-deleted default constructor}}
-struct Deleted7f : virtual PrivateDtor {}; // expected-note {{base class 'PrivateDtor' has an inaccessible destructor}}
-Deleted7f d7f; // expected-error {{implicitly-deleted default constructor}}
-struct Deleted7g { PrivateDtor a; }; // expected-note {{field 'a' has an inaccessible destructor}}
-Deleted7g d7g; // expected-error {{implicitly-deleted default constructor}}
-struct Deleted7h { PrivateDtor a = {}; }; // expected-note {{field 'a' has an inaccessible destructor}}
-Deleted7h d7h; // expected-error {{implicitly-deleted default constructor}}
+struct Deleted7a : DeletedDtor {}; // expected-note 2{{because base class 'DeletedDtor' has a deleted destructor}}
+Deleted7a d7a; // expected-error {{implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
+struct Deleted7b : virtual DeletedDtor {}; // expected-note 2{{because base class 'DeletedDtor' has a deleted destructor}}
+Deleted7b d7b; // expected-error {{implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
+struct Deleted7c { DeletedDtor a; }; // expected-note 2{{because field 'a' has a deleted destructor}}
+Deleted7c d7c; // expected-error {{implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
+struct Deleted7d { DeletedDtor a = {}; }; // expected-note 2{{because field 'a' has a deleted destructor}}
+Deleted7d d7d; // expected-error {{implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
+struct Deleted7e : PrivateDtor {}; // expected-note 2{{base class 'PrivateDtor' has an inaccessible destructor}}
+Deleted7e d7e; // expected-error {{implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
+struct Deleted7f : virtual PrivateDtor {}; // expected-note 2{{base class 'PrivateDtor' has an inaccessible destructor}}
+Deleted7f d7f; // expected-error {{implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
+struct Deleted7g { PrivateDtor a; }; // expected-note 2{{field 'a' has an inaccessible destructor}}
+Deleted7g d7g; // expected-error {{implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
+struct Deleted7h { PrivateDtor a = {}; }; // expected-note 2{{field 'a' has an inaccessible destructor}}
+Deleted7h d7h; // expected-error {{implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
 struct NotDeleted7i : Friend {};
 NotDeleted7i d7i;
 struct NotDeleted7j : virtual Friend {};
 NotDeleted7j d7j;
 struct NotDeleted7k { Friend a; };
 NotDeleted7k d7k;
 
 

clang/test/CodeCompletion/invalid-initialized-class.cpp

+struct Foo { Foo(int); int abc; };
+
+void test1() {
+  Foo foo;
+  foo.;
+  // RUN: not %clang_cc1 -fsyntax-only -code-completion-at=%s:5:7 %s -o - | FileCheck -check-prefix=CHECK-CC1 %s
+  // CHECK-CC1: COMPLETION: abc
+}
+
+void test2() {
+  Foo foo = garbage();
+  foo.;
+  // RUN: not %clang_cc1 -fsyntax-only -code-completion-at=%s:12:7 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
+  // CHECK-CC2: COMPLETION: abc
+}

clang/test/SemaCXX/cxx0x-deleted-default-ctor.cpp

 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
 
 struct non_trivial {
   non_trivial();
   non_trivial(const non_trivial&);
   non_trivial& operator = (const non_trivial&);
   ~non_trivial();
 };
 
 union bad_union {
-  non_trivial nt; // expected-note {{non-trivial default constructor}}
+  non_trivial nt; // expected-note {{non-trivial default constructor}} expected-note {{destructor of 'bad_union' is implicitly deleted}}
 };
-bad_union u; // expected-error {{call to implicitly-deleted default constructor}}
+bad_union u; // expected-error {{call to implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
 union bad_union2 { // expected-note {{all data members are const-qualified}}
   const int i;
 };
 bad_union2 u2; // expected-error {{call to implicitly-deleted default constructor}}
 
 struct bad_anon {
   union {
-    non_trivial nt; // expected-note {{non-trivial default constructor}}
+    non_trivial nt; // expected-note {{non-trivial default constructor}} expected-note {{destructor of 'bad_anon' is implicitly deleted}}
   };
 };
-bad_anon a; // expected-error {{call to implicitly-deleted default constructor}}
+bad_anon a; // expected-error {{call to implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
 struct bad_anon2 {
   union { // expected-note {{all data members of an anonymous union member are const-qualified}}
     const int i;
   };
 };
 bad_anon2 a2; // expected-error {{call to implicitly-deleted default constructor}}
 
 // This would be great except that we implement
struct good_const {
   const non_trivial nt;
 };
 good_const gc;
 
 struct no_default {
   no_default() = delete; // expected-note 5{{deleted here}}
 };
 struct no_dtor {
-  ~no_dtor() = delete; // expected-note 2{{deleted here}}
+  ~no_dtor() = delete; // expected-note 4{{deleted here}}
 };
 
 struct bad_field_default {
   no_default nd; // expected-note {{field 'nd' has a deleted default constructor}}
 };
 bad_field_default bfd; // expected-error {{call to implicitly-deleted default constructor}}
 struct bad_base_default : no_default { // expected-note {{base class 'no_default' has a deleted default constructor}}
 };
 bad_base_default bbd; // expected-error {{call to implicitly-deleted default constructor}}
 
 struct bad_field_dtor {
-  no_dtor nd; // expected-note {{field 'nd' has a deleted destructor}}
+  no_dtor nd; // expected-note {{field 'nd' has a deleted destructor}} expected-note {{destructor of 'bad_field_dtor' is implicitly deleted }}
 };
-bad_field_dtor bfx; // expected-error {{call to implicitly-deleted default constructor}}
-struct bad_base_dtor : no_dtor { // expected-note {{base class 'no_dtor' has a deleted destructor}}
+bad_field_dtor bfx; // expected-error {{call to implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
+struct bad_base_dtor : no_dtor { // expected-note {{base class 'no_dtor' has a deleted destructor}} expected-note {{destructor of 'bad_base_dtor' is implicitly deleted}}
 };
-bad_base_dtor bbx; // expected-error {{call to implicitly-deleted default constructor}}
+bad_base_dtor bbx; // expected-error {{call to implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
 
 struct ambiguous_default {
   ambiguous_default();
   ambiguous_default(int = 2);
 };
 struct has_amb_field {
   ambiguous_default ad; // expected-note {{field 'ad' has multiple default constructors}}
 };

clang/test/SemaCXX/virtual-base-used.cpp

#if __cplusplus <= 199711L
   // expected-error@-2 {{field of type 'NoDestroy' has private destructor}}
 #ifdef MSABI
   // expected-error@-4 {{field of type 'NoDestroy' has private destructor}}
 #endif
 #else
   // expected-note@-7 {{destructor of 'B' is implicitly deleted because field 'x' has an inaccessible destructor}}
 #ifdef MSABI
   // expected-note@-9 {{default constructor of 'B' is implicitly deleted because field 'x' has an inaccessible destructor}}
+  // expected-note@-10 {{destructor of 'B' is implicitly deleted}}
 #endif
 #endif
 };
 
 struct D : public virtual B {
 #if __cplusplus <= 199711L
 #ifdef MSABI
 // expected-note@-3 {{implicit default constructor for 'B' first required here}}
 // expected-note@-4 {{implicit destructor for 'B' first required here}}
 #endif
 #else
 #ifdef MSABI
 // expected-note@-8 {{default constructor of 'D' is implicitly deleted because base class 'B' has a deleted default constructor}}
 #endif
 #endif
   virtual void foo();
   ~D();
 #if __cplusplus >= 201103L
   //expected-error@-2 {{non-deleted function '~D' cannot override a deleted function}}
+#ifdef MSABI
+//expected-error@-4 {{use a deleted function}}
+#else
+#endif
 #endif
 };
 
 #ifdef MSABI
 D d;
 #if __cplusplus <= 199711L
 // expected-note@-2 2{{implicit default constructor for 'D' first required here}}
 #else
 // expected-error@-4 {{call to implicitly-deleted default constructor of 'D'}}
+// expected-note@-5 {{implicit destructor for 'D' first required here}}
 #endif
 #else
 void D::foo() {
 #if __cplusplus <= 199711L
 // expected-note@-2 {{implicit destructor for 'B' first required here}}
 #endif
 }
 #endif
 
 struct E : public virtual A {
 #if __cplusplus >= 201103L
 // expected-error@-2 {{deleted function '~E' cannot override a non-deleted function}}
 #endif
 
   NoDestroy x;
 #if __cplusplus <= 199711L
   // expected-error@-2 {{field of type 'NoDestroy' has private destructor}}
 #ifdef MSABI
   // expected-error@-4 {{field of type 'NoDestroy' has private destructor}}
 #endif
 #else
   // expected-note@-7 {{destructor of 'E' is implicitly deleted because field 'x' has an inaccessible destructor}}
 #ifdef MSABI
   // expected-note@-9 {{default constructor of 'E' is implicitly deleted because field 'x' has an inaccessible destructor}}
+  // expected-note@-10 {{destructor of 'E' is implicitly deleted}}
 #endif
 #endif
 };
 
 struct F : public E {
 #if __cplusplus <= 199711L
 // expected-note@-2 {{implicit destructor for 'E' first required here}}
 #ifdef MSABI
 // expected-note@-4 {{implicit default constructor for 'E' first required here}}
 #endif
 #else
 // expected-note@-7 {{overridden virtual function is here}}
 #ifdef MSABI
 // expected-note@-9 {{default constructor of 'F' is implicitly deleted because base class 'E' has a deleted default constructor}}
+// expected-note@-10 {{destructor of 'F' is implicitly deleted}}
 #endif
 #endif
 };
 
 
 struct G : public virtual F {
 #ifdef MSABI
 #if __cplusplus <= 199711L
 // expected-note@-3 {{implicit default constructor for 'F' first required here}}
 // expected-note@-4 {{implicit destructor for 'F' first required here}}
 #else
 // expected-note@-6 {{default constructor of 'G' is implicitly deleted because base class 'F' has a deleted default constructor}}
 #endif
 #endif
 
   virtual void foo();
   ~G();
 #if __cplusplus >= 201103L
   //expected-error@-2 {{non-deleted function '~G' cannot override a deleted function}}
+#ifdef MSABI
+  //expected-error@-4 {{use a deleted function}}
+#endif
 #endif
 };
 
 #ifdef MSABI
 G g;
 #if __cplusplus <= 199711L
 // expected-note@-2 2{{implicit default constructor for 'G' first required here}}
 #else
 // expected-error@-4 {{call to implicitly-deleted default constructor of 'G'}}
+// expected-note@-5 {{mplicit destructor for 'G' first required here}}
 #endif
 #else
 void G::foo() {
 #if __cplusplus <= 199711L
 // expected-note@-2 {{implicit destructor for 'F' first required here}}
 #endif
 }
 #endif
#if __cplusplus <= 199711L
   // expected-error@-2 {{field of type 'NoDestroy' has private destructor}}
 #ifdef MSABI
   // expected-error@-4 {{field of type 'NoDestroy' has private destructor}}
 #endif
 #else
   // expected-note@-7 {{destructor of 'H' is implicitly deleted because field 'x' has an inaccessible destructor}}
 #ifdef MSABI
   // expected-note@-9 {{default constructor of 'H' is implicitly deleted because field 'x' has an inaccessible destructor}}
+  // expected-note@-10 {{destructor of 'H' is implicitly deleted}}
 #endif
 #endif
 };
 
 struct I : public virtual H {
 #ifdef MSABI
 #if __cplusplus > 199711L
 // expected-note@-3 {{default constructor of 'I' is implicitly deleted because base class 'H' has a deleted default constructor}}

 // expected-note@-4 {{implicit destructor for 'H' first required here}}
 #else
 // expected-note@-6 {{default constructor of 'J' is implicitly deleted because base class 'I' has a deleted default constructor}}
 #endif
 #endif
 
   virtual void foo();
   ~J();
+#ifdef MSABI
+#if __cplusplus >= 201103L
+//expected-error@-3 {{use a deleted function}}
+#endif
+#endif
 };
 
 #ifdef MSABI
 J j;
 #if __cplusplus <= 199711L
 // expected-note@-2 2{{implicit default constructor for 'J' first required here}}
 #else
 // expected-error@-4 {{call to implicitly-deleted default constructor of 'J'}}
+// expected-note@-5 {{implicit destructor for 'J' first required here}}
 #endif
 
 #else
 void J::foo() {
 #if __cplusplus <= 199711L
 // expected-note@-2 {{implicit destructor for 'H' first required here}}
 #endif
 }
 #endif

clang/test/SemaObjCXX/arc-0x.mm

void test() {
     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}}
+    id f0; // expected-note 7 {{'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}}
+    __weak id f0; // expected-note 13 {{'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() = default; // expected-warning {{explicitly defaulted destructor is implicitly deleted}} expected-note 2{{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();
 
union 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}}
+      id f0; // expected-note 7 {{'' 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}}
+      union { // expected-note 2 {{'S1' is implicitly deleted because variant field '' has a non-trivial}} expected-note 5 {{'S1' is implicitly deleted because field '' has a deleted}}
+        id f0; // expected-note 3 {{'' 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}}
+      struct { // expected-note 7 {{'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}} expected-error {{attempt to use a deleted function}}
+    id g0; // expected-note {{default constructor of '' is implicitly deleted because variant field 'g0' is an ObjC pointer}} \
+           // expected-note {{destructor of '' is implicitly deleted because}}
   };
 
-  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}}
+  static union { // expected-error {{call to implicitly-deleted default constructor of}} expected-error {{attempt to use a deleted function}}
+    union { // expected-note {{default constructor of '' is implicitly deleted because field '' has a deleted default constructor}} \
+            // expected-note {{destructor of '' is implicitly deleted because}}
+      union { // expected-note {{default constructor of '' is implicitly deleted because field '' has a deleted default constructor}} \
+              // expected-note {{destructor of '' is implicitly deleted because}}
+        __weak id g1; // expected-note {{default constructor of '' is implicitly deleted because variant field 'g1' is an ObjC pointer}} \
+                      // expected-note {{destructor of '' is implicitly deleted because}}
         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}}
+    U0 t0; // expected-error {{call to implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
+    U1 t1; // expected-error {{call to implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
     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}}
+    S0 t4; // expected-error {{call to implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
+    S1 t5; // expected-error {{call to implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
+    S2 t6; // expected-error {{call to implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
   }
 
   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}}