Changes imported from Abseil "staging" branch:

  - a42e9b454ca8be7d021789cdb9bcada07d3e2d3e Merge pull request #57. by Derek Mauro <dmauro@google.com>
  - b1e03838f059c034a6489501804d516326246042 Move the long ostream tests into a separate source file u... by Alex Strelnikov <strel@google.com>
  - 7c56b7dbb05faa7e8653632e00be470331d79cb9 Return reference from absl::InlinedVector::emplace_back(). by Abseil Team <absl-team@google.com>
  - 85b070822b62688ff348d9ad9cc9e230a851f617 Treat \u or \U followed by Unicode surrogate character as... by Abseil Team <absl-team@google.com>

GitOrigin-RevId: a42e9b454ca8be7d021789cdb9bcada07d3e2d3e
Change-Id: I7d8fb68ffd7eb4e9e737f21fbed6d56b71985f94

absl/container/inlined_vector.h

@@ -365,13 +365,14 @@ class InlinedVector {
   // InlinedVector::emplace_back()
   //
   // Constructs and appends an object to the inlined vector.
+  //
+  // Returns a reference to the inserted element.
   template <typename... Args>
-  void emplace_back(Args&&... args) {
+  value_type& emplace_back(Args&&... args) {
     size_type s = size();
     assert(s <= capacity());
     if (ABSL_PREDICT_FALSE(s == capacity())) {
-      GrowAndEmplaceBack(std::forward<Args>(args)...);
-      return;
+      return GrowAndEmplaceBack(std::forward<Args>(args)...);
     }
     assert(s < capacity());
 
@@ -383,7 +384,7 @@ class InlinedVector {
       tag().set_inline_size(s + 1);
       space = inlined_space();
     }
-    Construct(space + s, std::forward<Args>(args)...);
+    return Construct(space + s, std::forward<Args>(args)...);
   }
 
   // InlinedVector::push_back()
@@ -703,26 +704,30 @@ class InlinedVector {
   }
 
   template <typename... Args>
-  void GrowAndEmplaceBack(Args&&... args) {
+  value_type& GrowAndEmplaceBack(Args&&... args) {
     assert(size() == capacity());
     const size_type s = size();
 
     Allocation new_allocation(allocator(), 2 * capacity());
 
+    value_type& new_element =
         Construct(new_allocation.buffer() + s, std::forward<Args>(args)...);
     UninitializedCopy(std::make_move_iterator(data()),
                       std::make_move_iterator(data() + s),
                       new_allocation.buffer());
 
     ResetAllocation(new_allocation, s + 1);
+
+    return new_element;
   }
 
   void InitAssign(size_type n);
   void InitAssign(size_type n, const value_type& t);
 
   template <typename... Args>
-  void Construct(pointer p, Args&&... args) {
+  value_type& Construct(pointer p, Args&&... args) {
     AllocatorTraits::construct(allocator(), p, std::forward<Args>(args)...);
+    return *p;
   }
 
   template <typename Iter>

absl/container/inlined_vector_test.cc

@@ -393,6 +393,19 @@ TEST(InlinedVectorTest, Noexcept) {
                 absl::InlinedVector<MoveCanThrow, 2>>::value));
 }
 
+TEST(InlinedVectorTest, EmplaceBack) {
+  absl::InlinedVector<std::pair<std::string, int>, 1> v;
+
+  auto& inlined_element = v.emplace_back("answer", 42);
+  EXPECT_EQ(&inlined_element, &v[0]);
+  EXPECT_EQ(inlined_element.first, "answer");
+  EXPECT_EQ(inlined_element.second, 42);
+
+  auto& allocated_element = v.emplace_back("taxicab", 1729);
+  EXPECT_EQ(&allocated_element, &v[1]);
+  EXPECT_EQ(allocated_element.first, "taxicab");
+  EXPECT_EQ(allocated_element.second, 1729);
+}
 
 TEST(IntVec, Insert) {
   for (int len = 0; len < 20; len++) {

absl/debugging/internal/stacktrace_config.h

@@ -26,7 +26,7 @@
 #error ABSL_STACKTRACE_INL_HEADER cannot be directly set
 #elif defined(__native_client__) || defined(__APPLE__) || \
     defined(__FreeBSD__) || defined(__ANDROID__) || defined(__myriad2__) || \
-    defined(asmjs__) || defined(__Fuchsia__)
+    defined(__asmjs__) || defined(__Fuchsia__)
 #define ABSL_STACKTRACE_INL_HEADER \
     "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
 

absl/numeric/BUILD.bazel

@@ -27,8 +27,8 @@ cc_test(
     name = "int128_test",
     size = "small",
     srcs = [
+        "int128_stream_test.cc",
         "int128_test.cc",
-        "int128_test_unsigned_ostream_cases.inc",
     ],
     copts = ABSL_TEST_COPTS,
     deps = [

absl/numeric/int128_test.cc

@@ -17,7 +17,6 @@
 #include <algorithm>
 #include <limits>
 #include <random>
-#include <sstream>
 #include <type_traits>
 #include <utility>
 #include <vector>
@@ -427,26 +426,4 @@ TEST(Uint128, ConstexprTest) {
   EXPECT_EQ(minus_two, absl::MakeUint128(-1, -2));
 }
 
-TEST(Uint128, OStream) {
-  struct StreamCase {
-    absl::uint128 val;
-    std::ios_base::fmtflags flags;
-    std::streamsize width;
-    char fill;
-    const char* rep;
-  };
-
-  std::vector<StreamCase> cases = {
-#include "absl/numeric/int128_test_unsigned_ostream_cases.inc"
-  };
-  for (const StreamCase& test_case : cases) {
-    std::ostringstream os;
-    os.flags(test_case.flags);
-    os.width(test_case.width);
-    os.fill(test_case.fill);
-    os << test_case.val;
-    EXPECT_EQ(test_case.rep, os.str());
-  }
-}
-
 }  // namespace

absl/strings/escaping.cc

@@ -72,6 +72,17 @@ inline int hex_digit_to_int(char c) {
   return x & 0xf;
 }
 
+inline bool IsSurrogate(char32_t c, absl::string_view src, std::string* error) {
+  if (c >= 0xD800 && c <= 0xDFFF) {
+    if (error) {
+      *error = absl::StrCat("invalid surrogate character (0xD800-DFFF): \\",
+                            src);
+    }
+    return true;
+  }
+  return false;
+}
+
 // ----------------------------------------------------------------------
 // CUnescapeInternal()
 //    Implements both CUnescape() and CUnescapeForNullTerminatedString().
@@ -214,6 +225,9 @@ bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped,
             d += 5;
             break;
           }
+          if (IsSurrogate(rune, absl::string_view(hex_start, 5), error)) {
+            return false;
+          }
           d += strings_internal::EncodeUTF8Char(d, rune);
           break;
         }
@@ -259,6 +273,9 @@ bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped,
             d += 9;
             break;
           }
+          if (IsSurrogate(rune, absl::string_view(hex_start, 9), error)) {
+            return false;
+          }
           d += strings_internal::EncodeUTF8Char(d, rune);
           break;
         }

absl/strings/escaping_test.cc

@@ -162,7 +162,10 @@ TEST(Unescape, BasicFunction) {
   std::string bad[] =
      {"\\u1",         // too short
       "\\U1",         // too short
-      "\\Uffffff",
+      "\\Uffffff",    // exceeds 0x10ffff (largest Unicode)
+      "\\U00110000",  // exceeds 0x10ffff (largest Unicode)
+      "\\uD835",      // surrogate character (D800-DFFF)
+      "\\U0000DD04",  // surrogate character (D800-DFFF)
       "\\777",        // exceeds 0xff
       "\\xABCD"};     // exceeds 0xff
   for (const std::string& e : bad) {