[cxx1z-constexpr-lambda] Make conversion function constexpr

[faisalv]

Summary

Mark the lambda's conversion to function-pointer as incontrovertibly constexpr.

auto L = [](auto a) { return a; };
constexpr int* (*fp)(int*) = L; // This is now allowed.

By itself this is not terribly useful. A subsequent patch will enable a call through the function pointer in a constant expression if the lambda's synthesized call operator is constexpr.

[faisalv]

*ping*

[faisalv]

*ping*

[faisalv]

*ping*

[faisalv]

Mark the lambda's conversion to function-pointer as incontrovertibly constexpr.

auto L = [](auto a) { return a; };
constexpr int* (*fp)(int*) = L; // This is now allowed.

Instead of inserting the extension/compatibility-warning into the same list that houses the notes that identify errors that occurred during constant-folding (and subsequently modifying the logic to ignore such warnings when determining the result of constant folding), I resorted to the simple approach used to emit a warning for integer-overflow (during constant folding) by invoking getDiagnostics().Report.

Richard I hope you're OK with this approach - I know in Oulu I was leaning towards inserting the warning into the same list that houses the error-notes (or potentially creating another one, or having EvalInfo track whether an error-note truly occurred instead of relying simply on the size of the list) - and while doable (and potentially cleaner) - that change is a larger one that requires handing some subtleties, and can be done at a later time, if you feel strongly about it.

[rsmith]

I don't see how this approach can work; the fact that we happened to ask the expression evaluator to evaluate an expression is not sufficient reason for us to issue this warning. For instance:

auto a = []{};
void (*p)() = a;

... will ask the evaluator to evaluate the initializer of p, which it appears will now generate a bogus extension warning in C++11 and C++14 mode.

If you want to carry on down this path, I think you will need to do something similar to what we discussed at Oulu, but I expect getting a correct warning to be complex and difficult, so I think the best approach would be to give up on this compat warning / extension, and instead only turn on the constexpr flag in C++17 mode. We could burn a lot of time getting this compatibility warning / extwarn to work, and it seems better to make progress on the rest of the constexpr lambdas feature instead :)

[faisalv]

See richard's comment for why this attempt at implementing a compatibility warning for the constexpr conversion operator for lambda's is being abandoned.

include/clang/Basic/DiagnosticASTKinds.td

 // implementation is complete, and like the preceding constexpr notes belongs
 // in Sema.
 def note_unimplemented_constexpr_lambda_feature_ast : Note<
-    "unimplemented constexpr lambda feature: %0 (coming soon!)">;
 
+// C++1z constexpr lambda expressions
+def warn_cxx14_compat_constexpr_conversion_on_lambda : Warning<
+  "constexpr conversion to pointer-to-function on lambdas is "
+  "incompatible with C++ standards before C++1z">,
+  InGroup<CXXPre1zCompat>, DefaultIgnore;
+def ext_constexpr_conversion_on_lambda_cxx1z : ExtWarn<
+  "constexpr conversion to pointer-to-function on lambdas is "
+  "a C++1z extension">, InGroup<CXX1z>;
+
 // inline asm related.
 let CategoryName = "Inline Assembly Issue" in {
   def err_asm_invalid_escape : Error<

lib/AST/ExprConstant.cpp

         if (!EvaluateObjectArgument(Info, ME->getBase(), ThisVal))
           return false;
         Member = ME->getMemberDecl();
+        // If this is a non-capturing lambda's closure type's conversion
+        // operator that results in a pointer-to-function, remind users that the
+        // conversion operator itself was made 'constexpr' in C++1z.
+        if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(Member))
+          if (Conv->getParent()->isLambda()) {
+            Info.Ctx.getDiagnostics().Report(
+                E->getExprLoc(),
+                !Info.Ctx.getLangOpts().CPlusPlus1z
+                    ? diag::ext_constexpr_conversion_on_lambda_cxx1z
+                    : diag::warn_cxx14_compat_constexpr_conversion_on_lambda);
+          }
         This = &ThisVal;
         HasQualifier = ME->hasQualifier();
       } else if (const BinaryOperator *BE = dyn_cast<BinaryOperator>(Callee)) {

lib/Sema/SemaLambda.cpp

                                 ConvTy, 
                                 ConvTSI,
                                 /*isInline=*/true, /*isExplicit=*/false,
-                                /*isConstexpr=*/false, 
+                                /*isConstexpr=*/true, 
                                 CallOperator->getBody()->getLocEnd());
   Conversion->setAccess(AS_public);
   Conversion->setImplicit(true);

test/SemaCXX/cxx1z-constexpr-lambdas.cpp

 // 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++1z -verify -fsyntax-only -fblocks -Wc++14-compat %s -DCHECK_COMPATIBILITY_WARNING
 
+#ifndef CHECK_COMPATIBILITY_WARNING
 namespace test_constexpr_checking {
 
 namespace ns1 {

       L(3); //expected-note{{non-constexpr function}}
 } 
 
-} // end ns test_constexpr_call
+} // end ns test_constexpr_call
+#endif
+
+#ifdef CHECK_COMPATIBILITY_WARNING
+//expected-warning@+6{{incompatible with C++ standards before C++1z}}
+//expected-warning@+6{{incompatible with C++ standards before C++1z}}
+#endif
+
+namespace ns4 {
+auto L = [](auto a) { return a; };
+constexpr int (*fp1)(int) = L;  
+constexpr int* (*fp2)(int*) = L; 
+
+} // end ns4
 No newline at end of file