Export of internal Abseil changes.

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

Don't create install rules when Abseil is used as a subdirectory.

Fix #287

PiperOrigin-RevId: 240559825

--
a5d9b06fe736143068997988b654b5f66ec3266a by Matt Calabrese <calabrese@google.com>:

Make absl::nullopt an inline constexpr variable, as specified in the standard (with a workaround for pre-c++17 compilers).

PiperOrigin-RevId: 240552286

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

Internal Change

PiperOrigin-RevId: 240425622

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

Add default link options to absl builds.

Currently all this does is add -ignore:4221 to Abseil msvc builds, but the structure is all in place to add more link options when necessary

Fix #277

Note: This CL changes tact for us in that it puts the default options in the helper function as opposed to the invocations of absl_cc_blah.  The original intent of keeping these out of the helper functions was to make generating the CMakeLists.txt files have a smaller diff, but looking now that is a problem for the future, and small compared to making maintenance and use of our CMake buildsystem easier
PiperOrigin-RevId: 240409463

--
4aa120e9dcf76d29e9ca0008d0f6d4d9fa8abe8c by Matt Kulukundis <kfm@google.com>:

Reduce flake rate for non-determistic test to < 1/10,000

PiperOrigin-RevId: 240370938

--
bc30e219531827bfbf90915b2067c7fb8160bb6d by Derek Mauro <dmauro@google.com>:

Add Bazel caching on Kokoro for new linux targets.

PiperOrigin-RevId: 240356556

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

include AbseilInstallDirs instead of GNUInstallDirs.  It worked before because global_CMakeLists.txt also included AbseilInstallDirs

PiperOrigin-RevId: 240206409

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

Fix logic for when we create the variant_exception_safety_test in CMake.  Currently we are only running in on gcc > 4.9, when we want it run on every compiler except gcc <= 4.8

PiperOrigin-RevId: 240194174

--
01518006b351d3670ba1d349cfbcb7dd6f3a8b84 by CJ Johnson <johnsoncj@google.com>:

Removes old implementation warning comment now that InlinedVector has an implementation detail file

PiperOrigin-RevId: 240167265

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

Remove the forward declaration of Span

PiperOrigin-RevId: 240156660

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

Prepare CMake install rule for LTS releases:
  * Remove the warning against installing in system install locations
  * Insert versioning to keep different LTS installs from colliding.  Headers are installed in <prefix>/absl_$version/include, .a files in <prefix>/absl_$version/lib, and config files in <prefix>/absl_$version/lib/cmake

PiperOrigin-RevId: 240153986

--
de63488ab6236e041f08260794b0b634a2b8ed16 by CJ Johnson <johnsoncj@google.com>:

Reduce reader confusion by using std::addressof(...) even when the type is known to not overload operator&(...)

PiperOrigin-RevId: 240131902
GitOrigin-RevId: f6c627ce4470a814adc377947b58346eef69a4c9
Change-Id: I95dbbacaaf65aceeeca9e9bee5fd9ea456225f62

1 files changed, 54 insertions, 43 deletions

diff --git a/absl/types/span.h b/absl/types/span.h
index d7f48d9f3f..e5c4fe1e4d 100644
--- a/absl/types/span.h
+++ b/absl/types/span.h
@@ -73,9 +73,6 @@
 
 namespace absl {
 
-template <typename T>
-class Span;
-
 namespace span_internal {
 // A constexpr min function
 constexpr size_t Min(size_t a, size_t b) noexcept { return a < b ? a : b; }
@@ -133,14 +130,16 @@ template <typename T>
 using EnableIfMutable =
     typename std::enable_if<!std::is_const<T>::value, int>::type;
 
-template <typename T>
-bool EqualImpl(Span<T> a, Span<T> b) {
+template <template <typename> class SpanT, typename T>
+bool EqualImpl(SpanT<T> a, SpanT<T> b) {
   static_assert(std::is_const<T>::value, "");
   return absl::equal(a.begin(), a.end(), b.begin(), b.end());
 }
 
-template <typename T>
-bool LessThanImpl(Span<T> a, Span<T> b) {
+template <template <typename> class SpanT, typename T>
+bool LessThanImpl(SpanT<T> a, SpanT<T> b) {
+  // We can't use value_type since that is remove_cv_t<T>, so we go the long way
+  // around.
   static_assert(std::is_const<T>::value, "");
   return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
 }
@@ -165,8 +164,8 @@ struct IsConvertible : IsConvertibleHelper<From, To>::type {};
 // TODO(zhangxy): replace `IsConvertible` with `std::is_convertible` once the
 // older version of libcxx is not supported.
 template <typename From, typename To>
-using EnableIfConvertibleToSpanConst =
-    typename std::enable_if<IsConvertible<From, Span<const To>>::value>::type;
+using EnableIfConvertibleTo =
+    typename std::enable_if<IsConvertible<From, To>::value>::type;
 }  // namespace span_internal
 
 //------------------------------------------------------------------------------
@@ -551,25 +550,27 @@ const typename Span<T>::size_type Span<T>::npos;
 // operator==
 template <typename T>
 bool operator==(Span<T> a, Span<T> b) {
-  return span_internal::EqualImpl<const T>(a, b);
+  return span_internal::EqualImpl<Span, const T>(a, b);
 }
 template <typename T>
 bool operator==(Span<const T> a, Span<T> b) {
-  return span_internal::EqualImpl<const T>(a, b);
+  return span_internal::EqualImpl<Span, const T>(a, b);
 }
 template <typename T>
 bool operator==(Span<T> a, Span<const T> b) {
-  return span_internal::EqualImpl<const T>(a, b);
+  return span_internal::EqualImpl<Span, const T>(a, b);
 }
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 bool operator==(const U& a, Span<T> b) {
-  return span_internal::EqualImpl<const T>(a, b);
+  return span_internal::EqualImpl<Span, const T>(a, b);
 }
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 bool operator==(Span<T> a, const U& b) {
-  return span_internal::EqualImpl<const T>(a, b);
+  return span_internal::EqualImpl<Span, const T>(a, b);
 }
 
 // operator!=
@@ -585,13 +586,15 @@ template <typename T>
 bool operator!=(Span<T> a, Span<const T> b) {
   return !(a == b);
 }
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 bool operator!=(const U& a, Span<T> b) {
   return !(a == b);
 }
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 bool operator!=(Span<T> a, const U& b) {
   return !(a == b);
 }
@@ -599,25 +602,27 @@ bool operator!=(Span<T> a, const U& b) {
 // operator<
 template <typename T>
 bool operator<(Span<T> a, Span<T> b) {
-  return span_internal::LessThanImpl<const T>(a, b);
+  return span_internal::LessThanImpl<Span, const T>(a, b);
 }
 template <typename T>
 bool operator<(Span<const T> a, Span<T> b) {
-  return span_internal::LessThanImpl<const T>(a, b);
+  return span_internal::LessThanImpl<Span, const T>(a, b);
 }
 template <typename T>
 bool operator<(Span<T> a, Span<const T> b) {
-  return span_internal::LessThanImpl<const T>(a, b);
+  return span_internal::LessThanImpl<Span, const T>(a, b);
 }
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 bool operator<(const U& a, Span<T> b) {
-  return span_internal::LessThanImpl<const T>(a, b);
+  return span_internal::LessThanImpl<Span, const T>(a, b);
 }
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 bool operator<(Span<T> a, const U& b) {
-  return span_internal::LessThanImpl<const T>(a, b);
+  return span_internal::LessThanImpl<Span, const T>(a, b);
 }
 
 // operator>
@@ -633,13 +638,15 @@ template <typename T>
 bool operator>(Span<T> a, Span<const T> b) {
   return b < a;
 }
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 bool operator>(const U& a, Span<T> b) {
   return b < a;
 }
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 bool operator>(Span<T> a, const U& b) {
   return b < a;
 }
@@ -657,13 +664,15 @@ template <typename T>
 bool operator<=(Span<T> a, Span<const T> b) {
   return !(b < a);
 }
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 bool operator<=(const U& a, Span<T> b) {
   return !(b < a);
 }
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 bool operator<=(Span<T> a, const U& b) {
   return !(b < a);
 }
@@ -681,13 +690,15 @@ template <typename T>
 bool operator>=(Span<T> a, Span<const T> b) {
   return !(a < b);
 }
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 bool operator>=(const U& a, Span<T> b) {
   return !(a < b);
 }
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 bool operator>=(Span<T> a, const U& b) {
   return !(a < b);
 }