Export of internal Abseil changes.

--
eca34da4ccb7bb6a580f1364dff9ca053418fa3b by Abseil Team <absl-team@google.com>:

Internal change.

PiperOrigin-RevId: 214305433

--
35393bdd21a87c4286f945fd34dda93afc4e0cd6 by Abseil Team <absl-team@google.com>:

Move some implementation details of string_view around to facilitate compiling on NVCC.

Abseil does not officially support NVCC as a reminder.

PiperOrigin-RevId: 214184876

--
61846cab9ab9476a4676ecade7173f68978cd038 by Jorg Brown <jorg@google.com>:

Move the initialization values for constants back to their declaration.

PiperOrigin-RevId: 214135927

--
7ac7df6c5f78f2faf419268c04618b936cb26065 by Abseil Team <absl-team@google.com>:

Performance improvements on format parser.

PiperOrigin-RevId: 214032366

--
90b4c0cf20e9feaa257a7ece40adaf7db40a60a7 by Xiaoyi Zhang <zhangxy@google.com>:

Add static_assert check to absl::visit to make sure all overloads of the visitor return the same type, as required by the C++ standard.

PiperOrigin-RevId: 213677001

--
787995342101b4c181291cde9ecea3048536e4bd by Abseil Team <absl-team@google.com>:

Update comment to indicate finite durations are less than InfiniteDuration.

PiperOrigin-RevId: 213660328

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

s/invariant/contract in the exceptions safety testing framework.  This is a better term as these can be type invariants or function post conditions.  They also are very similar ground as to what is covered by c++20 Contracts (and could even be replaced by them.

PiperOrigin-RevId: 213631019

--
0b3ff1a640de9a7391a6c233568802cf86245b0e by Abseil Team <absl-team@google.com>:

Add noinline attribute for GetStackTrace/GetStackFrames/... so the skipped frames will not change because of inlining difference.

PiperOrigin-RevId: 213009637
GitOrigin-RevId: eca34da4ccb7bb6a580f1364dff9ca053418fa3b
Change-Id: Iff1022fd24e440fcbdf3c4ab2a915ca8954daa31

15 files changed, 251 insertions, 223 deletions

diff --git a/WORKSPACE b/WORKSPACE
index e4a91197..72ef1398 100644
--- a/WORKSPACE
+++ b/WORKSPACE
@@ -5,11 +5,11 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 http_archive(
   name = "bazel_toolchains",
   urls = [
-    "https://mirror.bazel.build/github.com/bazelbuild/bazel-toolchains/archive/287b64e0a211fb7c23b74695f8d5f5205b61f4eb.tar.gz",
-    "https://github.com/bazelbuild/bazel-toolchains/archive/287b64e0a211fb7c23b74695f8d5f5205b61f4eb.tar.gz",
+    "https://mirror.bazel.build/github.com/bazelbuild/bazel-toolchains/archive/bc09b995c137df042bb80a395b73d7ce6f26afbe.tar.gz",
+    "https://github.com/bazelbuild/bazel-toolchains/archive/bc09b995c137df042bb80a395b73d7ce6f26afbe.tar.gz",
   ],
-  strip_prefix = "bazel-toolchains-287b64e0a211fb7c23b74695f8d5f5205b61f4eb",
-  sha256 = "aca8ac6afd7745027ee4a43032b51a725a61a75a30f02cc58681ee87e4dcdf4b",
+  strip_prefix = "bazel-toolchains-bc09b995c137df042bb80a395b73d7ce6f26afbe",
+  sha256 = "4329663fe6c523425ad4d3c989a8ac026b04e1acedeceb56aa4b190fa7f3973c",
 )
 
 # GoogleTest/GoogleMock framework. Used by most unit-tests.
diff --git a/absl/base/exception_safety_testing_test.cc b/absl/base/exception_safety_testing_test.cc
index 9141e39c..106bc34b 100644
--- a/absl/base/exception_safety_testing_test.cc
+++ b/absl/base/exception_safety_testing_test.cc
@@ -548,21 +548,21 @@ TEST(ExceptionSafetyTesterTest, IncompleteTypesAreNotTestable) {
   // Test that providing operation and inveriants still does not allow for the
   // the invocation of .Test() and .Test(op) because it lacks a factory
   auto without_fac =
-      testing::MakeExceptionSafetyTester().WithOperation(op).WithInvariants(
+      testing::MakeExceptionSafetyTester().WithOperation(op).WithContracts(
           inv, testing::strong_guarantee);
   EXPECT_FALSE(HasNullaryTest(without_fac));
   EXPECT_FALSE(HasUnaryTest(without_fac));
 
-  // Test that providing invariants and factory allows the invocation of
+  // Test that providing contracts and factory allows the invocation of
   // .Test(op) but does not allow for .Test() because it lacks an operation
   auto without_op = testing::MakeExceptionSafetyTester()
-                        .WithInvariants(inv, testing::strong_guarantee)
+                        .WithContracts(inv, testing::strong_guarantee)
                         .WithFactory(fac);
   EXPECT_FALSE(HasNullaryTest(without_op));
   EXPECT_TRUE(HasUnaryTest(without_op));
 
   // Test that providing operation and factory still does not allow for the
-  // the invocation of .Test() and .Test(op) because it lacks invariants
+  // the invocation of .Test() and .Test(op) because it lacks contracts
   auto without_inv =
       testing::MakeExceptionSafetyTester().WithOperation(op).WithFactory(fac);
   EXPECT_FALSE(HasNullaryTest(without_inv));
@@ -577,7 +577,7 @@ std::unique_ptr<ExampleStruct> ExampleFunctionFactory() {
 
 void ExampleFunctionOperation(ExampleStruct*) {}
 
-testing::AssertionResult ExampleFunctionInvariant(ExampleStruct*) {
+testing::AssertionResult ExampleFunctionContract(ExampleStruct*) {
   return testing::AssertionSuccess();
 }
 
@@ -593,16 +593,16 @@ struct {
 
 struct {
   testing::AssertionResult operator()(ExampleStruct* example_struct) const {
-    return ExampleFunctionInvariant(example_struct);
+    return ExampleFunctionContract(example_struct);
   }
-} example_struct_invariant;
+} example_struct_contract;
 
 auto example_lambda_factory = []() { return ExampleFunctionFactory(); };
 
 auto example_lambda_operation = [](ExampleStruct*) {};
 
-auto example_lambda_invariant = [](ExampleStruct* example_struct) {
-  return ExampleFunctionInvariant(example_struct);
+auto example_lambda_contract = [](ExampleStruct* example_struct) {
+  return ExampleFunctionContract(example_struct);
 };
 
 // Testing that function references, pointers, structs with operator() and
@@ -612,28 +612,28 @@ TEST(ExceptionSafetyTesterTest, MixedFunctionTypes) {
   EXPECT_TRUE(testing::MakeExceptionSafetyTester()
                   .WithFactory(ExampleFunctionFactory)
                   .WithOperation(ExampleFunctionOperation)
-                  .WithInvariants(ExampleFunctionInvariant)
+                  .WithContracts(ExampleFunctionContract)
                   .Test());
 
   // function pointer
   EXPECT_TRUE(testing::MakeExceptionSafetyTester()
                   .WithFactory(&ExampleFunctionFactory)
                   .WithOperation(&ExampleFunctionOperation)
-                  .WithInvariants(&ExampleFunctionInvariant)
+                  .WithContracts(&ExampleFunctionContract)
                   .Test());
 
   // struct
   EXPECT_TRUE(testing::MakeExceptionSafetyTester()
                   .WithFactory(example_struct_factory)
                   .WithOperation(example_struct_operation)
-                  .WithInvariants(example_struct_invariant)
+                  .WithContracts(example_struct_contract)
                   .Test());
 
   // lambda
   EXPECT_TRUE(testing::MakeExceptionSafetyTester()
                   .WithFactory(example_lambda_factory)
                   .WithOperation(example_lambda_operation)
-                  .WithInvariants(example_lambda_invariant)
+                  .WithContracts(example_lambda_contract)
                   .Test());
 }
 
@@ -658,9 +658,9 @@ struct {
 } invoker;
 
 auto tester =
-    testing::MakeExceptionSafetyTester().WithOperation(invoker).WithInvariants(
+    testing::MakeExceptionSafetyTester().WithOperation(invoker).WithContracts(
         CheckNonNegativeInvariants);
-auto strong_tester = tester.WithInvariants(testing::strong_guarantee);
+auto strong_tester = tester.WithContracts(testing::strong_guarantee);
 
 struct FailsBasicGuarantee : public NonNegative {
   void operator()() {
@@ -690,7 +690,7 @@ TEST(ExceptionCheckTest, StrongGuaranteeFailure) {
   EXPECT_FALSE(strong_tester.WithInitialValue(FollowsBasicGuarantee{}).Test());
 }
 
-struct BasicGuaranteeWithExtraInvariants : public NonNegative {
+struct BasicGuaranteeWithExtraContracts : public NonNegative {
   // After operator(), i is incremented.  If operator() throws, i is set to 9999
   void operator()() {
     int old_i = i;
@@ -701,21 +701,21 @@ struct BasicGuaranteeWithExtraInvariants : public NonNegative {
 
   static constexpr int kExceptionSentinel = 9999;
 };
-constexpr int BasicGuaranteeWithExtraInvariants::kExceptionSentinel;
+constexpr int BasicGuaranteeWithExtraContracts::kExceptionSentinel;
 
-TEST(ExceptionCheckTest, BasicGuaranteeWithExtraInvariants) {
+TEST(ExceptionCheckTest, BasicGuaranteeWithExtraContracts) {
   auto tester_with_val =
-      tester.WithInitialValue(BasicGuaranteeWithExtraInvariants{});
+      tester.WithInitialValue(BasicGuaranteeWithExtraContracts{});
   EXPECT_TRUE(tester_with_val.Test());
   EXPECT_TRUE(
       tester_with_val
-          .WithInvariants([](BasicGuaranteeWithExtraInvariants* o) {
-            if (o->i == BasicGuaranteeWithExtraInvariants::kExceptionSentinel) {
+          .WithContracts([](BasicGuaranteeWithExtraContracts* o) {
+            if (o->i == BasicGuaranteeWithExtraContracts::kExceptionSentinel) {
               return testing::AssertionSuccess();
             }
             return testing::AssertionFailure()
                    << "i should be "
-                   << BasicGuaranteeWithExtraInvariants::kExceptionSentinel
+                   << BasicGuaranteeWithExtraContracts::kExceptionSentinel
                    << ", but is " << o->i;
           })
           .Test());
@@ -740,7 +740,7 @@ struct HasReset : public NonNegative {
   void reset() { i = 0; }
 };
 
-testing::AssertionResult CheckHasResetInvariants(HasReset* h) {
+testing::AssertionResult CheckHasResetContracts(HasReset* h) {
   h->reset();
   return testing::AssertionResult(h->i == 0);
 }
@@ -759,14 +759,14 @@ TEST(ExceptionCheckTest, ModifyingChecker) {
   };
 
   EXPECT_FALSE(tester.WithInitialValue(FollowsBasicGuarantee{})
-                   .WithInvariants(set_to_1000, is_1000)
+                   .WithContracts(set_to_1000, is_1000)
                    .Test());
   EXPECT_TRUE(strong_tester.WithInitialValue(FollowsStrongGuarantee{})
-                  .WithInvariants(increment)
+                  .WithContracts(increment)
                   .Test());
   EXPECT_TRUE(testing::MakeExceptionSafetyTester()
                   .WithInitialValue(HasReset{})
-                  .WithInvariants(CheckHasResetInvariants)
+                  .WithContracts(CheckHasResetContracts)
                   .Test(invoker));
 }
 
@@ -799,7 +799,7 @@ TEST(ExceptionCheckTest, NonEqualityComparable) {
     return testing::AssertionResult(nec->i == NonEqualityComparable().i);
   };
   auto strong_nec_tester = tester.WithInitialValue(NonEqualityComparable{})
-                               .WithInvariants(nec_is_strong);
+                               .WithContracts(nec_is_strong);
 
   EXPECT_TRUE(strong_nec_tester.Test());
   EXPECT_FALSE(strong_nec_tester.Test(
@@ -833,14 +833,14 @@ struct {
   testing::AssertionResult operator()(ExhaustivenessTester<T>*) const {
     return testing::AssertionSuccess();
   }
-} CheckExhaustivenessTesterInvariants;
+} CheckExhaustivenessTesterContracts;
 
 template <typename T>
 unsigned char ExhaustivenessTester<T>::successes = 0;
 
 TEST(ExceptionCheckTest, Exhaustiveness) {
   auto exhaust_tester = testing::MakeExceptionSafetyTester()
-                            .WithInvariants(CheckExhaustivenessTesterInvariants)
+                            .WithContracts(CheckExhaustivenessTesterContracts)
                             .WithOperation(invoker);
 
   EXPECT_TRUE(
@@ -849,7 +849,7 @@ TEST(ExceptionCheckTest, Exhaustiveness) {
 
   EXPECT_TRUE(
       exhaust_tester.WithInitialValue(ExhaustivenessTester<ThrowingValue<>>{})
-          .WithInvariants(testing::strong_guarantee)
+          .WithContracts(testing::strong_guarantee)
           .Test());
   EXPECT_EQ(ExhaustivenessTester<ThrowingValue<>>::successes, 0xF);
 }
diff --git a/absl/base/internal/exception_safety_testing.h b/absl/base/internal/exception_safety_testing.h
index de4f0e28..5665a1b6 100644
--- a/absl/base/internal/exception_safety_testing.h
+++ b/absl/base/internal/exception_safety_testing.h
@@ -191,19 +191,19 @@ class TrackedObject {
   ~TrackedObject() noexcept { ConstructorTracker::ObjectDestructed(this); }
 };
 
-template <typename Factory, typename Operation, typename Invariant>
-absl::optional<testing::AssertionResult> TestSingleInvariantAtCountdownImpl(
+template <typename Factory, typename Operation, typename Contract>
+absl::optional<testing::AssertionResult> TestSingleContractAtCountdownImpl(
     const Factory& factory, const Operation& operation, int count,
-    const Invariant& invariant) {
+    const Contract& contract) {
   auto t_ptr = factory();
   absl::optional<testing::AssertionResult> current_res;
   SetCountdown(count);
   try {
     operation(t_ptr.get());
   } catch (const exceptions_internal::TestException& e) {
-    current_res.emplace(invariant(t_ptr.get()));
+    current_res.emplace(contract(t_ptr.get()));
     if (!current_res.value()) {
-      *current_res << e.what() << " failed invariant check";
+      *current_res << e.what() << " failed contract check";
     }
   }
   UnsetCountdown();
@@ -211,22 +211,22 @@ absl::optional<testing::AssertionResult> TestSingleInvariantAtCountdownImpl(
 }
 
 template <typename Factory, typename Operation>
-absl::optional<testing::AssertionResult> TestSingleInvariantAtCountdownImpl(
+absl::optional<testing::AssertionResult> TestSingleContractAtCountdownImpl(
     const Factory& factory, const Operation& operation, int count,
     StrongGuaranteeTagType) {
   using TPtr = typename decltype(factory())::pointer;
   auto t_is_strong = [&](TPtr t) { return *t == *factory(); };
-  return TestSingleInvariantAtCountdownImpl(factory, operation, count,
-                                            t_is_strong);
+  return TestSingleContractAtCountdownImpl(factory, operation, count,
+                                           t_is_strong);
 }
 
-template <typename Factory, typename Operation, typename Invariant>
-int TestSingleInvariantAtCountdown(
+template <typename Factory, typename Operation, typename Contract>
+int TestSingleContractAtCountdown(
     const Factory& factory, const Operation& operation, int count,
-    const Invariant& invariant,
+    const Contract& contract,
     absl::optional<testing::AssertionResult>* reduced_res) {
   // If reduced_res is empty, it means the current call to
-  // TestSingleInvariantAtCountdown(...) is the first test being run so we do
+  // TestSingleContractAtCountdown(...) is the first test being run so we do
   // want to run it. Alternatively, if it's not empty (meaning a previous test
   // has run) we want to check if it passed. If the previous test did pass, we
   // want to contine running tests so we do want to run the current one. If it
@@ -234,22 +234,22 @@ int TestSingleInvariantAtCountdown(
   // output. If that's the case, we do not run the current test and instead we
   // simply return.
   if (!reduced_res->has_value() || reduced_res->value()) {
-    *reduced_res = TestSingleInvariantAtCountdownImpl(factory, operation, count,
-                                                      invariant);
+    *reduced_res =
+        TestSingleContractAtCountdownImpl(factory, operation, count, contract);
   }
   return 0;
 }
 
-template <typename Factory, typename Operation, typename... Invariants>
-inline absl::optional<testing::AssertionResult> TestAllInvariantsAtCountdown(
+template <typename Factory, typename Operation, typename... Contracts>
+inline absl::optional<testing::AssertionResult> TestAllContractsAtCountdown(
     const Factory& factory, const Operation& operation, int count,
-    const Invariants&... invariants) {
+    const Contracts&... contracts) {
   absl::optional<testing::AssertionResult> reduced_res;
 
   // Run each checker, short circuiting after the first failure
   int dummy[] = {
-      0, (TestSingleInvariantAtCountdown(factory, operation, count, invariants,
-                                         &reduced_res))...};
+      0, (TestSingleContractAtCountdown(factory, operation, count, contracts,
+                                        &reduced_res))...};
   static_cast<void>(dummy);
   return reduced_res;
 }
@@ -884,15 +884,15 @@ class DefaultFactory {
   T t_;
 };
 
-template <size_t LazyInvariantsCount, typename LazyFactory,
+template <size_t LazyContractsCount, typename LazyFactory,
           typename LazyOperation>
 using EnableIfTestable = typename absl::enable_if_t<
-    LazyInvariantsCount != 0 &&
+    LazyContractsCount != 0 &&
     !std::is_same<LazyFactory, UninitializedT>::value &&
     !std::is_same<LazyOperation, UninitializedT>::value>;
 
 template <typename Factory = UninitializedT,
-          typename Operation = UninitializedT, typename... Invariants>
+          typename Operation = UninitializedT, typename... Contracts>
 class ExceptionSafetyTester;
 
 }  // namespace exceptions_internal
@@ -903,7 +903,7 @@ namespace exceptions_internal {
 
 /*
  * Builds a tester object that tests if performing a operation on a T follows
- * exception safety guarantees. Verification is done via invariant assertion
+ * exception safety guarantees. Verification is done via contract assertion
  * callbacks applied to T instances post-throw.
  *
  * Template parameters for ExceptionSafetyTester:
@@ -921,18 +921,18 @@ namespace exceptions_internal {
  *   fresh T instance so it's free to modify and destroy the T instances as it
  *   pleases.
  *
- * - Invariants...: The invariant assertion callback objects (passed in via
- *   tester.WithInvariants(...)) must be invocable with the signature
+ * - Contracts...: The contract assertion callback objects (passed in via
+ *   tester.WithContracts(...)) must be invocable with the signature
  *   `testing::AssertionResult operator()(T*) const` where T is the type being
- *   tested. Invariant assertion callbacks are provided T instances post-throw.
- *   They must return testing::AssertionSuccess when the type invariants of the
- *   provided T instance hold. If the type invariants of the T instance do not
+ *   tested. Contract assertion callbacks are provided T instances post-throw.
+ *   They must return testing::AssertionSuccess when the type contracts of the
+ *   provided T instance hold. If the type contracts of the T instance do not
  *   hold, they must return testing::AssertionFailure. Execution order of
- *   Invariants... is unspecified. They will each individually get a fresh T
+ *   Contracts... is unspecified. They will each individually get a fresh T
  *   instance so they are free to modify and destroy the T instances as they
  *   please.
  */
-template <typename Factory, typename Operation, typename... Invariants>
+template <typename Factory, typename Operation, typename... Contracts>
 class ExceptionSafetyTester {
  public:
   /*
@@ -948,7 +948,7 @@ class ExceptionSafetyTester {
    *   tester.WithFactory(...).
    */
   template <typename T>
-  ExceptionSafetyTester<DefaultFactory<T>, Operation, Invariants...>
+  ExceptionSafetyTester<DefaultFactory<T>, Operation, Contracts...>
   WithInitialValue(const T& t) const {
     return WithFactory(DefaultFactory<T>(t));
   }
@@ -961,9 +961,9 @@ class ExceptionSafetyTester {
    * method tester.WithInitialValue(...).
    */
   template <typename NewFactory>
-  ExceptionSafetyTester<absl::decay_t<NewFactory>, Operation, Invariants...>
+  ExceptionSafetyTester<absl::decay_t<NewFactory>, Operation, Contracts...>
   WithFactory(const NewFactory& new_factory) const {
-    return {new_factory, operation_, invariants_};
+    return {new_factory, operation_, contracts_};
   }
 
   /*
@@ -972,39 +972,39 @@ class ExceptionSafetyTester {
    * tester.
    */
   template <typename NewOperation>
-  ExceptionSafetyTester<Factory, absl::decay_t<NewOperation>, Invariants...>
+  ExceptionSafetyTester<Factory, absl::decay_t<NewOperation>, Contracts...>
   WithOperation(const NewOperation& new_operation) const {
-    return {factory_, new_operation, invariants_};
+    return {factory_, new_operation, contracts_};
   }
 
   /*
-   * Returns a new ExceptionSafetyTester with the provided MoreInvariants...
-   * combined with the Invariants... that were already included in the instance
-   * on which the method was called. Invariants... cannot be removed or replaced
+   * Returns a new ExceptionSafetyTester with the provided MoreContracts...
+   * combined with the Contracts... that were already included in the instance
+   * on which the method was called. Contracts... cannot be removed or replaced
    * once added to an ExceptionSafetyTester instance. A fresh object must be
-   * created in order to get an empty Invariants... list.
+   * created in order to get an empty Contracts... list.
    *
-   * In addition to passing in custom invariant assertion callbacks, this method
+   * In addition to passing in custom contract assertion callbacks, this method
    * accepts `testing::strong_guarantee` as an argument which checks T instances
    * post-throw against freshly created T instances via operator== to verify
    * that any state changes made during the execution of the operation were
    * properly rolled back.
    */
-  template <typename... MoreInvariants>
-  ExceptionSafetyTester<Factory, Operation, Invariants...,
-                        absl::decay_t<MoreInvariants>...>
-  WithInvariants(const MoreInvariants&... more_invariants) const {
-    return {factory_, operation_,
-            std::tuple_cat(invariants_,
-                           std::tuple<absl::decay_t<MoreInvariants>...>(
-                               more_invariants...))};
+  template <typename... MoreContracts>
+  ExceptionSafetyTester<Factory, Operation, Contracts...,
+                        absl::decay_t<MoreContracts>...>
+  WithContracts(const MoreContracts&... more_contracts) const {
+    return {
+        factory_, operation_,
+        std::tuple_cat(contracts_, std::tuple<absl::decay_t<MoreContracts>...>(
+                                       more_contracts...))};
   }
 
   /*
    * Returns a testing::AssertionResult that is the reduced result of the
    * exception safety algorithm. The algorithm short circuits and returns
-   * AssertionFailure after the first invariant callback returns an
-   * AssertionFailure. Otherwise, if all invariant callbacks return an
+   * AssertionFailure after the first contract callback returns an
+   * AssertionFailure. Otherwise, if all contract callbacks return an
    * AssertionSuccess, the reduced result is AssertionSuccess.
    *
    * The passed-in testable operation will not be saved in a new tester instance
@@ -1013,33 +1013,33 @@ class ExceptionSafetyTester {
    *
    * Preconditions for tester.Test(const NewOperation& new_operation):
    *
-   * - May only be called after at least one invariant assertion callback and a
+   * - May only be called after at least one contract assertion callback and a
    *   factory or initial value have been provided.
    */
   template <
       typename NewOperation,
-      typename = EnableIfTestable<sizeof...(Invariants), Factory, NewOperation>>
+      typename = EnableIfTestable<sizeof...(Contracts), Factory, NewOperation>>
   testing::AssertionResult Test(const NewOperation& new_operation) const {
-    return TestImpl(new_operation, absl::index_sequence_for<Invariants...>());
+    return TestImpl(new_operation, absl::index_sequence_for<Contracts...>());
   }
 
   /*
    * Returns a testing::AssertionResult that is the reduced result of the
    * exception safety algorithm. The algorithm short circuits and returns
-   * AssertionFailure after the first invariant callback returns an
-   * AssertionFailure. Otherwise, if all invariant callbacks return an
+   * AssertionFailure after the first contract callback returns an
+   * AssertionFailure. Otherwise, if all contract callbacks return an
    * AssertionSuccess, the reduced result is AssertionSuccess.
    *
    * Preconditions for tester.Test():
    *
-   * - May only be called after at least one invariant assertion callback, a
+   * - May only be called after at least one contract assertion callback, a
    *   factory or initial value and a testable operation have been provided.
    */
-  template <typename LazyOperation = Operation,
-            typename =
-                EnableIfTestable<sizeof...(Invariants), Factory, LazyOperation>>
+  template <
+      typename LazyOperation = Operation,
+      typename = EnableIfTestable<sizeof...(Contracts), Factory, LazyOperation>>
   testing::AssertionResult Test() const {
-    return TestImpl(operation_, absl::index_sequence_for<Invariants...>());
+    return TestImpl(operation_, absl::index_sequence_for<Contracts...>());
   }
 
  private:
@@ -1051,8 +1051,8 @@ class ExceptionSafetyTester {
   ExceptionSafetyTester() {}
 
   ExceptionSafetyTester(const Factory& f, const Operation& o,
-                        const std::tuple<Invariants...>& i)
-      : factory_(f), operation_(o), invariants_(i) {}
+                        const std::tuple<Contracts...>& i)
+      : factory_(f), operation_(o), contracts_(i) {}
 
   template <typename SelectedOperation, size_t... Indices>
   testing::AssertionResult TestImpl(const SelectedOperation& selected_operation,
@@ -1064,28 +1064,28 @@ class ExceptionSafetyTester {
 
       // Run the full exception safety test algorithm for the current countdown
       auto reduced_res =
-          TestAllInvariantsAtCountdown(factory_, selected_operation, count,
-                                       std::get<Indices>(invariants_)...);
-      // If there is no value in the optional, no invariants were run because no
+          TestAllContractsAtCountdown(factory_, selected_operation, count,
+                                      std::get<Indices>(contracts_)...);
+      // If there is no value in the optional, no contracts were run because no
       // exception was thrown. This means that the test is complete and the loop
       // can exit successfully.
       if (!reduced_res.has_value()) {
         return testing::AssertionSuccess();
       }
-      // If the optional is not empty and the value is falsy, an invariant check
+      // If the optional is not empty and the value is falsy, an contract check
       // failed so the test must exit to propegate the failure.
       if (!reduced_res.value()) {
         return reduced_res.value();
       }
       // If the optional is not empty and the value is not falsy, it means
-      // exceptions were thrown but the invariants passed so the test must
+      // exceptions were thrown but the contracts passed so the test must
       // continue to run.
     }
   }
 
   Factory factory_;
   Operation operation_;
-  std::tuple<Invariants...> invariants_;
+  std::tuple<Contracts...> contracts_;
 };
 
 }  // namespace exceptions_internal
@@ -1096,7 +1096,7 @@ class ExceptionSafetyTester {
  * instances of ExceptionSafetyTester.
  *
  * In order to test a T for exception safety, a factory for that T, a testable
- * operation, and at least one invariant callback returning an assertion
+ * operation, and at least one contract callback returning an assertion
  * result must be applied using the respective methods.
  */
 inline exceptions_internal::ExceptionSafetyTester<>
diff --git a/absl/container/fixed_array_exception_safety_test.cc b/absl/container/fixed_array_exception_safety_test.cc
index c123c2a1..da63dbfe 100644
--- a/absl/container/fixed_array_exception_safety_test.cc
+++ b/absl/container/fixed_array_exception_safety_test.cc
@@ -97,7 +97,7 @@ testing::AssertionResult ReadMemory(FixedArr* fixed_arr) {
 
 TEST(FixedArrayExceptionSafety, Fill) {
   auto test_fill = testing::MakeExceptionSafetyTester()
-                       .WithInvariants(ReadMemory)
+                       .WithContracts(ReadMemory)
                        .WithOperation([&](FixedArr* fixed_arr_ptr) {
                          auto thrower =
                              Thrower(kUpdatedValue, testing::nothrow_ctor);
diff --git a/absl/debugging/stacktrace.cc b/absl/debugging/stacktrace.cc
index 61fee619..463fad26 100644
--- a/absl/debugging/stacktrace.cc
+++ b/absl/debugging/stacktrace.cc
@@ -80,11 +80,13 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, int* sizes,
 
 }  // anonymous namespace
 
+ABSL_ATTRIBUTE_NOINLINE
 int GetStackFrames(void** result, int* sizes, int max_depth, int skip_count) {
   return Unwind<true, false>(result, sizes, max_depth, skip_count, nullptr,
                              nullptr);
 }
 
+ABSL_ATTRIBUTE_NOINLINE
 int GetStackFramesWithContext(void** result, int* sizes, int max_depth,
                               int skip_count, const void* uc,
                               int* min_dropped_frames) {
@@ -92,11 +94,13 @@ int GetStackFramesWithContext(void** result, int* sizes, int max_depth,
                             min_dropped_frames);
 }
 
+ABSL_ATTRIBUTE_NOINLINE
 int GetStackTrace(void** result, int max_depth, int skip_count) {
   return Unwind<false, false>(result, nullptr, max_depth, skip_count, nullptr,
                               nullptr);
 }
 
+ABSL_ATTRIBUTE_NOINLINE
 int GetStackTraceWithContext(void** result, int max_depth, int skip_count,
                              const void* uc, int* min_dropped_frames) {
   return Unwind<false, true>(result, nullptr, max_depth, skip_count, uc,
diff --git a/absl/memory/memory_exception_safety_test.cc b/absl/memory/memory_exception_safety_test.cc
index d1f6e84f..00d2b192 100644
--- a/absl/memory/memory_exception_safety_test.cc
+++ b/absl/memory/memory_exception_safety_test.cc
@@ -32,7 +32,7 @@ TEST(MakeUnique, CheckForLeaks) {
                     .WithInitialValue(Thrower(kValue))
                     // Ensures make_unique does not modify the input. The real
                     // test, though, is ConstructorTracker checking for leaks.
-                    .WithInvariants(testing::strong_guarantee);
+                    .WithContracts(testing::strong_guarantee);
 
   EXPECT_TRUE(tester.Test([](Thrower* thrower) {
     static_cast<void>(absl::make_unique<Thrower>(*thrower));
diff --git a/absl/strings/internal/str_format/parser.cc b/absl/strings/internal/str_format/parser.cc
index c3e16fce..5e3d0d05 100644
--- a/absl/strings/internal/str_format/parser.cc
+++ b/absl/strings/internal/str_format/parser.cc
@@ -84,16 +84,24 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
   const char *pos = src->data();
   const char *const end = pos + src->size();
   char c;
-  // Read the next char into `c` and update `pos`. Reads '\0' if at end.
-  const auto get_char = [&] { c = pos == end ? '\0' : *pos++; };
+  // Read the next char into `c` and update `pos`. Returns false if there are
+  // no more chars to read.
+#define ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR()        \
+  do {                                                \
+    if (ABSL_PREDICT_FALSE(pos == end)) return false; \
+    c = *pos++;                                       \
+  } while (0)
 
   const auto parse_digits = [&] {
     int digits = c - '0';
-    // We do not want to overflow `digits` so we consume at most digits10-1
+    // We do not want to overflow `digits` so we consume at most digits10
     // digits. If there are more digits the parsing will fail later on when the
     // digit doesn't match the expected characters.
-    int num_digits = std::numeric_limits<int>::digits10 - 2;
-    for (get_char(); num_digits && std::isdigit(c); get_char()) {
+    int num_digits = std::numeric_limits<int>::digits10;
+    for (;;) {
+      if (ABSL_PREDICT_FALSE(pos == end || !num_digits)) break;
+      c = *pos++;
+      if (!std::isdigit(c)) break;
       --num_digits;
       digits = 10 * digits + c - '0';
     }
@@ -101,14 +109,14 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
   };
 
   if (is_positional) {
-    get_char();
-    if (c < '1' || c > '9') return false;
+    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+    if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return false;
     conv->arg_position = parse_digits();
     assert(conv->arg_position > 0);
-    if (c != '$') return false;
+    if (ABSL_PREDICT_FALSE(c != '$')) return false;
   }
 
-  get_char();
+  ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
 
   // We should start with the basic flag on.
   assert(conv->flags.basic);
@@ -119,32 +127,39 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
   if (c < 'A') {
     conv->flags.basic = false;
 
-    for (; c <= '0'; get_char()) {
+    for (; c <= '0';) {
+      // FIXME: We might be able to speed this up reusing the kIds lookup table
+      // from above.
+      // It might require changing Flags to be a plain integer where we can |= a
+      // value.
       switch (c) {
         case '-':
           conv->flags.left = true;
-          continue;
+          break;
         case '+':
           conv->flags.show_pos = true;
-          continue;
+          break;
         case ' ':
           conv->flags.sign_col = true;
-          continue;
+          break;
         case '#':
           conv->flags.alt = true;
-          continue;
+          break;
         case '0':
           conv->flags.zero = true;
-          continue;
+          break;
+        default:
+          goto flags_done;
       }
-      break;
+      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
     }
+flags_done:
 
     if (c <= '9') {
       if (c >= '0') {
         int maybe_width = parse_digits();
         if (!is_positional && c == '$') {
-          if (*next_arg != 0) return false;
+          if (ABSL_PREDICT_FALSE(*next_arg != 0)) return false;
           // Positional conversion.
           *next_arg = -1;
           conv->flags = Flags();
@@ -153,12 +168,12 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
         }
         conv->width.set_value(maybe_width);
       } else if (c == '*') {
-        get_char();
+        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
         if (is_positional) {
-          if (c < '1' || c > '9') return false;
+          if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return false;
           conv->width.set_from_arg(parse_digits());
-          if (c != '$') return false;
-          get_char();
+          if (ABSL_PREDICT_FALSE(c != '$')) return false;
+          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
         } else {
           conv->width.set_from_arg(++*next_arg);
         }
@@ -166,16 +181,16 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
     }
 
     if (c == '.') {
-      get_char();
+      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
       if (std::isdigit(c)) {
         conv->precision.set_value(parse_digits());
       } else if (c == '*') {
-        get_char();
+        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
         if (is_positional) {
-          if (c < '1' || c > '9') return false;
+          if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return false;
           conv->precision.set_from_arg(parse_digits());
           if (c != '$') return false;
-          get_char();
+          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
         } else {
           conv->precision.set_from_arg(++*next_arg);
         }
@@ -188,23 +203,23 @@ bool ConsumeConversion(string_view *src, UnboundConversion *conv,
   std::int8_t id = kIds[static_cast<unsigned char>(c)];
 
   if (id < 0) {
-    if (id == none) return false;
+    if (ABSL_PREDICT_FALSE(id == none)) return false;
 
     // It is a length modifier.
     using str_format_internal::LengthMod;
     LengthMod length_mod = LengthMod::FromId(static_cast<LM>(~id));
-    get_char();
+    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
     if (c == 'h' && length_mod.id() == LengthMod::h) {
       conv->length_mod = LengthMod::FromId(LengthMod::hh);
-      get_char();
+      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
     } else if (c == 'l' && length_mod.id() == LengthMod::l) {
       conv->length_mod = LengthMod::FromId(LengthMod::ll);
-      get_char();
+      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
     } else {
       conv->length_mod = length_mod;
     }
     id = kIds[static_cast<unsigned char>(c)];
-    if (id < 0) return false;
+    if (ABSL_PREDICT_FALSE(id < 0)) return false;
   }
 
   assert(CheckFastPathSetting(*conv));
diff --git a/absl/strings/internal/str_format/parser_test.cc b/absl/strings/internal/str_format/parser_test.cc
index ac6886d0..ae402031 100644
--- a/absl/strings/internal/str_format/parser_test.cc
+++ b/absl/strings/internal/str_format/parser_test.cc
@@ -84,9 +84,9 @@ class ConsumeUnboundConversionTest : public ::testing::Test {
 TEST_F(ConsumeUnboundConversionTest, ConsumeSpecification) {
   struct Expectation {
     int line;
-    const char *src;
-    const char *out;
-    const char *src_post;
+    string_view src;
+    string_view out;
+    string_view src_post;
   };
   const Expectation kExpect[] = {
     {__LINE__, "",     "",     ""  },
@@ -236,6 +236,16 @@ TEST_F(ConsumeUnboundConversionTest, WidthAndPrecision) {
   EXPECT_EQ(9, o.precision.get_from_arg());
 
   EXPECT_FALSE(Run(".*0$d")) << "no arg 0";
+
+  // Large values
+  EXPECT_TRUE(Run("999999999.999999999d"));
+  EXPECT_FALSE(o.width.is_from_arg());
+  EXPECT_EQ(999999999, o.width.value());
+  EXPECT_FALSE(o.precision.is_from_arg());
+  EXPECT_EQ(999999999, o.precision.value());
+
+  EXPECT_FALSE(Run("1000000000.999999999d"));
+  EXPECT_FALSE(Run("999999999.1000000000d"));
 }
 
 TEST_F(ConsumeUnboundConversionTest, Flags) {
diff --git a/absl/strings/string_view.h b/absl/strings/string_view.h
index 9c03108b..6bcd3c4e 100644
--- a/absl/strings/string_view.h
+++ b/absl/strings/string_view.h
@@ -173,8 +173,19 @@ class string_view {
   // Implicit constructor of a `string_view` from nul-terminated `str`. When
   // accepting possibly null strings, use `absl::NullSafeStringView(str)`
   // instead (see below).
+#if ABSL_HAVE_BUILTIN(__builtin_strlen) || \
+    (defined(__GNUC__) && !defined(__clang__))
+  // GCC has __builtin_strlen according to
+  // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but
+  // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
+  // __builtin_strlen is constexpr.
+  constexpr string_view(const char* str)  // NOLINT(runtime/explicit)
+      : ptr_(str),
+        length_(CheckLengthInternal(str ? __builtin_strlen(str) : 0)) {}
+#else
   constexpr string_view(const char* str)  // NOLINT(runtime/explicit)
-      : ptr_(str), length_(CheckLengthInternal(StrLenInternal(str))) {}
+      : ptr_(str), length_(CheckLengthInternal(str ? strlen(str) : 0)) {}
+#endif
 
   // Implicit constructor of a `string_view` from a `const char*` and length.
   constexpr string_view(const char* data, size_type len)
@@ -481,22 +492,6 @@ class string_view {
   static constexpr size_type kMaxSize =
       std::numeric_limits<difference_type>::max();
 
-  // check whether __builtin_strlen is provided by the compiler.
-  // GCC doesn't have __has_builtin()
-  // (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66970),
-  // but has __builtin_strlen according to
-  // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html.
-#if ABSL_HAVE_BUILTIN(__builtin_strlen) || \
-    (defined(__GNUC__) && !defined(__clang__))
-  static constexpr size_type StrLenInternal(const char* str) {
-    return str ? __builtin_strlen(str) : 0;
-  }
-#else
-  static constexpr size_type StrLenInternal(const char* str) {
-    return str ? strlen(str) : 0;
-  }
-#endif
-
   static constexpr size_type CheckLengthInternal(size_type len) {
     return ABSL_ASSERT(len <= kMaxSize), len;
   }
diff --git a/absl/synchronization/internal/graphcycles.cc b/absl/synchronization/internal/graphcycles.cc
index ab1f3f84..d3878de2 100644
--- a/absl/synchronization/internal/graphcycles.cc
+++ b/absl/synchronization/internal/graphcycles.cc
@@ -204,8 +204,7 @@ class NodeSet {
   }
 
  private:
-  static const int32_t kEmpty;
-  static const int32_t kDel;
+  enum : int32_t { kEmpty = -1, kDel = -2 };
   Vec<int32_t> table_;
   uint32_t occupied_;     // Count of non-empty slots (includes deleted slots)
 
@@ -255,9 +254,6 @@ class NodeSet {
   NodeSet& operator=(const NodeSet&) = delete;
 };
 
-const int32_t NodeSet::kEmpty = -1;
-const int32_t NodeSet::kDel = -2;
-
 // We encode a node index and a node version in GraphId.  The version
 // number is incremented when the GraphId is freed which automatically
 // invalidates all copies of the GraphId.
diff --git a/absl/time/time.h b/absl/time/time.h
index 36e10b91..2f0fda4c 100644
--- a/absl/time/time.h
+++ b/absl/time/time.h
@@ -322,6 +322,9 @@ Duration Ceil(Duration d, Duration unit);
 //   0 == d / inf
 //   INT64_MAX == inf / d
 //
+//   d < inf
+//   -inf < d
+//
 //   // Division by zero returns infinity, or INT64_MIN/MAX where appropriate.
 //   inf == d / 0
 //   INT64_MAX == d / absl::ZeroDuration()
diff --git a/absl/types/any_exception_safety_test.cc b/absl/types/any_exception_safety_test.cc
index cfb82d80..f9dd8c48 100644
--- a/absl/types/any_exception_safety_test.cc
+++ b/absl/types/any_exception_safety_test.cc
@@ -107,7 +107,7 @@ TEST(AnyExceptionSafety, Assignment) {
   };
   auto any_strong_tester = testing::MakeExceptionSafetyTester()
                                .WithInitialValue(original)
-                               .WithInvariants(AnyInvariants, any_is_strong);
+                               .WithContracts(AnyInvariants, any_is_strong);
 
   Thrower val(2);
   absl::any any_val(val);
@@ -129,7 +129,7 @@ TEST(AnyExceptionSafety, Assignment) {
   auto strong_empty_any_tester =
       testing::MakeExceptionSafetyTester()
           .WithInitialValue(absl::any{})
-          .WithInvariants(AnyInvariants, empty_any_is_strong);
+          .WithContracts(AnyInvariants, empty_any_is_strong);
 
   EXPECT_TRUE(strong_empty_any_tester.Test(assign_any));
   EXPECT_TRUE(strong_empty_any_tester.Test(assign_val));
@@ -142,7 +142,7 @@ TEST(AnyExceptionSafety, Emplace) {
       absl::any{absl::in_place_type_t<Thrower>(), 1, testing::nothrow_ctor};
   auto one_tester = testing::MakeExceptionSafetyTester()
                         .WithInitialValue(initial_val)
-                        .WithInvariants(AnyInvariants, AnyIsEmpty);
+                        .WithContracts(AnyInvariants, AnyIsEmpty);
 
   auto emp_thrower = [](absl::any* ap) { ap->emplace<Thrower>(2); };
   auto emp_throwervec = [](absl::any* ap) {
diff --git a/absl/types/internal/variant.h b/absl/types/internal/variant.h
index f220afd0..eff4fefe 100644
--- a/absl/types/internal/variant.h
+++ b/absl/types/internal/variant.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Abseil Authors.
+// Copyright 2018 The Abseil Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -910,6 +910,11 @@ struct PerformVisitation {
   template <std::size_t... TupIs, std::size_t... Is>
   constexpr ReturnType Run(std::false_type /*has_valueless*/,
                            index_sequence<TupIs...>, SizeT<Is>...) const {
+    static_assert(
+        std::is_same<ReturnType,
+                     absl::result_of_t<Op(VariantAccessResult<
+                                          Is, QualifiedVariants>...)>>::value,
+        "All visitation overloads must have the same return type.");
     return absl::base_internal::Invoke(
         absl::forward<Op>(op),
         VariantCoreAccess::Access<Is>(
diff --git a/absl/types/optional_exception_safety_test.cc b/absl/types/optional_exception_safety_test.cc
index 31eb66df..d117ee51 100644
--- a/absl/types/optional_exception_safety_test.cc
+++ b/absl/types/optional_exception_safety_test.cc
@@ -43,7 +43,7 @@ bool ValueThrowsBadOptionalAccess(const OptionalT& optional) try {
 }
 
 template <typename OptionalT>
-AssertionResult CheckInvariants(OptionalT* optional_ptr) {
+AssertionResult OptionalInvariants(OptionalT* optional_ptr) {
   // Check the current state post-throw for validity
   auto& optional = *optional_ptr;
 
@@ -123,8 +123,8 @@ TEST(OptionalExceptionSafety, NothrowConstructors) {
 TEST(OptionalExceptionSafety, Emplace) {
   // Test the basic guarantee plus test the result of optional::has_value()
   // is false in all cases
-  auto disengaged_test = MakeExceptionSafetyTester().WithInvariants(
-      CheckInvariants<Optional>, CheckDisengaged<Optional>);
+  auto disengaged_test = MakeExceptionSafetyTester().WithContracts(
+      OptionalInvariants<Optional>, CheckDisengaged<Optional>);
   auto disengaged_test_empty = disengaged_test.WithInitialValue(Optional());
   auto disengaged_test_nonempty =
       disengaged_test.WithInitialValue(Optional(kInitialInteger));
@@ -147,11 +147,11 @@ TEST(OptionalExceptionSafety, EverythingThrowsSwap) {
   // Test the basic guarantee plus test the result of optional::has_value()
   // remains the same
   auto test =
-      MakeExceptionSafetyTester().WithInvariants(CheckInvariants<Optional>);
+      MakeExceptionSafetyTester().WithContracts(OptionalInvariants<Optional>);
   auto disengaged_test_empty = test.WithInitialValue(Optional())
-                                   .WithInvariants(CheckDisengaged<Optional>);
+                                   .WithContracts(CheckDisengaged<Optional>);
   auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger))
-                                   .WithInvariants(CheckEngaged<Optional>);
+                                   .WithContracts(CheckEngaged<Optional>);
 
   auto swap_empty = [](Optional* optional_ptr) {
     auto empty = Optional();
@@ -192,11 +192,11 @@ TEST(OptionalExceptionSafety, CopyAssign) {
   // Test the basic guarantee plus test the result of optional::has_value()
   // remains the same
   auto test =
-      MakeExceptionSafetyTester().WithInvariants(CheckInvariants<Optional>);
+      MakeExceptionSafetyTester().WithContracts(OptionalInvariants<Optional>);
   auto disengaged_test_empty = test.WithInitialValue(Optional())
-                                   .WithInvariants(CheckDisengaged<Optional>);
+                                   .WithContracts(CheckDisengaged<Optional>);
   auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger))
-                                   .WithInvariants(CheckEngaged<Optional>);
+                                   .WithContracts(CheckEngaged<Optional>);
 
   auto copyassign_nonempty = [](Optional* optional_ptr) {
     auto nonempty =
@@ -218,11 +218,11 @@ TEST(OptionalExceptionSafety, MoveAssign) {
   // Test the basic guarantee plus test the result of optional::has_value()
   // remains the same
   auto test =
-      MakeExceptionSafetyTester().WithInvariants(CheckInvariants<Optional>);
+      MakeExceptionSafetyTester().WithContracts(OptionalInvariants<Optional>);
   auto disengaged_test_empty = test.WithInitialValue(Optional())
-                                   .WithInvariants(CheckDisengaged<Optional>);
+                                   .WithContracts(CheckDisengaged<Optional>);
   auto engaged_test_nonempty = test.WithInitialValue(Optional(kInitialInteger))
-                                   .WithInvariants(CheckEngaged<Optional>);
+                                   .WithContracts(CheckEngaged<Optional>);
 
   auto moveassign_empty = [](Optional* optional_ptr) {
     auto empty = Optional();
diff --git a/absl/types/variant_exception_safety_test.cc b/absl/types/variant_exception_safety_test.cc
index a3c9eac3..58436f07 100644
--- a/absl/types/variant_exception_safety_test.cc
+++ b/absl/types/variant_exception_safety_test.cc
@@ -59,7 +59,7 @@ void ToValuelessByException(ThrowingVariant& v) {  // NOLINT
 }
 
 // Check that variant is still in a usable state after an exception is thrown.
-testing::AssertionResult CheckInvariants(ThrowingVariant* v) {
+testing::AssertionResult VariantInvariants(ThrowingVariant* v) {
   using testing::AssertionFailure;
   using testing::AssertionSuccess;
 
@@ -213,8 +213,8 @@ TEST(VariantExceptionSafetyTest, CopyAssign) {
         MakeExceptionSafetyTester()
             .WithInitialValue(WithThrower())
             .WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; });
-    EXPECT_TRUE(tester.WithInvariants(CheckInvariants).Test());
-    EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_TRUE(tester.WithContracts(VariantInvariants).Test());
+    EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test());
   }
   {
     const ThrowingVariant rhs(ExpectedThrowerVec());
@@ -222,8 +222,8 @@ TEST(VariantExceptionSafetyTest, CopyAssign) {
         MakeExceptionSafetyTester()
             .WithInitialValue(WithThrowerVec())
             .WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; });
-    EXPECT_TRUE(tester.WithInvariants(CheckInvariants).Test());
-    EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_TRUE(tester.WithContracts(VariantInvariants).Test());
+    EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test());
   }
   // libstdc++ std::variant has bugs on copy assignment regarding exception
   // safety.
@@ -251,12 +251,12 @@ TEST(VariantExceptionSafetyTest, CopyAssign) {
             .WithInitialValue(WithCopyNoThrow())
             .WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; });
     EXPECT_TRUE(tester
-                    .WithInvariants(CheckInvariants,
-                                    [](ThrowingVariant* lhs) {
-                                      return lhs->valueless_by_exception();
-                                    })
+                    .WithContracts(VariantInvariants,
+                                   [](ThrowingVariant* lhs) {
+                                     return lhs->valueless_by_exception();
+                                   })
                     .Test());
-    EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test());
   }
 #endif  // !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__))
   {
@@ -268,7 +268,7 @@ TEST(VariantExceptionSafetyTest, CopyAssign) {
     const ThrowingVariant rhs(MoveNothrow{});
     EXPECT_TRUE(MakeExceptionSafetyTester()
                     .WithInitialValue(WithThrower())
-                    .WithInvariants(CheckInvariants, strong_guarantee)
+                    .WithContracts(VariantInvariants, strong_guarantee)
                     .Test([&rhs](ThrowingVariant* lhs) { *lhs = rhs; }));
   }
 }
@@ -304,11 +304,11 @@ TEST(VariantExceptionSafetyTest, MoveAssign) {
                         *lhs = std::move(copy);
                       });
     EXPECT_TRUE(tester
-                    .WithInvariants(
-                        CheckInvariants,
+                    .WithContracts(
+                        VariantInvariants,
                         [&](ThrowingVariant* lhs) { return lhs->index() == j; })
                     .Test());
-    EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test());
   }
   {
     // - otherwise (index() != j), equivalent to
@@ -318,10 +318,10 @@ TEST(VariantExceptionSafetyTest, MoveAssign) {
     ThrowingVariant rhs(CopyNothrow{});
     EXPECT_TRUE(MakeExceptionSafetyTester()
                     .WithInitialValue(WithThrower())
-                    .WithInvariants(CheckInvariants,
-                                    [](ThrowingVariant* lhs) {
-                                      return lhs->valueless_by_exception();
-                                    })
+                    .WithContracts(VariantInvariants,
+                                   [](ThrowingVariant* lhs) {
+                                     return lhs->valueless_by_exception();
+                                   })
                     .Test([&](ThrowingVariant* lhs) {
                       auto copy = rhs;
                       *lhs = std::move(copy);
@@ -347,12 +347,12 @@ TEST(VariantExceptionSafetyTest, ValueAssign) {
             .WithInitialValue(WithThrower())
             .WithOperation([rhs](ThrowingVariant* lhs) { *lhs = rhs; });
     EXPECT_TRUE(copy_tester
-                    .WithInvariants(CheckInvariants,
-                                    [](ThrowingVariant* lhs) {
-                                      return !lhs->valueless_by_exception();
-                                    })
+                    .WithContracts(VariantInvariants,
+                                   [](ThrowingVariant* lhs) {
+                                     return !lhs->valueless_by_exception();
+                                   })
                     .Test());
-    EXPECT_FALSE(copy_tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_FALSE(copy_tester.WithContracts(strong_guarantee).Test());
     // move assign
     auto move_tester = MakeExceptionSafetyTester()
                            .WithInitialValue(WithThrower())
@@ -361,13 +361,13 @@ TEST(VariantExceptionSafetyTest, ValueAssign) {
                              *lhs = std::move(copy);
                            });
     EXPECT_TRUE(move_tester
-                    .WithInvariants(CheckInvariants,
-                                    [](ThrowingVariant* lhs) {
-                                      return !lhs->valueless_by_exception();
-                                    })
+                    .WithContracts(VariantInvariants,
+                                   [](ThrowingVariant* lhs) {
+                                     return !lhs->valueless_by_exception();
+                                   })
                     .Test());
 
-    EXPECT_FALSE(move_tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_FALSE(move_tester.WithContracts(strong_guarantee).Test());
   }
   // Otherwise (*this holds something else), if is_nothrow_constructible_v<Tj,
   // T> || !is_nothrow_move_constructible_v<Tj> is true, equivalent to
@@ -400,12 +400,12 @@ TEST(VariantExceptionSafetyTest, ValueAssign) {
             .WithInitialValue(WithCopyNoThrow())
             .WithOperation([&rhs](ThrowingVariant* lhs) { *lhs = rhs; });
     EXPECT_TRUE(copy_tester
-                    .WithInvariants(CheckInvariants,
-                                    [](ThrowingVariant* lhs) {
-                                      return lhs->valueless_by_exception();
-                                    })
+                    .WithContracts(VariantInvariants,
+                                   [](ThrowingVariant* lhs) {
+                                     return lhs->valueless_by_exception();
+                                   })
                     .Test());
-    EXPECT_FALSE(copy_tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_FALSE(copy_tester.WithContracts(strong_guarantee).Test());
     // move
     auto move_tester = MakeExceptionSafetyTester()
                            .WithInitialValue(WithCopyNoThrow())
@@ -413,12 +413,12 @@ TEST(VariantExceptionSafetyTest, ValueAssign) {
                              *lhs = ExpectedThrower(testing::nothrow_ctor);
                            });
     EXPECT_TRUE(move_tester
-                    .WithInvariants(CheckInvariants,
-                                    [](ThrowingVariant* lhs) {
-                                      return lhs->valueless_by_exception();
-                                    })
+                    .WithContracts(VariantInvariants,
+                                   [](ThrowingVariant* lhs) {
+                                     return lhs->valueless_by_exception();
+                                   })
                     .Test());
-    EXPECT_FALSE(move_tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_FALSE(move_tester.WithContracts(strong_guarantee).Test());
   }
   // Otherwise (if is_nothrow_constructible_v<Tj, T> == false &&
   // is_nothrow_move_constructible<Tj> == true),
@@ -432,7 +432,7 @@ TEST(VariantExceptionSafetyTest, ValueAssign) {
     MoveNothrow rhs;
     EXPECT_TRUE(MakeExceptionSafetyTester()
                     .WithInitialValue(WithThrower())
-                    .WithInvariants(CheckInvariants, strong_guarantee)
+                    .WithContracts(VariantInvariants, strong_guarantee)
                     .Test([&rhs](ThrowingVariant* lhs) { *lhs = rhs; }));
   }
 #endif  // !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__))
@@ -450,12 +450,12 @@ TEST(VariantExceptionSafetyTest, Emplace) {
                         v->emplace<Thrower>(args);
                       });
     EXPECT_TRUE(tester
-                    .WithInvariants(CheckInvariants,
-                                    [](ThrowingVariant* v) {
-                                      return v->valueless_by_exception();
-                                    })
+                    .WithContracts(VariantInvariants,
+                                   [](ThrowingVariant* v) {
+                                     return v->valueless_by_exception();
+                                   })
                     .Test());
-    EXPECT_FALSE(tester.WithInvariants(strong_guarantee).Test());
+    EXPECT_FALSE(tester.WithContracts(strong_guarantee).Test());
   }
 }
 
@@ -472,7 +472,7 @@ TEST(VariantExceptionSafetyTest, Swap) {
     ThrowingVariant rhs = ExpectedThrower();
     EXPECT_TRUE(MakeExceptionSafetyTester()
                     .WithInitialValue(WithThrower())
-                    .WithInvariants(CheckInvariants)
+                    .WithContracts(VariantInvariants)
                     .Test([&](ThrowingVariant* lhs) {
                       auto copy = rhs;
                       lhs->swap(copy);
@@ -486,7 +486,7 @@ TEST(VariantExceptionSafetyTest, Swap) {
     ThrowingVariant rhs = ExpectedThrower();
     EXPECT_TRUE(MakeExceptionSafetyTester()
                     .WithInitialValue(WithCopyNoThrow())
-                    .WithInvariants(CheckInvariants)
+                    .WithContracts(VariantInvariants)
                     .Test([&](ThrowingVariant* lhs) {
                       auto copy = rhs;
                       lhs->swap(copy);
@@ -496,7 +496,7 @@ TEST(VariantExceptionSafetyTest, Swap) {
     ThrowingVariant rhs = ExpectedThrower();
     EXPECT_TRUE(MakeExceptionSafetyTester()
                     .WithInitialValue(WithCopyNoThrow())
-                    .WithInvariants(CheckInvariants)
+                    .WithContracts(VariantInvariants)
                     .Test([&](ThrowingVariant* lhs) {
                       auto copy = rhs;
                       copy.swap(*lhs);