[clang] Add ElaboratedType sugaring for types on implicit special members

[brad.king]

Summary

Extend the change from commit 15f3cd6bfc67 ([clang] Implement
ElaboratedType sugaring for types written bare, 2021-10-11, D112374)
to cover types in the signatures of implicit copy-constructor,
copy-assignment, move-constructor, and move-assignment members in
C++ record types.

With this fix, diagnostic messages print types of special members
consistently whether they are explicitly or implicitly defined.

Fixes: https://github.com/llvm/llvm-project/issues/59557

[brad.king]

Clarify commit message

Revise the message to clarify the changes are for implicitly
generated members.

Also link to the corresponding issue with a full URL.

[rsmith]

This makes sense to me, and it looks like the memory impact from the extra type nodes should be relatively small.

[brad.king]

Thanks rsmith! Since I do not have commit privileges, can you land this for me, please?

clang/lib/Sema/SemaDeclCXX.cpp

else if (CSM == CXXCopyAssignment)
     CanHaveConstParam = RD->implicitCopyAssignmentHasConstParam();
 
   QualType ReturnType = Context.VoidTy;
   if (CSM == CXXCopyAssignment || CSM == CXXMoveAssignment) {
     // Check for return type matching.
     ReturnType = Type->getReturnType();
 
     QualType DeclType = Context.getTypeDeclType(RD);
+    DeclType = Context.getElaboratedType(ETK_None, nullptr, DeclType, nullptr);
     DeclType = Context.getAddrSpaceQualType(DeclType, MD->getMethodQualifiers().getAddressSpace());
     QualType ExpectedReturnType = Context.getLValueReferenceType(DeclType);
 
     if (!Context.hasSameType(ReturnType, ExpectedReturnType)) {
       Diag(MD->getLocation(), diag::err_defaulted_special_member_return_type)
         << (CSM == CXXMoveAssignment) << ExpectedReturnType;
       HadError = true;
     }
CXXMethodDecl *Sema::DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl) {
   // operators taking an object instead of a reference are allowed.
   assert(ClassDecl->needsImplicitCopyAssignment());
 
   DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyAssignment);
   if (DSM.isAlreadyBeingDeclared())
     return nullptr;
 
   QualType ArgType = Context.getTypeDeclType(ClassDecl);
+  ArgType = Context.getElaboratedType(ETK_None, nullptr, ArgType, nullptr);
   LangAS AS = getDefaultCXXMethodAddrSpace();
   if (AS != LangAS::Default)
     ArgType = Context.getAddrSpaceQualType(ArgType, AS);
   QualType RetType = Context.getLValueReferenceType(ArgType);
   bool Const = ClassDecl->implicitCopyAssignmentHasConstParam();
   if (Const)
     ArgType = ArgType.withConst();
 
CXXMethodDecl *Sema::DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl) {
   DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveAssignment);
   if (DSM.isAlreadyBeingDeclared())
     return nullptr;
 
   // Note: The following rules are largely analoguous to the move
   // constructor rules.
 
   QualType ArgType = Context.getTypeDeclType(ClassDecl);
+  ArgType = Context.getElaboratedType(ETK_None, nullptr, ArgType, nullptr);
   LangAS AS = getDefaultCXXMethodAddrSpace();
   if (AS != LangAS::Default)
     ArgType = Context.getAddrSpaceQualType(ArgType, AS);
   QualType RetType = Context.getLValueReferenceType(ArgType);
   ArgType = Context.getRValueReferenceType(ArgType);
 
   bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
                                                      CXXMoveAssignment,
CXXConstructorDecl *Sema::DeclareImplicitCopyConstructor(
   assert(ClassDecl->needsImplicitCopyConstructor());
 
   DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyConstructor);
   if (DSM.isAlreadyBeingDeclared())
     return nullptr;
 
   QualType ClassType = Context.getTypeDeclType(ClassDecl);
   QualType ArgType = ClassType;
+  ArgType = Context.getElaboratedType(ETK_None, nullptr, ArgType, nullptr);
   bool Const = ClassDecl->implicitCopyConstructorHasConstParam();
   if (Const)
     ArgType = ArgType.withConst();
 
   LangAS AS = getDefaultCXXMethodAddrSpace();
   if (AS != LangAS::Default)
     ArgType = Context.getAddrSpaceQualType(ArgType, AS);
 
CXXConstructorDecl *Sema::DeclareImplicitMoveConstructor(
 
   DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveConstructor);
   if (DSM.isAlreadyBeingDeclared())
     return nullptr;
 
   QualType ClassType = Context.getTypeDeclType(ClassDecl);
 
   QualType ArgType = ClassType;
+  ArgType = Context.getElaboratedType(ETK_None, nullptr, ArgType, nullptr);
   LangAS AS = getDefaultCXXMethodAddrSpace();
   if (AS != LangAS::Default)
     ArgType = Context.getAddrSpaceQualType(ClassType, AS);
   ArgType = Context.getRValueReferenceType(ArgType);
 
   bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
                                                      CXXMoveConstructor,
                                                      false);

clang/test/AST/ast-dump-decl.cpp

 // CHECK-NEXT:  | | `-RecordType 0{{.+}} 'testClassTemplateDecl::A'
 // CHECK-NEXT:  | |   `-CXXRecord 0x{{.+}} 'A'
 // CHECK-NEXT:  | |-CXXRecordDecl 0x{{.+}} <col:24, col:30> col:30 implicit class TestClassTemplate
 // CHECK-NEXT:  | |-AccessSpecDecl 0x{{.+}} <line:[[@LINE-67]]:3, col:9> col:3 public
 // CHECK-NEXT:  | |-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-67]]:5, col:23> col:5 used TestClassTemplate 'void ()'
 // CHECK-NEXT:  | |-CXXDestructorDecl 0x{{.+}} <line:[[@LINE-67]]:5, col:24> col:5 used ~TestClassTemplate 'void () noexcept'
 // CHECK-NEXT:  | |-CXXMethodDecl 0x{{.+}} <line:[[@LINE-67]]:5, col:11> col:9 j 'int ()'
 // CHECK-NEXT:  | |-FieldDecl 0x{{.+}} <line:[[@LINE-67]]:5, col:9> col:9 i 'int'
-// CHECK-NEXT:  | `-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-73]]:30> col:30 implicit constexpr TestClassTemplate 'void (const testClassTemplateDecl::TestClassTemplate<testClassTemplateDecl::A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}
-// CHECK-NEXT:  |   `-ParmVarDecl 0x{{.+}} <col:30> col:30 'const testClassTemplateDecl::TestClassTemplate<testClassTemplateDecl::A> &'
+// CHECK-NEXT:  | `-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-73]]:30> col:30 implicit constexpr TestClassTemplate 'void (const TestClassTemplate<A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}
+// CHECK-NEXT:  |   `-ParmVarDecl 0x{{.+}} <col:30> col:30 'const TestClassTemplate<A> &'
 // CHECK-NEXT:  |-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'
 // CHECK-NEXT:  |-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'
 // CHECK-NEXT:  `-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'
 
 // CHECK:       ClassTemplateSpecializationDecl 0x{{.+}} <{{.+}}:[[@LINE-67]]:3, line:[[@LINE-65]]:3> line:[[@LINE-67]]:20 class TestClassTemplate definition
 // CHECK-NEXT:  |-DefinitionData pass_in_registers standard_layout trivially_copyable trivial literal
 // CHECK-NEXT:  | |-DefaultConstructor exists trivial needs_implicit
 // CHECK-NEXT:  | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
namespace testCanonicalTemplate {
   // CHECK-NEXT:   |-CXXRecordDecl 0x{{.+}} <col:25, col:31> col:31 implicit class TestClassTemplate
   // CHECK-NEXT:   |-FriendDecl 0x{{.+}} <line:[[@LINE-30]]:5, col:40> col:40
   // CHECK-NEXT:   | `-ClassTemplateDecl 0x{{.+}} parent 0x{{.+}} prev 0x{{.+}} <col:5, col:40> col:40 TestClassTemplate
   // CHECK-NEXT:   |   |-TemplateTypeParmDecl 0x{{.+}} <col:14, col:23> col:23 typename depth 0 index 0 T2
   // CHECK-NEXT:   |   |-CXXRecordDecl 0x{{.+}} parent 0x{{.+}} prev 0x{{.+}} <col:34, col:40> col:40 class TestClassTemplate
   // CHECK-NEXT:   |   `-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate'
   // CHECK-NEXT:   |-CXXConstructorDecl 0x{{.+}} <line:[[@LINE-36]]:31> col:31 implicit used constexpr TestClassTemplate 'void () noexcept' inline default trivial
   // CHECK-NEXT:   | `-CompoundStmt 0x{{.+}} <col:31>
-  // CHECK-NEXT:   |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate 'void (const testCanonicalTemplate::TestClassTemplate<testCanonicalTemplate::A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}
-  // CHECK-NEXT:   | `-ParmVarDecl 0x{{.+}} <col:31> col:31 'const testCanonicalTemplate::TestClassTemplate<testCanonicalTemplate::A> &'
-  // CHECK-NEXT:   `-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate 'void (testCanonicalTemplate::TestClassTemplate<testCanonicalTemplate::A> &&)' inline default trivial noexcept-unevaluated 0x{{.+}}
-  // CHECK-NEXT:     `-ParmVarDecl 0x{{.+}} <col:31> col:31 'testCanonicalTemplate::TestClassTemplate<testCanonicalTemplate::A> &&'
+  // CHECK-NEXT:   |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate 'void (const TestClassTemplate<A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}
+  // CHECK-NEXT:   | `-ParmVarDecl 0x{{.+}} <col:31> col:31 'const TestClassTemplate<A> &'
+  // CHECK-NEXT:   `-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate 'void (TestClassTemplate<A> &&)' inline default trivial noexcept-unevaluated 0x{{.+}}
+  // CHECK-NEXT:     `-ParmVarDecl 0x{{.+}} <col:31> col:31 'TestClassTemplate<A> &&'
 
 
   template<typename T1> class TestClassTemplate2;
   template<typename T1> class TestClassTemplate2;
   template<typename T1> class TestClassTemplate2 {
   };
   TestClassTemplate2<A> a2;
   // CHECK:      ClassTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-5]]:3, col:31> col:31 TestClassTemplate2
   // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T1
   // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} <col:25, col:31> col:31 class TestClassTemplate2
   // CHECK-NEXT: `-ClassTemplateSpecializationDecl 0x{{.+}} <line:[[@LINE-6]]:3, line:[[@LINE-5]]:3> line:[[@LINE-6]]:31 class TestClassTemplate2 definition
   // CHECK-NEXT:   |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
   // CHECK-NEXT:   | |-DefaultConstructor exists trivial constexpr defaulted_is_constexpr
   // CHECK-NEXT:   | |-CopyConstructor simple trivial has_const_param implicit_has_const_param
   // CHECK-NEXT:   | |-MoveConstructor exists simple trivial
   // CHECK-NEXT:   | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
   // CHECK-NEXT:   | |-MoveAssignment exists simple trivial needs_implicit
   // CHECK-NEXT:   | `-Destructor simple irrelevant trivial needs_implicit
   // CHECK-NEXT:   |-TemplateArgument type 'testCanonicalTemplate::A'
   // CHECK-NEXT:   | `-RecordType 0x{{.+}} 'testCanonicalTemplate::A'
   // CHECK-NEXT:   |   `-CXXRecord 0x{{.+}} 'A'
   // CHECK-NEXT:   |-CXXRecordDecl 0x{{.+}} <col:25, col:31> col:31 implicit class TestClassTemplate2
   // CHECK-NEXT:   |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit used constexpr TestClassTemplate2 'void () noexcept' inline default trivial
   // CHECK-NEXT:   | `-CompoundStmt 0x{{.+}} <col:31>
-  // CHECK-NEXT:   |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate2 'void (const testCanonicalTemplate::TestClassTemplate2<testCanonicalTemplate::A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}
-  // CHECK-NEXT:   | `-ParmVarDecl 0x{{.+}} <col:31> col:31 'const testCanonicalTemplate::TestClassTemplate2<testCanonicalTemplate::A> &'
-  // CHECK-NEXT:   `-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate2 'void (testCanonicalTemplate::TestClassTemplate2<testCanonicalTemplate::A> &&)' inline default trivial noexcept-unevaluated 0x{{.+}}
-  // CHECK-NEXT:     `-ParmVarDecl 0x{{.+}} <col:31> col:31 'testCanonicalTemplate::TestClassTemplate2<testCanonicalTemplate::A> &&'
+  // CHECK-NEXT:   |-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate2 'void (const TestClassTemplate2<A> &)' inline default trivial noexcept-unevaluated 0x{{.+}}
+  // CHECK-NEXT:   | `-ParmVarDecl 0x{{.+}} <col:31> col:31 'const TestClassTemplate2<A> &'
+  // CHECK-NEXT:   `-CXXConstructorDecl 0x{{.+}} <col:31> col:31 implicit constexpr TestClassTemplate2 'void (TestClassTemplate2<A> &&)' inline default trivial noexcept-unevaluated 0x{{.+}}
+  // CHECK-NEXT:     `-ParmVarDecl 0x{{.+}} <col:31> col:31 'TestClassTemplate2<A> &&'
 
   // CHECK:      ClassTemplateDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-26]]:3, col:31> col:31 TestClassTemplate2
   // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T1
   // CHECK-NEXT: |-CXXRecordDecl 0x{{.+}} prev 0x{{.+}} <col:25, col:31> col:31 class TestClassTemplate2
   // CHECK-NEXT: `-ClassTemplateSpecialization 0x{{.+}} 'TestClassTemplate2'
 
   // CHECK:      ClassTemplateDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:[[@LINE-30]]:3, line:[[@LINE-29]]:3> line:[[@LINE-30]]:31 TestClassTemplate2
   // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T1

clang/test/AST/ast-dump-expr-json.cpp

 // CHECK-NEXT:         }
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "type": {
 // CHECK-NEXT:         "desugaredQualType": "NS::X",
 // CHECK-NEXT:         "qualType": "X"
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "valueCategory": "prvalue",
 // CHECK-NEXT:        "ctorType": {
-// CHECK-NEXT:         "qualType": "void (const NS::X &) noexcept"
+// CHECK-NEXT:         "qualType": "void (const X &) noexcept"
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "hadMultipleCandidates": true,
 // CHECK-NEXT:        "constructionKind": "complete",
 // CHECK-NEXT:        "inner": [
 // CHECK-NEXT:         {
 // CHECK-NEXT:          "id": "0x{{.*}}",
 // CHECK-NEXT:          "kind": "ImplicitCastExpr",
 // CHECK-NEXT:          "range": {
 // CHECK-NEXT:           "begin": {
 // CHECK-NEXT:            "offset": {{[0-9]+}},
 // CHECK-NEXT:            "col": 5,
 // CHECK-NEXT:            "tokLen": 1
 // CHECK-NEXT:           },
 // CHECK-NEXT:           "end": {
 // CHECK-NEXT:            "offset": {{[0-9]+}},
 // CHECK-NEXT:            "col": 5,
 // CHECK-NEXT:            "tokLen": 1
 // CHECK-NEXT:           }
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "type": {
-// CHECK-NEXT:           "qualType": "const NS::X"
+// CHECK-NEXT:           "desugaredQualType": "const NS::X",
+// CHECK-NEXT:           "qualType": "const X"
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "valueCategory": "lvalue",
 // CHECK-NEXT:          "castKind": "NoOp",
 // CHECK-NEXT:          "inner": [
 // CHECK-NEXT:           {
 // CHECK-NEXT:            "id": "0x{{.*}}",
 // CHECK-NEXT:            "kind": "DeclRefExpr",
 // CHECK-NEXT:            "range": {

 // CHECK-NEXT:         }
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "type": {
 // CHECK-NEXT:         "desugaredQualType": "NS::X",
 // CHECK-NEXT:         "qualType": "NS::X"
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "valueCategory": "prvalue",
 // CHECK-NEXT:        "ctorType": {
-// CHECK-NEXT:         "qualType": "void (const NS::X &) noexcept"
+// CHECK-NEXT:         "qualType": "void (const X &) noexcept"
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "hadMultipleCandidates": true,
 // CHECK-NEXT:        "constructionKind": "complete",
 // CHECK-NEXT:        "inner": [
 // CHECK-NEXT:         {
 // CHECK-NEXT:          "id": "0x{{.*}}",
 // CHECK-NEXT:          "kind": "ImplicitCastExpr",
 // CHECK-NEXT:          "range": {
 // CHECK-NEXT:           "begin": {
 // CHECK-NEXT:            "offset": {{[0-9]+}},
 // CHECK-NEXT:            "col": 5,
 // CHECK-NEXT:            "tokLen": 1
 // CHECK-NEXT:           },
 // CHECK-NEXT:           "end": {
 // CHECK-NEXT:            "offset": {{[0-9]+}},
 // CHECK-NEXT:            "col": 5,
 // CHECK-NEXT:            "tokLen": 1
 // CHECK-NEXT:           }
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "type": {
-// CHECK-NEXT:           "qualType": "const NS::X"
+// CHECK-NEXT:           "desugaredQualType": "const NS::X",
+// CHECK-NEXT:           "qualType": "const X"
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "valueCategory": "lvalue",
 // CHECK-NEXT:          "castKind": "NoOp",
 // CHECK-NEXT:          "inner": [
 // CHECK-NEXT:           {
 // CHECK-NEXT:            "id": "0x{{.*}}",
 // CHECK-NEXT:            "kind": "DeclRefExpr",
 // CHECK-NEXT:            "range": {

 // CHECK-NEXT:         }
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "type": {
 // CHECK-NEXT:         "desugaredQualType": "NS::X",
 // CHECK-NEXT:         "qualType": "X"
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "valueCategory": "prvalue",
 // CHECK-NEXT:        "ctorType": {
-// CHECK-NEXT:         "qualType": "void (const NS::X &) noexcept"
+// CHECK-NEXT:         "qualType": "void (const X &) noexcept"
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "hadMultipleCandidates": true,
 // CHECK-NEXT:        "constructionKind": "complete",
 // CHECK-NEXT:        "inner": [
 // CHECK-NEXT:         {
 // CHECK-NEXT:          "id": "0x{{.*}}",
 // CHECK-NEXT:          "kind": "ImplicitCastExpr",
 // CHECK-NEXT:          "range": {
 // CHECK-NEXT:           "begin": {
 // CHECK-NEXT:            "offset": {{[0-9]+}},
 // CHECK-NEXT:            "col": 9,
 // CHECK-NEXT:            "tokLen": 1
 // CHECK-NEXT:           },
 // CHECK-NEXT:           "end": {
 // CHECK-NEXT:            "offset": {{[0-9]+}},
 // CHECK-NEXT:            "col": 9,
 // CHECK-NEXT:            "tokLen": 1
 // CHECK-NEXT:           }
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "type": {
-// CHECK-NEXT:           "qualType": "const NS::X"
+// CHECK-NEXT:           "desugaredQualType": "const NS::X",
+// CHECK-NEXT:           "qualType": "const X"
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "valueCategory": "lvalue",
 // CHECK-NEXT:          "castKind": "NoOp",
 // CHECK-NEXT:          "inner": [
 // CHECK-NEXT:           {
 // CHECK-NEXT:            "id": "0x{{.*}}",
 // CHECK-NEXT:            "kind": "DeclRefExpr",
 // CHECK-NEXT:            "range": {

 // CHECK-NEXT:         }
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "type": {
 // CHECK-NEXT:         "desugaredQualType": "NS::X",
 // CHECK-NEXT:         "qualType": "X"
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "valueCategory": "prvalue",
 // CHECK-NEXT:        "ctorType": {
-// CHECK-NEXT:         "qualType": "void (const NS::X &) noexcept"
+// CHECK-NEXT:         "qualType": "void (const X &) noexcept"
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "hadMultipleCandidates": true,
 // CHECK-NEXT:        "constructionKind": "complete",
 // CHECK-NEXT:        "inner": [
 // CHECK-NEXT:         {
 // CHECK-NEXT:          "id": "0x{{.*}}",
 // CHECK-NEXT:          "kind": "ImplicitCastExpr",
 // CHECK-NEXT:          "range": {
 // CHECK-NEXT:           "begin": {
 // CHECK-NEXT:            "offset": {{[0-9]+}},
 // CHECK-NEXT:            "col": 5,
 // CHECK-NEXT:            "tokLen": 1
 // CHECK-NEXT:           },
 // CHECK-NEXT:           "end": {
 // CHECK-NEXT:            "offset": {{[0-9]+}},
 // CHECK-NEXT:            "col": 5,
 // CHECK-NEXT:            "tokLen": 1
 // CHECK-NEXT:           }
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "type": {
-// CHECK-NEXT:           "qualType": "const NS::X"
+// CHECK-NEXT:           "desugaredQualType": "const NS::X",
+// CHECK-NEXT:           "qualType": "const X"
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "valueCategory": "lvalue",
 // CHECK-NEXT:          "castKind": "NoOp",
 // CHECK-NEXT:          "inner": [
 // CHECK-NEXT:           {
 // CHECK-NEXT:            "id": "0x{{.*}}",
 // CHECK-NEXT:            "kind": "DeclRefExpr",
 // CHECK-NEXT:            "range": {

 // CHECK-NEXT:         }
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "type": {
 // CHECK-NEXT:         "desugaredQualType": "NS::X",
 // CHECK-NEXT:         "qualType": "NS::X"
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "valueCategory": "prvalue",
 // CHECK-NEXT:        "ctorType": {
-// CHECK-NEXT:         "qualType": "void (const NS::X &) noexcept"
+// CHECK-NEXT:         "qualType": "void (const X &) noexcept"
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "hadMultipleCandidates": true,
 // CHECK-NEXT:        "constructionKind": "complete",
 // CHECK-NEXT:        "inner": [
 // CHECK-NEXT:         {
 // CHECK-NEXT:          "id": "0x{{.*}}",
 // CHECK-NEXT:          "kind": "ImplicitCastExpr",
 // CHECK-NEXT:          "range": {
 // CHECK-NEXT:           "begin": {
 // CHECK-NEXT:            "offset": {{[0-9]+}},
 // CHECK-NEXT:            "col": 5,
 // CHECK-NEXT:            "tokLen": 1
 // CHECK-NEXT:           },
 // CHECK-NEXT:           "end": {
 // CHECK-NEXT:            "offset": {{[0-9]+}},
 // CHECK-NEXT:            "col": 5,
 // CHECK-NEXT:            "tokLen": 1
 // CHECK-NEXT:           }
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "type": {
-// CHECK-NEXT:           "qualType": "const NS::X"
+// CHECK-NEXT:           "desugaredQualType": "const NS::X",
+// CHECK-NEXT:           "qualType": "const X"
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "valueCategory": "lvalue",
 // CHECK-NEXT:          "castKind": "NoOp",
 // CHECK-NEXT:          "inner": [
 // CHECK-NEXT:           {
 // CHECK-NEXT:            "id": "0x{{.*}}",
 // CHECK-NEXT:            "kind": "DeclRefExpr",
 // CHECK-NEXT:            "range": {

 // CHECK-NEXT:         }
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "type": {
 // CHECK-NEXT:         "desugaredQualType": "NS::X",
 // CHECK-NEXT:         "qualType": "X"
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "valueCategory": "prvalue",
 // CHECK-NEXT:        "ctorType": {
-// CHECK-NEXT:         "qualType": "void (const NS::X &) noexcept"
+// CHECK-NEXT:         "qualType": "void (const X &) noexcept"
 // CHECK-NEXT:        },
 // CHECK-NEXT:        "hadMultipleCandidates": true,
 // CHECK-NEXT:        "constructionKind": "complete",
 // CHECK-NEXT:        "inner": [
 // CHECK-NEXT:         {
 // CHECK-NEXT:          "id": "0x{{.*}}",
 // CHECK-NEXT:          "kind": "ImplicitCastExpr",
 // CHECK-NEXT:          "range": {
 // CHECK-NEXT:           "begin": {
 // CHECK-NEXT:            "offset": {{[0-9]+}},
 // CHECK-NEXT:            "col": 5,
 // CHECK-NEXT:            "tokLen": 1
 // CHECK-NEXT:           },
 // CHECK-NEXT:           "end": {
 // CHECK-NEXT:            "offset": {{[0-9]+}},
 // CHECK-NEXT:            "col": 5,
 // CHECK-NEXT:            "tokLen": 1
 // CHECK-NEXT:           }
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "type": {
-// CHECK-NEXT:           "qualType": "const NS::X"
+// CHECK-NEXT:           "desugaredQualType": "const NS::X",
+// CHECK-NEXT:           "qualType": "const X"
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "valueCategory": "lvalue",
 // CHECK-NEXT:          "castKind": "NoOp",
 // CHECK-NEXT:          "inner": [
 // CHECK-NEXT:           {
 // CHECK-NEXT:            "id": "0x{{.*}}",
 // CHECK-NEXT:            "kind": "DeclRefExpr",
 // CHECK-NEXT:            "range": {

clang/test/Analysis/auto-obj-dtors-cfg-output.cpp

 // CHECK-NEXT:   3: [B3.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B4]
 // WARNINGS-NEXT:   1:  (CXXConstructExpr, A)
 // ANALYZER-NEXT:   1:  (CXXConstructExpr, [B4.2], A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   3: a
-// CHECK-NEXT:   4: [B4.3] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:   4: [B4.3] (ImplicitCastExpr, NoOp, const A)
 // WARNINGS-NEXT:   5: [B4.4] (CXXConstructExpr, A)
 // ANALYZER-NEXT:   5: [B4.4] (CXXConstructExpr, [B4.6], A)
 // CHECK-NEXT:   6: A b = a;
 // CHECK-NEXT:   7: b
 // CHECK-NEXT:   8: [B4.7] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   9: [B4.8].operator int
 // CHECK:       10: [B4.8]
 // CHECK:       11: [B4.10] (ImplicitCastExpr, UserDefinedConversion, int)

 // CHECK-NEXT:   T: if [B7.4]
 // CHECK-NEXT:   Preds (1): B8
 // CHECK-NEXT:   Succs (2): B6 B5
 // CHECK:      [B8]
 // WARNINGS-NEXT:   1:  (CXXConstructExpr, A)
 // ANALYZER-NEXT:   1:  (CXXConstructExpr, [B8.2], A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   3: a
-// CHECK-NEXT:   4: [B8.3] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:   4: [B8.3] (ImplicitCastExpr, NoOp, const A)
 // WARNINGS-NEXT:   5: [B8.4] (CXXConstructExpr, A)
 // ANALYZER-NEXT:   5: [B8.4] (CXXConstructExpr, [B8.6], A)
 // CHECK-NEXT:   6: A b = a;
 // CHECK-NEXT:   7: b
 // CHECK-NEXT:   8: [B8.7] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   9: [B8.8].operator int
 // CHECK:       10: [B8.8]
 // CHECK:       11: [B8.10] (ImplicitCastExpr, UserDefinedConversion, int)

 // ANALYZER-NEXT:   1:  (CXXConstructExpr, [B3.2], A)
 // CHECK-NEXT:   2: A c;
 // CHECK-NEXT:   3: [B3.2].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B4.4].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B2
 // CHECK:      [B4]
 // CHECK-NEXT:   1: a
-// CHECK-NEXT:   2: [B4.1] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:   2: [B4.1] (ImplicitCastExpr, NoOp, const A)
 // WARNINGS-NEXT:   3: [B4.2] (CXXConstructExpr, A)
 // ANALYZER-NEXT:   3: [B4.2] (CXXConstructExpr, [B4.4], A)
 // CHECK-NEXT:   4: A b = a;
 // CHECK-NEXT:   5: b
 // CHECK-NEXT:   6: [B4.5] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   7: [B4.6].operator int
 // CHECK-NEXT:   8: [B4.6]
 // CHECK-NEXT:   9: [B4.8] (ImplicitCastExpr, UserDefinedConversion, int)

 // CHECK-NEXT:   2: A c;
 // CHECK-NEXT:   3: UV
 // CHECK-NEXT:   4: [B9.3] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:   T: if [B9.4]
 // CHECK-NEXT:   Preds (1): B10
 // CHECK-NEXT:   Succs (2): B8 B7
 // CHECK:      [B10]
 // CHECK-NEXT:   1: a
-// CHECK-NEXT:   2: [B10.1] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:   2: [B10.1] (ImplicitCastExpr, NoOp, const A)
 // WARNINGS-NEXT:   3: [B10.2] (CXXConstructExpr, A)
 // ANALYZER-NEXT:   3: [B10.2] (CXXConstructExpr, [B10.4], A)
 // CHECK-NEXT:   4: A b = a;
 // CHECK-NEXT:   5: b
 // CHECK-NEXT:   6: [B10.5] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   7: [B10.6].operator int
 // CHECK-NEXT:   8: [B10.6]
 // CHECK-NEXT:   9: [B10.8] (ImplicitCastExpr, UserDefinedConversion, int)

 // CHECK-NEXT:   2: [B2.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (2): B3 B2
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B2]
 // WARNINGS-NEXT:   1:  (CXXConstructExpr, A)
 // ANALYZER-NEXT:   1:  (CXXConstructExpr, [B2.2], A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   3: a
-// CHECK-NEXT:   4: [B2.3] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:   4: [B2.3] (ImplicitCastExpr, NoOp, const A)
 // CHECK-NEXT:   5: [B2.4] (CXXConstructExpr, A)
 // CHECK-NEXT:   6: A b = a;
 // CHECK-NEXT:   7: b
 // CHECK-NEXT:   8: [B2.7] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   9: [B2.8].operator int
 // CHECK:       10: [B2.8]
 // CHECK:       11: [B2.10] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:   T: switch [B2.11]

 // CHECK-NEXT:   5: [B2.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (3): B3 B7 B2
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B2]
 // WARNINGS-NEXT:   1:  (CXXConstructExpr, A)
 // ANALYZER-NEXT:   1:  (CXXConstructExpr, [B2.2], A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   3: a
-// CHECK-NEXT:   4: [B2.3] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:   4: [B2.3] (ImplicitCastExpr, NoOp, const A)
 // CHECK-NEXT:   5: [B2.4] (CXXConstructExpr, A)
 // CHECK-NEXT:   6: A b = a;
 // CHECK-NEXT:   7: b
 // CHECK-NEXT:   8: [B2.7] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   9: [B2.8].operator int
 // CHECK:       10: [B2.8]
 // CHECK:       11: [B2.10] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:   T: switch [B2.11]

 // ANALYZER-NEXT:   1:  (CXXConstructExpr, [B3.2], A)
 // CHECK-NEXT:   2: A c;
 // CHECK-NEXT:   3: [B3.2].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B4.4].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B2
 // CHECK:      [B4]
 // CHECK-NEXT:   1: a
-// CHECK-NEXT:   2: [B4.1] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:   2: [B4.1] (ImplicitCastExpr, NoOp, const A)
 // WARNINGS-NEXT:   3: [B4.2] (CXXConstructExpr, A)
 // ANALYZER-NEXT:   3: [B4.2] (CXXConstructExpr, [B4.4], A)
 // CHECK-NEXT:   4: A b = a;
 // CHECK-NEXT:   5: b
 // CHECK-NEXT:   6: [B4.5] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   7: [B4.6].operator int
 // CHECK-NEXT:   8: [B4.6]
 // CHECK-NEXT:   9: [B4.8] (ImplicitCastExpr, UserDefinedConversion, int)

 // CHECK-NEXT:   2: A d;
 // CHECK-NEXT:   3: UV
 // CHECK-NEXT:   4: [B9.3] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:   T: if [B9.4]
 // CHECK-NEXT:   Preds (1): B10
 // CHECK-NEXT:   Succs (2): B8 B7
 // CHECK:      [B10]
 // CHECK-NEXT:   1: b
-// CHECK-NEXT:   2: [B10.1] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:   2: [B10.1] (ImplicitCastExpr, NoOp, const A)
 // WARNINGS-NEXT:   3: [B10.2] (CXXConstructExpr, A)
 // ANALYZER-NEXT:   3: [B10.2] (CXXConstructExpr, [B10.4], A)
 // CHECK-NEXT:   4: A c = b;
 // CHECK-NEXT:   5: c
 // CHECK-NEXT:   6: [B10.5] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   7: [B10.6].operator int
 // CHECK-NEXT:   8: [B10.6]
 // CHECK-NEXT:   9: [B10.8] (ImplicitCastExpr, UserDefinedConversion, int)

clang/test/Analysis/lifetime-cfg-output.cpp

 // CHECK-NEXT:    2: A c;
 // CHECK-NEXT:    3: [B3.2] (Lifetime ends)
 // CHECK-NEXT:    Preds (1): B4
 // CHECK-NEXT:    Succs (1): B1
 // CHECK:       [B4]
 // CHECK-NEXT:    1:  (CXXConstructExpr, A)
 // CHECK-NEXT:    2: A a;
 // CHECK-NEXT:    3: a
-// CHECK-NEXT:    4: [B4.3] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:    4: [B4.3] (ImplicitCastExpr, NoOp, const A)
 // CHECK-NEXT:    5: [B4.4] (CXXConstructExpr, A)
 // CHECK-NEXT:    6: A b = a;
 // CHECK-NEXT:    7: b
 // CHECK-NEXT:    8: [B4.7] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:    9: [B4.8].operator int
 // CHECK-NEXT:   10: [B4.8]
 // CHECK-NEXT:   11: [B4.10] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:   12: [B4.11] (ImplicitCastExpr, IntegralToBoolean, _Bool)

 // CHECK-NEXT:    4: [B7.3] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:    T: if [B7.4]
 // CHECK-NEXT:    Preds (1): B8
 // CHECK-NEXT:    Succs (2): B6 B5
 // CHECK:       [B8]
 // CHECK-NEXT:    1:  (CXXConstructExpr, A)
 // CHECK-NEXT:    2: A a;
 // CHECK-NEXT:    3: a
-// CHECK-NEXT:    4: [B8.3] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:    4: [B8.3] (ImplicitCastExpr, NoOp, const A)
 // CHECK-NEXT:    5: [B8.4] (CXXConstructExpr, A)
 // CHECK-NEXT:    6: A b = a;
 // CHECK-NEXT:    7: b
 // CHECK-NEXT:    8: [B8.7] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:    9: [B8.8].operator int
 // CHECK-NEXT:   10: [B8.8]
 // CHECK-NEXT:   11: [B8.10] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:   12: [B8.11] (ImplicitCastExpr, IntegralToBoolean, _Bool)

 // CHECK-NEXT:    1:  (CXXConstructExpr, A)
 // CHECK-NEXT:    2: A c;
 // CHECK-NEXT:    3: [B3.2] (Lifetime ends)
 // CHECK-NEXT:    4: [B4.4] (Lifetime ends)
 // CHECK-NEXT:    Preds (1): B4
 // CHECK-NEXT:    Succs (1): B2
 // CHECK:       [B4]
 // CHECK-NEXT:    1: a
-// CHECK-NEXT:    2: [B4.1] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:    2: [B4.1] (ImplicitCastExpr, NoOp, const A)
 // CHECK-NEXT:    3: [B4.2] (CXXConstructExpr, A)
 // CHECK-NEXT:    4: A b = a;
 // CHECK-NEXT:    5: b
 // CHECK-NEXT:    6: [B4.5] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:    7: [B4.6].operator int
 // CHECK-NEXT:    8: [B4.6]
 // CHECK-NEXT:    9: [B4.8] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:   10: [B4.9] (ImplicitCastExpr, IntegralToBoolean, _Bool)

 // CHECK-NEXT:    2: A c;
 // CHECK-NEXT:    3: UV
 // CHECK-NEXT:    4: [B9.3] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:    T: if [B9.4]
 // CHECK-NEXT:    Preds (1): B10
 // CHECK-NEXT:    Succs (2): B8 B7
 // CHECK:       [B10]
 // CHECK-NEXT:    1: a
-// CHECK-NEXT:    2: [B10.1] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:    2: [B10.1] (ImplicitCastExpr, NoOp, const A)
 // CHECK-NEXT:    3: [B10.2] (CXXConstructExpr, A)
 // CHECK-NEXT:    4: A b = a;
 // CHECK-NEXT:    5: b
 // CHECK-NEXT:    6: [B10.5] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:    7: [B10.6].operator int
 // CHECK-NEXT:    8: [B10.6]
 // CHECK-NEXT:    9: [B10.8] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:   10: [B10.9] (ImplicitCastExpr, IntegralToBoolean, _Bool)

 // CHECK-NEXT:    1:  (CXXConstructExpr, A)
 // CHECK-NEXT:    2: A c;
 // CHECK-NEXT:    3: [B3.2] (Lifetime ends)
 // CHECK-NEXT:    4: [B4.4] (Lifetime ends)
 // CHECK-NEXT:    Preds (1): B4
 // CHECK-NEXT:    Succs (1): B2
 // CHECK:       [B4]
 // CHECK-NEXT:    1: a
-// CHECK-NEXT:    2: [B4.1] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:    2: [B4.1] (ImplicitCastExpr, NoOp, const A)
 // CHECK-NEXT:    3: [B4.2] (CXXConstructExpr, A)
 // CHECK-NEXT:    4: A b = a;
 // CHECK-NEXT:    5: b
 // CHECK-NEXT:    6: [B4.5] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:    7: [B4.6].operator int
 // CHECK-NEXT:    8: [B4.6]
 // CHECK-NEXT:    9: [B4.8] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:   10: [B4.9] (ImplicitCastExpr, IntegralToBoolean, _Bool)

 // CHECK-NEXT:    2: A d;
 // CHECK-NEXT:    3: UV
 // CHECK-NEXT:    4: [B9.3] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:    T: if [B9.4]
 // CHECK-NEXT:    Preds (1): B10
 // CHECK-NEXT:    Succs (2): B8 B7
 // CHECK:       [B10]
 // CHECK-NEXT:    1: b
-// CHECK-NEXT:    2: [B10.1] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:    2: [B10.1] (ImplicitCastExpr, NoOp, const A)
 // CHECK-NEXT:    3: [B10.2] (CXXConstructExpr, A)
 // CHECK-NEXT:    4: A c = b;
 // CHECK-NEXT:    5: c
 // CHECK-NEXT:    6: [B10.5] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:    7: [B10.6].operator int
 // CHECK-NEXT:    8: [B10.6]
 // CHECK-NEXT:    9: [B10.8] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:   10: [B10.9] (ImplicitCastExpr, IntegralToBoolean, _Bool)

clang/test/Analysis/missing-bind-temporary.cpp

class B {
   A a;
 };
 
 // CHECK: void foo(int)
 // CHECK:       [B1]
 // CHECK-NEXT:    1:  (CXXConstructExpr, [B1.2], B)
 // CHECK-NEXT:    2: B i;
 // CHECK-NEXT:    3: operator=
-// CHECK-NEXT:    4: [B1.3] (ImplicitCastExpr, FunctionToPointerDecay, class variant_0::B &(*)(class variant_0::B &&) noexcept)
+// CHECK-NEXT:    4: [B1.3] (ImplicitCastExpr, FunctionToPointerDecay, B &(*)(B &&) noexcept)
 // CHECK-NEXT:    5: i
-// CHECK-NEXT:    6: {} (CXXConstructExpr, [B1.7], [B1.8], class variant_0::B)
+// CHECK-NEXT:    6: {} (CXXConstructExpr, [B1.7], [B1.8], B)
 // CHECK-NEXT:    7: [B1.6] (BindTemporary)
 // CHECK-NEXT:    8: [B1.7]
 // CHECK-NEXT:    9: [B1.5] = [B1.8] (OperatorCall)
-// CHECK-NEXT:   10: ~variant_0::B() (Temporary object destructor)
+// CHECK-NEXT:   10: ~B() (Temporary object destructor)
 // CHECK-NEXT:   11: [B1.2].~B() (Implicit destructor)
 void foo(int) {
   B i;
   i = {};
 }
 
 void bar() {
   global = 0;

 
 // FIXME: Find the construction context for {} and enforce the temporary
 // destructor.
 // CHECK: template<> void foo<int>(int)
 // CHECK:       [B1]
 // CHECK-NEXT:    1:  (CXXConstructExpr, [B1.2], B)
 // CHECK-NEXT:    2: B i;
 // CHECK-NEXT:    3: operator=
-// CHECK-NEXT:    4: [B1.3] (ImplicitCastExpr, FunctionToPointerDecay, class variant_1::B &(*)(class variant_1::B &&) noexcept)
+// CHECK-NEXT:    4: [B1.3] (ImplicitCastExpr, FunctionToPointerDecay, B &(*)(B &&) noexcept)
 // CHECK-NEXT:    5: i
-// CHECK-NEXT:    6: {} (CXXConstructExpr, class variant_1::B)
+// CHECK-NEXT:    6: {} (CXXConstructExpr, B)
 // CHECK-NEXT:    7: [B1.6]
 // CHECK-NEXT:    8: [B1.5] = [B1.7] (OperatorCall)
 // CHECK-NEXT:    9: [B1.2].~B() (Implicit destructor)
 template <typename T> void foo(T) {
   B i;
   i = {};
 }
 
public:
   A a;
 };
 
 // CHECK: template<> void foo<int>(int)
 // CHECK:       [B1]
 // CHECK-NEXT:    1:  (CXXConstructExpr, [B1.2], B)
 // CHECK-NEXT:    2: B i;
 // CHECK-NEXT:    3: operator=
-// CHECK-NEXT:    4: [B1.3] (ImplicitCastExpr, FunctionToPointerDecay, class variant_2::B &(*)(class variant_2::B &&) noexcept)
+// CHECK-NEXT:    4: [B1.3] (ImplicitCastExpr, FunctionToPointerDecay, B &(*)(B &&) noexcept)
 // CHECK-NEXT:    5: i
 // CHECK-NEXT:    6: {}
 // CHECK-NEXT:    7: {}
 // CHECK-NEXT:    8: [B1.7] (BindTemporary)
 // CHECK-NEXT:    9: [B1.8]
 // CHECK-NEXT:   10: [B1.5] = [B1.9] (OperatorCall)
-// CHECK-NEXT:   11: ~variant_2::B() (Temporary object destructor)
+// CHECK-NEXT:   11: ~B() (Temporary object destructor)
 // CHECK-NEXT:   12: [B1.2].~B() (Implicit destructor)
 template <typename T> void foo(T) {
   B i;
   i = {};
 }
 
 void bar() {
   global = 0;
   foo(1);
   // FIXME: Should be TRUE, i.e. we should call (and inline) two destructors.
   clang_analyzer_eval(global == 2); // expected-warning{{UNKNOWN}}
 }
 
 } // end namespace variant_2

clang/test/Analysis/scopes-cfg-output.cpp

 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B4]
 // CHECK-NEXT:   1: CFGScopeBegin(a)
 // CHECK-NEXT:   2:  (CXXConstructExpr, [B4.3], A)
 // CHECK-NEXT:   3: A a;
 // CHECK-NEXT:   4: CFGScopeBegin(b)
 // CHECK-NEXT:   5: a
-// CHECK-NEXT:   6: [B4.5] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:   6: [B4.5] (ImplicitCastExpr, NoOp, const A)
 // CHECK-NEXT:   7: [B4.6] (CXXConstructExpr, [B4.8], A)
 // CHECK-NEXT:   8: A b = a;
 // CHECK-NEXT:   9: b
 // CHECK-NEXT:  10: [B4.9] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:  11: [B4.10].operator int
 // CHECK-NEXT:  12: [B4.10]
 // CHECK-NEXT:  13: [B4.12] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:  14: [B4.13] (ImplicitCastExpr, IntegralToBoolean, _Bool)

 // CHECK-NEXT:   Preds (1): B8
 // CHECK-NEXT:   Succs (2): B6 B5
 // CHECK:      [B8]
 // CHECK-NEXT:   1: CFGScopeBegin(a)
 // CHECK-NEXT:   2:  (CXXConstructExpr, [B8.3], A)
 // CHECK-NEXT:   3: A a;
 // CHECK-NEXT:   4: CFGScopeBegin(b)
 // CHECK-NEXT:   5: a
-// CHECK-NEXT:   6: [B8.5] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:   6: [B8.5] (ImplicitCastExpr, NoOp, const A)
 // CHECK-NEXT:   7: [B8.6] (CXXConstructExpr, [B8.8], A)
 // CHECK-NEXT:   8: A b = a;
 // CHECK-NEXT:   9: b
 // CHECK-NEXT:  10: [B8.9] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:  11: [B8.10].operator int
 // CHECK-NEXT:  12: [B8.10]
 // CHECK-NEXT:  13: [B8.12] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:  14: [B8.13] (ImplicitCastExpr, IntegralToBoolean, _Bool)

 // CHECK-NEXT:   5: CFGScopeEnd(c)
 // CHECK-NEXT:   6: [B4.5].~A() (Implicit destructor)
 // CHECK-NEXT:   7: CFGScopeEnd(b)
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B2
 // CHECK:      [B4]
 // CHECK-NEXT:   1: CFGScopeBegin(b)
 // CHECK-NEXT:   2: a
-// CHECK-NEXT:   3: [B4.2] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:   3: [B4.2] (ImplicitCastExpr, NoOp, const A)
 // CHECK-NEXT:   4: [B4.3] (CXXConstructExpr, [B4.5], A)
 // CHECK-NEXT:   5: A b = a;
 // CHECK-NEXT:   6: b
 // CHECK-NEXT:   7: [B4.6] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   8: [B4.7].operator int
 // CHECK-NEXT:   9: [B4.7]
 // CHECK-NEXT:  10: [B4.9] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:  11: [B4.10] (ImplicitCastExpr, IntegralToBoolean, _Bool)

 // CHECK-NEXT:   4: UV
 // CHECK-NEXT:   5: [B9.4] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:   T: if [B9.5]
 // CHECK-NEXT:   Preds (1): B10
 // CHECK-NEXT:   Succs (2): B8 B7
 // CHECK:      [B10]
 // CHECK-NEXT:   1: CFGScopeBegin(b)
 // CHECK-NEXT:   2: a
-// CHECK-NEXT:   3: [B10.2] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:   3: [B10.2] (ImplicitCastExpr, NoOp, const A)
 // CHECK-NEXT:   4: [B10.3] (CXXConstructExpr, [B10.5], A)
 // CHECK-NEXT:   5: A b = a;
 // CHECK-NEXT:   6: b
 // CHECK-NEXT:   7: [B10.6] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   8: [B10.7].operator int
 // CHECK-NEXT:   9: [B10.7]
 // CHECK-NEXT:  10: [B10.9] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:  11: [B10.10] (ImplicitCastExpr, IntegralToBoolean, _Bool)

 // CHECK-NEXT:   5: CFGScopeEnd(c)
 // CHECK-NEXT:   6: [B4.5].~A() (Implicit destructor)
 // CHECK-NEXT:   7: CFGScopeEnd(b)
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B2
 // CHECK:      [B4]
 // CHECK-NEXT:   1: CFGScopeBegin(b)
 // CHECK-NEXT:   2: a
-// CHECK-NEXT:   3: [B4.2] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:   3: [B4.2] (ImplicitCastExpr, NoOp, const A)
 // CHECK-NEXT:   4: [B4.3] (CXXConstructExpr, [B4.5], A)
 // CHECK-NEXT:   5: A b = a;
 // CHECK-NEXT:   6: b
 // CHECK-NEXT:   7: [B4.6] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   8: [B4.7].operator int
 // CHECK-NEXT:   9: [B4.7]
 // CHECK-NEXT:  10: [B4.9] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:  11: [B4.10] (ImplicitCastExpr, IntegralToBoolean, _Bool)

 // CHECK-NEXT:   4: UV
 // CHECK-NEXT:   5: [B9.4] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:   T: if [B9.5]
 // CHECK-NEXT:   Preds (1): B10
 // CHECK-NEXT:   Succs (2): B8 B7
 // CHECK:      [B10]
 // CHECK-NEXT:   1: CFGScopeBegin(c)
 // CHECK-NEXT:   2: b
-// CHECK-NEXT:   3: [B10.2] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:   3: [B10.2] (ImplicitCastExpr, NoOp, const A)
 // CHECK-NEXT:   4: [B10.3] (CXXConstructExpr, [B10.5], A)
 // CHECK-NEXT:   5: A c = b;
 // CHECK-NEXT:   6: c
 // CHECK-NEXT:   7: [B10.6] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   8: [B10.7].operator int
 // CHECK-NEXT:   9: [B10.7]
 // CHECK-NEXT:  10: [B10.9] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:  11: [B10.10] (ImplicitCastExpr, IntegralToBoolean, _Bool)

 // CHECK-NEXT:   Succs (1): B2
 // CHECK:      [B4]
 // CHECK-NEXT:   1: CFGScopeBegin(i)
 // CHECK-NEXT:   2: __begin1
 // CHECK-NEXT:   3: [B4.2] (ImplicitCastExpr, LValueToRValue, A *)
 // CHECK-NEXT:   4: *[B4.3]
 // CHECK-NEXT:   5: auto &i
 // CHECK-NEXT:   6: operator=
-// CHECK-NEXT:   7: [B4.6] (ImplicitCastExpr, FunctionToPointerDecay, class A &(*)(const class A &)
+// CHECK-NEXT:   7: [B4.6] (ImplicitCastExpr, FunctionToPointerDecay, A &(*)(const A &)
 // CHECK-NEXT:   8: i
 // CHECK-NEXT:   9: b
-// CHECK-NEXT:  10: [B4.9] (ImplicitCastExpr, NoOp, const class A)
+// CHECK-NEXT:  10: [B4.9] (ImplicitCastExpr, NoOp, const A)
 // CHECK-NEXT:  11: [B4.8] = [B4.10] (OperatorCall)
 // CHECK-NEXT:  12: CFGScopeEnd(i)
 // CHECK-NEXT:   Preds (1): B2
 // CHECK-NEXT:   Succs (1): B3
 // CHECK:      [B5]
 // CHECK-NEXT:   1: CFGScopeBegin(a)
 // CHECK-NEXT:   2:  (CXXConstructExpr, [B5.3], A[10])
 // CHECK-NEXT:   3: A a[10];

clang/test/CXX/basic/basic.lookup/basic.lookup.argdep/p4.cpp

namespace B {
   B operator+(B,B);
 }
 
 namespace D {
   class D {};
 }
 
 namespace C {
-  class C {}; // expected-note {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'B::B' to 'const C::C &' for 1st argument}}
+  class C {}; // expected-note {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'B::B' to 'const C &' for 1st argument}}
 #if __cplusplus >= 201103L // C++11 or later
-  // expected-note@-2 {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'B::B' to 'C::C &&' for 1st argument}}
+  // expected-note@-2 {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'B::B' to 'C &&' for 1st argument}}
 #endif
   void func(C); // expected-note {{'C::func' declared here}} \
                 // expected-note {{passing argument to parameter here}}
   C operator+(C,C);
   D::D operator+(D::D,D::D);
 }
 
 namespace D {

clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct/dcl.fct.def.default/p2.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 // FIXME: test with non-std qualifiers
 
 namespace move {
   struct Const {
     Const(const Const&&) = default; // expected-error {{the parameter for an explicitly-defaulted move constructor may not be const}}
     Const& operator=(const Const&&) = default; // expected-error {{the parameter for an explicitly-defaulted move assignment operator may not be const}}
   };
 
   struct Volatile {
     Volatile(volatile Volatile&&) = default; // expected-error {{the parameter for an explicitly-defaulted move constructor may not be volatile}}
     Volatile& operator=(volatile Volatile&&) = default; // expected-error {{the parameter for an explicitly-defaulted move assignment operator may not be volatile}}
   };
 
   struct AssignmentRet1 {
-    AssignmentRet1&& operator=(AssignmentRet1&&) = default; // expected-error {{explicitly-defaulted move assignment operator must return 'move::AssignmentRet1 &'}}
+    AssignmentRet1&& operator=(AssignmentRet1&&) = default; // expected-error {{explicitly-defaulted move assignment operator must return 'AssignmentRet1 &'}}
   };
 
   struct AssignmentRet2 {
-    const AssignmentRet2& operator=(AssignmentRet2&&) = default; // expected-error {{explicitly-defaulted move assignment operator must return 'move::AssignmentRet2 &'}}
+    const AssignmentRet2& operator=(AssignmentRet2&&) = default; // expected-error {{explicitly-defaulted move assignment operator must return 'AssignmentRet2 &'}}
   };
 
   struct ConstAssignment {
     ConstAssignment& operator=(ConstAssignment&&) const = default; // expected-error {{an explicitly-defaulted move assignment operator may not have 'const', 'constexpr' or 'volatile' qualifiers}}
   };
 }
 
 namespace copy {
namespace copy {
 
   struct BadConst {
     BadConst(const BadConst&) = default; // expected-error {{is const, but}}
     BadConst& operator=(const BadConst&) = default; // expected-error {{is const, but}}
     NonConst nc; // makes implicit copy non-const
   };
 
   struct AssignmentRet1 {
-    AssignmentRet1&& operator=(const AssignmentRet1&) = default; // expected-error {{explicitly-defaulted copy assignment operator must return 'copy::AssignmentRet1 &'}}
+    AssignmentRet1&& operator=(const AssignmentRet1&) = default; // expected-error {{explicitly-defaulted copy assignment operator must return 'AssignmentRet1 &'}}
   };
 
   struct AssignmentRet2 {
-    const AssignmentRet2& operator=(const AssignmentRet2&) = default; // expected-error {{explicitly-defaulted copy assignment operator must return 'copy::AssignmentRet2 &'}}
+    const AssignmentRet2& operator=(const AssignmentRet2&) = default; // expected-error {{explicitly-defaulted copy assignment operator must return 'AssignmentRet2 &'}}
   };
 
   struct ConstAssignment {
     ConstAssignment& operator=(const ConstAssignment&) const = default; // expected-error {{an explicitly-defaulted copy assignment operator may not have 'const', 'constexpr' or 'volatile' qualifiers}}
   };
 }

clang/test/Index/print-type.cpp

 // CHECK: TemplateRef=TypeAlias:61:1 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: ClassTemplate=Specialization:66:8 (Definition) [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: TemplateTypeParameter=T:65:19 (Definition) [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
 // CHECK: StructDecl=Specialization:69:8 [Specialization of Specialization:66:8] [Template arg 0: kind: 1, type: int] [type=Specialization<int>] [typekind=Record] [templateargs/1= [type=int] [typekind=Int]] [isPOD=0]
 // CHECK: VarDecl=templRefParam:71:40 (Definition) [type=Specialization<Specialization<bool> &>] [typekind=Elaborated] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: TemplateRef=Specialization:66:8 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: CallExpr=Specialization:66:8 [type=Specialization<Specialization<bool> &>] [typekind=Elaborated] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: VarDecl=autoTemplRefParam:72:6 (Definition) [type=Specialization<Specialization<bool> &>] [typekind=Auto] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
-// CHECK: UnexposedExpr=templRefParam:71:40 [type=const Specialization<Specialization<bool> &>] [typekind=Record] const [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
+// CHECK: UnexposedExpr=templRefParam:71:40 [type=const Specialization<Specialization<bool> &>] [typekind=Elaborated] const [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=const Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1] [isAnonRecDecl=0]
 // CHECK: DeclRefExpr=templRefParam:71:40 [type=Specialization<Specialization<bool> &>] [typekind=Elaborated] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: TypeAliasDecl=baz:76:7 (Definition) [type=baz] [typekind=Typedef] [templateargs/1= [type=A<void>] [typekind=Elaborated]] [canonicaltype=A<void>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=void] [typekind=Void]] [isPOD=0]
 // CHECK: VarDecl=autoTemplPointer:78:6 (Definition) [type=Specialization<Specialization<bool> &> *] [typekind=Auto] [canonicaltype=Specialization<Specialization<bool> &> *] [canonicaltypekind=Pointer] [isPOD=1] [pointeetype=Specialization<Specialization<bool> &>] [pointeekind=Auto]
 // CHECK: CallExpr=Bar:17:3 [type=outer::inner::Bar] [typekind=Elaborated] [canonicaltype=outer::inner::Bar] [canonicaltypekind=Record] [args= [outer::Foo<bool> *] [Pointer]] [isPOD=0] [nbFields=3]
 // CHECK: StructDecl=(anonymous struct at {{.*}}):84:3 (Definition) [type=X::(anonymous struct at {{.*}}print-type.cpp:84:3)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1]
 // CHECK: ClassDecl=(anonymous class at {{.*}}:85:3 (Definition) [type=X::(anonymous class at {{.*}}print-type.cpp:85:3)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1]
 // CHECK: UnionDecl=(anonymous union at {{.*}}:86:3 (Definition) [type=X::(anonymous union at {{.*}}print-type.cpp:86:3)] [typekind=Record] [isPOD=1] [nbFields=2] [isAnon=1]
 // CHECK: EnumDecl=(unnamed enum at {{.*}}:87:3 (Definition) [type=X::(unnamed enum at {{.*}}print-type.cpp:87:3)] [typekind=Enum] [isPOD=1] [isAnon=1]
 // CHECK: Namespace=:90:11 (Definition) [type=] [typekind=Invalid] [isPOD=0] [isAnon=1]
 // CHECK: Namespace=InlineNS:94:18 (Definition) [type=] [typekind=Invalid] [isPOD=0] [isAnonRecDecl=0] [isInlineNamespace=1]

clang/test/Misc/diag-template-diffing.cpp

namespace rdar12931988 {
   }
 
   namespace B {
     template<typename T> struct X { };
   }
 
   void foo(A::X<int> &ax, B::X<int> bx) {
     // CHECK-ELIDE-NOTREE: no viable overloaded '='
-    // CHECK-ELIDE-NOTREE: no known conversion from 'B::X<int>' to 'const rdar12931988::A::X<int>'
+    // CHECK-ELIDE-NOTREE: no known conversion from 'B::X<int>' to 'const X<int>'
     ax = bx;
   }
 
   template<template<typename> class> class Y {};
 
   void bar(Y<A::X> ya, Y<B::X> yb) {
     // CHECK-ELIDE-NOTREE: no viable overloaded '='
     // CHECK-ELIDE-NOTREE: no known conversion from 'Y<template rdar12931988::B::X>' to 'Y<template rdar12931988::A::X>'

clang/test/SemaCXX/conversion-function.cpp

namespace PR12712 {
 
   A f(const C c) { return c; }
 }
 
 namespace PR18234 {
   struct A {
     operator enum E { e } (); // expected-error {{'PR18234::A::E' cannot be defined in a type specifier}}
     operator struct S { int n; } (); // expected-error {{'PR18234::A::S' cannot be defined in a type specifier}}
-    // expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'struct A' to 'const PR18234::A::S &' for 1st argument}}
+    // expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'struct A' to 'const S &' for 1st argument}}
 #if __cplusplus >= 201103L
-  // expected-note@-3 {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'struct A' to 'PR18234::A::S &&' for 1st argument}}
+  // expected-note@-3 {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'struct A' to 'S &&' for 1st argument}}
 #endif
   } a;
   A::S s = a; // expected-error {{no viable conversion from 'struct A' to 'A::S'}}
   A::E e = a;
   bool k1 = e == A::e; // expected-error {{no member named 'e'}}
   bool k2 = e.n == 0;
 }
 

clang/test/SemaCXX/cxx11-call-to-deleted-constructor.cpp

public:
     Matrix(const std::initializer_list<value_type>& list) = delete; // expected-note {{'Matrix' has been explicitly marked deleted here}}
 
 };
 
 void getLaplacianClosedForm()
 {
     Matrix<double> winI(0, 3);
     RGBFValue* inputPreL;
-    winI = { inputPreL->at() }; // expected-error {{call to deleted constructor of 'cva::Matrix<double> &&'}}
+    winI = { inputPreL->at() }; // expected-error {{call to deleted constructor of 'Matrix<double> &&'}}
 }
 
 }

clang/test/SemaCXX/deduced-return-type-cxx14.cpp

namespace OverloadResolutionTemplate {
 
   template<typename T> auto f(T) { return 0; }
 
   int &c = g(f); // expected-error {{ambiguous}}
 }
 
 namespace DefaultedMethods {
   struct A {
-    auto operator=(const A&) = default; // expected-error {{must return 'DefaultedMethods::A &'}}
+    auto operator=(const A&) = default; // expected-error {{must return 'A &'}}
     A &operator=(A&&); // expected-note {{previous}}
   };
   auto A::operator=(A&&) = default; // expected-error {{return type of out-of-line definition of 'DefaultedMethods::A::operator=' differs from that in the declaration}}
 }
 
 namespace Constexpr {
   constexpr auto f1(int n) { return n; }
   template<typename T> struct X { constexpr auto f() {} }; // PR18746