tuple: Mark more constructors constexpr.

2011-08-03  Benjamin Kosnik  <bkoz@redhat.com>

	* include/std/tuple: Mark more constructors constexpr.
	* testsuite/20_util/tuple/cons/constexpr.cc: Split into and extend as:
	* testsuite/20_util/tuple/cons/constexpr-2.cc: ...this.
	* testsuite/20_util/tuple/cons/constexpr-3.cc: ... and this.
	* testsuite/20_util/weak_ptr/comparison/cmp_neg.cc: Adjust line numbers.

2011-08-03  Benjamin Kosnik  <bkoz@redhat.com>
	    François Dumont  <francois.cppdevs@free.fr>

	* testsuite/23_containers/array/at_neg.cc: Move...
	* testsuite/23_containers/array/at.cc: ...here. Remove
	-fno-exceptions, call const at member function.


Co-Authored-By: François Dumont <francois.cppdevs@free.fr>

From-SVN: r177299

libstdc++-v3/ChangeLog

@@ -1,3 +1,18 @@
+2011-08-03  Benjamin Kosnik  <bkoz@redhat.com>
+
+	* include/std/tuple: Mark more constructors constexpr.
+	* testsuite/20_util/tuple/cons/constexpr.cc: Split into and extend as:
+	* testsuite/20_util/tuple/cons/constexpr-2.cc: ...this.
+	* testsuite/20_util/tuple/cons/constexpr-3.cc: ... and this.
+	* testsuite/20_util/weak_ptr/comparison/cmp_neg.cc: Adjust line numbers.
+
+2011-08-03  Benjamin Kosnik  <bkoz@redhat.com>
+	    François Dumont  <francois.cppdevs@free.fr>
+
+	* testsuite/23_containers/array/at_neg.cc: Move...
+	* testsuite/23_containers/array/at.cc: ...here. Remove
+	-fno-exceptions, call const at member function.
+
 2011-08-01  H.J. Lu  <hongjiu.lu@intel.com>
 
 	* config/abi/post/x86_64-linux-gnu/x32/baseline_symbols.txt: Generated.

libstdc++-v3/include/std/tuple

@@ -114,7 +114,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       template<typename _UHead, typename = typename
 	       enable_if<!is_convertible<_UHead,
 	                                 __uses_alloc_base>::value>::type>
-        _Head_base(_UHead&& __h)
+        constexpr _Head_base(_UHead&& __h)
 	: _Head(std::forward<_UHead>(__h)) { }
 
       _Head_base(__uses_alloc0)
@@ -140,8 +140,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
 	: _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
 
-      _Head&       _M_head() noexcept       { return *this; }
+      _Head&       
-      const _Head& _M_head() const noexcept { return *this; }
+      _M_head() noexcept { return *this; }
+
+      const _Head& 
+      _M_head() const noexcept { return *this; }
     };
 
   template<std::size_t _Idx, typename _Head>
@@ -156,7 +159,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       template<typename _UHead, typename = typename
 	       enable_if<!is_convertible<_UHead,
 	                                 __uses_alloc_base>::value>::type>
-        _Head_base(_UHead&& __h)
+        constexpr _Head_base(_UHead&& __h)
 	: _M_head_impl(std::forward<_UHead>(__h)) { }
 
       _Head_base(__uses_alloc0)
@@ -183,8 +186,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
 	: _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
 
-      _Head&       _M_head() noexcept       { return _M_head_impl; }
+      _Head&       
-      const _Head& _M_head() const noexcept { return _M_head_impl; }        
+      _M_head() noexcept { return _M_head_impl; }
+
+      const _Head& 
+      _M_head() const noexcept { return _M_head_impl; }        
 
       _Head _M_head_impl; 
     };
@@ -239,11 +245,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
       typedef _Head_base<_Idx, _Head, std::is_empty<_Head>::value> _Base;
 
-      _Head&            _M_head() noexcept       { return _Base::_M_head(); }
+      _Head&            
-      const _Head&      _M_head() const noexcept { return _Base::_M_head(); }
+      _M_head() noexcept { return _Base::_M_head(); }
 
-      _Inherited&       _M_tail() noexcept       { return *this; }
+      const _Head&      
-      const _Inherited& _M_tail() const noexcept { return *this; }
+      _M_head() const noexcept { return _Base::_M_head(); }
+
+      _Inherited&       
+      _M_tail() noexcept { return *this; }
+
+      const _Inherited& 
+      _M_tail() const noexcept { return *this; }
 
       constexpr _Tuple_impl()
       : _Inherited(), _Base() { }
@@ -255,7 +267,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       template<typename _UHead, typename... _UTail, typename = typename
                enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type> 
         explicit
-        _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
+        constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
 	: _Inherited(std::forward<_UTail>(__tail)...),
 	  _Base(std::forward<_UHead>(__head)) { }
 
@@ -371,7 +383,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       }
     };
 
-  /// tuple
+  /// Primary class template, tuple
   template<typename... _Elements> 
     class tuple : public _Tuple_impl<0, _Elements...>
     {
@@ -392,10 +404,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 					   __conv_types<_Elements...>>
 			 >::value>::type>
 	explicit
-        tuple(_UElements&&... __elements)
+        constexpr tuple(_UElements&&... __elements)
 	: _Inherited(std::forward<_UElements>(__elements)...) {	}
 
       constexpr tuple(const tuple&) = default;
+
       tuple(tuple&&) = default;
 
       template<typename... _UElements, typename = typename
@@ -417,7 +430,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         tuple(tuple<_UElements...>&& __in)
         : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
 
-      // allocator-extended constructors
+      // Allocator-extended constructors.
 
       template<typename _Alloc>
 	tuple(allocator_arg_t __tag, const _Alloc& __a)
@@ -503,6 +516,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       { _Inherited::_M_swap(__in); }
     };
 
+  // Explicit specialization, zero-element tuple.
   template<>  
     class tuple<>
     {
@@ -510,7 +524,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       void swap(tuple&) noexcept { /* no-op */ }
     };
 
-  /// tuple (2-element), with construction and assignment from a pair.
+  /// Partial specialization, 2-element tuple.
+  /// Includes construction and assignment from a pair.
   template<typename _T1, typename _T2>
     class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
     {
@@ -528,10 +543,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	       enable_if<__and_<is_convertible<_U1, _T1>,
 				is_convertible<_U2, _T2>>::value>::type>
         explicit
-        tuple(_U1&& __a1, _U2&& __a2)
+        constexpr tuple(_U1&& __a1, _U2&& __a2)
 	: _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
 
       constexpr tuple(const tuple&) = default;
+
       tuple(tuple&&) = default;
 
       template<typename _U1, typename _U2, typename = typename
@@ -549,7 +565,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       template<typename _U1, typename _U2, typename = typename
 	enable_if<__and_<is_convertible<const _U1&, _T1>,
 			 is_convertible<const _U2&, _T2>>::value>::type>
-        tuple(const pair<_U1, _U2>& __in)
+        constexpr tuple(const pair<_U1, _U2>& __in)
 	: _Inherited(__in.first, __in.second) { }
 
       template<typename _U1, typename _U2, typename = typename
@@ -559,7 +575,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	: _Inherited(std::forward<_U1>(__in.first),
 		     std::forward<_U2>(__in.second)) { }
 
-      // allocator-extended constructors
+      // Allocator-extended constructors.
 
       template<typename _Alloc>
 	tuple(allocator_arg_t __tag, const _Alloc& __a)

libstdc++-v3/testsuite/20_util/tuple/cons/constexpr-2.cc

@@ -0,0 +1,63 @@
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2010, 2011 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/>.
+
+#include <memory>
+#include <testsuite_common_types.h>
+
+#include <iostream>
+
+// 2 element tuple
+int main()
+{
+  typedef std::tuple<int, int> tuple_type;
+
+  // 01: default ctor
+  __gnu_test::constexpr_default_constructible test1;
+  test1.operator()<tuple_type>();
+
+  // 02: default copy ctor
+  __gnu_test::constexpr_single_value_constructible test2;
+  test2.operator()<tuple_type, tuple_type>();
+
+  // 03: element move ctor, single element
+  const int i1(415);
+  constexpr tuple_type t2 { 44, std::move(i1) };
+
+  // 04: element move ctor, two element
+  const int i2(510);
+  const int i3(408);
+  constexpr tuple_type t4 { std::move(i2), std::move(i3) };
+
+  // 05: value-type conversion constructor
+  const int i4(650);
+  const int i5(310);
+  constexpr tuple_type t8(i4, i5);
+
+  // 06: pair conversion ctor
+  test2.operator()<tuple_type, std::pair<int, int>>();
+  test2.operator()<std::tuple<short, short>, std::pair<int, int>>();
+  test2.operator()<tuple_type, std::pair<short, short>>();
+
+  // 07: different-tuple-type conversion constructor
+  // test2.operator()<tuple_type, std::tuple<short, short>>();
+  // test2.operator()<std::tuple<short, short>, tuple_type>();
+
+  return 0;
+}

libstdc++-v3/testsuite/20_util/tuple/cons/constexpr-3.cc

@@ -1,7 +1,7 @@
 // { dg-do compile }
 // { dg-options "-std=gnu++0x" }
 
-// Copyright (C) 2010 Free Software Foundation, Inc.
+// Copyright (C) 2011 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
@@ -21,27 +21,40 @@
 #include <memory>
 #include <testsuite_common_types.h>
 
+#include <iostream>
+
+// 3 element tuple
 int main()
 {
+  typedef std::tuple<int, int, int> tuple_type;
+
+  // 01: default ctor
   __gnu_test::constexpr_default_constructible test1;
-  test1.operator()<std::tuple<int, int>>();
+  test1.operator()<tuple_type>();
 
+  // 02: default copy ctor
   __gnu_test::constexpr_single_value_constructible test2;
-  test2.operator()<std::tuple<int, int>, std::tuple<int, int>>();
+  test2.operator()<tuple_type, tuple_type>();
-  //  test2.operator()<std::tuple<int, int>, std::pair<short, short>>();
-  //  test2.operator()<std::tuple<int>, std::tuple<short>>();
-  //  test2.operator()<std::tuple<int, int>, std::tuple<short, short>>();
 
-  // test 3
+  // 03: element move ctor, single element
-  const int i1(129);
+  const int i1(415);
-  const int i2(6);
+  constexpr tuple_type t2 { 44, 55, std::move(i1) };
-  constexpr std::tuple<int, int> p3(i1, i2);
 
-  // test 4
+  // 04: element move ctor, three element
-  const int i3(415);
+  const int i2(510);
-  const int i4(550);
+  const int i3(408);
-  const int i5(6414);
+  const int i4(650);
-  constexpr std::tuple<int, int, int, int, int> p4(i1, i2, i3, i4, i5);
+  constexpr tuple_type t4 { std::move(i2), std::move(i3), std::move(i4) };
+
+  // 05: value-type conversion constructor
+  const int i5(310);
+  const int i6(310);
+  const int i7(310);
+  constexpr tuple_type t8(i5, i6, i7);
+
+  // 06: different-tuple-type conversion constructor
+  // test2.operator()<tuple_type, std::tuple<short, short, short>>();
+  // test2.operator()<std::tuple<short, short, short>, tuple_type>();
 
   return 0;
 }

libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc

@@ -51,7 +51,7 @@ main()
 // { dg-warning "note" "" { target *-*-* } 485 }
 // { dg-warning "note" "" { target *-*-* } 479 }
 // { dg-warning "note" "" { target *-*-* } 468 }
-// { dg-warning "note" "" { target *-*-* } 813 }
+// { dg-warning "note" "" { target *-*-* } 829 }
 // { dg-warning "note" "" { target *-*-* } 1055 }
 // { dg-warning "note" "" { target *-*-* } 1049 }
 // { dg-warning "note" "" { target *-*-* } 341 }

libstdc++-v3/testsuite/23_containers/array/at.cc

@@ -1,5 +1,5 @@
 // { dg-do run { xfail *-*-* } }
-// { dg-options "-std=gnu++0x -fno-exceptions" }
+// { dg-options "-std=gnu++0x" }
 
 // Copyright (C) 2011 Free Software Foundation, Inc.
 //
@@ -22,7 +22,10 @@
 
 int main()
 {
-  std::array<int, 3> a{{1, 2, 3}};
+  // Expected behavior is to either throw and have the uncaught
-  auto i = a.at(4); // expected behavior is to either throw or abort
+  // exception end up in a terminate handler which eventually exits,
+  // or abort. (Depending on -fno-exceptions.)
+  constexpr std::array<int, 3> a{{1, 2, 3}};
+  auto i = a.at(4); 
   return 0;
 }