PR c++/89576 - if constexpr of lambda capture.

Now that we're doing implicit lambda capture in templates, we see x here as
the lambda capture.  maybe_convert_cond was doing nothing in a template, so
we never called mark_rvalue_use on x.  As part of the broad move toward
doing more processing of non-dependent expressions, let's do this
conversion.

	* semantics.c (maybe_convert_cond): Do convert a non-dependent
	condition in a template.
	* typeck.c (condition_conversion): Handle being called in a
	template.

From-SVN: r269433

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index cfd86b250d7401a9fd79f33180c350d9011b3d32..a076fa9a255e92048005fa01b744e7e62f1cbec4 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,11 @@
+2019-03-06  Jason Merrill  <jason@redhat.com>
+
+       PR c++/89576 - if constexpr of lambda capture.
+       * semantics.c (maybe_convert_cond): Do convert a non-dependent
+       condition in a template.
+       * typeck.c (condition_conversion): Handle being called in a
+       template.
+
 2019-03-06  Marek Polacek  <polacek@redhat.com>
 
        PR c++/87378 - bogus -Wredundant-move warning.

diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index c03e4ef247c51415f4bc6d562be1e1be2349d2af..2573b77f6d6e4bd6525a1214fe46fd5428cfbe1e 100644 (file)
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -646,10 +646,10 @@ maybe_convert_cond (tree cond)
     return NULL_TREE;
 
   /* Wait until we instantiate templates before doing conversion.  */
-  if (processing_template_decl)
+  if (type_dependent_expression_p (cond))
     return cond;
 
-  if (warn_sequence_point)
+  if (warn_sequence_point && !processing_template_decl)
     verify_sequence_points (cond);
 
   /* Do the conversion.  */

diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 43ff3d63abd592f8b7ba87677e4138ea7f7c269b..9ceb7af00220c058bbd225914df3985e9e83d3b2 100644 (file)
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -5867,18 +5867,17 @@ cp_truthvalue_conversion (tree expr)
     return c_common_truthvalue_conversion (input_location, expr);
 }
 
-/* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR.  */
+/* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR.  This
+   is a low-level function; most callers should use maybe_convert_cond.  */
 
 tree
 condition_conversion (tree expr)
 {
   tree t;
-  /* Anything that might happen in a template should go through
-     maybe_convert_cond.  */
-  gcc_assert (!processing_template_decl);
   t = perform_implicit_conversion_flags (boolean_type_node, expr,
                                         tf_warning_or_error, LOOKUP_NORMAL);
-  t = fold_build_cleanup_point_expr (boolean_type_node, t);
+  if (!processing_template_decl)
+    t = fold_build_cleanup_point_expr (boolean_type_node, t);
   return t;
 }
 

diff --git a/gcc/testsuite/g++.dg/cpp1z/constexpr-if15.C b/gcc/testsuite/g++.dg/cpp1z/constexpr-if15.C
index 1dd8beab89ca5d17e82e4e4b0a8f3f646ead257c..49c7b7abb6335f33c46cc0f83912e4fc747892de 100644 (file)
--- a/gcc/testsuite/g++.dg/cpp1z/constexpr-if15.C
+++ b/gcc/testsuite/g++.dg/cpp1z/constexpr-if15.C
@@ -7,5 +7,5 @@ constexpr int foo (int) { return 2; }
 template <typename>
 void a()
 {
-  if constexpr(foo) { };
+  if constexpr(foo) { };       // { dg-error "overloaded" }
 }

diff --git a/gcc/testsuite/g++.dg/cpp1z/constexpr-if28.C b/gcc/testsuite/g++.dg/cpp1z/constexpr-if28.C
new file mode 100644 (file)
index 0000000..8bfde6c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1z/constexpr-if28.C
@@ -0,0 +1,11 @@
+// PR c++/89576
+// { dg-do compile { target c++17 } }
+
+template <class T>
+void foo()
+{
+    constexpr int x = 0;
+    [&] {
+        if constexpr (x) {}
+    };
+}