Export of internal Abseil changes.

--
7672429b51fa4edc9e2386f3d6ead89a33e523c0 by Xiaoyi Zhang <zhangxy@google.com>:

Work around a bug in MSVC 2015 which causes compiler error when building
variant_test with inline namespace for the LTS release.
The bug is reduced to https://godbolt.org/g/hvqDVz.

PiperOrigin-RevId: 201343049

--
dfe4f3869aa4b70dda69631816103e7b2c53c593 by Shaindel Schwartz <shaindel@google.com>:

Update date for LTS branch.

PiperOrigin-RevId: 201335133

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

Update bazel_toolchains to the latest commit.

PiperOrigin-RevId: 201231595

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

Fix LTS wording, move to top level

PiperOrigin-RevId: 201054433
GitOrigin-RevId: 7672429b51fa4edc9e2386f3d6ead89a33e523c0
Change-Id: Id63a986870993889258f6364634a7880d226d187

2 files changed, 22 insertions, 29 deletions

diff --git a/absl/types/internal/variant.h b/absl/types/internal/variant.h
index 94c2dda..3414c91 100644
--- a/absl/types/internal/variant.h
+++ b/absl/types/internal/variant.h
@@ -1100,49 +1100,40 @@ using EqualResult = decltype(std::declval<T>() == std::declval<T>());
 template <class T>
 using NotEqualResult = decltype(std::declval<T>() != std::declval<T>());
 
-template <class T>
-using HasLessThan = is_detected_convertible<bool, LessThanResult, T>;
-
-template <class T>
-using HasGreaterThan = is_detected_convertible<bool, GreaterThanResult, T>;
-
-template <class T>
-using HasLessThanOrEqual =
-    is_detected_convertible<bool, LessThanOrEqualResult, T>;
-
-template <class T>
-using HasGreaterThanOrEqual =
-    is_detected_convertible<bool, GreaterThanOrEqualResult, T>;
-
-template <class T>
-using HasEqual = is_detected_convertible<bool, EqualResult, T>;
-
-template <class T>
-using HasNotEqual = is_detected_convertible<bool, NotEqualResult, T>;
-
 template <class... T>
-using RequireAllHaveEqualT =
-    absl::enable_if_t<absl::conjunction<HasEqual<T>...>::value, bool>;
+using RequireAllHaveEqualT = absl::enable_if_t<
+    absl::conjunction<is_detected_convertible<bool, EqualResult, T>...>::value,
+    bool>;
 
 template <class... T>
 using RequireAllHaveNotEqualT =
-    absl::enable_if_t<absl::conjunction<HasEqual<T>...>::value, bool>;
+    absl::enable_if_t<absl::conjunction<is_detected_convertible<
+                          bool, NotEqualResult, T>...>::value,
+                      bool>;
 
 template <class... T>
 using RequireAllHaveLessThanT =
-    absl::enable_if_t<absl::conjunction<HasLessThan<T>...>::value, bool>;
+    absl::enable_if_t<absl::conjunction<is_detected_convertible<
+                          bool, LessThanResult, T>...>::value,
+                      bool>;
 
 template <class... T>
 using RequireAllHaveLessThanOrEqualT =
-    absl::enable_if_t<absl::conjunction<HasLessThan<T>...>::value, bool>;
+    absl::enable_if_t<absl::conjunction<is_detected_convertible<
+                          bool, LessThanOrEqualResult, T>...>::value,
+                      bool>;
 
 template <class... T>
 using RequireAllHaveGreaterThanOrEqualT =
-    absl::enable_if_t<absl::conjunction<HasLessThan<T>...>::value, bool>;
+    absl::enable_if_t<absl::conjunction<is_detected_convertible<
+                          bool, GreaterThanOrEqualResult, T>...>::value,
+                      bool>;
 
 template <class... T>
 using RequireAllHaveGreaterThanT =
-    absl::enable_if_t<absl::conjunction<HasLessThan<T>...>::value, bool>;
+    absl::enable_if_t<absl::conjunction<is_detected_convertible<
+                          bool, GreaterThanResult, T>...>::value,
+                      bool>;
 
 // Helper template containing implementations details of variant that can't go
 // in the private section. For convenience, this takes the variant type as a
diff --git a/absl/types/variant.h b/absl/types/variant.h
index 5837a1b..55017ae 100644
--- a/absl/types/variant.h
+++ b/absl/types/variant.h
@@ -445,9 +445,11 @@ constexpr bool operator!=(monostate, monostate) noexcept { return false; }
 //------------------------------------------------------------------------------
 template <typename T0, typename... Tn>
 class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> {
+  // Intentionally not qualifing `negation` with `absl::` to work around a bug
+  // in MSVC 2015 with inline namespace and variadic template.
   static_assert(absl::conjunction<std::is_object<T0>, std::is_object<Tn>...,
-                                  absl::negation<std::is_array<T0>>,
-                                  absl::negation<std::is_array<Tn>>...,
+                                  negation<std::is_array<T0> >,
+                                  negation<std::is_array<Tn> >...,
                                   std::is_nothrow_destructible<T0>,
                                   std::is_nothrow_destructible<Tn>...>::value,
                 "Attempted to instantiate a variant with an unsupported type.");