https://gcc.gnu.org/git/?p=gcc.git;a=commitdiff;h=d417b4f5414d9076300ab41974a14424f722688c

https://gcc.gnu.org/git/?p=gcc.git;a=commitdiff;h=75b7b7fdc4597170f24c069ea13aa3e14f37fde7

https://gcc.gnu.org/git/?p=gcc.git;a=commitdiff;h=8e64d182850560dbedfabb88aac90d4fc6155067

diff --git a/gcc/cp/call.c b/gcc/cp/call.c

index 304c01619da..3a15e6e2e47 100644

--- a/gcc/cp/call.c

+++ b/gcc/cp/call.c

@@ -166,6 +166,8 @@ static tree build_over_call (struct z_candidate *, int, tsubst_flags_t);

 		     /*c_cast_p=*/false, (COMPLAIN))

 static tree convert_like_real (conversion *, tree, tree, int, bool,

 			       bool, tsubst_flags_t);

+static tree convert_like_real_1 (conversion *, tree, tree, int, bool,

+				 bool, tsubst_flags_t);

 static void op_error (const op_location_t &, enum tree_code, enum tree_code,

 		      tree, tree, tree, bool);

 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int,

@@ -6995,6 +6997,39 @@ maybe_inform_about_fndecl_for_bogus_argument_init (tree fn, int argnum)

 	    "  initializing argument %P of %qD", argnum, fn);

 }

+/* Wrapper for convert_like_real_1 that handles creating IMPLICIT_CONV_EXPR.  */

+

+static tree

+convert_like_real (conversion *convs, tree expr, tree fn, int argnum,

+		   bool issue_conversion_warnings,

+		   bool c_cast_p, tsubst_flags_t complain)

+{

+  /* Creating &TARGET_EXPR<> in a template breaks when substituting,

+     and creating a CALL_EXPR in a template breaks in finish_call_expr

+     so use an IMPLICIT_CONV_EXPR for this conversion.  We would have

+     created such codes e.g. when calling a user-defined conversion

+     function.  */

+  tree conv_expr = NULL_TREE;

+  if (processing_template_decl

+      && convs->kind != ck_identity

+      && (CLASS_TYPE_P (convs->type) || CLASS_TYPE_P (TREE_TYPE (expr))))

+    {

+      conv_expr = build1 (IMPLICIT_CONV_EXPR, convs->type, expr);

+      if (convs->kind != ck_ref_bind)

+	conv_expr = convert_from_reference (conv_expr);

+      if (!convs->bad_p)

+	return conv_expr;

+      /* Do the normal processing to give the bad_p errors.  But we still

+	 need to return the IMPLICIT_CONV_EXPR, unless we're returning

+	 error_mark_node.  */

+    }

+  expr = convert_like_real_1 (convs, expr, fn, argnum,

+			      issue_conversion_warnings, c_cast_p, complain);

+  if (expr == error_mark_node)

+    return error_mark_node;

+  return conv_expr ? conv_expr : expr;

+}

+

 /* Perform the conversions in CONVS on the expression EXPR.  FN and

    ARGNUM are used for diagnostics.  ARGNUM is zero based, -1

    indicates the `this' argument of a method.  INNER is nonzero when

@@ -7006,9 +7041,9 @@ maybe_inform_about_fndecl_for_bogus_argument_init (tree fn, int argnum)

    conversions to inaccessible bases are permitted.  */

 static tree

-convert_like_real (conversion *convs, tree expr, tree fn, int argnum,

-		   bool issue_conversion_warnings,

-		   bool c_cast_p, tsubst_flags_t complain)

+convert_like_real_1 (conversion *convs, tree expr, tree fn, int argnum,

+		     bool issue_conversion_warnings,

+		     bool c_cast_p, tsubst_flags_t complain)

 {

   tree totype = convs->type;

   diagnostic_t diag_kind;

@@ -7466,6 +7501,14 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum,

 		expr = convert_bitfield_to_declared_type (expr);

 		expr = fold_convert (type, expr);

 	      }

+

+	    /* Creating &TARGET_EXPR<> in a template would break when

+	       tsubsting the expression, so use an IMPLICIT_CONV_EXPR

+	       instead.  This can happen even when there's no class

+	       involved, e.g., when converting an integer to a reference

+	       type.  */

+	    if (processing_template_decl)

+	      return build1 (IMPLICIT_CONV_EXPR, totype, expr);

 	    expr = build_target_expr_with_type (expr, type, complain);

 	  }

diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c

index 782f0f6e60f..b7190fb8761 100644

--- a/gcc/cp/decl.c

+++ b/gcc/cp/decl.c

@@ -9752,13 +9752,12 @@ compute_array_index_type_loc (location_t name_loc, tree name, tree size,

 	   NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case.  */;

       else

 	{

-	  size = instantiate_non_dependent_expr_sfinae (size, complain);

 	  size = build_converted_constant_expr (size_type_node, size, complain);

 	  /* Pedantically a constant expression is required here and so

 	     __builtin_is_constant_evaluated () should fold to true if it

 	     is successfully folded into a constant.  */

-	  size = maybe_constant_value (size, NULL_TREE,

-				       /*manifestly_const_eval=*/true);

+	  size = fold_non_dependent_expr (size, complain,

+					  /*manifestly_const_eval=*/true);

 	  if (!TREE_CONSTANT (size))

 	    size = origsize;

@@ -16784,10 +16783,8 @@ build_explicit_specifier (tree expr, tsubst_flags_t complain)

     /* Wait for instantiation, tsubst_function_decl will handle it.  */

     return expr;

-  expr = instantiate_non_dependent_expr_sfinae (expr, complain);

-  /* Don't let convert_like_real create more template codes.  */

-  processing_template_decl_sentinel s;

   expr = build_converted_constant_bool_expr (expr, complain);

+  expr = instantiate_non_dependent_expr_sfinae (expr, complain);

   expr = cxx_constant_value (expr);

   return expr;

 }

diff --git a/gcc/cp/except.c b/gcc/cp/except.c

index 03a9c8e53c7..b113eacacb3 100644

--- a/gcc/cp/except.c

+++ b/gcc/cp/except.c

@@ -1288,10 +1288,8 @@ build_noexcept_spec (tree expr, tsubst_flags_t complain)

   if (TREE_CODE (expr) != DEFERRED_NOEXCEPT

       && !value_dependent_expression_p (expr))

     {

-      expr = instantiate_non_dependent_expr_sfinae (expr, complain);

-      /* Don't let convert_like_real create more template codes.  */

-      processing_template_decl_sentinel s;

       expr = build_converted_constant_bool_expr (expr, complain);

+      expr = instantiate_non_dependent_expr_sfinae (expr, complain);

       expr = cxx_constant_value (expr);

     }

   if (TREE_CODE (expr) == INTEGER_CST)

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c

index 612557bb717..710956e5a08 100644

--- a/gcc/cp/pt.c

+++ b/gcc/cp/pt.c

@@ -6919,19 +6919,6 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)

       else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type)

 	       || cxx_dialect >= cxx17)

 	{

-	  /* Calling build_converted_constant_expr might create a call to

-	     a conversion function with a value-dependent argument, which

-	     could invoke taking the address of a temporary representing

-	     the result of the conversion.  */

-	  if (COMPOUND_LITERAL_P (expr)

-	      && CONSTRUCTOR_IS_DEPENDENT (expr)

-	      && MAYBE_CLASS_TYPE_P (expr_type)

-	      && TYPE_HAS_CONVERSION (expr_type))

-	    {

-	      expr = build1 (IMPLICIT_CONV_EXPR, type, expr);

-	      IMPLICIT_CONV_EXPR_NONTYPE_ARG (expr) = true;

-	      return expr;

-	    }

 	  /* C++17: A template-argument for a non-type template-parameter shall

 	     be a converted constant expression (8.20) of the type of the

 	     template-parameter.  */

@@ -6940,6 +6927,11 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)

 	    /* Make sure we return NULL_TREE only if we have really issued

 	       an error, as described above.  */

 	    return (complain & tf_error) ? NULL_TREE : error_mark_node;

+	  else if (TREE_CODE (expr) == IMPLICIT_CONV_EXPR)

+	    {

+	      IMPLICIT_CONV_EXPR_NONTYPE_ARG (expr) = true;

+	      return expr;

+	    }

 	  expr = maybe_constant_value (expr, NULL_TREE,

 				       /*manifestly_const_eval=*/true);

 	  expr = convert_from_reference (expr);

diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c

index aae5ff24c98..7c5a45c0848 100644

--- a/gcc/cp/typeck2.c

+++ b/gcc/cp/typeck2.c

@@ -926,7 +926,11 @@ check_narrowing (tree type, tree init, tsubst_flags_t complain, bool const_only)

       return ok;

     }

-  init = maybe_constant_value (init);

+  /* Even non-dependent expressions can still have template

+     codes like CAST_EXPR, so use *_non_dependent_expr to cope.  */

+  init = fold_non_dependent_expr (init, complain);

+  if (init == error_mark_node)

+    return ok;

   /* If we were asked to only check constants, return early.  */

   if (const_only && !TREE_CONSTANT (init))

diff --git a/gcc/testsuite/g++.dg/conversion/op7.C b/gcc/testsuite/g++.dg/conversion/op7.C

new file mode 100644

index 00000000000..c6401d109b4

--- /dev/null

+++ b/gcc/testsuite/g++.dg/conversion/op7.C

@@ -0,0 +1,22 @@

+// PR c++/94190 - wrong no post-decrement operator error in template.

+

+struct S { operator long & (); } b;

+

+template<int> void

+foo ()

+{

+  b--;

+  ++b;

+  --b;

+  b++;

+  !b;

+  ~b;

+  +b;

+  -b;

+}

+

+void

+bar ()

+{

+  foo<0> ();

+}

diff --git a/gcc/testsuite/g++.dg/conversion/ref4.C b/gcc/testsuite/g++.dg/conversion/ref4.C

new file mode 100644

index 00000000000..464a4cf6c0f

--- /dev/null

+++ b/gcc/testsuite/g++.dg/conversion/ref4.C

@@ -0,0 +1,22 @@

+// PR c++/95789

+// { dg-do compile { target c++11 } }

+

+struct B {

+    int n;

+};

+

+template <typename T>

+struct A {

+    B& get() const { return f; } // { dg-error "binding reference" }

+

+    B f;

+};

+

+int main() {

+    A<int> a;

+    a.f = {};

+

+    a.get().n = 10;

+    if (a.f.n != 0)

+      __builtin_abort();

+}

diff --git a/gcc/testsuite/g++.dg/conversion/ref5.C b/gcc/testsuite/g++.dg/conversion/ref5.C

new file mode 100644

index 00000000000..0042acd0670

--- /dev/null

+++ b/gcc/testsuite/g++.dg/conversion/ref5.C

@@ -0,0 +1,14 @@

+// PR c++/96104

+

+template <typename T> void fn(T &);

+class E {};

+struct F {

+  template <typename T> void mfn(T t) { t, fn(E()); } // { dg-error "cannot bind non-const lvalue reference" }

+};

+int

+main()

+{

+  E e;

+  F f;

+  f.mfn(e);

+}

diff --git a/gcc/testsuite/g++.dg/conversion/ref6.C b/gcc/testsuite/g++.dg/conversion/ref6.C

new file mode 100644

index 00000000000..fc87199053c

--- /dev/null

+++ b/gcc/testsuite/g++.dg/conversion/ref6.C

@@ -0,0 +1,24 @@

+// PR c++/96179

+// { dg-do compile { target c++11 } }

+

+template<typename T> struct vector

+{

+  void push_back(T) { }

+};

+

+struct dummy{

+        int a;

+};

+

+void Modify_Dummy(dummy &d){

+        d.a=1;

+}

+

+template <bool bla=true> void Templated_Function(){

+        vector<dummy> A;

+        A.push_back(Modify_Dummy(dummy{0})); // { dg-error "cannot bind non-const lvalue reference" }

+}

+

+int main(){

+        Templated_Function();

+}

diff --git a/gcc/testsuite/g++.dg/cpp0x/conv-tmpl2.C b/gcc/testsuite/g++.dg/cpp0x/conv-tmpl2.C

new file mode 100644

index 00000000000..8a505769c3c

--- /dev/null

+++ b/gcc/testsuite/g++.dg/cpp0x/conv-tmpl2.C

@@ -0,0 +1,21 @@

+// PR c++/92031 - bogus taking address of rvalue error.

+// { dg-do compile { target c++11 } }

+

+struct x { const int& l; };

+

+void a(const x&) {}

+

+template<class E>                          

+void f() {

+  a(x { 0 });

+}

+

+void g() {

+  a(x { 0 });

+}

+

+void

+test ()

+{

+  f<int>();

+}

diff --git a/gcc/testsuite/g++.dg/cpp0x/conv-tmpl3.C b/gcc/testsuite/g++.dg/cpp0x/conv-tmpl3.C

new file mode 100644

index 00000000000..e2021aa13e1

--- /dev/null

+++ b/gcc/testsuite/g++.dg/cpp0x/conv-tmpl3.C

@@ -0,0 +1,16 @@

+// PR c++/91465 - ICE with template codes in check_narrowing.

+// { dg-do compile { target c++11 } }

+

+enum class D { X };

+enum class S { Z };

+

+D foo(S) { return D{}; }

+D foo(double) { return D{}; }

+

+template <typename>

+struct Bar {

+  D baz(S s)

+  {

+    return D{foo(s)};

+  }

+};

diff --git a/gcc/testsuite/g++.dg/cpp0x/conv-tmpl4.C b/gcc/testsuite/g++.dg/cpp0x/conv-tmpl4.C

new file mode 100644

index 00000000000..966a2e1ac9e

--- /dev/null

+++ b/gcc/testsuite/g++.dg/cpp0x/conv-tmpl4.C

@@ -0,0 +1,33 @@

+// PR c++/93870 - wrong error when converting template non-type arg.

+// { dg-do compile { target c++11 } }

+

+template <typename ENUM> struct EnumWrapper

+{

+	ENUM value;

+

+	constexpr operator ENUM() const

+	{

+		return value;

+	}

+};

+

+enum E : int { V };

+

+constexpr EnumWrapper<E> operator ~(E a)

+{

+    return {E(~int(a))};

+}

+

+template <E X> struct R

+{

+    static void Func();

+};

+

+template <E X> struct S : R<~X>

+{

+};

+

+void Test()

+{

+    S<E::V>::Func();

+}

diff --git a/gcc/testsuite/g++.dg/cpp0x/conv-tmpl5.C b/gcc/testsuite/g++.dg/cpp0x/conv-tmpl5.C

new file mode 100644

index 00000000000..c83e6d83ed9

--- /dev/null

+++ b/gcc/testsuite/g++.dg/cpp0x/conv-tmpl5.C

@@ -0,0 +1,13 @@

+// PR c++/94068 - ICE with template codes in check_narrowing.

+// { dg-do compile { target c++11 } }

+

+enum class A { A1, A2 };

+A foo ();

+long foo (int);

+

+template <typename>

+void

+bar ()

+{

+  const auto c{foo ()};

+}

diff --git a/gcc/testsuite/g++.dg/cpp0x/conv-tmpl6.C b/gcc/testsuite/g++.dg/cpp0x/conv-tmpl6.C

new file mode 100644

index 00000000000..2df3a6cc129

--- /dev/null

+++ b/gcc/testsuite/g++.dg/cpp0x/conv-tmpl6.C

@@ -0,0 +1,16 @@

+// { dg-do compile { target c++11 } }

+

+struct A

+{

+  constexpr A(int) { }

+  constexpr operator int() const { return 1; };

+};

+

+template <class T, int N>

+struct B

+{

+  static constexpr A a = A(N);

+  int ar[a];

+};

+

+B<int, 10> b;

diff --git a/gcc/testsuite/g++.dg/cpp1z/conv-tmpl1.C b/gcc/testsuite/g++.dg/cpp1z/conv-tmpl1.C

new file mode 100644

index 00000000000..5b1205349d0

--- /dev/null

+++ b/gcc/testsuite/g++.dg/cpp1z/conv-tmpl1.C

@@ -0,0 +1,10 @@

+// PR c++/91465 - ICE with template codes in check_narrowing.

+// { dg-do compile { target c++17 } }

+

+enum class E { Z };

+

+template <typename F>

+void foo(F)

+{

+  E{char(0)};

+}