Page MenuHomePhabricator

Please use GitHub pull requests for new patches. Avoid migrating existing patches. Phabricator shutdown timeline

Differential D107932 Diff 366656 libcxx/test/libcxx/ranges/range.nonprop.cache/emplace.pass.cpp

Changeset View

Standalone View

View Options

libcxx/test/libcxx/ranges/range.nonprop.cache/emplace.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-concepts
// UNSUPPORTED: libcpp-has-no-incomplete-ranges
// template<class ...Args>
// constexpr T& __emplace(Args&& ...);
#include <ranges>
#include <cassert>
#include <tuple>
template<int I>
struct X {
int value = -1;
template<int J>
friend constexpr bool operator==(X const& a, X<J> const& b) { return I == J && a.value == b.value; }
};
QuuxplusoneUnsubmitted
Done
ReplyInline Actions

friend constexpr https://quuxplusone.github.io/blog/2021/04/03/static-constexpr-whittling-knife/
and consider line-breaking somewhere.

High-level comment: I'm not sure what benefit you get from the templated operator== or the use of tuple. If you just want something with a couple of weird constructors, why not string?

using Cache = std::ranges::__non_propagating_cache<std::string>;
Cache cache;
std::string& result = cache.__emplace();
assert(&result == &cache.__value() && result == "");

Cache cache;
std::string& result = cache.__emplace("foobar");
assert(&result == &cache.__value() && result == "foobar");

Cache cache;
std::string& result = cache.__emplace("foobar", 3);
assert(&result == &cache.__value() && result == "foo");

In this PR, though, it seems more important to test that it's legal to __emplace a NonMovable, similar to what you did below in the __emplace_deref test.

Quuxplusone: `friend constexpr` https://quuxplusone.github.io/blog/2021/04/03/static-constexpr-whittling…
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

friend constexpr https://quuxplusone.github.io/blog/2021/04/03/static-constexpr-whittling-knife/ and consider line-breaking somewhere.

Done.

High-level comment: I'm not sure what benefit you get from the templated operator== or the use of tuple.

I just want to use any type where I can pass heterogeneous arguments through to the constructor.

In this PR, though, it seems more important to test that it's legal to __emplace a NonMovable, similar to what you did below in the __emplace_deref test.

It's not valid to do that, though, cause there is no way to perform move elision in that case AFAICT.

ldionne: > friend constexpr https://quuxplusone.github.io/blog/2021/04/03/static-constexpr-whittling…
QuuxplusoneUnsubmitted
Done
ReplyInline Actions

In this PR, though, it seems more important to test that it's legal to __emplace a NonMovable

std::ranges::__non_propagating_cache<NonMovable> cache;
NonMovable& result = cache.__emplace();
assert(&result == &*cache);
Quuxplusone: > In this PR, though, it seems more important to test that it's legal to `__emplace` a…
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

Ah, I see what you meant now. Done.

ldionne: Ah, I see what you meant now. Done.
constexpr bool test() {
{
using T = std::tuple<>;
using Cache = std::ranges::__non_propagating_cache<T>;
Cache cache;
T& result = cache.__emplace();
assert(&result == &*cache);
assert(result == T());
}
{
using T = std::tuple<X<0>>;
using Cache = std::ranges::__non_propagating_cache<T>;
Cache cache;
T& result = cache.__emplace();
assert(&result == &*cache);
assert(result == T());
}
{
using T = std::tuple<X<0>>;
using Cache = std::ranges::__non_propagating_cache<T>;
Cache cache;
T& result = cache.__emplace(X<0>{0});
assert(&result == &*cache);
assert(result == T(X<0>{0}));
}
{
using T = std::tuple<X<0>, X<1>>;
using Cache = std::ranges::__non_propagating_cache<T>;
Cache cache;
T& result = cache.__emplace();
assert(&result == &*cache);
assert(result == T());
}
{
using T = std::tuple<X<0>, X<1>>;
using Cache = std::ranges::__non_propagating_cache<T>;
Cache cache;
T& result = cache.__emplace(X<0>{0}, X<1>{1});
assert(&result == &*cache);
assert(result == T(X<0>{0}, X<1>{1}));
}
return true;
}
int main(int, char**) {
static_assert(test());
test();
return 0;
}