[v3 patch] Implement N4502 Standard Library Support for the C++ Detection Idiom

[Jonathan Wakely <jwakely at redhat dot com>]

This adds the "detection idiom" API from N4502

http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf

I've added the low-level parts to <type_traits>, with public aliases
in <experimental/type_traits>, so that I can use them elsewhere in the
library.

Tested powerpc64le-linux, committed to trunk.

commit 280016fc93e2c62e1c07f2588002d422ba5ac7b1
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Tue Jun 30 23:19:50 2015 +0100

    Implement N4502, the C++ Detection Idiom.
    
    	* doc/xml/manual/status_cxx2017.xml: Update status table.
    	* include/experimental/type_traits (void_t, is_detected,
    	is_detected_v, detected_t, detected_or, detected_or_t,
    	is_detected_exact, is_detected_exact_v, is_detected_convertible,
    	is_detected_convertible_v): Define.
    	* include/std/type_traits (__detector, __detected_or, __detected_or_t,
    	__detected_or_t_): Define.
    	* testsuite/experimental/type_traits/detection.cc: New.

diff --git a/libstdc++-v3/doc/xml/manual/status_cxx2017.xml b/libstdc++-v3/doc/xml/manual/status_cxx2017.xml
index d110572..07e2dbe 100644
--- a/libstdc++-v3/doc/xml/manual/status_cxx2017.xml
+++ b/libstdc++-v3/doc/xml/manual/status_cxx2017.xml
@@ -328,14 +328,13 @@ not in any particular release.
     </row>
 
     <row>
-      <?dbhtml bgcolor="#C8B0B0" ?>
       <entry>
 	<link xmlns:xlink="http://www.w3.org/1999/xlink"; xlink:href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf";>
 	  N4502
 	</link>
       </entry>
       <entry> Support for the C++ Detection Idiom, V2 </entry>
-      <entry>N</entry>
+      <entry>Y</entry>
       <entry>Library Fundamentals 2 TS</entry>
     </row>
 
diff --git a/libstdc++-v3/include/experimental/type_traits b/libstdc++-v3/include/experimental/type_traits
index db78eec..b0ed3b0 100644
--- a/libstdc++-v3/include/experimental/type_traits
+++ b/libstdc++-v3/include/experimental/type_traits
@@ -220,6 +220,59 @@ template <typename _From, typename _To>
   // raw_invocation_type_t (still unimplemented)
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace fundamentals_v1
+
+inline namespace fundamentals_v2
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#define __cpp_lib_experimental_detect 201505
+
+// [meta.detect]
+
+template<typename...> using void_t = void;
+
+struct nonesuch
+{
+  nonesuch() = delete;
+  ~nonesuch() = delete;
+  nonesuch(nonesuch const&) = delete;
+  void operator=(nonesuch const&) = delete;
+};
+
+template<template<typename...> class _Op, typename... _Args>
+  using is_detected
+    = typename std::__detector<nonesuch, void, _Op, _Args...>::value_t;
+
+template<template<typename...> class _Op, typename... _Args>
+  constexpr bool is_detected_v = is_detected<_Op, _Args...>::value;
+
+template<template<typename...> class _Op, typename... _Args>
+  using detected_t
+    = typename std::__detector<nonesuch, void, _Op, _Args...>::type;
+
+template<typename _Default, template<typename...> class _Op, typename... _Args>
+  using detected_or = std::__detected_or<_Default, _Op, _Args...>;
+
+template<typename _Default, template<typename...> class _Op, typename... _Args>
+  using detected_or_t = typename detected_or<_Default, _Op, _Args...>::type;
+
+template<typename Expected, template<typename...> class _Op, typename... _Args>
+  using is_detected_exact = is_same<Expected, detected_t<_Op, _Args...>>;
+
+template<typename Expected, template<typename...> class _Op, typename... _Args>
+  constexpr bool is_detected_exact_v
+    = is_detected_exact<Expected, _Op, _Args...>::value;
+
+template<typename _To, template<typename...> class _Op, typename... _Args>
+  using is_detected_convertible
+    = is_convertible<detected_t<_Op, _Args...>, _To>;
+
+template<typename _To, template<typename...> class _Op, typename... _Args>
+  constexpr bool is_detected_convertible_v
+    = is_detected_convertible<_To, _Op, _Args...>::value;
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace fundamentals_v2
 } // namespace experimental
 } // namespace std
 
diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
index e09c856..55ca916 100644
--- a/libstdc++-v3/include/std/type_traits
+++ b/libstdc++-v3/include/std/type_traits
@@ -2417,6 +2417,41 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename...> using void_t = void;
 #endif
 
+  /// Implementation of the detection idiom (negative case).
+  template<typename _Default, typename _AlwaysVoid,
+	   template<typename...> class _Op, typename... _Args>
+    struct __detector
+    {
+      using value_t = false_type;
+      using type = _Default;
+    };
+
+  /// Implementation of the detection idiom (positive case).
+  template<typename _Default, template<typename...> class _Op,
+	    typename... _Args>
+    struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
+    {
+      using value_t = true_type;
+      using type = _Op<_Args...>;
+    };
+
+  // Detect whether _Op<_Args...> is a valid type, use _Default if not.
+  template<typename _Default, template<typename...> class _Op,
+	   typename... _Args>
+    using __detected_or = __detector<_Default, void, _Op, _Args...>;
+
+  // _Op<_Args...> if that is a valid type, otherwise _Default.
+  template<typename _Default, template<typename...> class _Op,
+	   typename... _Args>
+    using __detected_or_t
+      = typename __detected_or<_Default, _Op, _Args...>::type;
+
+  // _Op<_Args...> if that is a valid type, otherwise _Default<_Args...>.
+  template<template<typename...> class _Default,
+	   template<typename...> class _Op, typename... _Args>
+    using __detected_or_t_ =
+      __detected_or_t<_Default<_Args...>, _Op, _Args...>;
+
   /// @} group metaprogramming
 
   /**
diff --git a/libstdc++-v3/testsuite/experimental/type_traits/detection.cc b/libstdc++-v3/testsuite/experimental/type_traits/detection.cc
new file mode 100644
index 0000000..45d0692
--- /dev/null
+++ b/libstdc++-v3/testsuite/experimental/type_traits/detection.cc
@@ -0,0 +1,85 @@
+// Copyright (C) 2015 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++14" }
+// { dg-do compile }
+
+#include <experimental/type_traits>
+
+using std::declval;
+using std::ptrdiff_t;
+using std::experimental::is_detected;
+using std::experimental::is_detected_exact;
+using std::experimental::detected_or_t;
+using std::experimental::is_same_v;
+
+// Examples taken from N4502
+
+// archetypal helper alias for a copy assignment operation:
+template <class T>
+using copy_assign_t = decltype(declval<T&>() = declval<T const &>());
+
+// plausible implementation for the is_assignable type trait:
+template <class T>
+  using is_copy_assignable = is_detected<copy_assign_t, T>;
+
+// plausible implementation for an augmented is_assignable type trait
+// that also checks the return type:
+template <class T>
+  using is_canonical_copy_assignable = is_detected_exact<T&, copy_assign_t, T>;
+
+struct A { };
+struct B { B& operator=(const B&); };
+struct C { void operator=(const C&); };
+struct D { D& operator=(D&); };
+struct E { E& operator=(E&&); };
+
+static_assert( is_copy_assignable<A>::value,  "A is copy assignable" );
+static_assert( is_copy_assignable<B>::value,  "B is copy assignable" );
+static_assert( is_copy_assignable<C>::value,  "C is copy assignable" );
+static_assert( !is_copy_assignable<D>::value, "D is not copy assignable" );
+static_assert( !is_copy_assignable<E>::value,  "E is not copy assignable" );
+
+static_assert( is_canonical_copy_assignable<A>::value,
+               "A has canonical copy assignment" );
+static_assert( is_canonical_copy_assignable<B>::value,
+               "B has canonical copy assignment" );
+static_assert( !is_canonical_copy_assignable<C>::value,
+               "C does not have canonical copy assignment" );
+static_assert( !is_canonical_copy_assignable<D>::value,
+               "D does not have canonical copy assignment" );
+static_assert( !is_canonical_copy_assignable<E>::value,
+               "E does not have canonical copy assignment" );
+
+// archetypal helper alias for a particular type member:
+template <class T>
+  using diff_t = typename T::difference_type;
+// alias the type member, if it exists, otherwise alias ptrdiff_t:
+template <class Ptr>
+  using difference_type = detected_or_t<ptrdiff_t, diff_t, Ptr>;
+
+struct has { using difference_type = char; };
+struct has_not { };
+struct inherits : has { };
+struct hides : private has { };
+struct reveals : private has { using has::difference_type; };
+
+static_assert( is_same_v<difference_type<has>,      char>,      "has" );
+static_assert( is_same_v<difference_type<has_not>,  ptrdiff_t>, "has not" );
+static_assert( is_same_v<difference_type<inherits>, char>,      "inherits" );
+static_assert( is_same_v<difference_type<hides>,    ptrdiff_t>, "hides" );
+static_assert( is_same_v<difference_type<reveals>,  char>,      "reveals" );