This is an archive of the discontinued LLVM Phabricator instance.

Differential D12486

std::experimental::propagate_const from LFTS v2
ClosedPublic

Authored by jbcoe on Aug 30 2015, 3:01 PM.

Details

Reviewers
mclow.lists
EricWF
Commits
rG945cacc8424b: Implement std::experimental::propagate_const from LFTS v2
rCXX273122: Implement std::experimental::propagate_const from LFTS v2
rL273122: Implement std::experimental::propagate_const from LFTS v2
Summary

An implementation of std::experimental::propagate_const from Library Fundamentals Technical Specification v2.

Tests are provided for specified behaviour (including non-compiling code by checking type_traits).

No tests are provided for disallowed types like fancy pointers or function pointers as no code was written to handle these.

Diff Detail

Event Timeline

jbcoe updated this revision to Diff 33549.Aug 30 2015, 3:01 PM
jbcoe retitled this revision from to std::experimental::propagate_const from LFTS v2.
jbcoe updated this object.
jbcoe added reviewers: mclow.lists, EricWF.
EricWF edited edge metadata.Aug 30 2015, 3:17 PM

Awesome and thanks for doing this. I've added some drive-by comments but I haven't really looked at it yet.

I'll start trying to figure out how libc++ should manage shipping both LFTS v1 and LFTS v2 headers.

include/experimental/propagate_const
131

Anything that isn't in the draft should use a reserved name. So this should probably be __get_pointer.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.fail.cpp
22

If the test types X and Y are the same in every test then please lift them into a test header.

EricWF added inline comments.Aug 30 2015, 3:17 PM
include/experimental/propagate_const
12

_LIBCPP_EXPERIMENTAL_PROPAGATE_CONST please.

127

_VSTD::declval to prevent ADL.

jbcoe added a comment.Aug 30 2015, 3:23 PM

Is there a good way to see if tests that fail (as expected) are failing for the right reason?

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.fail.cpp
22

X is always the same and Y is nearly always the same. I can split Y into Y and Y_explicit.
I assume that the test header would go in the root of the propagate_const tests directory?

EricWF added a comment.Aug 30 2015, 3:41 PM
In D12486#236149, @jbcoe wrote:

Is there a good way to see if tests that fail (as expected) are failing for the right reason?

Yes. We use clang verify (http://clang.llvm.org/doxygen/classclang_1_1VerifyDiagnosticConsumer.html#details) to check compilation failure tests. If a *.fail.cpp test contains any verify directives (// expected-{note,warning,error}) then that test is run using clang verify automatically.

Take a look at the following tests for examples:

  • std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/default01.fail.cpp
  • std/thread/futures/futures.promise/copy_ctor.fail.cpp

You only have to supply the expected diagnostics for errors and not notes. Let me know if I can make anything more clear.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.fail.cpp
22

I would put the header in libcxx/test/support which is an include directory that all tests share.

jbcoe updated this revision to Diff 33635.Aug 31 2015, 2:59 PM
jbcoe edited edge metadata.

Refactor tests to use helper classes.

Add __ to get_underlying.

Use _VSTD:: for declval to prevent ADL-induced name clashes.

jbcoe marked 5 inline comments as done.Aug 31 2015, 3:01 PM
jbcoe updated this revision to Diff 33636.Aug 31 2015, 3:04 PM

Correctly add _VSTD:: to declval in definition of element_type.

jbcoe marked an inline comment as done.Aug 31 2015, 3:05 PM
jbcoe updated this revision to Diff 33745.Sep 1 2015, 3:31 PM

Correct spelling of 'Constructable'

mclow.lists edited edge metadata.Sep 8 2015, 12:07 PM
In D12486#237757, @jbcoe wrote:

Correct spelling of 'Constructable'

While I approve of this cleanup, I don't think it belongs here - and makes reviewing the propogate_const stuff harder.

jbcoe added a comment.Sep 9 2015, 1:06 PM

This was utterly unintentional and very embarassing. I only mean to amend the propagate-const files.
I'll revert and update the patch.

jbcoe updated this revision to Diff 34364.Sep 9 2015, 1:13 PM
jbcoe edited edge metadata.

Undo spelling correction as it touched many more files than intended.

EricWF added a comment.Oct 6 2015, 5:12 PM

First I think the header is in great shape. I reviewed the constructors and they look good other than the inline nits. I would like to see some more tests though. If a constructor is constexpr then it should have a constexpr test.

I'll try and go through another section of it later this week.

include/experimental/propagate_const
25

s/__propagate/propagate

113

You'll want to add this below the include:

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
155

Use a reserved name. ie __is_propagate_const.

171

Just use = default directly. Other C++14 headers already do. Currently this constructor won't compile when _LIBCPP_DEFAULT evaluates to {}

175

Same as above.

177

is_convertible<Tp&&, Up> should be equivalent to is_convertible<Tp, Up>.I don't know why the LFTS draft adds the extra reference qualifiers but I"m 95% sure its redundant because declval<Tp>() should already do this for you.

209

Same as above. Don't use _LIBCPP_DEFAULT here.

jbcoe updated this revision to Diff 37709.Oct 18 2015, 7:00 AM

Address comments from Eric's review. Constexpr tests outstanding (How do I do this?).

jbcoe marked 7 inline comments as done.Oct 18 2015, 7:01 AM
jbcoe updated this revision to Diff 37710.Oct 18 2015, 9:10 AM

constexpr fixes and addition of constexpr to some tests.

I cannot get operator element_type* to work with constexpr - some input here would be good.

jbcoe updated this revision to Diff 37711.Oct 18 2015, 9:14 AM

Use _LIBCXX_CONSTEXPR not constexpr

jbcoe abandoned this revision.Jan 18 2016, 1:34 PM
jbcoe reclaimed this revision.Jan 18 2016, 2:53 PM

Abandoned in error.

EricWF added a comment.Jan 18 2016, 3:01 PM

Phew! I'll try and look through more of this tomorrow.

jbcoe added inline comments.Mar 4 2016, 6:17 PM
test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.fail.cpp
26

Y is undefined this needs fixing, compiling this file fails for the wrong reason

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
15

This comment is not right.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.fail.cpp
23

Y is undefined. compilation fails for the wrong reason.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.fail.cpp
23

Y is undefined. compilation fails for the wrong reason.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.fail.cpp
23

Y is undefined. compilation fails for the wrong reason.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp
27

if this is made global then this test will do what's required.

test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp
37

a test for non-member swap may be needed (just below)

jbcoe marked an inline comment as done.Mar 5 2016, 3:25 PM
jbcoe planned changes to this revision.Mar 22 2016, 4:18 AM
mclow.lists added a comment.Apr 13 2016, 8:47 AM

All the comments seem to be about the tests, which is good (and bad). Good, since the code seems to be pretty solid; bad because it means the tests need more work.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
30

"Will not compile" ?? -- in a test named "xxx.pass.cpp"? Which is correct? The test, the name of the test, or the comment?

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp
28

"Will not compile" ?? -- in a test named "xxx.pass.cpp"? Which is correct? The test, the name of the test, or the comment?

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
23

Is there some reason that you shouldn't just say:

bool operator<=(const X& lhs, const X& rhs) { return lhs.i <= rhs.i; }

and not open up namespace std?

jbcoe updated this revision to Diff 55188.Apr 27 2016, 4:59 AM
jbcoe marked 9 inline comments as done.

Corrections from Marshall's review.

jbcoe added inline comments.Apr 27 2016, 5:01 AM
test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
15

On reflection it looks ok.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
30

Removed spurious comment.

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
24

no. I've updated code to be more concise.

jbcoe added a comment.May 12 2016, 1:55 PM

Is more work required on this?

mclow.lists added a comment.May 23 2016, 5:26 PM

Jonathan - if you're happy with all the tests, especially if the failing tests fail for the right reasons, then I'm happy with you committing it.

EricWF added a comment.May 23 2016, 6:34 PM

I have some feedback before committing. I'll submit it shortly.

include/experimental/propagate_const
129

Please add static asserts before this that check 3.7.3[propagate_const.requirments]. This will lead to much nicer diagnostics.

EricWF added a comment.May 23 2016, 8:29 PM

Many of your failure tests can be rewritten as .pass.cpp tests using type traits. Esspecially the ones for the ctors.

For example convertible_element_type.explicit.ctor.fail.cpp can be written as a single static assertion.

static_assert(!is_convertible<int, propagate_const<ExplicitX>>::value, "");

Other than those changes this LGTM like Marshall said.

include/experimental/propagate_const
276

This call should be unqualified. It can't be implemented directly within the class though. I would do "_VSTD_LFTS_V2::swap(*this, __pt)" here. Please add a test for this of the form:

c++

bool swap_called = false;
void swap(X&, X&) {swap_called = true;}

int main() {
  typedef propagate_const<X> P;
  P p1(1);
  P p2(2);
  p1.swap(p2);
  assert(swap_called);
}
285

All calls to get_underlying should to be qualified with _VSTD_LFTS_V2. Currently all uses of get_underlying generate a perfect match with the two overloads we provide so it won't be hijacked by ADL but that may change.

EricWF added a comment.May 23 2016, 9:45 PM

FYI I generated some code coverage results for this patch: They can be found here http://efcs.ca/const-coverage/include/experimental/propagate_const.gcov.html.

The stats are misleading because uninstantiated templates aren't counted as uncovered.

jbcoe updated this revision to Diff 58217.May 24 2016, 4:10 AM

All tests are now 'pass' tests as static assert can be used to check for invalid type traits for previous failure cases.

jbcoe updated this object.May 24 2016, 4:13 AM
EricWF added a comment.May 24 2016, 2:28 PM

Once the swap issue is resolved I think this is good to go. @jbcoe do you have commit access?

EricWF resigned from this revision.May 31 2016, 12:47 AM
EricWF removed a reviewer: EricWF.
EricWF added a reviewer: EricWF.
EricWF added a subscriber: EricWF.

Woops, I thought this had landed.

jbcoe updated this revision to Diff 59775.Jun 6 2016, 1:27 PM

ADL-focused fixes from Eric's review (thanks for this).

jbcoe marked 4 inline comments as done.Jun 6 2016, 1:30 PM
jbcoe added inline comments.
include/experimental/propagate_const
130

Do you mean in the class body?

jbcoe updated this revision to Diff 59789.Jun 6 2016, 2:40 PM

Add static_asserts to class body for constraints on template type.

jbcoe marked 2 inline comments as done.Jun 6 2016, 2:41 PM
jbcoe added inline comments.
include/experimental/propagate_const
131

I can't see what else you might mean. Perhaps I could add enable_if's but I followed the approach taken in optional.

jbcoe marked an inline comment as done.Jun 8 2016, 1:15 AM
jbcoe added a comment.Jun 17 2016, 3:25 PM

I think I've addressed all comments. Is anything outstanding or is this good to go?

mclow.lists added a comment.Jun 17 2016, 4:41 PM

I've got nothing else. LGTM.

mclow.lists accepted this revision.Jun 17 2016, 4:41 PM
mclow.lists edited edge metadata.
This revision is now accepted and ready to land.Jun 17 2016, 4:41 PM
jbcoe updated this revision to Diff 61198.Jun 19 2016, 4:46 AM
jbcoe edited edge metadata.

Resolve conflict with upstream master to allow arc to apply patch.

Closed by commit rL273122: Implement std::experimental::propagate_const from LFTS v2 (authored by jbcoe). · Explain WhyJun 19 2016, 12:41 PM
This revision was automatically updated to reflect the committed changes.

Large Diff

This large diff affects 219 files. Files without inline comments have been collapsed. Expand All Files

Revision Contents

PathSize
include/
experimental/
4 lines
559 lines
test/
std/
algorithms/
alg.modifying.operations/
alg.copy/
2 lines
alg.generate/
2 lines
2 lines
alg.partitions/
2 lines
2 lines
alg.remove/
2 lines
2 lines
alg.replace/
2 lines
2 lines
alg.transform/
2 lines
2 lines
alg.unique/
2 lines
4 lines
2 lines
alg.nonmodifying/
alg.adjacent.find/
2 lines
alg.count/
2 lines
alg.equal/
2 lines
alg.find.end/
2 lines
alg.find.first.of/
2 lines
alg.find/
2 lines
2 lines
alg.foreach/
2 lines
mismatch/
2 lines
alg.sorting/
alg.heap.operations/
is.heap/
2 lines
make.heap/
2 lines
pop.heap/
2 lines
sort.heap/
2 lines
alg.binary.search/
binary.search/
2 lines
equal.range/
2 lines
upper.bound/
2 lines
alg.lex.comparison/
2 lines
alg.merge/
2 lines
2 lines
alg.min.max/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
alg.nth.element/
2 lines
alg.permutation.generators/
2 lines
2 lines
alg.set.operations/
set.difference/
2 lines
set.intersection/
2 lines
set.symmetric.difference/
2 lines
set.union/
2 lines
alg.sort/
is.sorted/
2 lines
2 lines
partial.sort.copy/
2 lines
partial.sort/
2 lines
sort/
2 lines
stable.sort/
2 lines
containers/
14 lines
sequences/
deque/
deque.cons/
6 lines
6 lines
forwardlist/
forwardlist.cons/
4 lines
6 lines
forwardlist.modifiers/
6 lines
vector/
vector.cons/
14 lines
unord/
unord.map/
unord.map.cnstr/
42 lines
34 lines
2 lines
2 lines
2 lines
2 lines
2 lines
34 lines
34 lines
38 lines
42 lines
46 lines
unord.multimap/
unord.multimap.cnstr/
42 lines
34 lines
2 lines
2 lines
2 lines
2 lines
2 lines
34 lines
34 lines
38 lines
42 lines
46 lines
unord.multiset/
unord.multiset.cnstr/
38 lines
30 lines
30 lines
30 lines
34 lines
38 lines
42 lines
unord.set/
unord.set.cnstr/
38 lines
30 lines
16 lines
30 lines
34 lines
38 lines
42 lines
depr/
depr.function.objects/
depr.adaptors/
depr.function.pointer.adaptors/
2 lines
2 lines
depr.member.pointer.adaptors/
2 lines
2 lines
2 lines
2 lines
experimental/
any/
any.class/
any.assign/
2 lines
any.cons/
2 lines
any.nonmembers/
any.cast/
4 lines
utilities/
propagate_const/
propagate_const.class/
propagate_const.assignment/
30 lines
34 lines
31 lines
34 lines
32 lines
33 lines
33 lines
propagate_const.ctors/
31 lines
32 lines
29 lines
33 lines
31 lines
28 lines
30 lines
30 lines
28 lines
propagate_const.non-const_observers/
30 lines
31 lines
31 lines
29 lines
35 lines
propagate_const.observers/
29 lines
29 lines
29 lines
29 lines
31 lines
40 lines
propagate_const.nonmembers/
44 lines
propagate_const.comparison_function_objects/
47 lines
49 lines
49 lines
49 lines
49 lines
47 lines
propagate_const.relops/
64 lines
54 lines
50 lines
55 lines
50 lines
62 lines
40 lines
iterators/
predef.iterators/
insert.iterators/
back.insert.iter.ops/
back.insert.iter.op=/
2 lines
2 lines
insert.iter.ops/
insert.iter.op=/
2 lines
2 lines
numerics/
numeric.ops/
accumulate/
2 lines
4 lines
adjacent.difference/
2 lines
4 lines
inner.product/
2 lines
6 lines
partial.sum/
2 lines
4 lines
utilities/
function.objects/
bind/
func.bind/
func.bind.bind/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
func.memfn/
2 lines
2 lines
2 lines
2 lines
func.wrap/
func.wrap.func/
func.wrap.func.alg/
2 lines
func.wrap.func.con/
2 lines
func.wrap.func.nullptr/
8 lines
2 lines
refwrap/
2 lines
memory/
unique.ptr/
unique.ptr.runtime/
2 lines
unique.ptr.runtime.ctor/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
unique.ptr.single/
unique.ptr.single.asgn/
2 lines
unique.ptr.single.ctor/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
12 lines
utility/
utility.swap/
2 lines
support/
119 lines

Diff 33745

include/experimental/__config

include/experimental/propagate_const

  • This file was added.
// -*- C++ -*-
//===------------------------ propagate_const -----------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
#define _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
EricWFUnsubmitted
Done
ReplyInline Actions

_LIBCPP_EXPERIMENTAL_PROPAGATE_CONST please.

EricWF: `_LIBCPP_EXPERIMENTAL_PROPAGATE_CONST` please.
/*
propagate_const synopsis
namespace std { namespace experimental { inline namespace fundamentals_v2 {
// [propagate_const]
template <class T> class propagate_const;
// [propagate_const.underlying], underlying pointer access
constexpr const _Tp& get_underlying(const propagate_const<T>& pt) noexcept;
constexpr T& get_underlying(__propagate_const<T>& pt) noexcept;
EricWFUnsubmitted
Done
ReplyInline Actions

s/__propagate/propagate

EricWF: s/__propagate/propagate
// [propagate_const.relational], relational operators
template <class T> constexpr bool operator==(const propagate_const<T>& pt, nullptr_t);
template <class T> constexpr bool operator==(nullptr_t, const propagate_const<T>& pu);
template <class T> constexpr bool operator!=(const propagate_const<T>& pt, nullptr_t);
template <class T> constexpr bool operator!=(nullptr_t, const propagate_const<T>& pu);
template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const _Up& u);
template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const _Up& u);
template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const _Up& u);
template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const _Up& u);
template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const _Up& u);
template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const _Up& u);
template <class T, class U> constexpr bool operator==(const _Tp& t, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator!=(const _Tp& t, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator<(const _Tp& t, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator>(const _Tp& t, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator<=(const _Tp& t, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator>=(const _Tp& t, const propagate_const<_Up>& pu);
// [propagate_const.algorithms], specialized algorithms
template <class T> constexpr void swap(propagate_const<T>& pt, propagate_const<T>& pu) noexcept(see below);
template <class T>
class propagate_const
{
public:
typedef remove_reference_t<decltype(*declval<T&>())> element_type;
// [propagate_const.ctor], constructors
constexpr propagate_const() = default;
propagate_const(const propagate_const& p) = delete;
constexpr propagate_const(propagate_const&& p) = default;
template <class U> EXPLICIT constexpr propagate_const(propagate_const<_Up>&& pu); // see below
template <class U> EXPLICIT constexpr propagate_const(U&& u); // see below
// [propagate_const.assignment], assignment
propagate_const& operator=(const propagate_const& p) = delete;
constexpr propagate_const& operator=(propagate_const&& p) = default;
template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
template <class U> constexpr propagate_const& operator=(U&& u); // see below
// [propagate_const.const_observers], const observers
explicit constexpr operator bool() const;
constexpr const element_type* operator->() const;
constexpr operator const element_type*() const; // Not always defined
constexpr const element_type& operator*() const;
constexpr const element_type* get() const;
// [propagate_const.non_const_observers], non-const observers
constexpr element_type* operator->();
constexpr operator element_type*(); // Not always defined
constexpr element_type& operator*();
constexpr element_type* get();
// [propagate_const.modifiers], modifiers
constexpr void swap(propagate_const& pt) noexcept(see below)
private:
T t_; // exposition only
};
} // namespace fundamentals_v2
} // namespace experimental
// [propagate_const.hash], hash support
template <class T> struct hash<experimental::fundamentals_v2::propagate_const<T>>;
// [propagate_const.comparison_function_objects], comparison function objects
template <class T> struct equal_to<experimental::fundamentals_v2::propagate_const<T>>;
template <class T> struct not_equal_to<experimental::fundamentals_v2::propagate_const<T>>;
template <class T> struct less<experimental::fundamentals_v2::propagate_const<T>>;
template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>;
template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;
} // namespace std
*/
#include <experimental/__config>
#if _LIBCPP_STD_VER > 11
EricWFUnsubmitted
Done
ReplyInline Actions

You'll want to add this below the include:

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
EricWF: You'll want to add this below the include: ``` #if !defined…
#include <type_traits>
#include <utility>
#include <functional>
_LIBCPP_BEGIN_NAMESPACE_LFTS_V2
template <class _Tp>
class propagate_const
{
public:
typedef remove_reference_t<decltype(*_VSTD::declval<_Tp&>())> element_type;
EricWFUnsubmitted
Done
ReplyInline Actions

_VSTD::declval to prevent ADL.

EricWF: `_VSTD::declval` to prevent ADL.
private:
template <class _Up>
EricWFUnsubmitted
Done
ReplyInline Actions

Please add static asserts before this that check 3.7.3[propagate_const.requirments]. This will lead to much nicer diagnostics.

EricWF: Please add static asserts before this that check 3.7.3[propagate_const.requirments]. This will…
static element_type* __get_pointer(_Up* __u)
jbcoeAuthorUnsubmitted
Done
ReplyInline Actions

Do you mean in the class body?

jbcoe: Do you mean in the class body?
{
EricWFUnsubmitted
Done
ReplyInline Actions

Anything that isn't in the draft should use a reserved name. So this should probably be __get_pointer.

EricWF: Anything that isn't in the draft should use a reserved name. So this should probably be…
jbcoeAuthorUnsubmitted
Not Done
ReplyInline Actions

I can't see what else you might mean. Perhaps I could add enable_if's but I followed the approach taken in optional.

jbcoe: I can't see what else you might mean. Perhaps I could add enable_if's but I followed the…
return __u;
}
template <class _Up>
static element_type* __get_pointer(_Up& __u)
{
return __get_pointer(__u.get());
}
template <class _Up>
static const element_type* __get_pointer(const _Up* __u)
{
return __u;
}
template <class _Up>
static const element_type* __get_pointer(const _Up& __u)
{
return __get_pointer(__u.get());
}
template <class _Up>
struct is_propagate_const : false_type
{
EricWFUnsubmitted
Done
ReplyInline Actions

Use a reserved name. ie __is_propagate_const.

EricWF: Use a reserved name. ie `__is_propagate_const`.
};
template <class _Up>
struct is_propagate_const<propagate_const<_Up>> : true_type
{
};
_Tp __t_;
public:
template <class _Up> friend _LIBCPP_CONSTEXPR const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
template <class _Up> friend _LIBCPP_CONSTEXPR _Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
_LIBCPP_CONSTEXPR propagate_const() _LIBCPP_DEFAULT
EricWFUnsubmitted
Done
ReplyInline Actions

Just use = default directly. Other C++14 headers already do. Currently this constructor won't compile when _LIBCPP_DEFAULT evaluates to {}

EricWF: Just use `= default` directly. Other C++14 headers already do. Currently this constructor…
propagate_const(const propagate_const&) = delete;
_LIBCPP_CONSTEXPR propagate_const(propagate_const&&) _LIBCPP_DEFAULT
EricWFUnsubmitted
Done
ReplyInline Actions

Same as above.

EricWF: Same as above.
template <class _Up, enable_if_t<!is_convertible<_Up&&, _Tp>::value &&
is_constructible<_Tp, _Up&&>::value,bool> = true>
EricWFUnsubmitted
Done
ReplyInline Actions

is_convertible<Tp&&, Up> should be equivalent to is_convertible<Tp, Up>.I don't know why the LFTS draft adds the extra reference qualifiers but I"m 95% sure its redundant because declval<Tp>() should already do this for you.

EricWF: `is_convertible<Tp&&, Up>` should be equivalent to `is_convertible<Tp, Up>`.I don't know why…
explicit _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
: __t_(std::move(get_underlying(__pu)))
{
}
template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
is_constructible<_Tp, _Up&&>::value,bool> = false>
_LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
: __t_(std::move(get_underlying(__pu)))
{
}
template <class _Up, enable_if_t<!is_convertible<_Up&&, _Tp>::value &&
is_constructible<_Tp, _Up&&>::value &&
!is_propagate_const<decay_t<_Up>>::value,bool> = true>
explicit _LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
: __t_(std::forward<_Up>(__u))
{
}
template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
is_constructible<_Tp, _Up&&>::value &&
!is_propagate_const<decay_t<_Up>>::value,bool> = false>
_LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
: __t_(std::forward<_Up>(__u))
{
}
propagate_const& operator=(const propagate_const&) = delete;
_LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const&&) _LIBCPP_DEFAULT
EricWFUnsubmitted
Done
ReplyInline Actions

Same as above. Don't use _LIBCPP_DEFAULT here.

EricWF: Same as above. Don't use `_LIBCPP_DEFAULT` here.
template <class _Up>
_LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const<_Up>&& __pu)
{
__t_ = std::move(get_underlying(__pu));
return *this;
}
template <class _Up, class _Vp = enable_if_t<!is_propagate_const<decay_t<_Up>>::value>>
_LIBCPP_CONSTEXPR propagate_const& operator=(_Up&& __u)
{
__t_ = std::forward<_Up>(__u);
return *this;
}
_LIBCPP_CONSTEXPR const element_type* get() const
{
return __get_pointer(__t_);
}
_LIBCPP_CONSTEXPR element_type* get()
{
return __get_pointer(__t_);
}
explicit _LIBCPP_CONSTEXPR operator bool() const
{
return get() != nullptr;
}
_LIBCPP_CONSTEXPR const element_type* operator->() const
{
return get();
}
template <class _Tp_ = _Tp, class _Up = enable_if_t<is_convertible<
const _Tp_, const element_type *>::value>>
operator const element_type *() const {
return get();
}
_LIBCPP_CONSTEXPR const element_type& operator*() const
{
return *get();
}
_LIBCPP_CONSTEXPR element_type* operator->()
{
return get();
}
template <class _Tp_ = _Tp, class _Up = enable_if_t<
is_convertible<_Tp_, element_type *>::value>>
operator element_type *() {
return get();
}
_LIBCPP_CONSTEXPR element_type& operator*()
{
return *get();
}
_LIBCPP_CONSTEXPR void swap(propagate_const& __pt) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
{
_VSTD::swap(__t_, __pt.__t_);
}
};
EricWFUnsubmitted
Done
ReplyInline Actions

This call should be unqualified. It can't be implemented directly within the class though. I would do "_VSTD_LFTS_V2::swap(*this, __pt)" here. Please add a test for this of the form:

c++

bool swap_called = false;
void swap(X&, X&) {swap_called = true;}

int main() {
  typedef propagate_const<X> P;
  P p1(1);
  P p2(2);
  p1.swap(p2);
  assert(swap_called);
}
EricWF: This call should be unqualified. It can't be implemented directly within the class though. I…
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, nullptr_t)
{
return get_underlying(__pt) == nullptr;
}
template <class _Tp>
EricWFUnsubmitted
Done
ReplyInline Actions

All calls to get_underlying should to be qualified with _VSTD_LFTS_V2. Currently all uses of get_underlying generate a perfect match with the two overloads we provide so it won't be hijacked by ADL but that may change.

EricWF: All calls to `get_underlying` should to be qualified with `_VSTD_LFTS_V2`. Currently all uses…
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator==(nullptr_t, const propagate_const<_Tp>& __pt)
{
return nullptr == get_underlying(__pt);
}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t)
{
return get_underlying(__pt) != nullptr;
}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator!=(nullptr_t, const propagate_const<_Tp>& __pt)
{
return nullptr != get_underlying(__pt);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt,
const propagate_const<_Up>& __pu)
{
return get_underlying(__pt) == get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt,
const propagate_const<_Up>& __pu)
{
return get_underlying(__pt) != get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt,
const propagate_const<_Up>& __pu)
{
return get_underlying(__pt) < get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt,
const propagate_const<_Up>& __pu)
{
return get_underlying(__pt) > get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt,
const propagate_const<_Up>& __pu)
{
return get_underlying(__pt) <= get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt,
const propagate_const<_Up>& __pu)
{
return get_underlying(__pt) >= get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u)
{
return get_underlying(__pt) == __u;
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u)
{
return get_underlying(__pt) != __u;
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u)
{
return get_underlying(__pt) < __u;
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u)
{
return get_underlying(__pt) > __u;
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u)
{
return get_underlying(__pt) <= __u;
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u)
{
return get_underlying(__pt) >= __u;
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu)
{
return __t == get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu)
{
return __t != get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu)
{
return __t < get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu)
{
return __t > get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu)
{
return __t <= get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu)
{
return __t >= get_underlying(__pu);
}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR void swap(propagate_const<_Tp>& __pc1, propagate_const<_Tp>& __pc2) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
{
_VSTD::swap(get_underlying(__pc1), get_underlying(__pc2));
}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR const _Tp& get_underlying(const propagate_const<_Tp>& __pt) _NOEXCEPT
{
return __pt.__t_;
}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT
{
return __pt.__t_;
}
_LIBCPP_END_NAMESPACE_LFTS_V2
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp>
struct hash<experimental::fundamentals_v2::propagate_const<_Tp>>
{
typedef size_t result_type;
typedef experimental::fundamentals_v2::propagate_const<_Tp> argument_type;
size_t operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1) const
{
return std::hash<_Tp>()(get_underlying(__pc1));
}
};
template <class _Tp>
struct equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
{
typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
{
return std::equal_to<_Tp>()(get_underlying(__pc1), get_underlying(__pc2));
}
};
template <class _Tp>
struct not_equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
{
typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
{
return std::not_equal_to<_Tp>()(get_underlying(__pc1), get_underlying(__pc2));
}
};
template <class _Tp>
struct less<experimental::fundamentals_v2::propagate_const<_Tp>>
{
typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
{
return std::less<_Tp>()(get_underlying(__pc1), get_underlying(__pc2));
}
};
template <class _Tp>
struct greater<experimental::fundamentals_v2::propagate_const<_Tp>>
{
typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
{
return std::greater<_Tp>()(get_underlying(__pc1), get_underlying(__pc2));
}
};
template <class _Tp>
struct less_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
{
typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
{
return std::less_equal<_Tp>()(get_underlying(__pc1), get_underlying(__pc2));
}
};
template <class _Tp>
struct greater_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
{
typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
{
return std::greater_equal<_Tp>()(get_underlying(__pc1), get_underlying(__pc2));
}
};
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 11
#endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST

test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp

test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp

test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp

test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp

test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp

test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp

test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp

test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp

test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp

test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp

test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp

test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp

test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp

test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp

test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp

test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp

test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp

test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp

test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp

test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp

test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp

test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp

test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp

test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp

test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp

test/std/containers/NotConstructible.h

test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp

test/std/containers/sequences/deque/deque.cons/default.pass.cpp

test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.fail.cpp

test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp

test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp

test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp

test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp

test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp

test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp

test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp

test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp

test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp

test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp

test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp

test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp

test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp

test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp

test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp

test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp

test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp

test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp

test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp

test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp

test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp

test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp

test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.pass.cpp

test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.pass.cpp

test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.pass.cpp

test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.pass.cpp

test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.pass.cpp

test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp

test/std/experimental/any/any.class/any.assign/value_non_copyable_assign.fail.cpp

test/std/experimental/any/any.class/any.cons/non_copyable_value.fail.cpp

test/std/experimental/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.fail.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> propagate_const& propagate_const::operator=(const propagate_const<U>&)=delete;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
int main() {
EricWFUnsubmitted
Done
ReplyInline Actions

If the test types X and Y are the same in every test then please lift them into a test header.

EricWF: If the test types `X` and `Y` are the same in every test then please lift them into a test…
jbcoeAuthorUnsubmitted
Done
ReplyInline Actions

X is always the same and Y is nearly always the same. I can split Y into Y and Y_explicit.
I assume that the test header would go in the root of the propagate_const tests directory?

jbcoe: X is always the same and Y is nearly always the same. I can split Y into Y and Y_explicit. I…
EricWFUnsubmitted
Done
ReplyInline Actions

I would put the header in libcxx/test/support which is an include directory that all tests share.

EricWF: I would put the header in `libcxx/test/support` which is an include directory that all tests…
typedef propagate_const<X> P;
P p1(1);
P p2(2);
p2=p1; // will not compile
}

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.fail.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> constexpr propagate_const& operator=(U&& u); // won't bind to propagate_const
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
int main() {
typedef propagate_const<X> PX;
typedef propagate_const<Y> PY;
jbcoeAuthorUnsubmitted
Done
ReplyInline Actions

Y is undefined this needs fixing, compiling this file fails for the wrong reason

jbcoe: `Y` is undefined this needs fixing, compiling this file fails for the wrong reason
PX px2(2);
PY py1(1);
py1=px2; // won't compile
}

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> propagate_const& propagate_const::operator=(U&&);
jbcoeAuthorUnsubmitted
Done
ReplyInline Actions

This comment is not right.

jbcoe: This comment is not right.
jbcoeAuthorUnsubmitted
Not Done
ReplyInline Actions

On reflection it looks ok.

jbcoe: On reflection it looks ok.
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
int main() {
typedef propagate_const<X> P;
X x1(1);
P p(2);
assert(*p==2);
p = x1;
assert(*p==1);
}

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.fail.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
typedef propagate_const<Y> P;
jbcoeAuthorUnsubmitted
Done
ReplyInline Actions

Y is undefined. compilation fails for the wrong reason.

jbcoe: `Y` is undefined. compilation fails for the wrong reason.
void f(const P& p)
{
}
int main() {
f(X(2)); // will not compile
}

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.fail.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> constexpr propagate_const& operator(propagate_const<_Up>&& pu);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
typedef propagate_const<Y> PY;
typedef propagate_const<X> PX;
jbcoeAuthorUnsubmitted
Done
ReplyInline Actions

Y is undefined. compilation fails for the wrong reason.

jbcoe: `Y` is undefined. compilation fails for the wrong reason.
int main() {
PX px(1);
PY py(px); // will not compile
}

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.fail.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> constexpr propagate_const(propagate_const<_Up>&& pu);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
typedef propagate_const<Y> PY;
typedef propagate_const<X> PX;
jbcoeAuthorUnsubmitted
Done
ReplyInline Actions

Y is undefined. compilation fails for the wrong reason.

jbcoe: `Y` is undefined. compilation fails for the wrong reason.
void f(const PY&)
{
}
int main() {
PX px(1);
f(std::move(px)); // will not compile
}

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.fail.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.fail.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> propagate_const(U&&);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
typedef propagate_const<X> P;
void f(const P&)
{
}
int main() {
f(2); // will not compile
}
mclow.listsUnsubmitted
Done
ReplyInline Actions

"Will not compile" ?? -- in a test named "xxx.pass.cpp"? Which is correct? The test, the name of the test, or the comment?

mclow.lists: "Will not compile" ?? -- in a test named "xxx.pass.cpp"? Which is correct? The test, the name…
jbcoeAuthorUnsubmitted
Done
ReplyInline Actions

Removed spurious comment.

jbcoe: Removed spurious comment.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// propagate_const(propagate_const&&)=default;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
int main() {
typedef propagate_const<X> P;
P p1(2);
P p2(std::move(p1)); // will not compile
}
mclow.listsUnsubmitted
Done
ReplyInline Actions

"Will not compile" ?? -- in a test named "xxx.pass.cpp"? Which is correct? The test, the name of the test, or the comment?

mclow.lists: "Will not compile" ?? -- in a test named "xxx.pass.cpp"? Which is correct? The test, the name…

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.fail.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.fail.cpp

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// propagate_const::operator const element_type*() const;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
int main() {
typedef propagate_const<XWithImplicitConstIntStarConversion> P;
P p(1);
jbcoeAuthorUnsubmitted
Done
ReplyInline Actions

if this is made global then this test will do what's required.

jbcoe: if this is made global then this test will do what's required.
const int* ptr_1 = p;
assert(*ptr_1==1);
}

test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> constexpr void propagate_const::swap(propagate_const<T>& x);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
void swap(X& x, X& y)
{
std::swap(x.i_,y.i_);
}
int main() {
typedef propagate_const<X> P;
P p1_1(1);
P p2_2(2);
assert(*p1_1 == 1);
assert(*p2_2 == 2);
p1_1.swap(p2_2);
jbcoeAuthorUnsubmitted
Done
ReplyInline Actions

a test for non-member swap may be needed (just below)

jbcoe: a test for non-member swap may be needed (just below)
assert(*p1_1 == 2);
assert(*p2_2 == 1);
}

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
namespace std {
template <> struct less_equal<X>
mclow.listsUnsubmitted
Done
ReplyInline Actions

Is there some reason that you shouldn't just say:

bool operator<=(const X& lhs, const X& rhs) { return lhs.i <= rhs.i; }

and not open up namespace std?

mclow.lists: Is there some reason that you shouldn't just say: bool operator<=(const X& lhs, const X&…
{
jbcoeAuthorUnsubmitted
Done
ReplyInline Actions

no. I've updated code to be more concise.

jbcoe: no. I've updated code to be more concise.
typedef X first_argument_type;
typedef X second_argument_type;
constexpr bool operator()(const first_argument_type& x1, const second_argument_type& x2) const
{
return less_equal<int>()(x1.i_,x2.i_);
}
};
} // namespace std
int main() {
typedef propagate_const<X> P;
P p1_1(1);
P p2_1(1);
P p3_2(2);
auto c = std::less_equal<P>();
assert(c(p1_1,p2_1));
assert(c(p2_1,p1_1));
assert(c(p1_1,p3_2));
assert(!c(p3_2,p1_1));
}

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp

test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp

test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp

test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp

test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp

test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp

test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp

test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp

test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp

test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp

test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp

test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp

test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp

test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp

test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp

test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp

test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp

test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp

test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp

test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp

test/std/utilities/function.objects/func.memfn/member_function.pass.cpp

test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp

test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp

test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp

test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp

test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp

test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp

test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp

test/std/utilities/function.objects/refwrap/type_properties.pass.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/move01.pass.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move01.pass.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move02.pass.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert01.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert02.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert03.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert04.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert05.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert06.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert07.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert08.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert09.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert10.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert11.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert12.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert13.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert14.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert15.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert16.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert17.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert18.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter01.pass.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter02.pass.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter03.pass.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter04.pass.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.asgn/move01.pass.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move.pass.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert.pass.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert02.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert03.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert04.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert05.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert06.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert07.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert08.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert09.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert10.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert11.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert12.fail.cpp

test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/pointer_deleter.pass.cpp

test/std/utilities/utility/utility.swap/swap.pass.cpp

test/support/propagate_const_helpers.h