@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/base/internal/low_level_alloc.h

@@ -1,133 +0,0 @@
-// Copyright 2017 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.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
-#define ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
-
-// A simple thread-safe memory allocator that does not depend on
-// mutexes or thread-specific data.  It is intended to be used
-// sparingly, and only when malloc() would introduce an unwanted
-// dependency, such as inside the heap-checker, or the Mutex
-// implementation.
-
-// IWYU pragma: private, include "base/low_level_alloc.h"
-
-#include <sys/types.h>
-
-#include <cstdint>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-
-// LowLevelAlloc requires that the platform support low-level
-// allocation of virtual memory. Platforms lacking this cannot use
-// LowLevelAlloc.
-#ifdef ABSL_LOW_LEVEL_ALLOC_MISSING
-#error ABSL_LOW_LEVEL_ALLOC_MISSING cannot be directly set
-#elif !defined(ABSL_HAVE_MMAP) && !defined(_WIN32)
-#define ABSL_LOW_LEVEL_ALLOC_MISSING 1
-#endif
-
-// Using LowLevelAlloc with kAsyncSignalSafe isn't supported on Windows or
-// asm.js / WebAssembly.
-// See https://kripken.github.io/emscripten-site/docs/porting/pthreads.html
-// for more information.
-#ifdef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
-#error ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING cannot be directly set
-#elif defined(_WIN32) || defined(__asmjs__) || defined(__wasm__) || \
-    defined(__hexagon__)
-#define ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING 1
-#endif
-
-#include <cstddef>
-
-#include "absl/base/port.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-class LowLevelAlloc {
- public:
-  struct Arena;       // an arena from which memory may be allocated
-
-  // Returns a pointer to a block of at least "request" bytes
-  // that have been newly allocated from the specific arena.
-  // for Alloc() call the DefaultArena() is used.
-  // Returns 0 if passed request==0.
-  // Does not return 0 under other circumstances; it crashes if memory
-  // is not available.
-  static void *Alloc(size_t request) ABSL_ATTRIBUTE_SECTION(malloc_hook);
-  static void *AllocWithArena(size_t request, Arena *arena)
-      ABSL_ATTRIBUTE_SECTION(malloc_hook);
-
-  // Deallocates a region of memory that was previously allocated with
-  // Alloc().   Does nothing if passed 0.   "s" must be either 0,
-  // or must have been returned from a call to Alloc() and not yet passed to
-  // Free() since that call to Alloc().  The space is returned to the arena
-  // from which it was allocated.
-  static void Free(void *s) ABSL_ATTRIBUTE_SECTION(malloc_hook);
-
-  // ABSL_ATTRIBUTE_SECTION(malloc_hook) for Alloc* and Free
-  // are to put all callers of MallocHook::Invoke* in this module
-  // into special section,
-  // so that MallocHook::GetCallerStackTrace can function accurately.
-
-  // Create a new arena.
-  // The root metadata for the new arena is allocated in the
-  // meta_data_arena; the DefaultArena() can be passed for meta_data_arena.
-  // These values may be ored into flags:
-  enum {
-    // Report calls to Alloc() and Free() via the MallocHook interface.
-    // Set in the DefaultArena.
-    kCallMallocHook = 0x0001,
-
-#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
-    // Make calls to Alloc(), Free() be async-signal-safe. Not set in
-    // DefaultArena(). Not supported on all platforms.
-    kAsyncSignalSafe = 0x0002,
-#endif
-  };
-  // Construct a new arena.  The allocation of the underlying metadata honors
-  // the provided flags.  For example, the call NewArena(kAsyncSignalSafe)
-  // is itself async-signal-safe, as well as generatating an arena that provides
-  // async-signal-safe Alloc/Free.
-  static Arena *NewArena(uint32_t flags);
-
-  // Destroys an arena allocated by NewArena and returns true,
-  // provided no allocated blocks remain in the arena.
-  // If allocated blocks remain in the arena, does nothing and
-  // returns false.
-  // It is illegal to attempt to destroy the DefaultArena().
-  static bool DeleteArena(Arena *arena);
-
-  // The default arena that always exists.
-  static Arena *DefaultArena();
-
- private:
-  LowLevelAlloc();      // no instances
-};
-
-// Returns a global async-signal-safe arena for LowLevelAlloc.
-LowLevelAlloc::Arena *SigSafeArena();
-
-// Ensures the global async-signal-safe arena for LowLevelAlloc is initialized.
-void InitSigSafeArena();
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_

package/deps/abseil-cpp/absl/base/internal/low_level_alloc_test.cc

@@ -1,180 +0,0 @@
-// Copyright 2017 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.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "absl/base/internal/low_level_alloc.h"
-
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <thread>  // NOLINT(build/c++11)
-#include <unordered_map>
-#include <utility>
-
-#ifdef __EMSCRIPTEN__
-#include <emscripten.h>
-#endif
-
-#include "absl/container/node_hash_map.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-namespace {
-
-// This test doesn't use gtest since it needs to test that everything
-// works before main().
-#define TEST_ASSERT(x)                                           \
-  if (!(x)) {                                                    \
-    printf("TEST_ASSERT(%s) FAILED ON LINE %d\n", #x, __LINE__); \
-    abort();                                                     \
-  }
-
-// a block of memory obtained from the allocator
-struct BlockDesc {
-  char *ptr;      // pointer to memory
-  int len;        // number of bytes
-  int fill;       // filled with data starting with this
-};
-
-// Check that the pattern placed in the block d
-// by RandomizeBlockDesc is still there.
-static void CheckBlockDesc(const BlockDesc &d) {
-  for (int i = 0; i != d.len; i++) {
-    TEST_ASSERT((d.ptr[i] & 0xff) == ((d.fill + i) & 0xff));
-  }
-}
-
-// Fill the block "*d" with a pattern
-// starting with a random byte.
-static void RandomizeBlockDesc(BlockDesc *d) {
-  d->fill = rand() & 0xff;
-  for (int i = 0; i != d->len; i++) {
-    d->ptr[i] = (d->fill + i) & 0xff;
-  }
-}
-
-// Use to indicate to the malloc hooks that
-// this calls is from LowLevelAlloc.
-static bool using_low_level_alloc = false;
-
-// n times, toss a coin, and based on the outcome
-// either allocate a new block or deallocate an old block.
-// New blocks are placed in a std::unordered_map with a random key
-// and initialized with RandomizeBlockDesc().
-// If keys conflict, the older block is freed.
-// Old blocks are always checked with CheckBlockDesc()
-// before being freed.  At the end of the run,
-// all remaining allocated blocks are freed.
-// If use_new_arena is true, use a fresh arena, and then delete it.
-// If call_malloc_hook is true and user_arena is true,
-// allocations and deallocations are reported via the MallocHook
-// interface.
-static void Test(bool use_new_arena, bool call_malloc_hook, int n) {
-  typedef absl::node_hash_map<int, BlockDesc> AllocMap;
-  AllocMap allocated;
-  AllocMap::iterator it;
-  BlockDesc block_desc;
-  int rnd;
-  LowLevelAlloc::Arena *arena = nullptr;
-  if (use_new_arena) {
-    int32_t flags = call_malloc_hook ? LowLevelAlloc::kCallMallocHook : 0;
-    arena = LowLevelAlloc::NewArena(flags);
-  }
-  for (int i = 0; i != n; i++) {
-    if (i != 0 && i % 10000 == 0) {
-      printf(".");
-      fflush(stdout);
-    }
-
-    switch (rand() & 1) {      // toss a coin
-    case 0:     // coin came up heads: add a block
-      using_low_level_alloc = true;
-      block_desc.len = rand() & 0x3fff;
-      block_desc.ptr = reinterpret_cast<char *>(
-          arena == nullptr
-              ? LowLevelAlloc::Alloc(block_desc.len)
-              : LowLevelAlloc::AllocWithArena(block_desc.len, arena));
-      using_low_level_alloc = false;
-      RandomizeBlockDesc(&block_desc);
-      rnd = rand();
-      it = allocated.find(rnd);
-      if (it != allocated.end()) {
-        CheckBlockDesc(it->second);
-        using_low_level_alloc = true;
-        LowLevelAlloc::Free(it->second.ptr);
-        using_low_level_alloc = false;
-        it->second = block_desc;
-      } else {
-        allocated[rnd] = block_desc;
-      }
-      break;
-    case 1:     // coin came up tails: remove a block
-      it = allocated.begin();
-      if (it != allocated.end()) {
-        CheckBlockDesc(it->second);
-        using_low_level_alloc = true;
-        LowLevelAlloc::Free(it->second.ptr);
-        using_low_level_alloc = false;
-        allocated.erase(it);
-      }
-      break;
-    }
-  }
-  // remove all remaining blocks
-  while ((it = allocated.begin()) != allocated.end()) {
-    CheckBlockDesc(it->second);
-    using_low_level_alloc = true;
-    LowLevelAlloc::Free(it->second.ptr);
-    using_low_level_alloc = false;
-    allocated.erase(it);
-  }
-  if (use_new_arena) {
-    TEST_ASSERT(LowLevelAlloc::DeleteArena(arena));
-  }
-}
-
-// LowLevelAlloc is designed to be safe to call before main().
-static struct BeforeMain {
-  BeforeMain() {
-    Test(false, false, 50000);
-    Test(true, false, 50000);
-    Test(true, true, 50000);
-  }
-} before_main;
-
-}  // namespace
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-int main(int argc, char *argv[]) {
-  // The actual test runs in the global constructor of `before_main`.
-  printf("PASS\n");
-#ifdef __EMSCRIPTEN__
-  // clang-format off
-// This is JS here. Don't try to format it.
-    MAIN_THREAD_EM_ASM({
-      if (ENVIRONMENT_IS_WEB) {
-        if (typeof TEST_FINISH === 'function') {
-          TEST_FINISH($0);
-        } else {
-          console.error('Attempted to exit with status ' + $0);
-          console.error('But TEST_FINSIHED is not a function.');
-        }
-      }
-    }, 0);
-// clang-format on
-#endif
-  return 0;
-}

package/deps/abseil-cpp/absl/base/internal/low_level_scheduling.h

@@ -1,134 +0,0 @@
-// Copyright 2017 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.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Core interfaces and definitions used by by low-level interfaces such as
-// SpinLock.
-
-#ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
-#define ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
-
-#include "absl/base/internal/raw_logging.h"
-#include "absl/base/internal/scheduling_mode.h"
-#include "absl/base/macros.h"
-
-// The following two declarations exist so SchedulingGuard may friend them with
-// the appropriate language linkage.  These callbacks allow libc internals, such
-// as function level statics, to schedule cooperatively when locking.
-extern "C" bool __google_disable_rescheduling(void);
-extern "C" void __google_enable_rescheduling(bool disable_result);
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-class CondVar;
-class Mutex;
-
-namespace synchronization_internal {
-int MutexDelay(int32_t c, int mode);
-}  // namespace synchronization_internal
-
-namespace base_internal {
-
-class SchedulingHelper;  // To allow use of SchedulingGuard.
-class SpinLock;          // To allow use of SchedulingGuard.
-
-// SchedulingGuard
-// Provides guard semantics that may be used to disable cooperative rescheduling
-// of the calling thread within specific program blocks.  This is used to
-// protect resources (e.g. low-level SpinLocks or Domain code) that cooperative
-// scheduling depends on.
-//
-// Domain implementations capable of rescheduling in reaction to involuntary
-// kernel thread actions (e.g blocking due to a pagefault or syscall) must
-// guarantee that an annotated thread is not allowed to (cooperatively)
-// reschedule until the annotated region is complete.
-//
-// It is an error to attempt to use a cooperatively scheduled resource (e.g.
-// Mutex) within a rescheduling-disabled region.
-//
-// All methods are async-signal safe.
-class SchedulingGuard {
- public:
-  // Returns true iff the calling thread may be cooperatively rescheduled.
-  static bool ReschedulingIsAllowed();
-  SchedulingGuard(const SchedulingGuard&) = delete;
-  SchedulingGuard& operator=(const SchedulingGuard&) = delete;
-
- private:
-  // Disable cooperative rescheduling of the calling thread.  It may still
-  // initiate scheduling operations (e.g. wake-ups), however, it may not itself
-  // reschedule.  Nestable.  The returned result is opaque, clients should not
-  // attempt to interpret it.
-  // REQUIRES: Result must be passed to a pairing EnableScheduling().
-  static bool DisableRescheduling();
-
-  // Marks the end of a rescheduling disabled region, previously started by
-  // DisableRescheduling().
-  // REQUIRES: Pairs with innermost call (and result) of DisableRescheduling().
-  static void EnableRescheduling(bool disable_result);
-
-  // A scoped helper for {Disable, Enable}Rescheduling().
-  // REQUIRES: destructor must run in same thread as constructor.
-  struct ScopedDisable {
-    ScopedDisable() { disabled = SchedulingGuard::DisableRescheduling(); }
-    ~ScopedDisable() { SchedulingGuard::EnableRescheduling(disabled); }
-
-    bool disabled;
-  };
-
-  // A scoped helper to enable rescheduling temporarily.
-  // REQUIRES: destructor must run in same thread as constructor.
-  class ScopedEnable {
-   public:
-    ScopedEnable();
-    ~ScopedEnable();
-
-   private:
-    int scheduling_disabled_depth_;
-  };
-
-  // Access to SchedulingGuard is explicitly permitted.
-  friend class absl::CondVar;
-  friend class absl::Mutex;
-  friend class SchedulingHelper;
-  friend class SpinLock;
-  friend int absl::synchronization_internal::MutexDelay(int32_t c, int mode);
-};
-
-//------------------------------------------------------------------------------
-// End of public interfaces.
-//------------------------------------------------------------------------------
-
-inline bool SchedulingGuard::ReschedulingIsAllowed() {
-  return false;
-}
-
-inline bool SchedulingGuard::DisableRescheduling() {
-  return false;
-}
-
-inline void SchedulingGuard::EnableRescheduling(bool /* disable_result */) {
-  return;
-}
-
-inline SchedulingGuard::ScopedEnable::ScopedEnable()
-    : scheduling_disabled_depth_(0) {}
-inline SchedulingGuard::ScopedEnable::~ScopedEnable() {
-  ABSL_RAW_CHECK(scheduling_disabled_depth_ == 0, "disable unused warning");
-}
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_

package/deps/abseil-cpp/absl/base/internal/nullability_traits.h

@@ -1,71 +0,0 @@
-// Copyright 2025 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.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_NULLABILITY_TRAITS_H_
-#define ABSL_BASE_INTERNAL_NULLABILITY_TRAITS_H_
-
-#include <type_traits>
-
-#include "absl/base/config.h"
-#include "absl/base/nullability.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// `value` is true if the type `T` is compatible with nullability annotations
-// (is a raw pointer, a smart pointer, or marked with
-// ABSL_NULLABILITY_COMPATIBLE). Prefer to use the higher-level
-// `AddNonnullIfCompatible` if that is sufficient.
-//
-// NOTE: This should not be used to detect if the compiler is Clang (since
-// Clang is the only compiler that supports nullability annotations).
-#if defined(__clang__) && !defined(__OBJC__) && \
-    ABSL_HAVE_FEATURE(nullability_on_classes)
-template <class T, class = void>
-struct IsNullabilityCompatibleType {
-  constexpr static bool value = false;
-};
-
-template <class T>
-struct IsNullabilityCompatibleType<T, std::void_t<absl_nullable T>> {
-  constexpr static bool value = true;
-};
-#else
-// False when absl_nullable is a no-op (for non-Clang compilers or Objective-C.)
-template <class T, class = void>
-struct IsNullabilityCompatibleType {
-  constexpr static bool value = false;
-};
-#endif
-
-// A trait to add `absl_nonnull` to a type if it is compatible with nullability
-// annotations.
-template <typename T, bool ShouldAdd = IsNullabilityCompatibleType<T>::value>
-struct AddNonnullIfCompatible;
-
-template <typename T>
-struct AddNonnullIfCompatible<T, false> {
-  using type = T;
-};
-template <typename T>
-struct AddNonnullIfCompatible<T, true> {
-  using type = absl_nonnull T;
-};
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_BASE_INTERNAL_NULLABILITY_TRAITS_H_

package/deps/abseil-cpp/absl/base/internal/nullability_traits_test.cc

@@ -1,98 +0,0 @@
-// Copyright 2025 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.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "absl/base/internal/nullability_traits.h"
-
-#include <memory>
-#include <type_traits>
-
-#include "gtest/gtest.h"
-#include "absl/base/config.h"
-#include "absl/base/nullability.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-namespace {
-
-struct NotSmartPtr {
-  int* x;
-};
-
-class ABSL_NULLABILITY_COMPATIBLE MySmartPtr : std::unique_ptr<int> {};
-
-// The IsNullabilityCompatibleType trait value can only be true when we define
-// `absl_nullable` (isn't a no-op).
-#if defined(__clang__) && !defined(__OBJC__) && \
-    ABSL_HAVE_FEATURE(nullability_on_classes)
-#define EXPECT_TRUE_IF_SUPPORTED EXPECT_TRUE
-#else
-#define EXPECT_TRUE_IF_SUPPORTED EXPECT_FALSE
-#endif
-
-TEST(NullabilityTraitsTest, IsNullabilityEligibleTypePrimitives) {
-  EXPECT_FALSE(IsNullabilityCompatibleType<int>::value);
-  EXPECT_FALSE(IsNullabilityCompatibleType<int*&>::value);
-
-  EXPECT_TRUE_IF_SUPPORTED(IsNullabilityCompatibleType<int*>::value);
-  EXPECT_TRUE_IF_SUPPORTED(IsNullabilityCompatibleType<int**>::value);
-  EXPECT_TRUE_IF_SUPPORTED(IsNullabilityCompatibleType<int* const>::value);
-  EXPECT_TRUE_IF_SUPPORTED(IsNullabilityCompatibleType<const int*>::value);
-  EXPECT_TRUE_IF_SUPPORTED(IsNullabilityCompatibleType<void (*)(int)>::value);
-}
-
-TEST(NullabilityTraitsTest, IsNullabilityCompatibleTypeAliases) {
-  using MyInt = int;
-  using MyIntPtr = int*;
-  EXPECT_FALSE(IsNullabilityCompatibleType<MyInt>::value);
-  EXPECT_TRUE_IF_SUPPORTED(IsNullabilityCompatibleType<MyIntPtr>::value);
-}
-
-TEST(NullabilityTraitsTest, IsNullabilityCompatibleTypeSmartPointers) {
-  EXPECT_TRUE_IF_SUPPORTED(
-      IsNullabilityCompatibleType<std::unique_ptr<int>>::value);
-  EXPECT_TRUE_IF_SUPPORTED(
-      IsNullabilityCompatibleType<std::shared_ptr<int>>::value);
-
-  EXPECT_FALSE(IsNullabilityCompatibleType<NotSmartPtr>::value);
-  EXPECT_TRUE_IF_SUPPORTED(IsNullabilityCompatibleType<NotSmartPtr*>::value);
-  EXPECT_TRUE_IF_SUPPORTED(IsNullabilityCompatibleType<MySmartPtr>::value);
-}
-
-#undef EXPECT_TRUE_IF_SUPPORTED
-
-TEST(NullabilityTraitsTest, AddNonnullIfCompatiblePassThroughPrimitives) {
-  EXPECT_TRUE((std::is_same_v<AddNonnullIfCompatible<int>::type, int>));
-  EXPECT_TRUE((std::is_same_v<AddNonnullIfCompatible<int*>::type, int*>));
-  EXPECT_TRUE(
-      (std::is_same_v<AddNonnullIfCompatible<int* const>::type, int* const>));
-}
-
-TEST(NullabilityTraitsTest, AddNonnullIfCompatiblePassThroughSmartPointers) {
-  EXPECT_TRUE(
-      (std::is_same_v<AddNonnullIfCompatible<std::unique_ptr<int>>::type,
-                      std::unique_ptr<int>>));
-  EXPECT_TRUE(
-      (std::is_same_v<AddNonnullIfCompatible<std::shared_ptr<int>>::type,
-                      std::shared_ptr<int>>));
-  EXPECT_TRUE(
-      (std::is_same_v<AddNonnullIfCompatible<NotSmartPtr>::type, NotSmartPtr>));
-  EXPECT_TRUE(
-      (std::is_same_v<AddNonnullIfCompatible<MySmartPtr>::type, MySmartPtr>));
-}
-
-}  // namespace
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/base/internal/per_thread_tls.h

@@ -1,52 +0,0 @@
-// Copyright 2017 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.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
-#define ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
-
-// This header defines two macros:
-//
-// If the platform supports thread-local storage:
-//
-// * ABSL_PER_THREAD_TLS_KEYWORD is the C keyword needed to declare a
-//   thread-local variable
-// * ABSL_PER_THREAD_TLS is 1
-//
-// Otherwise:
-//
-// * ABSL_PER_THREAD_TLS_KEYWORD is empty
-// * ABSL_PER_THREAD_TLS is 0
-//
-// Microsoft C supports thread-local storage.
-// GCC supports it if the appropriate version of glibc is available,
-// which the programmer can indicate by defining ABSL_HAVE_TLS
-
-#include "absl/base/port.h"  // For ABSL_HAVE_TLS
-
-#if defined(ABSL_PER_THREAD_TLS)
-#error ABSL_PER_THREAD_TLS cannot be directly set
-#elif defined(ABSL_PER_THREAD_TLS_KEYWORD)
-#error ABSL_PER_THREAD_TLS_KEYWORD cannot be directly set
-#elif defined(ABSL_HAVE_TLS)
-#define ABSL_PER_THREAD_TLS_KEYWORD __thread
-#define ABSL_PER_THREAD_TLS 1
-#elif defined(_MSC_VER)
-#define ABSL_PER_THREAD_TLS_KEYWORD __declspec(thread)
-#define ABSL_PER_THREAD_TLS 1
-#else
-#define ABSL_PER_THREAD_TLS_KEYWORD
-#define ABSL_PER_THREAD_TLS 0
-#endif
-
-#endif  // ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_