Implement P0522R0, matching of template template arguments.

gcc/c-family/
	* c.opt (-fnew-ttp-matching): New flag.
	* c-opts.c (c_common_post_options): Default on if -std=c++1z.
gcc/cp/
	* pt.c (coerce_template_template_parms): Allow a template argument
	that's less specialized than the parameter.
	(unify_bound_ttp_args): Adjust parm's args to apply to arg's
	template.
	(coerce_template_args_for_ttp): Split out from
	lookup_template_class_1.
	(coerce_ttp_args_for_tta, store_defaulted_ttp)
	(lookup_defaulted_ttp, add_defaults_to_ttp): New.
	(process_partial_specialization): Set DECL_CONTEXT of
	template template-parameters.
	(coerce_template_parms): Only inform when complain.
	(expand_template_argument_pack): Handle error_mark_node.
	(convert_template_argument, template_args_equal, unify): Handle
	any_targ_node.
	* cp-tree.h (enum cp_tree_index): Add CPTI_ANY_TARG.
	(any_targ_node): New.
	* decl.c (cxx_init_decl_processing): Set it.
	* name-lookup.c (consider_binding_level): Ignore names with embedded
	spaces.

From-SVN: r243871

gcc/c-family/ChangeLog

+2016-12-21  Jason Merrill  <jason@redhat.com>
+
+	* c.opt (-fnew-ttp-matching): New flag.
+	* c-opts.c (c_common_post_options): Default on if -std=c++1z.
+
 2016-12-14  Martin Jambor  <mjambor@suse.cz>
 
 	* c-omp.c: Include omp-general.h instead of omp-low.h.

gcc/c-family/c-opts.c

@@ -920,6 +920,10 @@ c_common_post_options (const char **pfilename)
   if (!global_options_set.x_flag_new_inheriting_ctors)
     flag_new_inheriting_ctors = abi_version_at_least (11);
 
+  /* For GCC 7, only enable DR150 resolution by default if -std=c++1z.  */
+  if (!global_options_set.x_flag_new_ttp)
+    flag_new_ttp = (cxx_dialect >= cxx1z);
+
   if (cxx_dialect >= cxx11)
     {
       /* If we're allowing C++0x constructs, don't warn about C++98

gcc/c-family/c.opt

@@ -1443,6 +1443,10 @@ C++ ObjC++ Joined Ignore Warn(switch %qs is no longer supported)
 fnew-abi
 C++ ObjC++ Ignore Warn(switch %qs is no longer supported)
 
+fnew-ttp-matching
+C++ ObjC++ Var(flag_new_ttp)
+Implement resolution of DR 150 for matching of template template arguments.
+
 fnext-runtime
 ObjC ObjC++ LTO Report RejectNegative Var(flag_next_runtime)
 Generate code for NeXT (Apple Mac OS X) runtime environment.

gcc/cp/ChangeLog

 2016-12-21  Jason Merrill  <jason@redhat.com>
 
+	Implement P0522R0, matching of template template arguments.
+	* pt.c (coerce_template_template_parms): Allow a template argument
+	that's less specialized than the parameter.
+	(unify_bound_ttp_args): Adjust parm's args to apply to arg's
+	template.
+	(coerce_template_args_for_ttp): Split out from
+	lookup_template_class_1.
+	(coerce_ttp_args_for_tta, store_defaulted_ttp)
+	(lookup_defaulted_ttp, add_defaults_to_ttp): New.
+	(process_partial_specialization): Set DECL_CONTEXT of
+	template template-parameters.
+	(coerce_template_parms): Only inform when complain.
+	(expand_template_argument_pack): Handle error_mark_node.
+	(convert_template_argument, template_args_equal, unify): Handle
+	any_targ_node.
+	* cp-tree.h (enum cp_tree_index): Add CPTI_ANY_TARG.
+	(any_targ_node): New.
+	* decl.c (cxx_init_decl_processing): Set it.
+	* name-lookup.c (consider_binding_level): Ignore names with embedded
+	spaces.
+
 	PR c++/42329
 	* pt.c (unify_bound_ttp_args): Split out from unify.
 	(try_class_unification): Handle BOUND_TEMPLATE_TEMPLATE_PARM.

gcc/cp/cp-tree.h

@@ -1140,6 +1140,8 @@ enum cp_tree_index
 
     CPTI_ALIGN_TYPE,
 
+    CPTI_ANY_TARG,
+
     CPTI_MAX
 };
 
@@ -1245,6 +1247,9 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];
 
 #define keyed_classes			cp_global_trees[CPTI_KEYED_CLASSES]
 
+/* A node which matches any template argument.  */
+#define any_targ_node			cp_global_trees[CPTI_ANY_TARG]
+
 /* Node to indicate default access. This must be distinct from the
    access nodes in tree.h.  */
 

gcc/cp/decl.c

@@ -4161,6 +4161,9 @@ cxx_init_decl_processing (void)
   global_type_node = make_node (LANG_TYPE);
   record_unknown_type (global_type_node, "global type");
 
+  any_targ_node = make_node (LANG_TYPE);
+  record_unknown_type (any_targ_node, "any type");
+
   /* Now, C++.  */
   current_lang_name = lang_name_cplusplus;
 

gcc/cp/name-lookup.c

@@ -4758,8 +4758,10 @@ consider_binding_level (tree name, best_match <tree, tree> &bm,
 	  && DECL_ANTICIPATED (d))
 	continue;
 
-      if (DECL_NAME (d))
-	bm.consider (DECL_NAME (d));
+      if (tree name = DECL_NAME (d))
+	/* Ignore internal names with spaces in them.  */
+	if (!strchr (IDENTIFIER_POINTER (name), ' '))
+	  bm.consider (DECL_NAME (d));
     }
 }
 

gcc/doc/invoke.texi

@@ -201,6 +201,7 @@ in the following sections.
 -fno-implicit-inline-templates @gol
 -fno-implement-inlines  -fms-extensions @gol
 -fnew-inheriting-ctors @gol
+-fnew-ttp-matching @gol
 -fno-nonansi-builtins  -fnothrow-opt  -fno-operator-names @gol
 -fno-optional-diags  -fpermissive @gol
 -fno-pretty-templates @gol
@@ -2455,6 +2456,14 @@ inheritance.  This is part of C++17 but also considered to be a Defect
 Report against C++11 and C++14.  This flag is enabled by default
 unless @option{-fabi-version=10} or lower is specified.
 
+@item -fnew-ttp-matching
+@opindex fnew-ttp-matching
+Enable the P0522 resolution to Core issue 150, template template
+parameters and default arguments: this allows a template with default
+template arguments as an argument for a template template parameter
+with fewer template parameters.  This flag is enabled by default for
+@option{-std=c++1z}.
+
 @item -fno-nonansi-builtins
 @opindex fno-nonansi-builtins
 Disable built-in declarations of functions that are not mandated by

gcc/testsuite/g++.dg/cpp0x/variadic-ex14.C

 // { dg-do compile { target c++11 } }
-
+// { dg-options -fno-new-ttp-matching }
 template<class T> class A { /* ... */ };
 template<class T, class U = T> class B { /* ... */ };
 template<class... Types> class C { /* ... */ };

gcc/testsuite/g++.dg/cpp0x/variadic-ex14a.C

+// CWG 150: Matching of template template-arguments excludes compatible
+// templates
+// { dg-options -fnew-ttp-matching }
+
+template<class T> class A { /* ... */ };
+template<class T, class U = T> class B { /* ... */ };
+template<template<class> class P> class X { /* ... */ };
+X<A> xa; // OK
+X<B> xb; // OK since P0522R0
+
+#if __cpp_variadic_templates
+template <class ... Types> class C { /* ... */ };
+template<template<class ...> class Q> class Y { /* ... */ };
+X<C> xc; // OK since P0522R0
+Y<A> ya; // OK
+Y<B> yb; // OK
+Y<C> yc; // OK
+#endif
+
+#if __cpp_template_auto
+template<auto n> class D { /* ... */ };
+template<template<int> class R> class Z { /* ... */ };
+Z<D> zd; // OK
+#endif

gcc/testsuite/g++.dg/cpp0x/variadic-ttp4.C

+// { dg-do compile { target c++11 } }
+
+template<typename _Tp>
+struct get_first_arg;
+
+template<template<typename, typename...> class _Template, typename _Tp,
+	 typename... _Types>
+struct get_first_arg<_Template<_Tp, _Types...>>
+{ using type = _Tp; };
+
+template<typename T> struct A { };
+
+template<class,class> struct same;
+template<class T> struct same<T,T> {};
+
+same<get_first_arg<A<int>>::type,
+     int> x;

gcc/testsuite/g++.dg/cpp0x/variadic-ttp5.C

+// { dg-do compile { target c++11 } }
+
+template <typename, typename> struct A { };
+template <typename T> struct B { };
+
+template <typename T, template <T...> class C, T... Is>
+struct A<B<T>, C<Is...>>
+{
+  using type = C<Is...>;
+};

gcc/testsuite/g++.dg/cpp0x/variadic79.C

 // PR c++/33213
 // { dg-do compile { target c++11 } }
+// { dg-options -fno-new-ttp-matching }
 
 template<template<typename> class...> struct A;
 

gcc/testsuite/g++.dg/cpp0x/variadic79a.C

+// PR c++/33213
+// { dg-do compile { target c++11 } }
+// { dg-options -fnew-ttp-matching }
+
+template<template<typename> class...> struct A;
+
+template<template<typename...> class... B> struct A<B...> {};

gcc/testsuite/g++.dg/cpp0x/variadic85.C

 // PR c++/32565
 // { dg-do compile { target c++11 } }
+// { dg-options -fno-new-ttp-matching }
 
 template<typename...> struct A1;
 template<template<int, int...> class T> struct A1<T<0, 1> > {};

gcc/testsuite/g++.dg/cpp0x/variadic85a.C

+// PR c++/32565
+// { dg-do compile { target c++11 } }
+// { dg-options -fnew-ttp-matching }
+
+template<typename...> struct A1;
+template<template<int, int...> class T> struct A1<T<0, 1> > {};
+template<int, int, int...> struct B1 {};
+A1<B1<0, 1> > a1;
+template<int...> struct B2 {};
+A1<B2<0, 1> > a2;

gcc/testsuite/g++.dg/cpp1z/ttp1.C

+// CWG 150: Matching of template template-arguments excludes compatible
+// templates
+
+// { dg-options -fnew-ttp-matching }
+
+template<class T, class U = T> class B { /* ... */ };
+#if __cpp_variadic_templates
+template <class ... Types> class C { /* ... */ };
+#endif
+template<template<class> class P, class T> void f(P<T>);
+
+int main()
+{
+  f(B<int>());
+  f(B<int,float>());		// { dg-error "no match" }
+#if __cpp_variadic_templates
+  f(C<int>());
+#endif
+}

gcc/testsuite/g++.dg/template/ttp16.C

+// { dg-options -fno-new-ttp-matching }
+
 template <template <typename> class C>
 void f() {}
 

gcc/testsuite/g++.dg/template/ttp16a.C

+// { dg-options -fnew-ttp-matching }
+
+template <template <typename> class C>
+void f() {}
+
+template <typename T, typename U = int>
+struct S {};
+
+template void f<S>();

gcc/testsuite/g++.dg/template/ttp17.C

+// { dg-options -fno-new-ttp-matching }
+
 template <template <typename> class C>
 void f(C<double>) {}
 

gcc/testsuite/g++.dg/template/ttp17a.C

+// { dg-options -fnew-ttp-matching }
+
+template <template <typename> class C>
+void f(C<double>) {}
+
+template <typename T, typename U = int>
+struct S {};
+
+template void f(S<double>);

gcc/testsuite/g++.dg/torture/pr68220.C

+// { dg-options -fno-new-ttp-matching }
 // { dg-do compile }
 namespace mpl {
 template <typename, typename = int> struct lambda;

gcc/testsuite/g++.old-deja/g++.pt/ttp49.C

-// { dg-do assemble  }
+// { dg-options -fno-new-ttp-matching }
 
 template <int i> class C {};
 template <template <long> class TT> class D {};

gcc/testsuite/g++.old-deja/g++.pt/ttp49a.C

+// { dg-options -fnew-ttp-matching }
+
+template <int i> class C {};
+template <template <long> class TT> class D {};
+
+int main()
+{
+  D<C> d;
+}

libstdc++-v3/ChangeLog

-2016-12-16  Jason Merrill  <jason@redhat.com>
+2016-12-21  Jason Merrill  <jason@redhat.com>
 
 	* testsuite/util/testsuite_tr1.h (test_property): Don't define both
 	variadic and non-variadic overloads.