Another issue with dependent alias template specializations. In this
case, we were dealing with an alias template that expands to a function
type; dependent_type_p_r was looking at the function type and never
considering whether the alias specialization itself was dependent.
Fixed by checking that sooner.
Tested x86_64-pc-linux-gnu, applying to trunk.
commit c9afe9335ac08dcbbfbf4aeee747d76ad36e74d1
Author: Jason Merrill <ja...@redhat.com>
Date: Wed Jun 24 15:28:06 2015 -0400
PR c++/66647
* pt.c (dependent_type_p_r): Check for dependent alias template
specialization sooner.
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 8800af8..b63c0d4 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -20992,6 +20992,12 @@ dependent_type_p_r (tree type)
names a dependent type. */
if (TREE_CODE (type) == TYPENAME_TYPE)
return true;
+
+ /* An alias template specialization can be dependent even if the
+ resulting type is not. */
+ if (dependent_alias_template_spec_p (type))
+ return true;
+
/* -- a cv-qualified type where the cv-unqualified type is
dependent.
No code is necessary for this bullet; the code below handles
@@ -21043,10 +21049,6 @@ dependent_type_p_r (tree type)
&& (any_dependent_template_arguments_p
(INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
return true;
- /* For an alias template specialization, check the arguments both to the
- class template and the alias template. */
- else if (dependent_alias_template_spec_p (type))
- return true;
/* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
dependent; if the argument of the `typeof' expression is not
diff --git a/gcc/testsuite/g++.dg/cpp0x/alias-decl-49.C b/gcc/testsuite/g++.dg/cpp0x/alias-decl-49.C
new file mode 100644
index 0000000..5fd3b65
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/alias-decl-49.C
@@ -0,0 +1,54 @@
+// PR c++/66647
+// { dg-do compile { target c++11 } }
+
+template <typename _Tp> struct A
+{
+ static constexpr _Tp value = 1;
+};
+template <typename> class B
+{
+public:
+ template <typename> struct rebind
+ {
+ };
+};
+
+template <typename _Alloc, typename _Tp> class C
+{
+ template <typename _Alloc2, typename _Tp2>
+ static A<int> _S_chk (typename _Alloc2::template rebind<_Tp2> *);
+
+public:
+ using __type = decltype (_S_chk<_Alloc, _Tp> (0));
+};
+
+template <typename _Alloc, typename _Tp, int = C<_Alloc, _Tp>::__type::value>
+struct D;
+template <typename _Alloc, typename _Tp> struct D<_Alloc, _Tp, 1>
+{
+ typedef typename _Alloc::template rebind<_Tp> __type;
+};
+template <typename _Alloc> struct F
+{
+ template <typename _Tp> using rebind_alloc = typename D<_Alloc, _Tp>::__type;
+};
+template <typename _Alloc> struct __alloc_traits
+{
+ template <typename> struct rebind
+ {
+ typedef typename F<_Alloc>::template rebind_alloc<int> other;
+ };
+};
+template <typename _Alloc> struct G
+{
+ typename __alloc_traits<_Alloc>::template rebind<int>::other _Tp_alloc_type;
+};
+template <typename _Tp, typename _Alloc = B<_Tp> > class vector : G<_Alloc>
+{
+};
+
+template <int> using tfuncptr = void();
+template <int d> struct H
+{
+ vector<tfuncptr<d> > funcs;
+};
