[cxx1z-constexpr-lambda] Make a lambda's closure type a literal type in C++1z.

[faisalv]

Summary

One more step towards implementing constexpr lambdas.

In passing, also fix it so that when we emit a diagnostic referencing a lambda, instead of using the nameless CXXRecordDecl, use its type.

All regressions pass.

[faisalv]

Factor out the diagnostic builder RAII creation (through Sema.Diag) and reduce repetition.

[rsmith]

Everything other than the diagnostics change LGTM; can we handle the diagnostics change as a central patch and put this fallback logic directly into the diagnostics formatting code, so it applies everywhere we try to print the name of an unnamed class?

lib/Sema/SemaType.cpp

7168–7176

This seems like something that would be better handled centrally by the diagnostics machinery.

[faisalv]

Thanks Richard. Your request to separate out and centralize the diagnostic portion of the patch certainly seems like a good idea - and I shall do so separately.

The approved portion of this small patch is committed as: r276514.

http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20160718/165670.html

Thanks!

include/clang/AST/DeclCXX.h

         MethodTyInfo(Info) {
       IsLambda = true;
 
-      // C++11 [expr.prim.lambda]p3:
-      //   This class type is neither an aggregate nor a literal type.
+      // C++1z [expr.prim.lambda]p4:
+      //   This class type is not an aggregate type.
       Aggregate = false;
       PlainOldData = false;
-      HasNonLiteralTypeFieldsOrBases = true;
     }
 
     /// \brief Whether this lambda is known to be dependent, even if its

   ///
   /// We resolve DR1361 by ignoring the second bullet. We resolve DR1452 by
   /// treating types with trivial default constructors as literal types.
+  ///
+  /// Only in C++1z and beyond, are lambdas literal types.
   bool isLiteral() const {
     return hasTrivialDestructor() &&
-           (isAggregate() || hasConstexprNonCopyMoveConstructor() ||
-            hasTrivialDefaultConstructor()) &&
-           !hasNonLiteralTypeFieldsOrBases();
+           (!isLambda() || getASTContext().getLangOpts().CPlusPlus1z) &&
+           !hasNonLiteralTypeFieldsOrBases() &&
+           (isAggregate() || isLambda() ||
+            hasConstexprNonCopyMoveConstructor() ||
+            hasTrivialDefaultConstructor());
   }
 
   /// \brief If this record is an instantiation of a member class,

lib/Sema/SemaType.cpp

           << I.getSourceRange();
   } else if (!RD->isAggregate() && !RD->hasConstexprNonCopyMoveConstructor() &&
              !RD->hasTrivialDefaultConstructor()) {
-    Diag(RD->getLocation(), diag::note_non_literal_no_constexpr_ctors) << RD;
+    // If the class does not have a name (for e.g. a lambda's closure class) use
+    // its type which we should know how to pretty-print, otherwise use the
+    // class's name.
+    auto &&DiagBuilder =
+        Diag(RD->getLocation(), diag::note_non_literal_no_constexpr_ctors);
+    if (!RD->getIdentifier())
+      DiagBuilder << Context.getRecordType(RD);
+    else
+      DiagBuilder << RD;
   } else if (RD->hasNonLiteralTypeFieldsOrBases()) {
     for (const auto &I : RD->bases()) {
       if (!I.getType()->isLiteralType(Context)) {

test/SemaCXX/cxx1z-constexpr-lambdas.cpp

 // RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks %s
 // RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s 
-// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fms-extensions %s 
-// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing -fms-extensions %s 
+// RUN: %clang_cc1 -std=c++14 -verify -fsyntax-only -fblocks %s -DCPP14_AND_EARLIER
 
+#ifndef CPP14_AND_EARLIER
 namespace test_constexpr_checking {
 
 namespace ns1 {

       L(3); //expected-note{{non-constexpr function}}
 } 
 
-} // end ns test_constexpr_call
+} // end ns test_constexpr_call
+
+#endif
+
+namespace test_lambda_is_literal {
+#ifdef CPP14_AND_EARLIER
+//expected-error@+4{{not a literal type}}
+//expected-note@+2{{not an aggregate and has no constexpr constructors}}
+#endif
+auto L = [] { };
+constexpr int foo(decltype(L) l) { return 0; }
+
+}
 No newline at end of file