Changes imported from Abseil "staging" branch:

  - 06abebb2bdb201c572da209fc7f781d6bd774d6b Documentation fixes for `absl::optional`. by Abseil Team <absl-team@google.com>
  - 42adc4c4daade2e070dc337e94d8851a1fd4bead  Rolling back the previous change because `__has_warning`... by Xiaoyi Zhang <zhangxy@google.com>
  - 02a42cbaa97d82ee7942bc498538359185d75087 Remove literal UTF8 strings in abseil code to avoid file ... by Jon Cohen <cohenjon@google.com>

GitOrigin-RevId: 06abebb2bdb201c572da209fc7f781d6bd774d6b
Change-Id: I4f4659c2e7ca6fc585b6c089bcf20ca61aced75d

6 files changed, 26 insertions, 38 deletions

diff --git a/absl/base/internal/inline_variable.h b/absl/base/internal/inline_variable.h
index a65fe89354cb..f7bb8c56525d 100644
--- a/absl/base/internal/inline_variable.h
+++ b/absl/base/internal/inline_variable.h
@@ -53,24 +53,7 @@
 //   it will likely be a reference type).
 ////////////////////////////////////////////////////////////////////////////////
 
-// ABSL_INTERNAL_HAS_WARNING()
-//
-// If the compiler supports the `__has_warning` extension for detecting
-// warnings, then this macro is defined to be `__has_warning`.
-//
-// If the compiler does not support `__has_warning`, invocations expand to 0.
-//
-// For clang's documentation of `__has_warning`, see
-// https://clang.llvm.org/docs/LanguageExtensions.html#has-warning
-#if defined(__has_warning)
-#define ABSL_INTERNAL_HAS_WARNING __has_warning
-#else  // Otherwise, be optimistic and assume the warning is not enabled.
-#define ABSL_INTERNAL_HAS_WARNING(warning) 0
-#endif  // defined(__has_warning)
-
-// If the compiler supports inline variables and does not warn when used...
-#if defined(__cpp_inline_variables) && \
-    !ABSL_INTERNAL_HAS_WARNING("-Wc++98-c++11-c++14-compat")
+#ifdef __cpp_inline_variables
 
 // Clang's -Wmissing-variable-declarations option erroneously warned that
 // inline constexpr objects need to be pre-declared. This has now been fixed,
@@ -83,21 +66,19 @@
 //   identity_t is used here so that the const and name are in the
 //   appropriate place for pointer types, reference types, function pointer
 //   types, etc..
-#if defined(__clang__) && \
-    ABSL_INTERNAL_HAS_WARNING("-Wmissing-variable-declarations")
+#if defined(__clang__)
 #define ABSL_INTERNAL_EXTERN_DECL(type, name) \
   extern const ::absl::internal::identity_t<type> name;
 #else  // Otherwise, just define the macro to do nothing.
 #define ABSL_INTERNAL_EXTERN_DECL(type, name)
-#endif  // defined(__clang__) &&
-        // ABSL_INTERNAL_HAS_WARNING("-Wmissing-variable-declarations")
+#endif  // defined(__clang__)
 
 // See above comment at top of file for details.
 #define ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init) \
   ABSL_INTERNAL_EXTERN_DECL(type, name)                  \
   inline constexpr ::absl::internal::identity_t<type> name = init
 
-#else  // Otherwise, we need to emulate inline variables...
+#else
 
 // See above comment at top of file for details.
 //
@@ -121,7 +102,6 @@
   static_assert(sizeof(void (*)(decltype(name))) != 0,                        \
                 "Silence unused variable warnings.")
 
-#endif  // defined(__cpp_inline_variables) &&
-        // !ABSL_INTERNAL_HAS_WARNING("-Wc++98-c++11-c++14-compat")
+#endif  // __cpp_inline_variables
 
 #endif  // ABSL_BASE_INTERNAL_INLINE_VARIABLE_EMULATION_H_
diff --git a/absl/base/internal/unaligned_access.h b/absl/base/internal/unaligned_access.h
index ea30829b0e18..c5724362a4e3 100644
--- a/absl/base/internal/unaligned_access.h
+++ b/absl/base/internal/unaligned_access.h
@@ -142,7 +142,7 @@ inline void UnalignedStore64(void *p, uint64_t v) {
 // and 32-bit values (not 64-bit); older versions either raise a fatal signal,
 // do an unaligned read and rotate the words around a bit, or do the reads very
 // slowly (trip through kernel mode). There's no simple #define that says just
-// “ARMv7 or higher”, so we have to filter away all ARMv5 and ARMv6
+// "ARMv7 or higher", so we have to filter away all ARMv5 and ARMv6
 // sub-architectures. Newer gcc (>= 4.6) set an __ARM_FEATURE_ALIGNED #define,
 // so in time, maybe we can move on to that.
 //
diff --git a/absl/strings/str_split_test.cc b/absl/strings/str_split_test.cc
index 500f3cbc3789..b1db1c5647e7 100644
--- a/absl/strings/str_split_test.cc
+++ b/absl/strings/str_split_test.cc
@@ -621,23 +621,28 @@ TEST(Split, StringDelimiter) {
 
 TEST(Split, UTF8) {
   // Tests splitting utf8 strings and utf8 delimiters.
+  std::string utf8_string = "\u03BA\u1F79\u03C3\u03BC\u03B5";
   {
     // A utf8 input std::string with an ascii delimiter.
-    std::vector<absl::string_view> v = absl::StrSplit("a,κόσμε", ',');
-    EXPECT_THAT(v, ElementsAre("a", "κόσμε"));
+    std::string to_split = "a," + utf8_string;
+    std::vector<absl::string_view> v = absl::StrSplit(to_split, ',');
+    EXPECT_THAT(v, ElementsAre("a", utf8_string));
   }
 
   {
     // A utf8 input std::string and a utf8 delimiter.
-    std::vector<absl::string_view> v = absl::StrSplit("a,κόσμε,b", ",κόσμε,");
+    std::string to_split = "a," + utf8_string + ",b";
+    std::string unicode_delimiter = "," + utf8_string + ",";
+    std::vector<absl::string_view> v =
+        absl::StrSplit(to_split, unicode_delimiter);
     EXPECT_THAT(v, ElementsAre("a", "b"));
   }
 
   {
     // A utf8 input std::string and ByAnyChar with ascii chars.
     std::vector<absl::string_view> v =
-        absl::StrSplit("Foo hällo th丞re", absl::ByAnyChar(" \t"));
-    EXPECT_THAT(v, ElementsAre("Foo", "hällo", "th丞re"));
+        absl::StrSplit("Foo h\u00E4llo th\u4E1Ere", absl::ByAnyChar(" \t"));
+    EXPECT_THAT(v, ElementsAre("Foo", "h\u00E4llo", "th\u4E1Ere"));
   }
 }
 
diff --git a/absl/strings/string_view_test.cc b/absl/strings/string_view_test.cc
index df307ac7cfab..3077d240d17b 100644
--- a/absl/strings/string_view_test.cc
+++ b/absl/strings/string_view_test.cc
@@ -684,8 +684,11 @@ TEST(StringViewTest, TruncSubstr) {
 }
 
 TEST(StringViewTest, UTF8) {
-  EXPECT_EQ(strlen("á"), absl::string_view("á á").find_first_of(" "));
-  EXPECT_EQ(strlen("á"), absl::string_view("á á").find_first_of(" \t"));
+  std::string utf8 = "\u00E1";
+  std::string utf8_twice = utf8 + " " + utf8;
+  int utf8_len = strlen(utf8.data());
+  EXPECT_EQ(utf8_len, absl::string_view(utf8_twice).find_first_of(" "));
+  EXPECT_EQ(utf8_len, absl::string_view(utf8_twice).find_first_of(" \t"));
 }
 
 TEST(StringViewTest, FindConformance) {
diff --git a/absl/types/any.h b/absl/types/any.h
index cee9cd324fc9..760a160e7562 100644
--- a/absl/types/any.h
+++ b/absl/types/any.h
@@ -304,7 +304,7 @@ class any {
   // object of type `VT` with the arguments `std::forward<Args>(args)...`, and
   // returning a reference to the new contained value.
   //
-  // Note: If an exception is thrown during the call to `VT`’s constructor,
+  // Note: If an exception is thrown during the call to `VT`'s constructor,
   // `*this` does not contain a value, and any previously contained value has
   // been destroyed.
   template <
@@ -325,7 +325,7 @@ class any {
   // `initilizer_list, std::forward<Args>(args)...`, and returning a reference
   // to the new contained value.
   //
-  // Note: If an exception is thrown during the call to `VT`’s constructor,
+  // Note: If an exception is thrown during the call to `VT`'s constructor,
   // `*this` does not contain a value, and any previously contained value has
   // been destroyed. The function shall not participate in overload resolution
   // unless `is_copy_constructible_v<VT>` is `true` and
diff --git a/absl/types/optional.h b/absl/types/optional.h
index 9858a9749766..07e439448dcc 100644
--- a/absl/types/optional.h
+++ b/absl/types/optional.h
@@ -492,11 +492,11 @@ class optional : private optional_internal::optional_data<T>,
 
   // Constructors
 
-  // Constructs a default-constructed `optional` holding the empty value, NOT a
-  // default constructed `T`.
+  // Constructs an `optional` holding an empty value, NOT a default constructed
+  // `T`.
   constexpr optional() noexcept {}
 
-  // Construct an `optional` initialized with `nullopt` to hold an empty value.
+  // Constructs an `optional` initialized with `nullopt` to hold an empty value.
   constexpr optional(nullopt_t) noexcept {}  // NOLINT(runtime/explicit)
 
   // Copy constructor, standard semantics