Tweak the diagnostic machinery to emit a NamedDecl's type, instead of empty quotes, if it represents an unnamed TypeDecl.

[faisalv]

Summary

Currently the following code triggers diagnostics that match:

auto L = []{ }; expected-note{{'' is not literal}}
constexpr int f(decltype(L)) { return 0; } expected-error{{not a literal type}}

After applying this patch the diagnostics match:
auto L = []{ }; //expected-note{{'(lambda at <source-info>)' is not literal}}

As encouraged by Richard during his review of: https://reviews.llvm.org/D22662 .

[faisalv]

Refactored the common code from each insertion operator into a single template function called: addNameDeclOrItsTypeToDiagnostic(...).

include/clang/AST/Decl.h

   static bool classofKind(Kind K) { return K == Empty; }
 };
 
+
+
+// Helper function that checks to see if the NamedDecl Node is am unnamed
+// TypeDecl (such as a lambda, or anonymous union or struct etc.) and if so adds
+// its type to the diagnostic instead of the Decl.
+
+template <class DiagnosticTy>
+void addNamedDeclOrItsTypeToDiagnostic(const DiagnosticTy &DT,
+                                    const NamedDecl *ND) {
+  if (ND && isa<TypeDecl>(ND) && !ND->getIdentifier()) {
+    extern QualType getTypeDeclTypeFromASTContext(const TypeDecl *T,
+                                                  ASTContext &Ctx);
+    QualType Ty(
+        getTypeDeclTypeFromASTContext(cast<TypeDecl>(ND), ND->getASTContext()));
+    DT.AddTaggedVal(reinterpret_cast<intptr_t>(Ty.getAsOpaquePtr()),
+                    DiagnosticsEngine::ak_qualtype);
+  } else {
+    DT.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
+                    DiagnosticsEngine::ak_nameddecl);
+  }
+}
+
 /// Insertion operator for diagnostics.  This allows sending NamedDecl's
 /// into a diagnostic with <<.
 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                            const NamedDecl* ND) {
-  DB.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
-                  DiagnosticsEngine::ak_nameddecl);
+  addNamedDeclOrItsTypeToDiagnostic(DB, ND); 
   return DB;
 }
 inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                            const NamedDecl* ND) {
-  PD.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
-                  DiagnosticsEngine::ak_nameddecl);
+  addNamedDeclOrItsTypeToDiagnostic(PD, ND); 
   return PD;
 }
 

lib/AST/ASTContext.cpp

 
   return QualType(Decl->TypeForDecl, 0);
 }
-
+namespace clang {
+  QualType getTypeDeclTypeFromASTContext(const TypeDecl *T,
+                                                  ASTContext &Ctx) {
+    return Ctx.getTypeDeclType(T);
+  }
+}
 /// getTypedefType - Return the unique reference to the type for the
 /// specified typedef name decl.
 QualType

test/SemaCXX/constant-expression-cxx11.cpp

     return B().x == k; // expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}}
   }
 }
+namespace  NonLiteralTypes {
 
+auto L = [] { 
+  return []{}; //expected-note{{lambda at}}
+}; 
+
+constexpr int f(decltype(L()) l) { return 0; } //expected-error{{not a literal type}}
+
+auto U = [] { 
+  union { volatile int I; } obj;  //expected-note{{anonymous union at}}
+  return obj; 
+};
+constexpr int f(decltype(U()) l) { return 0; } //expected-error{{not a literal type}}
+
+}
+
 namespace ExprWithCleanups {
   struct A { A(); ~A(); int get(); };
   constexpr int get(bool FromA) { return FromA ? A().get() : 1; }