[AST] Suppress the spammy "attempt to use a deleted fucntion" diagnostic.

[hokein]

Summary

This patch fixes the regression diagnostic, which was introduced in
https://reviews.llvm.org/D77395.

[hokein]

fix the broken tests.

[sammccall]

Sorry to go back and forth on this, but I'm not sure whether these diagnostics are actually spam to be suppressed. I think @adamcz mentioned these today as reasonable diagnostics we're enabling.

@rsmith do you have an opinion here?

clang/lib/Sema/SemaDeclCXX.cpp

15006

This deserves a comment, like "if initializing the variable failed, don't also diagnose problems with the desctructor, they're likely related".

[rsmith]

In D78100#1981620, @sammccall wrote:

Sorry to go back and forth on this, but I'm not sure whether these diagnostics are actually spam to be suppressed. I think @adamcz mentioned these today as reasonable diagnostics we're enabling.

@rsmith do you have an opinion here?

My initial reaction was certainly that it wasn't obvious why an initialization error would necessarily have anything to do with a destruction error. But this line of thinking helped me: suppose we would encounter both an (unrecoverable) initialization error *and* an error during destruction. How likely is it that they have a common cause? My guess would be way more than half the time. Given that we know we're on an error recovery path, and that we've already produced an unrecoverable error during initialization, skipping the destruction checks is probably the better choice. Even if we're wrong, the worst case is that the programmer fixes the initialization error and is then presented with a destruction error that they didn't see before, which doesn't seem all that bad of an outcome.

(Generally I don't think we need to be sure that errors would be correlated to suppress latter errors as being follow-on diagnostics from earlier errors, and should lean towards suppressing diagnostics in order to make the second and subsequent diagnostic as likely as possible to be meaningful and useful.)

clang/lib/Sema/SemaDecl.cpp

11985–11986

Should we attach a RecoveryExpr initializer in this case?

11998–12001

Should we attach a RecoveryExpr initializer in this case?

12268

Should we attach a RecoveryExpr initializer in this case too?

12562–12563

I don't think this is accurate (we didn't "leave var uninitialized"). Maybe something like: "If default-init fails, attach an initializer that's marked invalid to track that initialization was attempted and failed."

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

1–6

I'm not really happy about improving our quality of diagnostics only under -frecovery-ast. Do we really need that flag? The way I see it, we can divide the users of Clang up into:

• We want valid code (eg, as a compiler): if we hit an error, it doesn't matter too much whether we build RecoveryExprs or not, since we're on a path to bailing out anyway. If RecoveryExprs allow us to improve our diagnostics, we should build them. (Exception: if we want valid code or to get a simple pass/fail as early as possible, maybe not.)
• We want to accept invalid code (eg, tooling): if we hit an error, we probably want to retain as much information as we reasonably can about the non-erroneous parts of the program.

So I think at least the default should be to build RecoveryExprs, and maybe we can remove the flag entirely?

[sammccall]

In D78100#1981729, @rsmith wrote:

In D78100#1981620, @sammccall wrote:

Sorry to go back and forth on this, but I'm not sure whether these diagnostics are actually spam to be suppressed. I think @adamcz mentioned these today as reasonable diagnostics we're enabling.

@rsmith do you have an opinion here?

My initial reaction was certainly that it wasn't obvious why an initialization error would necessarily have anything to do with a destruction error. But this line of thinking helped me: suppose we would encounter both an (unrecoverable) initialization error *and* an error during destruction. How likely is it that they have a common cause? My guess would be way more than half the time. Given that we know we're on an error recovery path, and that we've already produced an unrecoverable error during initialization, skipping the destruction checks is probably the better choice. Even if we're wrong, the worst case is that the programmer fixes the initialization error and is then presented with a destruction error that they didn't see before, which doesn't seem all that bad of an outcome.

(Generally I don't think we need to be sure that errors would be correlated to suppress latter errors as being follow-on diagnostics from earlier errors, and should lean towards suppressing diagnostics in order to make the second and subsequent diagnostic as likely as possible to be meaningful and useful.)

Thanks, that's useful. The common cause was our original intuition but I wasn't sure if that was an appropriate reason to suppress.

clang/lib/Sema/SemaDecl.cpp

11998–12001

This is D78116 (which should probably handle the case above, too)

12268

Now we're really slipping into a different set of use-cases for RecoveryExpr...
I assume we're talking about a RecoveryExpr that has no children, at least in the short term, as parsing failures don't return the likely subexpressions found. So it's a pure error marker in the form of an AST node. Quite a lot of ExprError()s could become these...

Actually there's another virtue here: even without subexpressions, the RecoveryExpr can capture the token range. So VarDecl::getSourceRange() will include the malformed initializer, so tools can at least attribute these tokens to the right part of the AST.

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

1–6

Agree that want to flip the default to true, and maybe eventually get rid of it. But:

• we're still fighting quite a lot of new crash-on-invalids, and can't fix them all in one big patch. We plan to find more by rolling this out to a subset of google-internal IDE users (where we have good monitoring), the flag is needed for this.
• we expect this to be stable for C++ long before it can be enabled for C, because that requires making the C codepaths safe handle (at least error-)dependence. So there'll be a similar testing/improvement period later.

However I don't like adding -frecovery-ast to big existing tests, we lose coverage of today's production behavior. I think we may need to create new tests to show the effect of these changes, and clean them up after flipping the default.

[hokein]

address comments:

• don't modify the existing tests
• add new tests for -frecovery-ast only.

[hokein]

clang/lib/Sema/SemaDecl.cpp

11985–11986

I think so, will address in a separate patch.

12268

yeah, I'm not sure how much benefit we can get from the recovery-expr in this case, if the initializer is failed to parse, we don't have any ast nodes.

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

1–6

yeah, it is not perfect, given that we are at intermediate stage. We plan to enable the flag for C++ by default (we did it once, but failed with many crashes), this means we'd eventually focus on '-frecovery-ast' only (at least C++), it seems not too harmful to add the -frecovery-ast flag to exiting tests at the moment. But it is not great..

Another way is to adjust existing tests to support both, but this seems non-trivial, maybe creating new tests for '-frecovery-ast' is a best way to go.

life can be easier if the flag is turned on by default. Currently, I have to maintain a local patch with a long tail of adjusted tests when doing recovery-expr developments, I need to run all tests with&without -frecovery-ast to make sure it doesn't introduce big issures.

[rsmith]

clang/lib/Sema/SemaDecl.cpp

12268

What I'm thinking is that we should have some kind of marker in the AST to track that an initializer was provided for the variable but was malformed. Right now, we use the "invalid" bit for that, which means that downstream code that refers to the variable will have poor recovery. If we attach an initialization expression marked with the "contains errors" bit instead, then we can keep the VarDecl valid, and improve the recovery not necessarily for this node but for things downstream of it.

(I guess ultimately it seems reasonable to me to use the same AST representation for "no initializer was provided and implicit default init failed", "an initializer was provided but we couldn't parse / semantically analyze it", and "an initializer was provided but was incompatible with the variable's type" -- except that in the third case we can track the expression that we formed for the initializer.)

I don't think there's any urgency to this, and having both AST models for a while (in different cases) doesn't seem like it's going to cause much pain.

[sammccall]

LG but please fix the sourcerange

clang/lib/Sema/SemaDecl.cpp

12268

Yeah, I think this makes sense. @hokein: even without child AST nodes, this will improve SelectionTree accuracy in clangd: go to definition on some part of an invalid initializer currently goes to the vardecl, and after adding RecoveryExpr here it'll go nowhere instead which is progress.

But the expr needs to have at least the source range, so this isn't a trivial change --> another patch?

12565

This seems like it's going to claim some actual tokens, when the thing it represents doesn't cover any tokens.

I think both start/end source locations should be invalid.

clang/lib/Sema/SemaDeclCXX.cpp

15007

desctructor -> destructor
(sorry, you copied my typo)

[hokein]

clang/lib/Sema/SemaDecl.cpp

12565

actually, I think it is still valuable to set the var location to recovery-expr.

Foo [[foo]]; // if there is a valid default ctor, we have a CtorExpr which has the `foo` range; otherwise there is a recoveryExpr with the same range.

[sammccall]

OK LG without changes

clang/lib/Sema/SemaDecl.cpp

12565

Yeah, invalid source range is scary too. Let's go with this and see if things break. I think more likely it'll be a mild annoyance like the range of CXXConstructExpr.

(In a perfect world maybe this would have a location but no range, or a SourceRange would have half-open semantics and could represent a point).

clang/lib/Sema/SemaDecl.cpp

if (!VDecl->isInvalidDecl()) {
 
     // Try to correct any TypoExprs in the initialization arguments.
     for (size_t Idx = 0; Idx < Args.size(); ++Idx) {
       ExprResult Res = CorrectDelayedTyposInExpr(
           Args[Idx], VDecl, [this, Entity, Kind](Expr *E) {
             InitializationSequence Init(*this, Entity, Kind, MultiExprArg(E));
             return Init.Failed() ? ExprError() : E;
           });
       if (Res.isInvalid()) {
         VDecl->setInvalidDecl();
       } else if (Res.get() != Args[Idx]) {
         Args[Idx] = Res.get();
       }
     }
     if (VDecl->isInvalidDecl())
       return;
 
     InitializationSequence InitSeq(*this, Entity, Kind, Args,
                                    /*TopLevelOfInitList=*/false,
                                    /*TreatUnavailableAsInvalid=*/false);
     ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);
     if (Result.isInvalid()) {
       VDecl->setInvalidDecl();
       return;
     }
 
     Init = Result.getAs<Expr>();
   }
 
   // Check for self-references within variable initializers.
   // Variables declared within a function/method body (except for references)
   // are handled by a dataflow analysis.
   // This is undefined behavior in C++, but valid in C.
void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, bool DirectInit) {
   if (LangOpts.OpenMP && VDecl->isFileVarDecl())
     DeclsToCheckForDeferredDiags.push_back(VDecl);
   CheckCompleteVariableDeclaration(VDecl);
 }
 
 /// ActOnInitializerError - Given that there was an error parsing an
 /// initializer for the given declaration, try to return to some form
 /// of sanity.
 void Sema::ActOnInitializerError(Decl *D) {
   // Our main concern here is re-establishing invariants like "a
   // variable's type is either dependent or complete".
   if (!D || D->isInvalidDecl()) return;
 
   VarDecl *VD = dyn_cast<VarDecl>(D);
   if (!VD) return;
 
   // Bindings are not usable if we can't make sense of the initializer.
if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
     //   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 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);
+    } else {
+      // If default-init fails, leave var uninitialized but valid, and build
+      // a recovery-expr for recovery.
+      auto RecoveryExpr =
+          CreateRecoveryExpr(Var->getLocation(), Var->getEndLoc(), {});
+      if (RecoveryExpr.get())
+        Var->setInit(RecoveryExpr.get());
     }
 
     CheckCompleteVariableDeclaration(Var);
   }
 }
 
 void Sema::ActOnCXXForRangeDecl(Decl *D) {
   // If there is no declaration, there was an error parsing it. Ignore it.

clang/lib/Sema/SemaDeclCXX.cpp

 //===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements semantic analysis for C++ declarations.
ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
   // Recover by marking the field invalid, unless we're in a SFINAE context.
   if (!isSFINAEContext())
     Field->setInvalidDecl();
   return ExprError();
 }
 
 void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) {
   if (VD->isInvalidDecl()) return;
+  if (VD->getInit() && VD->getInit()->containsErrors()) return;
 
   CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Record->getDecl());
   if (ClassDecl->isInvalidDecl()) return;
   if (ClassDecl->hasIrrelevantDestructor()) return;
   if (ClassDecl->isDependentContext()) return;
 
   if (VD->isNoDestroy(getASTContext()))
     return;
 

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

-// RUN: %clang_cc1 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++98 %s
-// RUN: %clang_cc1 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s
-// RUN: %clang_cc1 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
-// RUN: %clang_cc1 -triple x86_64-windows-msvc -fms-compatibility-version=19 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++98 %s
-// RUN: %clang_cc1 -triple x86_64-windows-msvc -fms-compatibility-version=19 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s
-// RUN: %clang_cc1 -triple x86_64-windows-msvc -fms-compatibility-version=19 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
+// RUN: %clang_cc1 -frecovery-ast -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -frecovery-ast -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -frecovery-ast -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
+// RUN: %clang_cc1 -frecovery-ast -triple x86_64-windows-msvc -fms-compatibility-version=19 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -frecovery-ast -triple x86_64-windows-msvc -fms-compatibility-version=19 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -frecovery-ast -triple x86_64-windows-msvc -fms-compatibility-version=19 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
 
 // C++0x [class.access]p4:
 
 //   Access control is applied uniformly to all names, whether the
 //   names are referred to from declarations or expressions.  In the
 //   case of overloaded function names, access control is applied to
 //   the function selected by overload resolution.
 
class Derived2 : // expected-error {{inherited virtual base class 'Base<2>' 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
   {
     ~Derived2() {}
   };
 
   class Derived3 :
-    Base<0>, // expected-note 2{{deleted because base class 'Base<0>' has an inaccessible destructor}}
+    Base<0>, // expected-note {{deleted because base class 'Base<0>' has an inaccessible destructor}}
     virtual Base<1>,
     Base2,
     virtual Base3
   {};
-  Derived3 d3; // expected-error {{implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
+  Derived3 d3; // expected-error {{implicitly-deleted default constructor}}
 #elif __cplusplus >= 201103L && defined(_MSC_VER)
-  template <unsigned N> class Base { ~Base(); }; // expected-note 9{{declared private here}}
+  template <unsigned N> class Base { ~Base(); }; // expected-note 6{{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 : // expected-error 3{{has private destructor}}
+  class Derived3 :
     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}} expected-error {{use a deleted function}}
-               // expected-note@-1 {{implicit destructor for}}
+  Derived3 d3; // expected-error {{implicitly-deleted default constructor}}
 #else
 #error "missing case of MSVC cross C++ versions"
 #endif
 }
 
 // Conversion functions.
 namespace test4 {
   class Base {

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

-// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -Wno-defaulted-function-deleted
+// RUN: %clang_cc1 -frecovery-ast -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 8{{explicitly marked deleted here}}
+struct DeletedDtor { ~DeletedDtor() = delete; }; // expected-note 4{{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 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 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 NotDeleted7i : Friend {};
 NotDeleted7i d7i;
 struct NotDeleted7j : virtual Friend {};
 NotDeleted7j d7j;
 struct NotDeleted7k { Friend a; };
 NotDeleted7k d7k;
 
 

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

-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -frecovery-ast -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}} expected-note {{destructor of 'bad_union' is implicitly deleted}}
+  non_trivial nt; // expected-note {{non-trivial default constructor}}
 };
-bad_union u; // expected-error {{call to implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
+bad_union u; // expected-error {{call to implicitly-deleted default constructor}}
 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}} expected-note {{destructor of 'bad_anon' is implicitly deleted}}
+    non_trivial nt; // expected-note {{non-trivial default constructor}}
   };
 };
-bad_anon a; // expected-error {{call to implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
+bad_anon a; // expected-error {{call to implicitly-deleted default constructor}}
 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 4{{deleted here}}
+  ~no_dtor() = delete; // expected-note 2{{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}} expected-note {{destructor of 'bad_field_dtor' is implicitly deleted }}
+  no_dtor nd; // expected-note {{field 'nd' 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_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_base_dtor bbx; // expected-error {{call to implicitly-deleted default constructor}} expected-error {{attempt to use a deleted function}}
+bad_base_dtor bbx; // expected-error {{call to implicitly-deleted default constructor}}
 
 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

-// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify %s
-// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify -std=c++98 %s
-// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify -std=c++11 %s
-// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify %s
-// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=c++98 %s
-// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=c++11 %s
+// RUN: %clang_cc1 -frecovery-ast -fsyntax-only -triple %itanium_abi_triple -verify %s
+// RUN: %clang_cc1 -frecovery-ast -fsyntax-only -triple %itanium_abi_triple -verify -std=c++98 %s
+// RUN: %clang_cc1 -frecovery-ast -fsyntax-only -triple %itanium_abi_triple -verify -std=c++11 %s
+// RUN: %clang_cc1 -frecovery-ast -fsyntax-only -triple %ms_abi_triple -DMSABI -verify %s
+// RUN: %clang_cc1 -frecovery-ast -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=c++98 %s
+// RUN: %clang_cc1 -frecovery-ast -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=c++11 %s
 // PR7800
 
 // The Microsoft ABI doesn't have the concept of key functions, so we have different
 // expectations about when functions are first required for that case.
 
 class NoDestroy { ~NoDestroy(); };
 #if __cplusplus <= 199711L
 // expected-note@-2 3 {{declared private here}}
#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

-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fobjc-arc -fobjc-runtime-has-weak -fobjc-weak -verify -fblocks -fobjc-exceptions %s
+// RUN: %clang_cc1 -frecovery-ast -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
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 7 {{'U0' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
+    id f0; // expected-note 6 {{'U0' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
   };
 
   union U1 {
-    __weak id f0; // expected-note 13 {{'U1' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
+    __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 2{{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();
 
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 7 {{'' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
+      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 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}}
+      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 7 {{'S2' is implicitly deleted because variant field '' has a non-trivial}}
+      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}} 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}}
+    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}}
-    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}}
+  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}} 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}}
+    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}} 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}}
+    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}}