From 783f0cfc8d973c147a5243d7312b85e7ea892e1c Mon Sep 17 00:00:00 2001
From: Paolo Carlini <paolo@gcc.gnu.org>
Date: Tue, 17 Sep 2013 17:46:03 +0000
Subject: [PATCH] re PR c++/58435 (Applying a type transformation to a list:
 const ignored)

/cp
2013-09-17  Paolo Carlini  <paolo.carlini@oracle.com>

	PR c++/58435
	* pt.c (tsubst, [BOUND_TEMPLATE_TEMPLATE_PARM]): Take into account
	the cp_type_quals (r) too.

/testsuite
2013-09-17  Paolo Carlini  <paolo.carlini@oracle.com>

	PR c++/58435
	* g++.dg/cpp0x/alias-decl-38.C: New.

From-SVN: r202662
---
 gcc/cp/ChangeLog                           |  9 ++++-
 gcc/cp/pt.c                                |  2 +-
 gcc/testsuite/ChangeLog                    |  6 ++++
 gcc/testsuite/g++.dg/cpp0x/alias-decl-38.C | 41 ++++++++++++++++++++++
 4 files changed, 56 insertions(+), 2 deletions(-)
 create mode 100644 gcc/testsuite/g++.dg/cpp0x/alias-decl-38.C

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 5fbc78c1c2a..7e2c13beb5e 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,9 @@
+2013-09-17  Paolo Carlini  <paolo.carlini@oracle.com>
+
+	PR c++/58435
+	* pt.c (tsubst, [BOUND_TEMPLATE_TEMPLATE_PARM]): Take into account
+	the cp_type_quals (r) too.
+
 2013-09-16  Adam Butcher  <adam@jessamine.co.uk>
 
 	* cp-tree.h (type_uses_auto_or_concept): Declare.
@@ -11,7 +17,8 @@
 	(is_auto_or_concept): New function.
 	(type_uses_auto_or_concept): New function.
 	* parser.h (struct cp_parser): Add fully_implicit_function_template_p.
-	* parser.c (cp_parser_new): Initialize fully_implicit_function_template_p.
+	* parser.c (cp_parser_new): Initialize
+	fully_implicit_function_template_p.
 	(cp_parser_new): Initialize fully_implicit_function_template_p.
 	(cp_parser_lambda_expression): Copy and restore value of
 	fully_implicit_function_template_p as per other parser fields.
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index c2e251aaf85..e0b71108fcf 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -11540,7 +11540,7 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
 					    /*entering_scope=*/0,
 					   complain);
 		return cp_build_qualified_type_real
-		  (r, cp_type_quals (t), complain);
+		  (r, cp_type_quals (t) | cp_type_quals (r), complain);
 	      }
 	    else
 	      /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX.  */
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index b36c03355cd..205dee8b01f 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,9 @@
+2013-09-17  Paolo Carlini  <paolo.carlini@oracle.com>
+
+	PR c++/58435
+	* pt.c (tsubst, [BOUND_TEMPLATE_TEMPLATE_PARM]): Take into account
+	the cp_type_quals (r) too.
+
 2013-09-17  Jan Hubicka  <jh@suse.cz>
 
 	PR middle-end/58332
diff --git a/gcc/testsuite/g++.dg/cpp0x/alias-decl-38.C b/gcc/testsuite/g++.dg/cpp0x/alias-decl-38.C
new file mode 100644
index 00000000000..bc98737b849
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/alias-decl-38.C
@@ -0,0 +1,41 @@
+// PR c++/58435
+// { dg-do compile { target c++11 } }
+
+template<typename T, typename U>
+struct same { static const bool value = false; };
+template<typename T>
+struct same<T, T> { static const bool value = true; };
+
+template <template <typename> class F, typename T> struct apply
+{ typedef F<T> type; };
+template <template <typename> class F, typename T> struct applyc
+{ typedef const F<T> type; };
+template <template <typename> class F, typename T> struct applyv
+{ typedef volatile F<T> type; };
+template <template <typename> class F, typename T> struct applycv
+{ typedef const volatile F<T> type; };
+
+template <typename T> using map = T;
+template <typename T> using mapc = const T;
+template <typename T> using mapv = volatile T;
+template <typename T> using mapcv = const volatile T;
+
+static_assert(same<apply<map, int>::type, int>::value, "");
+static_assert(same<apply<mapc, int>::type, const int>::value, "");
+static_assert(same<apply<mapv, int>::type, volatile int>::value, "");
+static_assert(same<apply<mapcv, int>::type, const volatile int>::value, "");
+
+static_assert(same<applyc<map, int>::type, const int>::value, "");
+static_assert(same<applyc<mapc, int>::type, const int>::value, "");
+static_assert(same<applyc<mapv, int>::type, const volatile int>::value, "");
+static_assert(same<applyc<mapcv, int>::type, const volatile int>::value, "");
+
+static_assert(same<applyv<map, int>::type, volatile int>::value, "");
+static_assert(same<applyv<mapc, int>::type, const volatile int>::value, "");
+static_assert(same<applyv<mapv, int>::type, volatile int>::value, "");
+static_assert(same<applyv<mapcv, int>::type, const volatile int>::value, "");
+
+static_assert(same<applycv<map, int>::type, const volatile int>::value, "");
+static_assert(same<applycv<mapc, int>::type, const volatile int>::value, "");
+static_assert(same<applycv<mapv, int>::type, const volatile int>::value, "");
+static_assert(same<applycv<mapcv, int>::type, const volatile int>::value, "");