about summary refs log tree commit diff
path: root/absl
diff options
context:
space:
mode:
Diffstat (limited to 'absl')
-rw-r--r--absl/base/config.h2
-rw-r--r--absl/container/inlined_vector.h15
-rw-r--r--absl/meta/type_traits.h28
-rw-r--r--absl/strings/str_cat_test.cc14
-rw-r--r--absl/time/clock_test.cc4
-rw-r--r--absl/types/optional.h7
6 files changed, 55 insertions, 15 deletions
diff --git a/absl/base/config.h b/absl/base/config.h
index 4aff49237964..5f0dd04c8e66 100644
--- a/absl/base/config.h
+++ b/absl/base/config.h
@@ -180,7 +180,7 @@
 #ifdef ABSL_HAVE_INTRINSIC_INT128
 #error ABSL_HAVE_INTRINSIC_INT128 cannot be directly set
 #elif (defined(__clang__) && defined(__SIZEOF_INT128__) &&               \
-       !defined(__ppc64__) && !defined(__aarch64__)) ||                  \
+       !defined(__aarch64__)) ||                                         \
     (defined(__CUDACC__) && defined(__SIZEOF_INT128__) &&                \
      __CUDACC_VER__ >= 70000) ||                                         \
     (!defined(__clang__) && !defined(__CUDACC__) && defined(__GNUC__) && \
diff --git a/absl/container/inlined_vector.h b/absl/container/inlined_vector.h
index f060f5c5c40f..f68ca5074149 100644
--- a/absl/container/inlined_vector.h
+++ b/absl/container/inlined_vector.h
@@ -124,9 +124,24 @@ class InlinedVector {
   InlinedVector(const InlinedVector& v);
   InlinedVector(const InlinedVector& v, const allocator_type& alloc);
 
+  // This move constructor does not allocate and only moves the underlying
+  // objects, so its `noexcept` specification depends on whether moving the
+  // underlying objects can throw or not. We assume
+  //  a) move constructors should only throw due to allocation failure and
+  //  b) if `value_type`'s move constructor allocates, it uses the same
+  //     allocation function as the `InlinedVector`'s allocator, so the move
+  //     constructor is non-throwing if the allocator is non-throwing or
+  //     `value_type`'s move constructor is specified as `noexcept`.
   InlinedVector(InlinedVector&& v) noexcept(
       absl::allocator_is_nothrow<allocator_type>::value ||
       std::is_nothrow_move_constructible<value_type>::value);
+
+  // This move constructor allocates and also moves the underlying objects, so
+  // its `noexcept` specification depends on whether the allocation can throw
+  // and whether moving the underlying objects can throw. Based on the same
+  // assumptions above, the `noexcept` specification is dominated by whether the
+  // allocation can throw regardless of whether `value_type`'s move constructor
+  // is specified as `noexcept`.
   InlinedVector(InlinedVector&& v, const allocator_type& alloc) noexcept(
       absl::allocator_is_nothrow<allocator_type>::value);
 
diff --git a/absl/meta/type_traits.h b/absl/meta/type_traits.h
index ced66269b063..6f7138c2d8db 100644
--- a/absl/meta/type_traits.h
+++ b/absl/meta/type_traits.h
@@ -135,8 +135,11 @@ struct negation : std::integral_constant<bool, !T::value> {};
 //
 // Determines whether the passed type `T` is trivially destructable.
 //
-// This metafunction is designed to be a drop-in replacement for the C++17
-// `std::is_trivially_destructible()` metafunction.
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_trivially_destructible()` metafunction for platforms that have
+// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+// fully support C++11, we check whether this yields the same result as the std
+// implementation.
 //
 // NOTE: the extensions (__has_trivial_xxx) are implemented in gcc (version >=
 // 4.3) and clang. Since we are supporting libstdc++ > 4.7, they should always
@@ -157,8 +160,11 @@ struct is_trivially_destructible
 //
 // Determines whether the passed type `T` is trivially default constructible.
 //
-// This metafunction is designed to be a drop-in replacement for the C++17
-// `std::is_trivially_default_constructible()` metafunction.
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_trivially_default_constructible()` metafunction for platforms that
+// have incomplete C++11 support (such as libstdc++ 4.x). On any platforms that
+// do fully support C++11, we check whether this yields the same result as the
+// std implementation.
 //
 // NOTE: according to the C++ standard, Section: 20.15.4.3 [meta.unary.prop]
 // "The predicate condition for a template specialization is_constructible<T,
@@ -199,8 +205,11 @@ struct is_trivially_default_constructible
 //
 // Determines whether the passed type `T` is trivially copy constructible.
 //
-// This metafunction is designed to be a drop-in replacement for the C++17
-// `std::is_trivially_copy_constructible()` metafunction.
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_trivially_copy_constructible()` metafunction for platforms that have
+// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+// fully support C++11, we check whether this yields the same result as the std
+// implementation.
 //
 // NOTE: `T obj(declval<const T&>());` needs to be well-formed and not call any
 // nontrivial operation.  Nontrivally destructible types will cause the
@@ -221,8 +230,11 @@ struct is_trivially_copy_constructible
 //
 // Determines whether the passed type `T` is trivially copy assignable.
 //
-// This metafunction is designed to be a drop-in replacement for the C++17
-// `std::is_trivially_copy_assignable()` metafunction.
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_trivially_copy_assignable()` metafunction for platforms that have
+// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+// fully support C++11, we check whether this yields the same result as the std
+// implementation.
 //
 // NOTE: `is_assignable<T, U>::value` is `true` if the expression
 // `declval<T>() = declval<U>()` is well-formed when treated as an unevaluated
diff --git a/absl/strings/str_cat_test.cc b/absl/strings/str_cat_test.cc
index 293d1943b16e..dd063b015b63 100644
--- a/absl/strings/str_cat_test.cc
+++ b/absl/strings/str_cat_test.cc
@@ -300,6 +300,12 @@ TEST(StrAppend, Basics) {
     "World"
   };
 
+  std::string stdstrs[] = {
+    "std::Hello",
+    "std::Cruel",
+    "std::World"
+  };
+
   absl::string_view pieces[] = {"Hello", "Cruel", "World"};
 
   const char* c_strs[] = {
@@ -324,12 +330,12 @@ TEST(StrAppend, Basics) {
   EXPECT_EQ(result.substr(old_size), "CruelWorld");
 
   old_size = result.size();
-  absl::StrAppend(&result, strs[0], ", ", pieces[2]);
-  EXPECT_EQ(result.substr(old_size), "Hello, World");
+  absl::StrAppend(&result, stdstrs[0], ", ", pieces[2]);
+  EXPECT_EQ(result.substr(old_size), "std::Hello, World");
 
   old_size = result.size();
-  absl::StrAppend(&result, strs[0], ", ", strs[1], " ", strs[2], "!");
-  EXPECT_EQ(result.substr(old_size), "Hello, Cruel World!");
+  absl::StrAppend(&result, strs[0], ", ", stdstrs[1], " ", strs[2], "!");
+  EXPECT_EQ(result.substr(old_size), "Hello, std::Cruel World!");
 
   old_size = result.size();
   absl::StrAppend(&result, pieces[0], ", ", pieces[1], " ", pieces[2]);
diff --git a/absl/time/clock_test.cc b/absl/time/clock_test.cc
index 933ed240b2a8..f143c0360b0d 100644
--- a/absl/time/clock_test.cc
+++ b/absl/time/clock_test.cc
@@ -41,7 +41,7 @@ TEST(SleepForTest, BasicSanity) {
   absl::SleepFor(sleep_time);
   absl::Time end = absl::Now();
   EXPECT_LE(sleep_time - absl::Milliseconds(100), end - start);
-  EXPECT_GE(sleep_time + absl::Milliseconds(100), end - start);
+  EXPECT_GE(sleep_time + absl::Milliseconds(200), end - start);
 }
 
 #ifdef ABSL_HAVE_ALARM
@@ -62,7 +62,7 @@ TEST(SleepForTest, AlarmSupport) {
   absl::Time end = absl::Now();
   EXPECT_TRUE(alarm_handler_invoked);
   EXPECT_LE(sleep_time - absl::Milliseconds(100), end - start);
-  EXPECT_GE(sleep_time + absl::Milliseconds(100), end - start);
+  EXPECT_GE(sleep_time + absl::Milliseconds(200), end - start);
   signal(SIGALRM, old_alarm);
 }
 #endif  // ABSL_HAVE_ALARM
diff --git a/absl/types/optional.h b/absl/types/optional.h
index f1b41ace8195..e952a04aa90c 100644
--- a/absl/types/optional.h
+++ b/absl/types/optional.h
@@ -118,6 +118,13 @@ namespace absl {
 //      and `is_nothrow_swappable()` is the same as `std::is_trivial()`.
 //    * `make_optional()` cannot be declared `constexpr` due to the absence of
 //      guaranteed copy elision.
+//    * The move constructor's `noexcept` specification is stronger, i.e. if the
+//      default allocator is non-throwing (via setting
+//      `ABSL_ALLOCATOR_NOTHROW`), it evaluates to `noexcept(true)`, because
+//      we assume
+//       a) move constructors should only throw due to allocation failure and
+//       b) if T's move constructor allocates, it uses the same allocation
+//          function as the default allocator.
 template <typename T>
 class optional;
generated by cgit-pink 1.4.1 (git 2.44.2) at 2024-12-21T09ยท47+0000