Export of internal Abseil changes.

--
89b5e681db1d4f0b039daebb86c49bda77c8931b by Tom Manshreck <shreck@google.com>:

Add clarification that absl::Hash does not produce stable values across instances.

PiperOrigin-RevId: 238316564

--
56dec1d1e37fb2a02aa10d7c81bcd78f8486c093 by Eric Fiselier <ericwf@google.com>:

Add SFINAE to absl::optional::optional(in_place_t, Args...)

This constructor previously didn't have SFINAE because the SFINAE
acted badly when Clang was trying to figure out what special
members to declare. Specifically, while considering copy
constructors it would attempt to call `optional(in_place_t) [ with Args = <>
]`, which evaluated `is_constructible<T>`, which shouldn't have been
evaluated.

This patch avoids the eager SFINAE bug by deducing the in_place_t tag
and short-circuting the SFINAE if the argument passed is not exactly
in_place_t.

I fixed the same bug in libc++ in the same way.

PiperOrigin-RevId: 238290810

--
ffe6d087df495f7f990c89b0a4e1f1664c2c4f9d by Jon Cohen <cohenjon@google.com>:

Remove absl_internal_blah names form CMake.  We are always creating the alias target now, since use of these targets still requires including a header with internal in the name. This simplifies target naming a bit, especially for installation where we have to generate non-prefixed target names to export in the absl:: namespace.

PiperOrigin-RevId: 238280135

--
9d8ae92ff8727fa49391f7f5386810ff81e80aa7 by Derek Mauro <dmauro@google.com>:

Use ABSL_TEST_COPTS for spinlock_benchmark_common and mutex_benchmark_common.
Despite being cc_library, these are really tests and the warning for the
used-but-marked-unused iterator in Google Benchmark needs to be supressed.

PiperOrigin-RevId: 238225200

--
fcde1a79420ce15c8925944c45b69f9fd5226f12 by Matt Armstrong <marmstrong@google.com>:

Qualify calls to certain functions from the cmath library.

PiperOrigin-RevId: 238163972

--
4b931e5ef4ba76961b0e2a9edab1e586ba12dfd4 by Tom Manshreck <shreck@google.com>:

Add clarification that absl::Hash does not produce stable values across instances.

PiperOrigin-RevId: 238125817

--
8963ea8c65cac1e396a72fe77d6eb6a7313d76db by Derek Mauro <dmauro@google.com>:

Fix -Wc++14-binary-literal warning.

PiperOrigin-RevId: 238069157
GitOrigin-RevId: 89b5e681db1d4f0b039daebb86c49bda77c8931b
Change-Id: Ib06f1ee8efcddb7e2f332bc5bf1c1325458e1073
This commit is contained in:
Abseil Team 2019-03-13 14:59:43 -07:00 committed by vslashg
parent 256be56344
commit 7c7754fb3e
8 changed files with 64 additions and 32 deletions

View file

@ -35,13 +35,13 @@ set(ABSL_IDE_FOLDER Abseil)
# COPTS: List of private compile options
# DEFINES: List of public defines
# LINKOPTS: List of link options
# PUBLIC: Add this so that this library will be exported under absl:: (see Note).
# PUBLIC: Add this so that this library will be exported under absl::
# Also in IDE, target will appear in Abseil folder while non PUBLIC will be in Abseil/internal.
# TESTONLY: When added, this target will only be built if user passes -DABSL_RUN_TESTS=ON to CMake.
#
# Note:
# By default, absl_cc_library will always create a library named absl_internal_${NAME},
# and alias target absl::${NAME}.
# By default, absl_cc_library will always create a library named absl_${NAME},
# and alias target absl::${NAME}. The absl:: form should always be used.
# This is to reduce namespace pollution.
#
# absl_cc_library(
@ -83,11 +83,7 @@ function(absl_cc_library)
)
if (NOT ABSL_CC_LIB_TESTONLY OR ABSL_RUN_TESTS)
if (ABSL_CC_LIB_PUBLIC)
set(_NAME "absl_${ABSL_CC_LIB_NAME}")
else()
set(_NAME "absl_internal_${ABSL_CC_LIB_NAME}")
endif()
set(_NAME "absl_${ABSL_CC_LIB_NAME}")
# Check if this is a header-only library
# Note that as of February 2019, many popular OS's (for example, Ubuntu

View file

@ -326,7 +326,7 @@ cc_library(
name = "spinlock_benchmark_common",
testonly = 1,
srcs = ["internal/spinlock_benchmark.cc"],
copts = ABSL_DEFAULT_COPTS,
copts = ABSL_TEST_COPTS,
visibility = [
"//absl/base:__pkg__",
],

View file

@ -241,7 +241,7 @@ absl_cc_test(
"throw_delegate_test.cc"
DEPS
absl::base
absl_internal_throw_delegate
absl::throw_delegate
gtest_main
)

View file

@ -135,14 +135,14 @@ TEST(BitMask, WithShift) {
}
TEST(BitMask, LeadingTrailing) {
EXPECT_EQ((BitMask<uint32_t, 16>(0b0001101001000000).LeadingZeros()), 3);
EXPECT_EQ((BitMask<uint32_t, 16>(0b0001101001000000).TrailingZeros()), 6);
EXPECT_EQ((BitMask<uint32_t, 16>(0x00001a40).LeadingZeros()), 3);
EXPECT_EQ((BitMask<uint32_t, 16>(0x00001a40).TrailingZeros()), 6);
EXPECT_EQ((BitMask<uint32_t, 16>(0b0000000000000001).LeadingZeros()), 15);
EXPECT_EQ((BitMask<uint32_t, 16>(0b0000000000000001).TrailingZeros()), 0);
EXPECT_EQ((BitMask<uint32_t, 16>(0x00000001).LeadingZeros()), 15);
EXPECT_EQ((BitMask<uint32_t, 16>(0x00000001).TrailingZeros()), 0);
EXPECT_EQ((BitMask<uint32_t, 16>(0b1000000000000000).LeadingZeros()), 0);
EXPECT_EQ((BitMask<uint32_t, 16>(0b1000000000000000).TrailingZeros()), 15);
EXPECT_EQ((BitMask<uint32_t, 16>(0x00008000).LeadingZeros()), 0);
EXPECT_EQ((BitMask<uint32_t, 16>(0x00008000).TrailingZeros()), 15);
EXPECT_EQ((BitMask<uint64_t, 8, 3>(0x0000008080808000).LeadingZeros()), 3);
EXPECT_EQ((BitMask<uint64_t, 8, 3>(0x0000008080808000).TrailingZeros()), 1);

View file

@ -785,7 +785,7 @@ void ExhaustiveFloat(uint32_t cases, R&& runnable) {
if (iters_per_float == 0) iters_per_float = 1;
for (float f : floats) {
if (f == last) continue;
float testf = nextafter(last, std::numeric_limits<float>::max());
float testf = std::nextafter(last, std::numeric_limits<float>::max());
runnable(testf);
runnable(-testf);
last = testf;
@ -799,7 +799,7 @@ void ExhaustiveFloat(uint32_t cases, R&& runnable) {
last = testf;
}
}
testf = nextafter(f, 0.0f);
testf = std::nextafter(f, 0.0f);
if (testf > last) {
runnable(testf);
runnable(-testf);

View file

@ -178,7 +178,7 @@ cc_library(
name = "mutex_benchmark_common",
testonly = 1,
srcs = ["mutex_benchmark.cc"],
copts = ABSL_DEFAULT_COPTS,
copts = ABSL_TEST_COPTS,
visibility = [
"//absl/synchronization:__pkg__",
],

View file

@ -513,10 +513,11 @@ class optional : private optional_internal::optional_data<T>,
// the arguments `std::forward<Args>(args)...` within the `optional`.
// (The `in_place_t` is a tag used to indicate that the contained object
// should be constructed in-place.)
//
// TODO(absl-team): Add std::is_constructible<T, Args&&...> SFINAE.
template <typename... Args>
constexpr explicit optional(in_place_t, Args&&... args)
template <typename InPlaceT, typename... Args,
absl::enable_if_t<absl::conjunction<
std::is_same<InPlaceT, in_place_t>,
std::is_constructible<T, Args&&...> >::value>* = nullptr>
constexpr explicit optional(InPlaceT, Args&&... args)
: data_base(in_place_t(), absl::forward<Args>(args)...) {}
// Constructs a non-empty `optional` direct-initialized value of type `T` from

View file

@ -157,6 +157,16 @@ struct NonMovable {
NonMovable& operator=(NonMovable&&) = delete;
};
struct NoDefault {
NoDefault() = delete;
NoDefault(const NoDefault&) {}
NoDefault& operator=(const NoDefault&) { return *this; }
};
struct ConvertsFromInPlaceT {
ConvertsFromInPlaceT(absl::in_place_t) {} // NOLINT
};
TEST(optionalTest, DefaultConstructor) {
absl::optional<int> empty;
EXPECT_FALSE(empty);
@ -337,16 +347,18 @@ TEST(optionalTest, InPlaceConstructor) {
static_assert((*opt2).x == ConstexprType::kCtorInitializerList, "");
#endif
// TODO(absl-team): uncomment these when std::is_constructible<T, Args&&...>
// SFINAE is added to optional::optional(absl::in_place_t, Args&&...).
// struct I {
// I(absl::in_place_t);
// };
EXPECT_FALSE((std::is_constructible<absl::optional<ConvertsFromInPlaceT>,
absl::in_place_t>::value));
EXPECT_FALSE((std::is_constructible<absl::optional<ConvertsFromInPlaceT>,
const absl::in_place_t&>::value));
EXPECT_TRUE(
(std::is_constructible<absl::optional<ConvertsFromInPlaceT>,
absl::in_place_t, absl::in_place_t>::value));
// EXPECT_FALSE((std::is_constructible<absl::optional<I>,
// absl::in_place_t>::value));
// EXPECT_FALSE((std::is_constructible<absl::optional<I>, const
// absl::in_place_t&>::value));
EXPECT_FALSE((std::is_constructible<absl::optional<NoDefault>,
absl::in_place_t>::value));
EXPECT_FALSE((std::is_constructible<absl::optional<NoDefault>,
absl::in_place_t&&>::value));
}
// template<U=T> optional(U&&);
@ -1624,4 +1636,27 @@ TEST(optionalTest, AssignmentConstraints) {
EXPECT_TRUE(absl::is_copy_assignable<absl::optional<AnyLike>>::value);
}
struct NestedClassBug {
struct Inner {
bool dummy = false;
};
absl::optional<Inner> value;
};
TEST(optionalTest, InPlaceTSFINAEBug) {
NestedClassBug b;
((void)b);
using Inner = NestedClassBug::Inner;
EXPECT_TRUE((std::is_default_constructible<Inner>::value));
EXPECT_TRUE((std::is_constructible<Inner>::value));
EXPECT_TRUE(
(std::is_constructible<absl::optional<Inner>, absl::in_place_t>::value));
absl::optional<Inner> o(absl::in_place);
EXPECT_TRUE(o.has_value());
o.emplace();
EXPECT_TRUE(o.has_value());
}
} // namespace