From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wm1-x32e.google.com (mail-wm1-x32e.google.com [IPv6:2a00:1450:4864:20::32e]) by sourceware.org (Postfix) with ESMTPS id 3D4AD3858D35; Wed, 29 Jul 2020 09:33:29 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 3D4AD3858D35 Received: by mail-wm1-x32e.google.com with SMTP id 184so2266304wmb.0; Wed, 29 Jul 2020 02:33:29 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-language; bh=zquHAYK2TP8CNkeQjKAlLjVfoRb7zkxTzYYgpSRRkI4=; b=Z5I0cDP5lvt3k5Mp+nRmRippqY/didvD5NjSfCMkWVQjB8MiGWg9Yv2t64kwrub+E2 x8+6VfnyKJcAoTmq6ep34r78xOB+W3lIS3D8JQ/VdeJjAM0DApLZYBNf7Rjwp9VTRCfm x2KsDIaKpYJdhChIkFkL5zFleK023FRx1ko3AX7coVD9xA2917r71QHlXptxcVhkCu3R 3rXLZvavJ66txBAiw573BBykSHUjM+5VCU4XhQWjWE7RX2FtCXVjKJPLIRK4uygZ6qPv 84CFHWC6hXinxeM4e/bNiXAdbibA90T1MpQY8VOoc1edLeA+mgJLKtnFTbacrA6v55+o 6RIw== X-Gm-Message-State: AOAM532aMQCBUtnB56LNnCwtIaO/v70g3toYEvLRpMIwPs/ouZjZrN/B 7xJ6ZxWE8A4bceATYaQZhLkUB9IBD+8= X-Google-Smtp-Source: ABdhPJyB7kT2wP/WZV3knc9Xm4bF/hAnBBHD9AGPU0+aUrjI9ZRpZj5pHUROtXy5a3U7GAHuqlVHvw== X-Received: by 2002:a1c:23c2:: with SMTP id j185mr1129918wmj.84.1596015207835; Wed, 29 Jul 2020 02:33:27 -0700 (PDT) Received: from [192.168.42.161] ([37.167.158.175]) by smtp.googlemail.com with ESMTPSA id h11sm4365743wrb.68.2020.07.29.02.33.25 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Wed, 29 Jul 2020 02:33:26 -0700 (PDT) Subject: Re: [PATCH][Hashtable 3/6] Fix noexcept qualifications To: Jonathan Wakely Cc: "libstdc++@gcc.gnu.org" , gcc-patches References: <20200717095522.GA2827066@redhat.com> From: =?UTF-8?Q?Fran=c3=a7ois_Dumont?= Message-ID: <62f5d078-dfcf-84d7-a539-0062405ec931@gmail.com> Date: Wed, 29 Jul 2020 11:33:24 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.8.0 MIME-Version: 1.0 In-Reply-To: <20200717095522.GA2827066@redhat.com> Content-Type: multipart/mixed; boundary="------------B4279385FA08A711E91FCB06" Content-Language: en-US X-Spam-Status: No, score=-9.2 required=5.0 tests=BAYES_00, BODY_8BITS, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, KAM_SHORT, NICE_REPLY_A, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: libstdc++@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libstdc++ mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 29 Jul 2020 09:33:33 -0000 This is a multi-part message in MIME format. --------------B4279385FA08A711E91FCB06 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit I eventually committed the attached patch which consider all your remarks and moreover put back the move constructor implementation where it used to be (not inline). It limits the size of the patch. I also added comments on true_type/false_type new usages like you advised on [Hashtable 0/6] thread. François On 17/07/20 11:55 am, Jonathan Wakely wrote: > On 17/11/19 21:59 +0100, François Dumont wrote: >> This patch adds noexcept qualification on allocator aware >> constructors and fix the one on the default constructor. >> >>     * include/bits/hashtable.h >>     (_Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, >> true_type)): >>     Add noexcept qualification. >>     (_Hashtable(_Hashtable&&)): Fix noexcept qualification. >>     (_Hashtable(_Hashtable&&, const allocator_type&)): Add noexcept >>     qualification. >>     * include/bits/unordered_map.h >>     (unordered_map(unordered_map&&, const allocator_type&)): Add >> noexcept >>     qualification. >>     (unordered_multimap(unordered_multimap&&, const >> allocator_type&)): Add >>     noexcept qualification. >>     * include/bits/unordered_set.h >>     (unordered_set(unordered_set&&, const allocator_type&)): Add >> noexcept >>     qualification. >>     (unordered_multiset(unordered_multiset&&, const >> allocator_type&)): Add >>     noexcept qualification. >>     * >> testsuite/23_containers/unordered_map/allocator/default_init.cc: >>     New. >>     * testsuite/23_containers/unordered_map/cons/ >>     noexcept_default_construct.cc: New. >>     * testsuite/23_containers/unordered_map/cons/ >>     noexcept_move_construct.cc: New. >>     * testsuite/23_containers/unordered_map/modifiers/move_assign.cc: >>     New. >>     * testsuite/23_containers/unordered_multimap/cons/ >>     noexcept_default_construct.cc: New. >>     * testsuite/23_containers/unordered_multimap/cons/ >>     noexcept_move_construct.cc: New. >>     * testsuite/23_containers/unordered_multiset/cons/ >>     noexcept_default_construct.cc: New. >>     * testsuite/23_containers/unordered_multiset/cons/ >>     noexcept_move_construct.cc: New. >>     * >> testsuite/23_containers/unordered_set/allocator/default_init.cc: New. >>     * testsuite/23_containers/unordered_set/cons/ >>     noexcept_default_construct.cc: New. >>     * >> testsuite/23_containers/unordered_set/cons/noexcept_move_construct.cc: >>     New. >> >> Tested under Linux x86_64. >> >> François >> > >> diff --git a/libstdc++-v3/include/bits/hashtable.h >> b/libstdc++-v3/include/bits/hashtable.h >> index 5f785d4904d..ad07a36eb83 100644 >> --- a/libstdc++-v3/include/bits/hashtable.h >> +++ b/libstdc++-v3/include/bits/hashtable.h >> @@ -463,6 +463,35 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION >>     __hashtable_alloc(__node_alloc_type(__a)) >>       { } >> >> +      _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, true_type) >> + noexcept(std::is_nothrow_copy_constructible<_H1>::value && >> + std::is_nothrow_copy_constructible<_Equal>::value) >> +      : __hashtable_base(__ht), >> +    __map_base(__ht), >> +    __rehash_base(__ht), >> +    __hashtable_alloc(std::move(__a)), >> +    _M_buckets(__ht._M_buckets), >> +    _M_bucket_count(__ht._M_bucket_count), >> +    _M_before_begin(__ht._M_before_begin._M_nxt), >> +    _M_element_count(__ht._M_element_count), >> +    _M_rehash_policy(__ht._M_rehash_policy) >> +      { >> +    // Update, if necessary, buckets if __ht is using its single >> bucket. > > I know the comment was already present, but I can't parse this. > > There are two 'if' conditions, but don't they refer to the same thing? > It's necessary if __ht is using a single bucket, so shouldn't it be > either "Update buckets if __ht is using its single bucket" or "Update > buckets if necessary"? > > "Update buckets if __ht is using its single bucket" seems preferable. > >> +    if (__ht._M_uses_single_bucket()) >> +      { >> +        _M_buckets = &_M_single_bucket; >> +        _M_single_bucket = __ht._M_single_bucket; >> +      } >> + >> +    // Fix bucket containing the _M_before_begin pointer that can't be >> +    // moved. >> +    _M_update_bbegin(); >> + >> +    __ht._M_reset(); >> +      } >> + >> +      _Hashtable(_Hashtable&&, __node_alloc_type&&, false_type); >> + >>       template >>     _Hashtable(_InputIterator __first, _InputIterator __last, >>            size_type __bkt_count_hint, >> @@ -489,11 +518,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION >> >>       _Hashtable(const _Hashtable&); >> >> -      _Hashtable(_Hashtable&&) noexcept; >> +      _Hashtable(_Hashtable&& __ht) >> +    noexcept( noexcept( >> +      _Hashtable(std::declval<_Hashtable&&>(), > > The && here is redundant, declval adds && to the type anyway. > >> + std::declval<__node_alloc_type&&>(), std::declval())) ) > > Same for __node_alloc_type&& here. > > And true_type{} is shorter and simpler than std::declval(). > We know is_nothrow_default_constructible is true, so we can > just use that. > >> +      : _Hashtable(std::move(__ht), >> std::move(__ht._M_node_allocator()), >> +           true_type{}) >> +      { } >> >>       _Hashtable(const _Hashtable&, const allocator_type&); >> >> -      _Hashtable(_Hashtable&&, const allocator_type&); >> +      _Hashtable(_Hashtable&& __ht, const allocator_type& __a) >> +    noexcept( noexcept( >> +      _Hashtable(std::declval<_Hashtable&&>(), >> +        std::declval<__node_alloc_type&&>(), > > Redundant &&s. > >> +        std::declval> __node_alloc_traits::is_always_equal>())) ) > > Redundant declval: typename __node_alloc_traits::is_always_equal{} > >> +      : _Hashtable(std::move(__ht), __node_alloc_type(__a), >> +           typename __node_alloc_traits::is_always_equal{}) >> +      { } >> >>       // Use delegating constructors. >>       template >> @@ -1368,36 +1410,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION >>       _M_assign(__ht, __alloc_node_gen); >>     } >> >> -  template> -       typename _Alloc, typename _ExtractKey, typename _Equal, >> -       typename _H1, typename _H2, typename _Hash, typename >> _RehashPolicy, >> -       typename _Traits> >> -    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, >> -           _H1, _H2, _Hash, _RehashPolicy, _Traits>:: >> -    _Hashtable(_Hashtable&& __ht) noexcept >> -    : __hashtable_base(__ht), >> -      __map_base(__ht), >> -      __rehash_base(__ht), >> -      __hashtable_alloc(std::move(__ht._M_base_alloc())), >> -      _M_buckets(__ht._M_buckets), >> -      _M_bucket_count(__ht._M_bucket_count), >> -      _M_before_begin(__ht._M_before_begin._M_nxt), >> -      _M_element_count(__ht._M_element_count), >> -      _M_rehash_policy(__ht._M_rehash_policy) >> -    { >> -      // Update, if necessary, buckets if __ht is using its single >> bucket. >> -      if (__ht._M_uses_single_bucket()) >> -    { >> -      _M_buckets = &_M_single_bucket; >> -      _M_single_bucket = __ht._M_single_bucket; >> -    } >> - >> -      // Fix bucket containing the _M_before_begin pointer that >> can't be moved. >> -      _M_update_bbegin(); >> - >> -      __ht._M_reset(); >> -    } >> - >>   template>        typename _Alloc, typename _ExtractKey, typename _Equal, >>        typename _H1, typename _H2, typename _Hash, typename >> _RehashPolicy, >> @@ -1424,11 +1436,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION >>        typename _Traits> >>     _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, >>            _H1, _H2, _Hash, _RehashPolicy, _Traits>:: >> -    _Hashtable(_Hashtable&& __ht, const allocator_type& __a) >> +    _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, false_type) >>     : __hashtable_base(__ht), >>       __map_base(__ht), >>       __rehash_base(__ht), >> -      __hashtable_alloc(__node_alloc_type(__a)), >> +      __hashtable_alloc(std::move(__a)), >>       _M_buckets(nullptr), >>       _M_bucket_count(__ht._M_bucket_count), >>       _M_element_count(__ht._M_element_count), >> diff --git a/libstdc++-v3/include/bits/unordered_map.h >> b/libstdc++-v3/include/bits/unordered_map.h >> index 49c175a90be..5131e02e8aa 100644 >> --- a/libstdc++-v3/include/bits/unordered_map.h >> +++ b/libstdc++-v3/include/bits/unordered_map.h >> @@ -209,6 +209,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER >>        */ >>       unordered_map(unordered_map&& __umap, >>             const allocator_type& __a) >> +    noexcept( noexcept(_Hashtable(declval<_Hashtable&&>(), __a)) ) > > declval should be qualified. It might be simpler to just say: > >     noexcept( noexcept(_Hashtable(std::move(__umap._M_h), __a)) ) > >>       : _M_h(std::move(__umap._M_h), __a) >>       { } >> >> @@ -1356,6 +1357,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER >>        */ >>       unordered_multimap(unordered_multimap&& __ummap, >>              const allocator_type& __a) >> +    noexcept( noexcept(_Hashtable(declval<_Hashtable&&>(), __a)) ) > > Same here. > >>       : _M_h(std::move(__ummap._M_h), __a) >>       { } >> >> diff --git a/libstdc++-v3/include/bits/unordered_set.h >> b/libstdc++-v3/include/bits/unordered_set.h >> index 855579ee623..7154ec843db 100644 >> --- a/libstdc++-v3/include/bits/unordered_set.h >> +++ b/libstdc++-v3/include/bits/unordered_set.h >> @@ -203,6 +203,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER >>        */ >>       unordered_set(unordered_set&& __uset, >>             const allocator_type& __a) >> +    noexcept( noexcept(_Hashtable(declval<_Hashtable&&>(), __a)) ) > > Same here. > >>       : _M_h(std::move(__uset._M_h), __a) >>       { } >> >> @@ -1044,6 +1045,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER >>        */ >>       unordered_multiset(unordered_multiset&& __umset, >>              const allocator_type& __a) >> +    noexcept( noexcept(_Hashtable(declval<_Hashtable&&>(), __a)) ) > > Same here. > >>       : _M_h(std::move(__umset._M_h), __a) >>       { } >> >> diff --git >> a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/default_init.cc >> b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/default_init.cc >> >> new file mode 100644 >> index 00000000000..8c3103c2614 >> --- /dev/null >> +++ >> b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/default_init.cc >> @@ -0,0 +1,69 @@ >> +// Copyright (C) 2019 Free Software Foundation, Inc. > > Please remember to update the dates in the new tests. > > OK for master with those adjustments. Thanks. > > --------------B4279385FA08A711E91FCB06 Content-Type: text/x-patch; charset=UTF-8; name="hashtable.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="hashtable.patch" diff --git a/libstdc++-v3/include/bits/hashtable.h b/libstdc++-v3/include/bits/hashtable.h index 9d1ad592553..dc8ed2ee18c 100644 --- a/libstdc++-v3/include/bits/hashtable.h +++ b/libstdc++-v3/include/bits/hashtable.h @@ -460,6 +460,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __hashtable_alloc(__node_alloc_type(__a)) { } + _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, + true_type /* alloc always equal */) + noexcept(std::is_nothrow_copy_constructible<_H1>::value && + std::is_nothrow_copy_constructible<_Equal>::value); + + _Hashtable(_Hashtable&&, __node_alloc_type&&, + false_type /* alloc always equal */); + template _Hashtable(_InputIterator __first, _InputIterator __last, size_type __bkt_count_hint, @@ -486,11 +494,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Hashtable(const _Hashtable&); - _Hashtable(_Hashtable&&) noexcept; + _Hashtable(_Hashtable&& __ht) + noexcept( noexcept( + _Hashtable(std::declval<_Hashtable>(), + std::declval<__node_alloc_type>(), + true_type{})) ) + : _Hashtable(std::move(__ht), std::move(__ht._M_node_allocator()), + true_type{}) + { } _Hashtable(const _Hashtable&, const allocator_type&); - _Hashtable(_Hashtable&&, const allocator_type&); + _Hashtable(_Hashtable&& __ht, const allocator_type& __a) + noexcept( noexcept( + _Hashtable(std::declval<_Hashtable>(), + std::declval<__node_alloc_type>(), + typename __node_alloc_traits::is_always_equal{})) ) + : _Hashtable(std::move(__ht), __node_alloc_type(__a), + typename __node_alloc_traits::is_always_equal{}) + { } // Use delegating constructors. template @@ -1342,18 +1364,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typename _Traits> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: - _Hashtable(_Hashtable&& __ht) noexcept + _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, + true_type /* alloc always equal */) + noexcept(std::is_nothrow_copy_constructible<_H1>::value && + std::is_nothrow_copy_constructible<_Equal>::value) : __hashtable_base(__ht), __map_base(__ht), __rehash_base(__ht), - __hashtable_alloc(std::move(__ht._M_base_alloc())), + __hashtable_alloc(std::move(__a)), _M_buckets(__ht._M_buckets), _M_bucket_count(__ht._M_bucket_count), _M_before_begin(__ht._M_before_begin._M_nxt), _M_element_count(__ht._M_element_count), _M_rehash_policy(__ht._M_rehash_policy) { - // Update, if necessary, buckets if __ht is using its single bucket. + // Update buckets if __ht is using its single bucket. if (__ht._M_uses_single_bucket()) { _M_buckets = &_M_single_bucket; @@ -1392,11 +1417,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typename _Traits> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: - _Hashtable(_Hashtable&& __ht, const allocator_type& __a) + _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, + false_type /* alloc always equal */) : __hashtable_base(__ht), __map_base(__ht), __rehash_base(__ht), - __hashtable_alloc(__node_alloc_type(__a)), + __hashtable_alloc(std::move(__a)), _M_buckets(nullptr), _M_bucket_count(__ht._M_bucket_count), _M_element_count(__ht._M_element_count), diff --git a/libstdc++-v3/include/bits/unordered_map.h b/libstdc++-v3/include/bits/unordered_map.h index 33f632ddb79..1aaa1a1a6ee 100644 --- a/libstdc++-v3/include/bits/unordered_map.h +++ b/libstdc++-v3/include/bits/unordered_map.h @@ -209,6 +209,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER */ unordered_map(unordered_map&& __umap, const allocator_type& __a) + noexcept( noexcept(_Hashtable(std::move(__umap._M_h), __a)) ) : _M_h(std::move(__umap._M_h), __a) { } @@ -1303,6 +1304,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER */ unordered_multimap(unordered_multimap&& __ummap, const allocator_type& __a) + noexcept( noexcept(_Hashtable(std::move(__ummap._M_h), __a)) ) : _M_h(std::move(__ummap._M_h), __a) { } diff --git a/libstdc++-v3/include/bits/unordered_set.h b/libstdc++-v3/include/bits/unordered_set.h index c9c9e9f38b7..6cbfcb1f0b6 100644 --- a/libstdc++-v3/include/bits/unordered_set.h +++ b/libstdc++-v3/include/bits/unordered_set.h @@ -203,6 +203,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER */ unordered_set(unordered_set&& __uset, const allocator_type& __a) + noexcept( noexcept(_Hashtable(std::move(__uset._M_h), __a)) ) : _M_h(std::move(__uset._M_h), __a) { } @@ -1044,6 +1045,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER */ unordered_multiset(unordered_multiset&& __umset, const allocator_type& __a) + noexcept( noexcept(_Hashtable(std::move(__umset._M_h), __a)) ) : _M_h(std::move(__umset._M_h), __a) { } diff --git a/libstdc++-v3/include/debug/unordered_map b/libstdc++-v3/include/debug/unordered_map index 7d55174f63b..4fa5c124d5a 100644 --- a/libstdc++-v3/include/debug/unordered_map +++ b/libstdc++-v3/include/debug/unordered_map @@ -144,6 +144,7 @@ namespace __debug unordered_map(unordered_map&& __umap, const allocator_type& __a) + noexcept( noexcept(_Base(std::move(__umap._M_base()), __a)) ) : _Safe(std::move(__umap._M_safe()), __a), _Base(std::move(__umap._M_base()), __a) { } @@ -847,6 +848,7 @@ namespace __debug unordered_multimap(unordered_multimap&& __umap, const allocator_type& __a) + noexcept( noexcept(_Base(std::move(__umap._M_base()), __a)) ) : _Safe(std::move(__umap._M_safe()), __a), _Base(std::move(__umap._M_base()), __a) { } diff --git a/libstdc++-v3/include/debug/unordered_set b/libstdc++-v3/include/debug/unordered_set index 37031da947e..94dde0d0ded 100644 --- a/libstdc++-v3/include/debug/unordered_set +++ b/libstdc++-v3/include/debug/unordered_set @@ -141,6 +141,7 @@ namespace __debug unordered_set(unordered_set&& __uset, const allocator_type& __a) + noexcept( noexcept(_Base(std::move(__uset._M_base()), __a)) ) : _Safe(std::move(__uset._M_safe()), __a), _Base(std::move(__uset._M_base()), __a) { } @@ -717,6 +718,7 @@ namespace __debug unordered_multiset(unordered_multiset&& __uset, const allocator_type& __a) + noexcept( noexcept(_Base(std::move(__uset._M_base()), __a)) ) : _Safe(std::move(__uset._M_safe()), __a), _Base(std::move(__uset._M_base()), __a) { } diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/default_init.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/default_init.cc new file mode 100644 index 00000000000..473a5f1ce47 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/default_init.cc @@ -0,0 +1,69 @@ +// Copyright (C) 2020 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 +// . + +// { dg-do run { target c++11 } } +// { dg-options "-O0" } +// { dg-xfail-run-if "PR c++/65816" { *-*-* } } + +#include +#include +#include + +#include + +using T = int; + +using __gnu_test::default_init_allocator; + +void test01() +{ + typedef default_init_allocator> alloc_type; + typedef std::unordered_map, std::equal_to, + alloc_type> test_type; + + __gnu_cxx::__aligned_buffer buf; + __builtin_memset(buf._M_addr(), ~0, sizeof(test_type)); + + test_type *tmp = ::new(buf._M_addr()) test_type; + + VERIFY( tmp->get_allocator().state == 0 ); + + tmp->~test_type(); +} + +void test02() +{ + typedef default_init_allocator> alloc_type; + typedef std::unordered_map, std::equal_to, + alloc_type> test_type; + + __gnu_cxx::__aligned_buffer buf; + __builtin_memset(buf._M_addr(), ~0, sizeof(test_type)); + + test_type *tmp = ::new(buf._M_addr()) test_type(); + + VERIFY( tmp->get_allocator().state == 0 ); + + tmp->~test_type(); +} + +int main() +{ + test01(); + test02(); + return 0; +} diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/noexcept_default_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/noexcept_default_construct.cc new file mode 100644 index 00000000000..f859ec939d0 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/noexcept_default_construct.cc @@ -0,0 +1,68 @@ +// Copyright (C) 2020 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 +// . + +// { dg-do compile { target c++11 } } + +#include + +using type1 = std::unordered_map; + +static_assert(std::is_nothrow_default_constructible::value, + "noexcept default constructible"); + +struct not_noexcept_dflt_cons_hash +{ + not_noexcept_dflt_cons_hash() /* noexcept */; + + std::size_t + operator()(int) const noexcept; +}; + +using type2 = std::unordered_map; + +static_assert( !std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); + +struct not_noexcept_dflt_cons_equal_to +{ + not_noexcept_dflt_cons_equal_to() /* noexcept */; + + bool + operator()(int, int) const noexcept; +}; + +using type3 = std::unordered_map, + not_noexcept_dflt_cons_equal_to>; + +static_assert( !std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); + +template + struct not_noexcept_dflt_cons_alloc : std::allocator<_Tp> + { + not_noexcept_dflt_cons_alloc() /* noexcept */; + + template + struct rebind + { typedef not_noexcept_dflt_cons_alloc<_Tp1> other; }; + }; + +using type4 = std::unordered_map, std::equal_to, + not_noexcept_dflt_cons_alloc>>; + +static_assert(!std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/noexcept_move_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/noexcept_move_construct.cc new file mode 100644 index 00000000000..99852b248d0 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/noexcept_move_construct.cc @@ -0,0 +1,65 @@ +// { dg-do compile { target c++11 } } + +// Copyright (C) 2020 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 +// . + +#include + +using type1 = std::unordered_map; + +static_assert( std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( std::is_nothrow_constructible::value, + "noexcept move constructor with allocator" ); + +struct not_noexcept_copy_cons_hash +{ + not_noexcept_copy_cons_hash() noexcept; + not_noexcept_copy_cons_hash(const not_noexcept_copy_cons_hash&) /* noexcept */; + not_noexcept_copy_cons_hash(not_noexcept_copy_cons_hash&&) noexcept; + + std::size_t + operator()(int) const noexcept; +}; + +using type2 = std::unordered_map; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::value, + "not noexcept move constructor with allocator" ); + +struct not_noexcept_copy_cons_equal_to +{ + not_noexcept_copy_cons_equal_to() noexcept; + not_noexcept_copy_cons_equal_to(const not_noexcept_copy_cons_equal_to&) /* noexcept */; + not_noexcept_copy_cons_equal_to(not_noexcept_copy_cons_equal_to&&) noexcept; + + bool + operator()(int, int) const noexcept; +}; + +using type3 = std::unordered_map, + not_noexcept_copy_cons_equal_to>; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::value, + "not noexcept move constructor with allocator" ); diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/modifiers/move_assign.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/modifiers/move_assign.cc new file mode 100644 index 00000000000..0a5ef1113d9 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_map/modifiers/move_assign.cc @@ -0,0 +1,81 @@ +// { dg-do compile { target c++11 } } + +// Copyright (C) 2020 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 +// . + +#include +#include +#include + +#include +#include +#include + +void test01() +{ + using namespace std; + using __gnu_test::counter_type; + + std::vector> insts { { 0, 0 }, { 1, 1 }, { 2, 2 } }; + typedef unordered_map Map; + Map m; + + counter_type::reset(); + + m.insert(make_move_iterator(insts.begin()), make_move_iterator(insts.end())); + + VERIFY( m.size() == 3 ); + VERIFY( counter_type::default_count == 0 ); + VERIFY( counter_type::copy_count == 0 ); + VERIFY( counter_type::move_count == 3 ); +} + +void test02() +{ + using namespace std; + using __gnu_test::counter_type; + using __gnu_test::propagating_allocator; + + typedef propagating_allocator, false> Alloc; + typedef unordered_map, equal_to, + Alloc> Map; + + Alloc a1(1); + Map m1(3, a1); + m1 = { { 0, 0 }, { 1, 1 }, { 2, 2 } }; + Alloc a2(2); + Map m2(3, a2); + m2 = { { 3, 0 }, { 4, 1 }, { 5, 2 } }; + + counter_type::reset(); + + m2 = move(m1); + + VERIFY( m1.empty() ); + VERIFY( m2.size() == 3 ); + VERIFY( counter_type::default_count == 0 ); + VERIFY( counter_type::copy_count == 0 ); + VERIFY( counter_type::move_count == 3 ); +} + +int main() +{ + test01(); + test02(); + return 0; +} diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/noexcept_default_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/noexcept_default_construct.cc new file mode 100644 index 00000000000..98e2b017ca9 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/noexcept_default_construct.cc @@ -0,0 +1,68 @@ +// Copyright (C) 2020 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 +// . + +// { dg-do compile { target c++11 } } + +#include + +using type1 = std::unordered_multimap; + +static_assert(std::is_nothrow_default_constructible::value, + "noexcept default constructible"); + +struct not_noexcept_dflt_cons_hash +{ + not_noexcept_dflt_cons_hash() /* noexcept */; + + std::size_t + operator()(int) const noexcept; +}; + +using type2 = std::unordered_multimap; + +static_assert( !std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); + +struct not_noexcept_dflt_cons_equal_to +{ + not_noexcept_dflt_cons_equal_to() /* noexcept */; + + bool + operator()(int, int) const noexcept; +}; + +using type3 = std::unordered_multimap, + not_noexcept_dflt_cons_equal_to>; + +static_assert( !std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); + +template + struct not_noexcept_dflt_cons_alloc : std::allocator<_Tp> + { + not_noexcept_dflt_cons_alloc() /* noexcept */; + + template + struct rebind + { typedef not_noexcept_dflt_cons_alloc<_Tp1> other; }; + }; + +using type4 = std::unordered_multimap, std::equal_to, + not_noexcept_dflt_cons_alloc>>; + +static_assert(!std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/noexcept_move_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/noexcept_move_construct.cc new file mode 100644 index 00000000000..1d60c0184eb --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/noexcept_move_construct.cc @@ -0,0 +1,65 @@ +// { dg-do compile { target c++11 } } + +// Copyright (C) 2020 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 +// . + +#include + +using type1 = std::unordered_multimap; + +static_assert( std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( std::is_nothrow_constructible::value, + "noexcept move constructor with allocator" ); + +struct not_noexcept_copy_cons_hash +{ + not_noexcept_copy_cons_hash() noexcept; + not_noexcept_copy_cons_hash(const not_noexcept_copy_cons_hash&) /* noexcept */; + not_noexcept_copy_cons_hash(not_noexcept_copy_cons_hash&&) noexcept; + + std::size_t + operator()(int) const noexcept; +}; + +using type2 = std::unordered_multimap; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::value, + "not noexcept move constructor with allocator" ); + +struct not_noexcept_copy_cons_equal_to +{ + not_noexcept_copy_cons_equal_to() noexcept; + not_noexcept_copy_cons_equal_to(const not_noexcept_copy_cons_equal_to&) /* noexcept */; + not_noexcept_copy_cons_equal_to(not_noexcept_copy_cons_equal_to&&) noexcept; + + bool + operator()(int, int) const noexcept; +}; + +using type3 = std::unordered_multimap, + not_noexcept_copy_cons_equal_to>; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::value, + "not noexcept move constructor with allocator" ); diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/noexcept_default_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/noexcept_default_construct.cc new file mode 100644 index 00000000000..b7c0d802125 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/noexcept_default_construct.cc @@ -0,0 +1,68 @@ +// Copyright (C) 2020 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 +// . + +// { dg-do compile { target c++11 } } + +#include + +using type1 = std::unordered_multiset; + +static_assert(std::is_nothrow_default_constructible::value, + "noexcept default constructible"); + +struct not_noexcept_dflt_cons_hash +{ + not_noexcept_dflt_cons_hash() /* noexcept */; + + std::size_t + operator()(int) const noexcept; +}; + +using type2 = std::unordered_multiset; + +static_assert( !std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); + +struct not_noexcept_dflt_cons_equal_to +{ + not_noexcept_dflt_cons_equal_to() /* noexcept */; + + bool + operator()(int, int) const noexcept; +}; + +using type3 = std::unordered_multiset, + not_noexcept_dflt_cons_equal_to>; + +static_assert( !std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); + +template + struct not_noexcept_dflt_cons_alloc : std::allocator<_Tp> + { + not_noexcept_dflt_cons_alloc() /* noexcept */; + + template + struct rebind + { typedef not_noexcept_dflt_cons_alloc<_Tp1> other; }; + }; + +using type4 = std::unordered_multiset, std::equal_to, + not_noexcept_dflt_cons_alloc>>; + +static_assert(!std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/noexcept_move_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/noexcept_move_construct.cc new file mode 100644 index 00000000000..dd0e4ca920b --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/noexcept_move_construct.cc @@ -0,0 +1,65 @@ +// { dg-do compile { target c++11 } } + +// Copyright (C) 2020 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 +// . + +#include + +using type1 = std::unordered_multiset; + +static_assert( std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( std::is_nothrow_constructible::value, + "noexcept move constructor with allocator" ); + +struct not_noexcept_copy_cons_hash +{ + not_noexcept_copy_cons_hash() noexcept; + not_noexcept_copy_cons_hash(const not_noexcept_copy_cons_hash&) /* noexcept */; + not_noexcept_copy_cons_hash(not_noexcept_copy_cons_hash&&) noexcept; + + std::size_t + operator()(int) const noexcept; +}; + +using type2 = std::unordered_multiset; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::value, + "not noexcept move constructor with allocator" ); + +struct not_noexcept_copy_cons_equal_to +{ + not_noexcept_copy_cons_equal_to() noexcept; + not_noexcept_copy_cons_equal_to(const not_noexcept_copy_cons_equal_to&) /* noexcept */; + not_noexcept_copy_cons_equal_to(not_noexcept_copy_cons_equal_to&&) noexcept; + + bool + operator()(int, int) const noexcept; +}; + +using type3 = std::unordered_multiset, + not_noexcept_copy_cons_equal_to>; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::value, + "not noexcept move constructor with allocator" ); diff --git a/libstdc++-v3/testsuite/23_containers/unordered_set/allocator/default_init.cc b/libstdc++-v3/testsuite/23_containers/unordered_set/allocator/default_init.cc new file mode 100644 index 00000000000..37110dd6eb0 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_set/allocator/default_init.cc @@ -0,0 +1,69 @@ +// Copyright (C) 2020 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 +// . + +// { dg-do run { target c++11 } } +// { dg-options "-O0" } +// { dg-xfail-run-if "PR c++/65816" { *-*-* } } + +#include +#include +#include + +#include + +using T = int; + +using __gnu_test::default_init_allocator; + +void test01() +{ + typedef default_init_allocator alloc_type; + typedef std::unordered_set, std::equal_to, + alloc_type> test_type; + + __gnu_cxx::__aligned_buffer buf; + __builtin_memset(buf._M_addr(), ~0, sizeof(test_type)); + + test_type *tmp = ::new(buf._M_addr()) test_type; + + VERIFY( tmp->get_allocator().state == 0 ); + + tmp->~test_type(); +} + +void test02() +{ + typedef default_init_allocator alloc_type; + typedef std::unordered_set, std::equal_to, + alloc_type> test_type; + + __gnu_cxx::__aligned_buffer buf; + __builtin_memset(buf._M_addr(), ~0, sizeof(test_type)); + + test_type *tmp = ::new(buf._M_addr()) test_type(); + + VERIFY( tmp->get_allocator().state == 0 ); + + tmp->~test_type(); +} + +int main() +{ + test01(); + test02(); + return 0; +} diff --git a/libstdc++-v3/testsuite/23_containers/unordered_set/cons/noexcept_default_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/noexcept_default_construct.cc new file mode 100644 index 00000000000..d60a81ffb7c --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/noexcept_default_construct.cc @@ -0,0 +1,68 @@ +// Copyright (C) 2020 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 +// . + +// { dg-do compile { target c++11 } } + +#include + +using type1 = std::unordered_set; + +static_assert(std::is_nothrow_default_constructible::value, + "noexcept default constructible"); + +struct not_noexcept_dflt_cons_hash +{ + not_noexcept_dflt_cons_hash() /* noexcept */; + + std::size_t + operator()(int) const noexcept; +}; + +using type2 = std::unordered_set; + +static_assert( !std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); + +struct not_noexcept_dflt_cons_equal_to +{ + not_noexcept_dflt_cons_equal_to() /* noexcept */; + + bool + operator()(int, int) const noexcept; +}; + +using type3 = std::unordered_set, + not_noexcept_dflt_cons_equal_to>; + +static_assert( !std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); + +template + struct not_noexcept_dflt_cons_alloc : std::allocator<_Tp> + { + not_noexcept_dflt_cons_alloc() /* noexcept */; + + template + struct rebind + { typedef not_noexcept_dflt_cons_alloc<_Tp1> other; }; + }; + +using type4 = std::unordered_set, std::equal_to, + not_noexcept_dflt_cons_alloc>>; + +static_assert(!std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); diff --git a/libstdc++-v3/testsuite/23_containers/unordered_set/cons/noexcept_move_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/noexcept_move_construct.cc new file mode 100644 index 00000000000..9be5ed07a33 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/noexcept_move_construct.cc @@ -0,0 +1,65 @@ +// { dg-do compile { target c++11 } } + +// Copyright (C) 2020 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 +// . + +#include + +using type1 = std::unordered_set; + +static_assert( std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( std::is_nothrow_constructible::value, + "noexcept move constructor with allocator" ); + +struct not_noexcept_copy_cons_hash +{ + not_noexcept_copy_cons_hash() noexcept; + not_noexcept_copy_cons_hash(const not_noexcept_copy_cons_hash&) /* noexcept */; + not_noexcept_copy_cons_hash(not_noexcept_copy_cons_hash&&) noexcept; + + std::size_t + operator()(int) const noexcept; +}; + +using type2 = std::unordered_set; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::value, + "not noexcept move constructor with allocator" ); + +struct not_noexcept_copy_cons_equal_to +{ + not_noexcept_copy_cons_equal_to() noexcept; + not_noexcept_copy_cons_equal_to(const not_noexcept_copy_cons_equal_to&) /* noexcept */; + not_noexcept_copy_cons_equal_to(not_noexcept_copy_cons_equal_to&&) noexcept; + + bool + operator()(int, int) const noexcept; +}; + +using type3 = std::unordered_set, + not_noexcept_copy_cons_equal_to>; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::value, + "not noexcept move constructor with allocator" ); --------------B4279385FA08A711E91FCB06--