diff --git a/CMake/AbseilDll.cmake b/CMake/AbseilDll.cmake index 358a131..0fa06af 100644 --- a/CMake/AbseilDll.cmake +++ b/CMake/AbseilDll.cmake
@@ -153,14 +153,6 @@ "debugging/internal/utf8_for_code_point.h" "debugging/internal/vdso_support.cc" "debugging/internal/vdso_support.h" - "extend/internal/aggregate.h" - "extend/internal/dependencies.h" - "extend/internal/is_tuple_hashable.h" - "extend/internal/num_bases.h" - "extend/internal/num_initializers.h" - "extend/internal/reflection.cc" - "extend/internal/reflection.h" - "extend/internal/tuple.h" "functional/any_invocable.h" "functional/internal/front_binder.h" "functional/bind_front.h"
diff --git a/FAQ.md b/FAQ.md index fbd92ce..30291fe 100644 --- a/FAQ.md +++ b/FAQ.md
@@ -2,9 +2,9 @@ ## Is Abseil the right home for my utility library? -Most often the answer to the question is "no." As both the [About -Abseil](https://abseil.io/about/) page and our [contributing -guidelines](https://github.com/abseil/abseil-cpp/blob/master/CONTRIBUTING.md#contribution-guidelines) +Most often the answer to the question is "no." As both the +[About Abseil](https://abseil.io/about/) page and our +[contributing guidelines](https://github.com/abseil/abseil-cpp/blob/master/CONTRIBUTING.md#contribution-guidelines) explain, Abseil contains a variety of core C++ library code that is widely used at [Google](https://www.google.com/). As such, Abseil's primary purpose is to be used as a dependency by Google's open source C++ projects. While we do hope that @@ -12,27 +12,24 @@ means that we are unlikely to accept a contribution of utility code that isn't already widely used by Google. -## How to I set the C++ dialect used to build Abseil? +## How do I set the C++ dialect used to build Abseil? The short answer is that whatever mechanism you choose, you need to make sure that you set this option consistently at the global level for your entire project. If, for example, you want to set the C++ dialect to C++17, with -[Bazel](https://bazel/build/) as the build system and `gcc` or `clang` as the -compiler, there several ways to do this: -* Pass `--cxxopt=-std=c++17` on the command line (for example, `bazel build - --cxxopt=-std=c++17 ...`) -* Set the environment variable `BAZEL_CXXOPTS` (for example, - `BAZEL_CXXOPTS=-std=c++17`) -* Add `build --cxxopt=-std=c++17` to your [`.bazelrc` - file](https://docs.bazel.build/versions/master/guide.html#bazelrc) +[Bazel](https://bazel.build/) as the build system and `gcc` or `clang` as the +compiler, there are several ways to do this: * Pass `--cxxopt=-std=c++17` on the +command line (for example, `bazel build --cxxopt=-std=c++17 ...`) * Set the +environment variable `BAZEL_CXXOPTS` (for example, `BAZEL_CXXOPTS=-std=c++17`) * +Add `build --cxxopt=-std=c++17` to your +[`.bazelrc` file](https://docs.bazel.build/versions/master/guide.html#bazelrc) If you are using CMake as the build system, you'll need to add a line like -`set(CMAKE_CXX_STANDARD 17)` to your top level `CMakeLists.txt` file. If you -are developing a library designed to be used by other clients, you should -instead leave `CMAKE_CXX_STANDARD` unset and configure the minimum C++ standard -required by each of your library targets via `target_compile_features`. See the -[CMake build -instructions](https://github.com/abseil/abseil-cpp/blob/master/CMake/README.md) +`set(CMAKE_CXX_STANDARD 17)` to your top level `CMakeLists.txt` file. If you are +developing a library designed to be used by other clients, you should instead +leave `CMAKE_CXX_STANDARD` unset and configure the minimum C++ standard required +by each of your library targets via `target_compile_features`. See the +[CMake build instructions](https://github.com/abseil/abseil-cpp/blob/master/CMake/README.md) for more information. For a longer answer to this question and to understand why some other approaches @@ -42,12 +39,12 @@ ## What is ABI and why don't you recommend using a pre-compiled version of Abseil? -For the purposes of this discussion, you can think of -[ABI](https://en.wikipedia.org/wiki/Application_binary_interface) as the -compiled representation of the interfaces in code. This is in contrast to +For the purposes of this discussion, +[ABI](https://en.wikipedia.org/wiki/Application_binary_interface) refers to the +compiled representation of code interfaces. This contrasts with [API](https://en.wikipedia.org/wiki/Application_programming_interface), which -you can think of as the interfaces as defined by the code itself. [Abseil has a -strong promise of API compatibility, but does not make any promise of ABI +refers to the interfaces defined in the source code. [Abseil has a strong +promise of API compatibility, but does not make any promise of ABI compatibility](https://abseil.io/about/compatibility). Let's take a look at what this means in practice. @@ -72,19 +69,19 @@ class/function/variable/enum, etc. As a rule, all compile options that affect the ABI of a program need to be applied to the entire build on a global basis. -C++ has something called the [One Definition -Rule](https://en.wikipedia.org/wiki/One_Definition_Rule) (ODR). C++ doesn't -allow multiple definitions of the same class/function/variable/enum, etc. ODR -violations sometimes result in linker errors, but linkers do not always catch -violations. Uncaught ODR violations can result in strange runtime behaviors or -crashes that can be hard to debug. +C++ has something called the +[One Definition Rule](https://en.wikipedia.org/wiki/One_Definition_Rule) (ODR). +C++ doesn't allow multiple definitions of the same class/function/variable/enum, +etc. ODR violations sometimes result in linker errors, but linkers do not always +catch violations. Uncaught ODR violations can result in strange runtime +behaviors or crashes that can be hard to debug. If you build the Abseil library and your code using different compile options that affect ABI, there is a good chance you will run afoul of the One Definition Rule. Examples of GCC compile options that affect ABI include (but aren't limited to) language dialect (e.g. `-std=`), optimization level (e.g. `-O2`), -code generation flags (e.g. `-fexceptions`), and preprocessor defines -(e.g. `-DNDEBUG`). +code generation flags (e.g. `-fexceptions`), and preprocessor defines (e.g. +`-DNDEBUG`). If you use a pre-compiled version of Abseil, (for example, from your Linux distribution package manager or from something like @@ -98,16 +95,16 @@ reasons we warn against - though do not outright reject - using Abseil as a pre-compiled library. -Another possible way that you might afoul of ABI issues is if you accidentally -include two versions of Abseil in your program. Multiple versions of Abseil can -end up within the same binary if your program uses the Abseil library and -another library also transitively depends on Abseil (resulting in what is -sometimes called the diamond dependency problem). In cases such as this you must -structure your build so that all libraries use the same version of Abseil. -[Abseil's strong promise of API compatibility between -releases](https://abseil.io/about/compatibility) means the latest "HEAD" release -of Abseil is almost certainly the right choice if you are doing as we recommend -and building all of your code from source. +Another possible way that you might run afoul of ABI issues is if you +accidentally include two versions of Abseil in your program. Multiple versions +of Abseil can end up within the same binary if your program uses the Abseil +library and another library also transitively depends on Abseil (resulting in +what is sometimes called the diamond dependency problem). In cases such as this +you must structure your build so that all libraries use the same version of +Abseil. +[Abseil's strong promise of API compatibility between releases](https://abseil.io/about/compatibility) +means the latest "HEAD" release of Abseil is almost certainly the right choice +if you are doing as we recommend and building all of your code from source. For these reasons we recommend you avoid pre-compiled code and build the Abseil library yourself in a consistent manner with the rest of your code. @@ -121,47 +118,101 @@ extremely rare. This means that upgrading from one source release to another should be a routine practice that can and should be performed often. -We recommend you update to the [latest commit in the `master` branch of -Abseil](https://github.com/abseil/abseil-cpp/commits/master) as often as -possible. Not only will you pick up bug fixes more quickly, but if you have good -automated testing, you will catch and be able to fix any [Hyrum's -Law](https://www.hyrumslaw.com/) dependency problems on an incremental basis -instead of being overwhelmed by them and having difficulty isolating them if you -wait longer between updates. +We recommend you update to the +[latest commit in the `master` branch of Abseil](https://github.com/abseil/abseil-cpp/commits/master) +as often as possible. Not only will you pick up bug fixes more quickly, but if +you have good automated testing, you will catch and be able to fix any +[Hyrum's Law](https://www.hyrumslaw.com/) dependency problems on an incremental +basis instead of being overwhelmed by them and having difficulty isolating them +if you wait longer between updates. -If you are using the [Bazel](https://bazel.build/) build system and its -[external dependencies](https://docs.bazel.build/versions/master/external.html) -feature, updating the -[`http_archive`](https://docs.bazel.build/versions/master/repo/http.html#http_archive) -rule in your -[`WORKSPACE`](https://docs.bazel.build/versions/master/be/workspace.html) for -`com_google_abseil` to point to the [latest commit in the `master` branch of -Abseil](https://github.com/abseil/abseil-cpp/commits/master) is all you need to -do. For example, on February 11, 2020, the latest commit to the master branch -was `98eb410c93ad059f9bba1bf43f5bb916fc92a5ea`. To update to this commit, you -would add the following snippet to your `WORKSPACE` file: +If you are using the [Bazel](https://bazel.build/) build system with +[Bzlmod](https://bazel.build/external/overview#bzlmod), you can use a +`git_override` in your `MODULE.bazel` file to track the latest commit. -``` -http_archive( - name = "com_google_absl", - urls = ["https://github.com/abseil/abseil-cpp/archive/98eb410c93ad059f9bba1bf43f5bb916fc92a5ea.zip"], # 2020-02-11T18:50:53Z - strip_prefix = "abseil-cpp-98eb410c93ad059f9bba1bf43f5bb916fc92a5ea", - sha256 = "aabf6c57e3834f8dc3873a927f37eaf69975d4b28117fc7427dfb1c661542a87", +For example, to update to the latest commit, you would add (or update) the +following snippet in your `MODULE.bazel` file: + +```starlark +bazel_dep(name = "abseil-cpp", version = "20260107.1") + +git_override( + module_name = "abseil-cpp", + remote = "https://github.com/abseil/abseil-cpp.git", + # Replace the following line with the latest commit. + commit = "6ec9964c325db0610a376b3cb81de073ea6ada90", ) ``` -To get the `sha256` of this URL, run `curl -sL --output - -https://github.com/abseil/abseil-cpp/archive/98eb410c93ad059f9bba1bf43f5bb916fc92a5ea.zip -| sha256sum -`. - -You can commit the updated `WORKSPACE` file to your source control every time +You can commit the updated `MODULE.bazel` file to your source control every time you update, and if you have good automated testing, you might even consider automating this. -One thing we don't recommend is using GitHub's `master.zip` files (for example -[https://github.com/abseil/abseil-cpp/archive/master.zip](https://github.com/abseil/abseil-cpp/archive/master.zip)), -which are always the latest commit in the `master` branch, to implement live at -head. Since these `master.zip` URLs are not versioned, you will lose build -reproducibility. In addition, some build systems, including Bazel, will simply -cache this file, which means you won't actually be updating to the latest -release until your cache is cleared or invalidated. +## Why do I see strange behaviors when I use Abseil hash tables? + +Abseil's hash function uses a random seed. + +Many programmers believe incorrectly that this is a defense against +[hash flooding](https://en.wikipedia.org/wiki/Collision_attack#Hash_flooding). +While it does make a hash flooding attack more difficult, Abseil's hash function +prioritizes speed over thorough mixing (and thus is not cryptographically +secure), and the current seed implementation is also not cryptographically +secure. If you are storing a large amount of attacker-controlled data, the most +reliable defense against hash-flooding is to use a container that does not have +`O(n)` worst-case behavior. + +The real reason for hash randomization is to prevent +[Hyrum's Law](https://www.hyrumslaw.com/) dependencies on iteration order. This +has allowed us to roll out steady improvements to the implementation without +breaking users who may have otherwise written code that was dependent on +ordering or other characteristics. + +The current implementation uses a global seed, which, if linked incorrectly +(e.g., static Abseil in multiple DSOs), can cause the ODR violations. If more +than one seed is linked, different calls to the hash function may return +different values, rendering hash elements inaccessible, causing crashes, or +other arbitrarily bad behaviors. + +We are often asked for a knob to disable hash randomization. The answer is a +hard "no", even under test or under a flag, because people will find a way to +force it and allow their code or tests to depend on it. At Google-scale, the +compute costs that are saved by preserving the ability to improve the +implementation far outweigh the inconvenience of learning how to write code +resilient to change. + +## How do I use the LLVM Sanitizers with Abseil? + +LLVM Sanitizers are a suite of powerful, dynamic analysis tools that +automatically detect various critical bugs during program execution. They work +by instrumenting the compiled binary and linking a runtime library to intercept +operations and report issues. + +We receive many incorrect bug reports from users trying to use the sanitizers. +The most common cause of these issues is ODR violations in the form of an +instrumentation mismatch. This happens when users try to link libraries compiled +with sanitizer instrumentation with uninstrumented libraries. It is important +that all code in the application is built with the same sanitizer configuration. + +The easiest way to do this is to use [Bazel](https://bazel.build) and pass the +sanitizer options on the commandline, but it is important not to overlook the +importance of avoiding precompiled system libraries, including the C++ standard +library. For instance, +[MemorySanitizer requires an instrumented `libc++`](https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo). + +Since most users are not going to build `libc++` with Bazel, here is a +MemorySanitizer recipe that currently works (and could easily be tweaked for +ThreadSanitizer and friends): + +```shell +# From the root of the LLVM source tree, configure libc++ to be instrumented with MSAN: +cmake -G Ninja -S runtimes -B build_msan -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi;libunwind" -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX="${HOME}/llvm-msan" -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DLLVM_USE_SANITIZER=MemoryWithOrigins -DLLVM_TARGETS_TO_BUILD="host" + +# Build and install it into ${HOME}/llvm-msan +ninja -C build_msan install-cxx install-cxxabi install-unwind + +# Then build (or test) your code like this: +bazel test --repo_env=CC=clang --repo_env=BAZEL_CXXOPTS=nostdinc++ --repo_env=BAZEL_LINKOPTS=-L${HOME}/llvm-msan/lib:-lc++:-lc++abi:-lgcc_s:-lm:-Wl,-rpath=${HOME}/llvm-msan/lib --repo_env=CPLUS_INCLUDE_PATH=${HOME}/llvm-msan/include/c++/v1 --copt=-fsanitize=memory --linkopt=-fsanitize=memory --linkopt=-fsanitize-link-c++-runtime ... +``` + +You should consider adding these options to a +[`.bazelrc`](https://bazel.build/run/bazelrc) file to avoid retyping them.
diff --git a/absl/CMakeLists.txt b/absl/CMakeLists.txt index 2a986c3..810d7f3 100644 --- a/absl/CMakeLists.txt +++ b/absl/CMakeLists.txt
@@ -20,7 +20,6 @@ add_subdirectory(container) add_subdirectory(crc) add_subdirectory(debugging) -add_subdirectory(extend) add_subdirectory(flags) add_subdirectory(functional) add_subdirectory(hash)
diff --git a/absl/container/internal/hashtablez_sampler.cc b/absl/container/internal/hashtablez_sampler.cc index 4f6e946..18c8ca4 100644 --- a/absl/container/internal/hashtablez_sampler.cc +++ b/absl/container/internal/hashtablez_sampler.cc
@@ -81,7 +81,6 @@ capacity.store(0, std::memory_order_relaxed); size.store(0, std::memory_order_relaxed); num_erases.store(0, std::memory_order_relaxed); - num_insert_hits.store(0, std::memory_order_relaxed); num_rehashes.store(0, std::memory_order_relaxed); max_probe_length.store(0, std::memory_order_relaxed); total_probe_length.store(0, std::memory_order_relaxed);
diff --git a/absl/container/internal/hashtablez_sampler.h b/absl/container/internal/hashtablez_sampler.h index 6c20dc3..eff44bf 100644 --- a/absl/container/internal/hashtablez_sampler.h +++ b/absl/container/internal/hashtablez_sampler.h
@@ -82,7 +82,6 @@ std::atomic<size_t> capacity; std::atomic<size_t> size; std::atomic<size_t> num_erases; - std::atomic<size_t> num_insert_hits; std::atomic<size_t> num_rehashes; std::atomic<size_t> max_probe_length; std::atomic<size_t> total_probe_length; @@ -111,16 +110,6 @@ void RecordRehashSlow(HashtablezInfo* info, size_t total_probe_length); -// This is inline to avoid calling convention overhead for an otherwise -// lightweight operation. -inline void RecordInsertHitSlow(HashtablezInfo* info) { - // We avoid fetch_add since no other thread should be mutating the table - // simultaneously without synchronization. - info->num_insert_hits.store( - info->num_insert_hits.load(std::memory_order_relaxed) + 1, - std::memory_order_relaxed); -} - void RecordReservationSlow(HashtablezInfo* info, size_t target_capacity); void RecordClearedReservationSlow(HashtablezInfo* info); @@ -194,11 +183,6 @@ RecordEraseSlow(info_); } - inline void RecordInsertHit() { - if (ABSL_PREDICT_TRUE(info_ == nullptr)) return; - RecordInsertHitSlow(info_); - } - friend inline void swap(HashtablezInfoHandle& lhs, HashtablezInfoHandle& rhs) { std::swap(lhs.info_, rhs.info_); @@ -225,7 +209,6 @@ inline void RecordInsertMiss(size_t /*hash*/, size_t /*distance_from_desired*/) {} inline void RecordErase() {} - inline void RecordInsertHit() {} friend inline void swap(HashtablezInfoHandle& /*lhs*/, HashtablezInfoHandle& /*rhs*/) {}
diff --git a/absl/container/internal/hashtablez_sampler_test.cc b/absl/container/internal/hashtablez_sampler_test.cc index 9391e94..c313693 100644 --- a/absl/container/internal/hashtablez_sampler_test.cc +++ b/absl/container/internal/hashtablez_sampler_test.cc
@@ -99,7 +99,6 @@ EXPECT_EQ(info.capacity.load(), 0); EXPECT_EQ(info.size.load(), 0); EXPECT_EQ(info.num_erases.load(), 0); - EXPECT_EQ(info.num_insert_hits.load(), 0); EXPECT_EQ(info.num_rehashes.load(), 0); EXPECT_EQ(info.max_probe_length.load(), 0); EXPECT_EQ(info.total_probe_length.load(), 0); @@ -116,7 +115,6 @@ info.capacity.store(1, std::memory_order_relaxed); info.size.store(1, std::memory_order_relaxed); info.num_erases.store(1, std::memory_order_relaxed); - info.num_insert_hits.store(1, std::memory_order_relaxed); info.max_probe_length.store(1, std::memory_order_relaxed); info.total_probe_length.store(1, std::memory_order_relaxed); info.hashes_bitwise_or.store(1, std::memory_order_relaxed); @@ -131,7 +129,6 @@ EXPECT_EQ(info.capacity.load(), 0); EXPECT_EQ(info.size.load(), 0); EXPECT_EQ(info.num_erases.load(), 0); - EXPECT_EQ(info.num_insert_hits.load(), 0); EXPECT_EQ(info.num_rehashes.load(), 0); EXPECT_EQ(info.max_probe_length.load(), 0); EXPECT_EQ(info.total_probe_length.load(), 0); @@ -218,25 +215,6 @@ EXPECT_EQ(info.soo_capacity, 1); } -TEST(HashtablezInfoTest, RecordInsertHit) { - const int64_t test_stride = 31; - const size_t test_element_size = 29; - const size_t test_key_size = 27; - const size_t test_value_size = 25; - - HashtablezInfo info; - absl::MutexLock l(info.init_mu); - info.PrepareForSampling(test_stride, test_element_size, - /*key_size=*/test_key_size, - /*value_size=*/test_value_size, - /*soo_capacity_value=*/1); - EXPECT_EQ(info.num_insert_hits.load(), 0); - RecordInsertHitSlow(&info); - EXPECT_EQ(info.num_insert_hits.load(), 1); - RecordInsertHitSlow(&info); - EXPECT_EQ(info.num_insert_hits.load(), 2); -} - TEST(HashtablezInfoTest, RecordRehash) { const int64_t test_stride = 33; const size_t test_element_size = 31;
diff --git a/absl/container/internal/raw_hash_set.h b/absl/container/internal/raw_hash_set.h index 8e27bbb..e6ea164 100644 --- a/absl/container/internal/raw_hash_set.h +++ b/absl/container/internal/raw_hash_set.h
@@ -3227,7 +3227,6 @@ } if (!empty()) { if (equal_to(key, single_slot())) { - common().infoz().RecordInsertHit(); return {single_iterator(), false}; } } @@ -3259,7 +3258,6 @@ if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) { index = seq.offset(i); inserted = false; - common().infoz().RecordInsertHit(); return; } }
diff --git a/absl/container/internal/raw_hash_set_test.cc b/absl/container/internal/raw_hash_set_test.cc index 7136691..5b3cd0e 100644 --- a/absl/container/internal/raw_hash_set_test.cc +++ b/absl/container/internal/raw_hash_set_test.cc
@@ -2831,7 +2831,6 @@ absl::flat_hash_set<const HashtablezInfo*> preexisting_info(10); absl::flat_hash_map<size_t, int> observed_checksums(10); absl::flat_hash_map<ssize_t, int> reservations(10); - absl::flat_hash_map<std::pair<size_t, size_t>, int> hit_misses(10); start_size += sampler.Iterate([&](const HashtablezInfo& info) { preexisting_info.insert(&info); @@ -2844,8 +2843,6 @@ const bool do_reserve = (i % 10 > 5); const bool do_rehash = !do_reserve && (i % 10 > 0); - const bool do_first_insert_hit = i % 2 == 0; - const bool do_second_insert_hit = i % 4 == 0; if (do_reserve) { // Don't reserve on all tables. @@ -2853,14 +2850,7 @@ } tables.back().insert(1); - if (do_first_insert_hit) { - tables.back().insert(1); - tables.back().insert(1); - } tables.back().insert(i % 5); - if (do_second_insert_hit) { - tables.back().insert(i % 5); - } if (do_rehash) { // Rehash some other tables. @@ -2872,10 +2862,6 @@ ++end_size; if (preexisting_info.contains(&info)) return; reservations[info.max_reserve.load(std::memory_order_relaxed)]++; - hit_misses[std::make_pair( - info.num_insert_hits.load(std::memory_order_relaxed), - info.size.load(std::memory_order_relaxed))]++; - EXPECT_EQ(info.inline_element_size, sizeof(typename TypeParam::value_type)); EXPECT_EQ(info.key_size, sizeof(typename TypeParam::key_type)); EXPECT_EQ(info.value_size, sizeof(typename TypeParam::value_type)); @@ -2899,21 +2885,6 @@ EXPECT_NEAR((100 * count) / static_cast<double>(tables.size()), 0.1, 0.05) << reservation; } - - EXPECT_THAT(hit_misses, testing::SizeIs(6)); - const double sampled_tables = end_size - start_size; - // i % 20: { 1, 11 } - EXPECT_NEAR((hit_misses[{1, 1}] / sampled_tables), 0.10, 0.02); - // i % 20: { 6 } - EXPECT_NEAR((hit_misses[{3, 1}] / sampled_tables), 0.05, 0.02); - // i % 20: { 0, 4, 8, 12 } - EXPECT_NEAR((hit_misses[{3, 2}] / sampled_tables), 0.20, 0.02); - // i % 20: { 2, 10, 14, 18 } - EXPECT_NEAR((hit_misses[{2, 2}] / sampled_tables), 0.20, 0.02); - // i % 20: { 16 } - EXPECT_NEAR((hit_misses[{4, 1}] / sampled_tables), 0.05, 0.02); - // i % 20: { 3, 5, 7, 9, 13, 15, 17, 19 } - EXPECT_NEAR((hit_misses[{0, 2}] / sampled_tables), 0.40, 0.02); } std::vector<const HashtablezInfo*> SampleSooMutation(
diff --git a/absl/extend/CMakeLists.txt b/absl/extend/CMakeLists.txt deleted file mode 100644 index dba0c5c..0000000 --- a/absl/extend/CMakeLists.txt +++ /dev/null
@@ -1,140 +0,0 @@ -# Copyright 2026 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. - -absl_cc_library( - NAME - dependencies_internal - HDRS - "internal/dependencies.h" - COPTS - ${ABSL_DEFAULT_COPTS} -) - -absl_cc_test( - NAME - dependencies_internal_test - SRCS - "internal/dependencies_test.cc" - COPTS - ${ABSL_TEST_COPTS} - DEPS - absl::dependencies_internal - GTest::gmock_main -) - -absl_cc_library( - NAME - num_initializers_internal - HDRS - "internal/num_initializers.h" - COPTS - ${ABSL_DEFAULT_COPTS} - DEPS - absl::core_headers -) - -absl_cc_test( - NAME - num_initializers_internal_test - SRCS - "internal/num_initializers_test.cc" - COPTS - ${ABSL_TEST_COPTS} - DEPS - absl::num_initializers_internal - GTest::gmock_main -) - -absl_cc_library( - NAME - num_bases_internal - HDRS - "internal/num_bases.h" - COPTS - ${ABSL_DEFAULT_COPTS} - DEPS - absl::num_initializers_internal - absl::type_traits - absl::optional -) - -absl_cc_test( - NAME - num_bases_internal_test - SRCS - "internal/num_bases_test.cc" - COPTS - ${ABSL_TEST_COPTS} - DEPS - absl::num_bases_internal - GTest::gmock_main -) - -absl_cc_library( - NAME - aggregate_internal - HDRS - "internal/aggregate.h" - COPTS - ${ABSL_DEFAULT_COPTS} - DEPS - absl::num_bases_internal - absl::num_initializers_internal -) - -absl_cc_test( - NAME - aggregate_internal_test - SRCS - "internal/aggregate_test.cc" - COPTS - ${ABSL_TEST_COPTS} - DEPS - absl::aggregate_internal - GTest::gmock_main -) - -absl_cc_library( - NAME - tuple_internal - HDRS - "internal/tuple.h" - COPTS - ${ABSL_DEFAULT_COPTS} -) - -absl_cc_library( - NAME - is_tuple_hashable_internal - HDRS - "internal/is_tuple_hashable.h" - COPTS - ${ABSL_DEFAULT_COPTS} - DEPS - absl::hash -) - -absl_cc_library( - NAME - reflection_internal - HDRS - "internal/reflection.h" - SRCS - "internal/reflection.cc" - COPTS - ${ABSL_DEFAULT_COPTS} - DEPS - absl::strings - absl::span -)
diff --git a/absl/extend/internal/BUILD.bazel b/absl/extend/internal/BUILD.bazel deleted file mode 100644 index 79b8361..0000000 --- a/absl/extend/internal/BUILD.bazel +++ /dev/null
@@ -1,127 +0,0 @@ -# Copyright 2026 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. - -load("@rules_cc//cc:cc_library.bzl", "cc_library") -load("@rules_cc//cc:cc_test.bzl", "cc_test") - -# Internal extend utilities and implementation details. -package( - default_visibility = [ - "//absl/extend:__subpackages__", - ], - features = ["header_modules"], -) - -cc_library( - name = "tuple", - hdrs = ["tuple.h"], - deps = ["//absl/base:config"], -) - -cc_library( - name = "is_tuple_hashable", - hdrs = ["is_tuple_hashable.h"], - deps = [ - "//absl/base:config", - "//absl/hash", - ], -) - -cc_library( - name = "reflection", - srcs = ["reflection.cc"], - hdrs = ["reflection.h"], - deps = [ - "//absl/base:config", - "//absl/strings", - "//absl/types:span", - ], -) - -cc_library( - name = "aggregate", - hdrs = ["aggregate.h"], - deps = [ - ":num_bases", - ":num_initializers", - "//absl/base:config", - ], -) - -cc_test( - name = "aggregate_test", - srcs = ["aggregate_test.cc"], - deps = [ - ":aggregate", - "//absl/base:config", - "@googletest//:gtest_main", - ], -) - -cc_library( - name = "num_bases", - hdrs = ["num_bases.h"], - deps = [ - ":num_initializers", - "//absl/base:config", - ], -) - -cc_test( - name = "num_bases_test", - srcs = ["num_bases_test.cc"], - deps = [ - ":num_bases", - "//absl/base:config", - "@googletest//:gtest_main", - ], -) - -cc_library( - name = "num_initializers", - hdrs = ["num_initializers.h"], - deps = [ - "//absl/base:config", - "//absl/base:core_headers", - ], -) - -cc_test( - name = "num_initializers_test", - srcs = ["num_initializers_test.cc"], - tags = [ - "no_test_ios_arm64", - ], - deps = [ - ":num_initializers", - "//absl/base:config", - "@googletest//:gtest_main", - ], -) - -cc_library( - name = "dependencies", - hdrs = ["dependencies.h"], - deps = ["//absl/base:config"], -) - -cc_test( - name = "dependencies_test", - srcs = ["dependencies_test.cc"], - deps = [ - ":dependencies", - "//absl/base:config", - "@googletest//:gtest_main", - ], -)
diff --git a/absl/extend/internal/aggregate.h b/absl/extend/internal/aggregate.h deleted file mode 100644 index 815865c..0000000 --- a/absl/extend/internal/aggregate.h +++ /dev/null
@@ -1,1687 +0,0 @@ -// Copyright 2026 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_EXTEND_INTERNAL_AGGREGATE_H_ -#define ABSL_EXTEND_INTERNAL_AGGREGATE_H_ - -#include <tuple> -#include <type_traits> -#include <utility> - -#include "absl/base/config.h" -#include "absl/extend/internal/num_bases.h" -#include "absl/extend/internal/num_initializers.h" - -namespace absl { -ABSL_NAMESPACE_BEGIN -namespace aggregate_internal { - -// This collection of constants to serialize information about type qualifiers -// in C++. Together with `ExtractQualifiers` and `ApplyQualifiers` below, this -// allows us to apply metafunctions that change the type but preserve -// qualifiers. For example, a meta-function that converted `T` to -// `std::vector<T>` could use `CopyQualifiers` below to ensure that -// `std::string` became `std::vector<std::string>`, and that -// `const std::string&` became `const std::vector<std::string>&`. -// -// Note: We use a non-power-of-2 for kRef so that operator| matches reference -// collapsing semantics. That is, `(kRefRef | kRef) == kRef` in the same way -// that `T&& &` is `T&`. -inline constexpr int kRefRef = 1; -inline constexpr int kRef = 3; -inline constexpr int kConst = 4; -inline constexpr int kVolatile = 8; - -// `ExtractQualifiers` returns an integer value representing the qualifiers that -// are applied to the template parameter `T`. -template <typename T> -constexpr int ExtractQualifiers() { - int quals = 0; - if constexpr (std::is_lvalue_reference_v<T>) { - quals |= kRef; - } else if constexpr (std::is_rvalue_reference_v<T>) { - quals |= kRefRef; - } - - using dereffed_type = std::remove_reference_t<T>; - if constexpr (std::is_const_v<dereffed_type>) quals |= kConst; - if constexpr (std::is_volatile_v<dereffed_type>) quals |= kVolatile; - - return quals; -} - -// `ApplyQualifiers<T, kQuals>::type` evaluates to a type which has the same -// underlying type as `T` but with additional qualifiers from `kQuals` applied. -// Note that we do not remove the qualifiers from `T`. So, for example, -// `ApplyQualifiers<const int, kRef>::type` will be `const int&` rather than -// `int&`. -// -// Also note that, because ` -template <typename T, int kQuals> -struct ApplyQualifiers { - private: - static_assert(!std::is_reference_v<T>, - "Apply qualifiers cannot be called on a reference type."); - using handle_volatile = - std::conditional_t<((kQuals & kVolatile) == kVolatile), volatile T, T>; - using handle_const = - std::conditional_t<((kQuals & kConst) == kConst), const handle_volatile, - handle_volatile>; - using handle_refref = std::conditional_t<((kQuals & kRefRef) == kRefRef), - handle_const&&, handle_const>; - using handle_ref = std::conditional_t<((kQuals & kRef) == kRef), - handle_refref&, handle_refref>; - - public: - using type = handle_ref; -}; - -// `CopyQualifiers` extracts qualifiers from `From` and overwrites the -// qualifiers on `To`. -template <typename From, typename To> -using CopyQualifiers = - typename ApplyQualifiers<To, ExtractQualifiers<From>()>::type; - -// `CorrectQualifiers` is specific to the implementation of `GetFields`. In -// particular, when constructing a tuple of references to fields of a struct, we -// need to know which fields should be referenced and which should be forwarded. -// `CorrectQualifiers` forwards reference-members and otherwise copies the -// qualifiers on the struct to its members being referenced in the tuple. -template <typename Aggregate, typename Field, typename T> -constexpr decltype(auto) CorrectQualifiers(T& val) { - if constexpr (std::is_reference_v<Field>) { - return static_cast<Field>(val); - } else { - using type = CopyQualifiers<Aggregate&&, Field>; - return static_cast<type>(val); - } -} - -// `RemoveQualifiersAndReferencesFromTuple` removes volatile and const -// qualifiers from the underlying type of each reference type within a tuple. -template <typename T> -struct RemoveQualifiersAndReferencesFromTuple; - -template <typename... U> -struct RemoveQualifiersAndReferencesFromTuple<std::tuple<U...>> { - using type = - std::tuple<typename std::remove_cv_t<std::remove_reference_t<U>>...>; -}; - -template <typename T, int kNumBases = -1> -constexpr int NumFields() { - if constexpr (std::is_empty_v<T>) { - return 0; - } else if constexpr (std::is_aggregate_v<T>) { - if constexpr (kNumBases == -1) { - constexpr auto num_bases = aggregate_internal::NumBases<T>(); - static_assert(num_bases.has_value(), - "This library can only detect the number of bases when the " - "type is non-empty and has exactly 0 or 1 base classes. " - "However, the type has >= 2 bases."); - return aggregate_internal::NumInitializers<T>() - num_bases.value(); - } else { - return aggregate_internal::NumInitializers<T>() - kNumBases; - } - } else { - return -1; - } -} - -// Structured binding declarations are weird in that they produce the same -// bindings whether the object is an rvalue or lvalue. Hence we add reference -// qualifiers ourselves. - -struct FieldGetter { - struct Error {}; - template <int kNumBases, int kFieldCount, typename T> - constexpr static auto Unpack(T&& t) { - static_assert( - kNumBases == -1 || kNumBases == 0 || kNumBases == 1, - "Unpack() only supports aggregate types that have either no " - "base class or 1 empty base class (absl::Extend). You can " - "also set the number of bases to -1 to let the library try " - "to detect the number of bases. All other values are invalid."); - if constexpr (kFieldCount == -1) { - constexpr int kNumFields = NumFields<std::decay_t<T>, kNumBases>(); - if constexpr (kNumFields != -1) { - return Unpack<kNumBases, kNumFields>(std::forward<T>(t)); - } else { - return Error{}; - } - } else if constexpr (kFieldCount == 0) { - return std::make_tuple(); - } else if constexpr (kFieldCount == 1) { - auto&& [f0] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0)); - } else if constexpr (kFieldCount == 2) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1)); - } else if constexpr (kFieldCount == 3) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2)); - } else if constexpr (kFieldCount == 4) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3)); - } else if constexpr (kFieldCount == 5) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4)); - } else if constexpr (kFieldCount == 6) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5)); - } else if constexpr (kFieldCount == 7) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6)); - } else if constexpr (kFieldCount == 8) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7)); - } else if constexpr (kFieldCount == 9) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8)); - } else if constexpr (kFieldCount == 10) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9)); - } else if constexpr (kFieldCount == 11) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10)); - } else if constexpr (kFieldCount == 12) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11)); - } else if constexpr (kFieldCount == 13) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12)); - } else if constexpr (kFieldCount == 14) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13)); - } else if constexpr (kFieldCount == 15) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14)); - } else if constexpr (kFieldCount == 16) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, - f15] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15)); - } else if constexpr (kFieldCount == 17) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16)); - } else if constexpr (kFieldCount == 18) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17)); - } else if constexpr (kFieldCount == 19) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18)); - } else if constexpr (kFieldCount == 20) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19)); - } else if constexpr (kFieldCount == 21) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20)); - } else if constexpr (kFieldCount == 22) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21)); - } else if constexpr (kFieldCount == 23) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22)); - } else if constexpr (kFieldCount == 24) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23)); - } else if constexpr (kFieldCount == 25) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24)); - } else if constexpr (kFieldCount == 26) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25)); - } else if constexpr (kFieldCount == 27) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26)); - } else if constexpr (kFieldCount == 28) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27)); - } else if constexpr (kFieldCount == 29) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28] = - t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28)); - } else if constexpr (kFieldCount == 30) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29)); - } else if constexpr (kFieldCount == 31) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30)); - } else if constexpr (kFieldCount == 32) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31)); - } else if constexpr (kFieldCount == 33) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32)); - } else if constexpr (kFieldCount == 34) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33)); - } else if constexpr (kFieldCount == 35) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34)); - } else if constexpr (kFieldCount == 36) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34, f35] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34), - CorrectQualifiers<T, decltype(f35)>(f35)); - } else if constexpr (kFieldCount == 37) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34, f35, f36] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34), - CorrectQualifiers<T, decltype(f35)>(f35), - CorrectQualifiers<T, decltype(f36)>(f36)); - } else if constexpr (kFieldCount == 38) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34, f35, f36, f37] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34), - CorrectQualifiers<T, decltype(f35)>(f35), - CorrectQualifiers<T, decltype(f36)>(f36), - CorrectQualifiers<T, decltype(f37)>(f37)); - } else if constexpr (kFieldCount == 39) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34, f35, f36, f37, f38] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34), - CorrectQualifiers<T, decltype(f35)>(f35), - CorrectQualifiers<T, decltype(f36)>(f36), - CorrectQualifiers<T, decltype(f37)>(f37), - CorrectQualifiers<T, decltype(f38)>(f38)); - } else if constexpr (kFieldCount == 40) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34, f35, f36, f37, f38, f39] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34), - CorrectQualifiers<T, decltype(f35)>(f35), - CorrectQualifiers<T, decltype(f36)>(f36), - CorrectQualifiers<T, decltype(f37)>(f37), - CorrectQualifiers<T, decltype(f38)>(f38), - CorrectQualifiers<T, decltype(f39)>(f39)); - } else if constexpr (kFieldCount == 41) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34, f35, f36, f37, f38, f39, f40] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34), - CorrectQualifiers<T, decltype(f35)>(f35), - CorrectQualifiers<T, decltype(f36)>(f36), - CorrectQualifiers<T, decltype(f37)>(f37), - CorrectQualifiers<T, decltype(f38)>(f38), - CorrectQualifiers<T, decltype(f39)>(f39), - CorrectQualifiers<T, decltype(f40)>(f40)); - } else if constexpr (kFieldCount == 42) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34, f35, f36, f37, f38, f39, f40, f41] = - t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34), - CorrectQualifiers<T, decltype(f35)>(f35), - CorrectQualifiers<T, decltype(f36)>(f36), - CorrectQualifiers<T, decltype(f37)>(f37), - CorrectQualifiers<T, decltype(f38)>(f38), - CorrectQualifiers<T, decltype(f39)>(f39), - CorrectQualifiers<T, decltype(f40)>(f40), - CorrectQualifiers<T, decltype(f41)>(f41)); - } else if constexpr (kFieldCount == 43) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34, f35, f36, f37, f38, f39, f40, f41, - f42] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34), - CorrectQualifiers<T, decltype(f35)>(f35), - CorrectQualifiers<T, decltype(f36)>(f36), - CorrectQualifiers<T, decltype(f37)>(f37), - CorrectQualifiers<T, decltype(f38)>(f38), - CorrectQualifiers<T, decltype(f39)>(f39), - CorrectQualifiers<T, decltype(f40)>(f40), - CorrectQualifiers<T, decltype(f41)>(f41), - CorrectQualifiers<T, decltype(f42)>(f42)); - } else if constexpr (kFieldCount == 44) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34, f35, f36, f37, f38, f39, f40, f41, - f42, f43] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34), - CorrectQualifiers<T, decltype(f35)>(f35), - CorrectQualifiers<T, decltype(f36)>(f36), - CorrectQualifiers<T, decltype(f37)>(f37), - CorrectQualifiers<T, decltype(f38)>(f38), - CorrectQualifiers<T, decltype(f39)>(f39), - CorrectQualifiers<T, decltype(f40)>(f40), - CorrectQualifiers<T, decltype(f41)>(f41), - CorrectQualifiers<T, decltype(f42)>(f42), - CorrectQualifiers<T, decltype(f43)>(f43)); - } else if constexpr (kFieldCount == 45) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34, f35, f36, f37, f38, f39, f40, f41, - f42, f43, f44] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34), - CorrectQualifiers<T, decltype(f35)>(f35), - CorrectQualifiers<T, decltype(f36)>(f36), - CorrectQualifiers<T, decltype(f37)>(f37), - CorrectQualifiers<T, decltype(f38)>(f38), - CorrectQualifiers<T, decltype(f39)>(f39), - CorrectQualifiers<T, decltype(f40)>(f40), - CorrectQualifiers<T, decltype(f41)>(f41), - CorrectQualifiers<T, decltype(f42)>(f42), - CorrectQualifiers<T, decltype(f43)>(f43), - CorrectQualifiers<T, decltype(f44)>(f44)); - } else if constexpr (kFieldCount == 46) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34, f35, f36, f37, f38, f39, f40, f41, - f42, f43, f44, f45] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34), - CorrectQualifiers<T, decltype(f35)>(f35), - CorrectQualifiers<T, decltype(f36)>(f36), - CorrectQualifiers<T, decltype(f37)>(f37), - CorrectQualifiers<T, decltype(f38)>(f38), - CorrectQualifiers<T, decltype(f39)>(f39), - CorrectQualifiers<T, decltype(f40)>(f40), - CorrectQualifiers<T, decltype(f41)>(f41), - CorrectQualifiers<T, decltype(f42)>(f42), - CorrectQualifiers<T, decltype(f43)>(f43), - CorrectQualifiers<T, decltype(f44)>(f44), - CorrectQualifiers<T, decltype(f45)>(f45)); - } else if constexpr (kFieldCount == 47) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34, f35, f36, f37, f38, f39, f40, f41, - f42, f43, f44, f45, f46] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34), - CorrectQualifiers<T, decltype(f35)>(f35), - CorrectQualifiers<T, decltype(f36)>(f36), - CorrectQualifiers<T, decltype(f37)>(f37), - CorrectQualifiers<T, decltype(f38)>(f38), - CorrectQualifiers<T, decltype(f39)>(f39), - CorrectQualifiers<T, decltype(f40)>(f40), - CorrectQualifiers<T, decltype(f41)>(f41), - CorrectQualifiers<T, decltype(f42)>(f42), - CorrectQualifiers<T, decltype(f43)>(f43), - CorrectQualifiers<T, decltype(f44)>(f44), - CorrectQualifiers<T, decltype(f45)>(f45), - CorrectQualifiers<T, decltype(f46)>(f46)); - } else if constexpr (kFieldCount == 48) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34, f35, f36, f37, f38, f39, f40, f41, - f42, f43, f44, f45, f46, f47] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34), - CorrectQualifiers<T, decltype(f35)>(f35), - CorrectQualifiers<T, decltype(f36)>(f36), - CorrectQualifiers<T, decltype(f37)>(f37), - CorrectQualifiers<T, decltype(f38)>(f38), - CorrectQualifiers<T, decltype(f39)>(f39), - CorrectQualifiers<T, decltype(f40)>(f40), - CorrectQualifiers<T, decltype(f41)>(f41), - CorrectQualifiers<T, decltype(f42)>(f42), - CorrectQualifiers<T, decltype(f43)>(f43), - CorrectQualifiers<T, decltype(f44)>(f44), - CorrectQualifiers<T, decltype(f45)>(f45), - CorrectQualifiers<T, decltype(f46)>(f46), - CorrectQualifiers<T, decltype(f47)>(f47)); - } else if constexpr (kFieldCount == 49) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34, f35, f36, f37, f38, f39, f40, f41, - f42, f43, f44, f45, f46, f47, f48] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34), - CorrectQualifiers<T, decltype(f35)>(f35), - CorrectQualifiers<T, decltype(f36)>(f36), - CorrectQualifiers<T, decltype(f37)>(f37), - CorrectQualifiers<T, decltype(f38)>(f38), - CorrectQualifiers<T, decltype(f39)>(f39), - CorrectQualifiers<T, decltype(f40)>(f40), - CorrectQualifiers<T, decltype(f41)>(f41), - CorrectQualifiers<T, decltype(f42)>(f42), - CorrectQualifiers<T, decltype(f43)>(f43), - CorrectQualifiers<T, decltype(f44)>(f44), - CorrectQualifiers<T, decltype(f45)>(f45), - CorrectQualifiers<T, decltype(f46)>(f46), - CorrectQualifiers<T, decltype(f47)>(f47), - CorrectQualifiers<T, decltype(f48)>(f48)); - } else if constexpr (kFieldCount == 50) { - auto&& [f0, // Did you forget `friend absl::EnableExtensions`? - f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, - f29, f30, f31, f32, f33, f34, f35, f36, f37, f38, f39, f40, f41, - f42, f43, f44, f45, f46, f47, f48, f49] = t; - return std::forward_as_tuple(CorrectQualifiers<T, decltype(f0)>(f0), - CorrectQualifiers<T, decltype(f1)>(f1), - CorrectQualifiers<T, decltype(f2)>(f2), - CorrectQualifiers<T, decltype(f3)>(f3), - CorrectQualifiers<T, decltype(f4)>(f4), - CorrectQualifiers<T, decltype(f5)>(f5), - CorrectQualifiers<T, decltype(f6)>(f6), - CorrectQualifiers<T, decltype(f7)>(f7), - CorrectQualifiers<T, decltype(f8)>(f8), - CorrectQualifiers<T, decltype(f9)>(f9), - CorrectQualifiers<T, decltype(f10)>(f10), - CorrectQualifiers<T, decltype(f11)>(f11), - CorrectQualifiers<T, decltype(f12)>(f12), - CorrectQualifiers<T, decltype(f13)>(f13), - CorrectQualifiers<T, decltype(f14)>(f14), - CorrectQualifiers<T, decltype(f15)>(f15), - CorrectQualifiers<T, decltype(f16)>(f16), - CorrectQualifiers<T, decltype(f17)>(f17), - CorrectQualifiers<T, decltype(f18)>(f18), - CorrectQualifiers<T, decltype(f19)>(f19), - CorrectQualifiers<T, decltype(f20)>(f20), - CorrectQualifiers<T, decltype(f21)>(f21), - CorrectQualifiers<T, decltype(f22)>(f22), - CorrectQualifiers<T, decltype(f23)>(f23), - CorrectQualifiers<T, decltype(f24)>(f24), - CorrectQualifiers<T, decltype(f25)>(f25), - CorrectQualifiers<T, decltype(f26)>(f26), - CorrectQualifiers<T, decltype(f27)>(f27), - CorrectQualifiers<T, decltype(f28)>(f28), - CorrectQualifiers<T, decltype(f29)>(f29), - CorrectQualifiers<T, decltype(f30)>(f30), - CorrectQualifiers<T, decltype(f31)>(f31), - CorrectQualifiers<T, decltype(f32)>(f32), - CorrectQualifiers<T, decltype(f33)>(f33), - CorrectQualifiers<T, decltype(f34)>(f34), - CorrectQualifiers<T, decltype(f35)>(f35), - CorrectQualifiers<T, decltype(f36)>(f36), - CorrectQualifiers<T, decltype(f37)>(f37), - CorrectQualifiers<T, decltype(f38)>(f38), - CorrectQualifiers<T, decltype(f39)>(f39), - CorrectQualifiers<T, decltype(f40)>(f40), - CorrectQualifiers<T, decltype(f41)>(f41), - CorrectQualifiers<T, decltype(f42)>(f42), - CorrectQualifiers<T, decltype(f43)>(f43), - CorrectQualifiers<T, decltype(f44)>(f44), - CorrectQualifiers<T, decltype(f45)>(f45), - CorrectQualifiers<T, decltype(f46)>(f46), - CorrectQualifiers<T, decltype(f47)>(f47), - CorrectQualifiers<T, decltype(f48)>(f48), - CorrectQualifiers<T, decltype(f49)>(f49)); - } else { - static_assert( - kFieldCount <= 50, - "We are unlikely to extend support beyond 50 fields, both because of " - "the compile-time cost associated with doing so, and because we " - "believe structs this large are probably better off grouped into " - "well-designed smaller structs that can be nested."); - } - } -}; - -template <typename T, - typename = std::enable_if_t<!std::is_same_v<T, FieldGetter::Error>>> -T NotAnError(T); - -// Given a reference to an aggregate `T`, constructs a tuple of references to -// the fields in the aggregate. This only works for types that have either no -// base class or 1 empty base class. -template <typename T> -auto Unpack(T&& t) -> decltype(NotAnError( - FieldGetter::Unpack< - 0, absl::aggregate_internal::NumFields<std::decay_t<T>>(), T>( - std::forward<T>(t)))) { - return FieldGetter::Unpack< - 0, absl::aggregate_internal::NumFields<std::decay_t<T>>(), T>( - std::forward<T>(t)); -} - -} // namespace aggregate_internal -ABSL_NAMESPACE_END -} // namespace absl - -#endif // ABSL_EXTEND_INTERNAL_AGGREGATE_H_
diff --git a/absl/extend/internal/aggregate_test.cc b/absl/extend/internal/aggregate_test.cc deleted file mode 100644 index 30316c9..0000000 --- a/absl/extend/internal/aggregate_test.cc +++ /dev/null
@@ -1,867 +0,0 @@ -// Copyright 2026 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/extend/internal/aggregate.h" - -#include <tuple> -#include <type_traits> -#include <utility> - -#include "gtest/gtest.h" -#include "absl/base/config.h" - -namespace absl { -ABSL_NAMESPACE_BEGIN -namespace aggregate_internal { -namespace { - -TEST(Qualifiers, Collapse) { - EXPECT_EQ(kRef | kRefRef, kRef); - EXPECT_NE(kConst, kVolatile); - EXPECT_NE(kConst, kRef); - EXPECT_NE(kConst, kRefRef); - EXPECT_NE(kVolatile, kRef); - EXPECT_NE(kVolatile, kRefRef); - EXPECT_NE(kRef, kRefRef); -} - -TEST(ExtractQualifiers, Works) { - EXPECT_EQ(ExtractQualifiers<int>(), 0); - EXPECT_EQ(ExtractQualifiers<int&>(), kRef); - EXPECT_EQ(ExtractQualifiers<int&&>(), kRefRef); - EXPECT_EQ(ExtractQualifiers<const int>(), kConst); - EXPECT_EQ(ExtractQualifiers<const int&>(), kConst | kRef); - EXPECT_EQ(ExtractQualifiers<const int&&>(), kConst | kRefRef); - EXPECT_EQ(ExtractQualifiers<volatile int>(), kVolatile); - EXPECT_EQ(ExtractQualifiers<volatile int&>(), kVolatile | kRef); - EXPECT_EQ(ExtractQualifiers<volatile int&&>(), kVolatile | kRefRef); - EXPECT_EQ(ExtractQualifiers<volatile const int>(), kVolatile | kConst); - EXPECT_EQ(ExtractQualifiers<volatile const int&>(), - kVolatile | kConst | kRef); - EXPECT_EQ(ExtractQualifiers<volatile const int&&>(), - kVolatile | kConst | kRefRef); -} - -TEST(ApplyQualifiers, OnBareType) { - EXPECT_TRUE((std::is_same_v<typename ApplyQualifiers<int, 0>::type, int>)); - EXPECT_TRUE( - (std::is_same_v<typename ApplyQualifiers<int, kRef>::type, int&>)); - EXPECT_TRUE( - (std::is_same_v<typename ApplyQualifiers<int, kRefRef>::type, int&&>)); - EXPECT_TRUE( - (std::is_same_v<typename ApplyQualifiers<int, kConst>::type, const int>)); - EXPECT_TRUE( - (std::is_same_v<typename ApplyQualifiers<int, kConst | kRef>::type, - const int&>)); - EXPECT_TRUE( - (std::is_same_v<typename ApplyQualifiers<int, kConst | kRefRef>::type, - const int&&>)); - EXPECT_TRUE((std::is_same_v<typename ApplyQualifiers<int, kVolatile>::type, - volatile int>)); - EXPECT_TRUE( - (std::is_same_v<typename ApplyQualifiers<int, kVolatile | kRef>::type, - volatile int&>)); - EXPECT_TRUE( - (std::is_same_v<typename ApplyQualifiers<int, kVolatile | kRefRef>::type, - volatile int&&>)); - EXPECT_TRUE( - (std::is_same_v<typename ApplyQualifiers<int, kVolatile | kConst>::type, - volatile const int>)); - EXPECT_TRUE((std::is_same_v< - typename ApplyQualifiers<int, kVolatile | kConst | kRef>::type, - volatile const int&>)); - EXPECT_TRUE( - (std::is_same_v< - typename ApplyQualifiers<int, kVolatile | kConst | kRefRef>::type, - volatile const int&&>)); -} - -TEST(ApplyQualifiers, OnConstType) { - EXPECT_TRUE(( - std::is_same_v<typename ApplyQualifiers<const int, 0>::type, const int>)); - EXPECT_TRUE((std::is_same_v<typename ApplyQualifiers<const int, kRef>::type, - const int&>)); - EXPECT_TRUE( - (std::is_same_v<typename ApplyQualifiers<const int, kRefRef>::type, - const int&&>)); - EXPECT_TRUE((std::is_same_v<typename ApplyQualifiers<const int, kConst>::type, - const int>)); - EXPECT_TRUE( - (std::is_same_v<typename ApplyQualifiers<const int, kConst | kRef>::type, - const int&>)); - EXPECT_TRUE((std::is_same_v< - typename ApplyQualifiers<const int, kConst | kRefRef>::type, - const int&&>)); - EXPECT_TRUE( - (std::is_same_v<typename ApplyQualifiers<const int, kVolatile>::type, - const volatile int>)); - EXPECT_TRUE((std::is_same_v< - typename ApplyQualifiers<const int, kVolatile | kRef>::type, - const volatile int&>)); - EXPECT_TRUE((std::is_same_v< - typename ApplyQualifiers<const int, kVolatile | kRefRef>::type, - const volatile int&&>)); - EXPECT_TRUE((std::is_same_v< - typename ApplyQualifiers<const int, kVolatile | kConst>::type, - volatile const int>)); - EXPECT_TRUE( - (std::is_same_v< - typename ApplyQualifiers<const int, kVolatile | kConst | kRef>::type, - volatile const int&>)); - EXPECT_TRUE( - (std::is_same_v<typename ApplyQualifiers<const int, kVolatile | kConst | - kRefRef>::type, - volatile const int&&>)); -} - -TEST(CorrectQualifiers, Type) { - struct A { - int val; - int&& rval; - const int cval; - const int& clval; - const int&& crval; - }; - - A a{ - 3, // .val - static_cast<int&&>(a.val), // .rval - 3, // .cval - a.cval, // .clval - static_cast<const int&&>(a.cval) // .crval - }; - auto&& [v, r, c, cl, cr] = a; - testing::StaticAssertTypeEq<decltype(CorrectQualifiers<A, decltype(v)>(v)), - int&&>(); - testing::StaticAssertTypeEq<decltype(CorrectQualifiers<A, decltype(r)>(r)), - int&&>(); - testing::StaticAssertTypeEq<decltype(CorrectQualifiers<A, decltype(c)>(c)), - const int&&>(); - testing::StaticAssertTypeEq<decltype(CorrectQualifiers<A, decltype(cl)>(cl)), - const int&>(); - - testing::StaticAssertTypeEq<decltype(CorrectQualifiers<A&, decltype(v)>(v)), - int&>(); - testing::StaticAssertTypeEq<decltype(CorrectQualifiers<A&, decltype(r)>(r)), - int&&>(); - testing::StaticAssertTypeEq<decltype(CorrectQualifiers<A&, decltype(c)>(c)), - const int&>(); - testing::StaticAssertTypeEq<decltype(CorrectQualifiers<A&, decltype(cl)>(cl)), - const int&>(); - - testing::StaticAssertTypeEq< - decltype(CorrectQualifiers<const A&, decltype(v)>(v)), const int&>(); - testing::StaticAssertTypeEq< - decltype(CorrectQualifiers<const A&, decltype(r)>(r)), int&&>(); -} - -TEST(RemoveQualifiersAndReferencesFromTuple, Type) { - EXPECT_TRUE( - (std::is_same_v<RemoveQualifiersAndReferencesFromTuple<std::tuple< - int, int&, const int&, volatile const int&>>::type, - std::tuple<int, int, int, int>>)); -} - -TEST(Unpack, Basic) { - struct A1 { - int a; - }; - struct A2 { - int a; - int b; - }; - struct A3 { - int a; - int&& b; - }; - - { - A1 a; - auto [f1] = Unpack(a); - EXPECT_EQ(&f1, &a.a); - } - - { - A2 a; - auto [f1, f2] = Unpack(a); - EXPECT_EQ(&f1, &a.a); - EXPECT_EQ(&f2, &a.b); - } - - { - int b = 0; - A3 a{0, std::move(b)}; // NOLINT(performance-move-const-arg) - auto [f1, f2] = Unpack(a); - EXPECT_EQ(&f1, &a.a); - EXPECT_EQ(&f2, &a.b); - } -} - -TEST(Unpack, Types) { - struct A3 { - int field_v; - const int& field_l; - int&& field_r; - }; - - int x = 0, y = 0; - A3 my_struct{0, x, std::move(y)}; // NOLINT(performance-move-const-arg) - auto unpacked = Unpack(my_struct); - const auto& const_lvalue_ref = my_struct; - auto unpacked_const_lvalue_ref = Unpack(const_lvalue_ref); - auto unpacked_rvalue_ref = Unpack(std::move(my_struct)); - testing::StaticAssertTypeEq<decltype(unpacked), - std::tuple<int&, const int&, int&&>>(); - testing::StaticAssertTypeEq<decltype(unpacked_const_lvalue_ref), - std::tuple<const int&, const int&, int&&>>(); - testing::StaticAssertTypeEq<decltype(unpacked_rvalue_ref), - std::tuple<int&&, const int&, int&&>>(); -} - -TEST(Unpack, Const) { - struct A1 { - const int a; - }; - struct A2 { - const int a; - const int b; - }; - struct A3 { - const int a; - const int& b; - int&& c; - }; - - { - A1 a{}; - auto [f1] = Unpack(a); - EXPECT_EQ(&f1, &a.a); - } - - { - A2 a{}; - auto [f1, f2] = Unpack(a); - EXPECT_EQ(&f1, &a.a); - EXPECT_EQ(&f2, &a.b); - } - - { - int b = 0, c = 0; - A3 a{0, b, std::move(c)}; // NOLINT(performance-move-const-arg) - auto [f1, f2, f3] = Unpack(a); - EXPECT_EQ(&f1, &a.a); - EXPECT_EQ(&f2, &a.b); - EXPECT_EQ(&f3, &a.c); - } -} - -TEST(Unpack, BaseClass) { - struct Base {}; - struct A2 : Base { - int a1, a2; - }; - - A2 a; - auto [f1, f2] = Unpack(a); - EXPECT_EQ(&f1, &a.a1); - EXPECT_EQ(&f2, &a.a2); -} - -// Not supported on older compilers due to mysterious compiler bug(s) that are -// somewhat difficult to track down. (See b/478243383.) -// -// TODO(b/479561657): Enable this unconditionally. -#if !defined(_MSC_VER) || _MSC_VER >= 1939 -TEST(Unpack, Immovable) { - struct Immovable { - Immovable() = default; - Immovable(Immovable&&) = delete; - }; - struct A2 { - const Immovable& a; - Immovable&& b; - }; - - Immovable i1, i2; - A2 a{i1, std::move(i2)}; - auto [f1, f2] = Unpack(a); - EXPECT_EQ(&f1, &a.a); - EXPECT_EQ(&f2, &a.b); -} -#endif // _MSC_VER >= 1939 - -TEST(Unpack, Empty) { - struct Empty {}; - EXPECT_TRUE((std::is_same_v<std::tuple<>, decltype(Unpack(Empty{}))>)); - Empty lvalue_empty; - EXPECT_TRUE((std::is_same_v<std::tuple<>, decltype(Unpack(lvalue_empty))>)); - - struct EmptyWithBase : Empty {}; - EXPECT_TRUE( - (std::is_same_v<std::tuple<>, decltype(Unpack(EmptyWithBase{}))>)); -} - -TEST(Unpack, Autodetect) { - struct NoBases { - int i = 7; - } no_bases; - auto [i2] = Unpack(no_bases); - EXPECT_EQ(i2, 7); - - struct Base {}; - struct OneBase : Base { - int j = 17; - } one_base; - auto [j2] = Unpack(one_base); - EXPECT_EQ(j2, 17); - - constexpr auto try_unpack = - [](auto&& v) -> decltype(NumBases(std::forward<decltype(v)>(v))) {}; - - struct Base2 {}; - struct TwoBases : Base, Base2 { - int k; - }; - EXPECT_FALSE((std::is_invocable_v<decltype(try_unpack), TwoBases>)); -} - -TEST(Unpack, FailsSubstitution) { - struct Aggregate { - int i; - }; - struct NonAggregate { - explicit NonAggregate(int) {} - int i; - }; - - const auto unpack = - [](auto&& v) -> decltype(Unpack(std::forward<decltype(v)>(v))) {}; - EXPECT_TRUE((std::is_invocable_v<decltype(unpack), Aggregate>)); - EXPECT_FALSE((std::is_invocable_v<decltype(unpack), NonAggregate>)); -} - -// Not supported on older compilers due to mysterious compiler bug(s) that are -// somewhat difficult to track down. (See b/478243383.) -// -// TODO(b/479561657): Enable this unconditionally. -#if !defined(_MSC_VER) || _MSC_VER >= 1939 -template <int N, class T> -void CheckTupleElementsEqualToIndex(const T& t) { - if constexpr (N > 0) { - EXPECT_EQ(std::get<N - 1>(t), N - 1); - CheckTupleElementsEqualToIndex<N - 1>(t); - } -} - -TEST(Unpack, CorrectOrder1) { - struct S1 { - int a0 = 0; - }; - CheckTupleElementsEqualToIndex<1>(Unpack(S1())); -} - -TEST(Unpack, CorrectOrder2) { - struct S2 { - int a0 = 0, a1 = 1; - }; - CheckTupleElementsEqualToIndex<2>(Unpack(S2())); -} - -TEST(Unpack, CorrectOrder3) { - struct S3 { - int a0 = 0, a1 = 1, a2 = 2; - }; - CheckTupleElementsEqualToIndex<3>(Unpack(S3())); -} - -TEST(Unpack, CorrectOrder4) { - struct S4 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3; - }; - CheckTupleElementsEqualToIndex<4>(Unpack(S4())); -} - -TEST(Unpack, CorrectOrder5) { - struct S5 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4; - }; - CheckTupleElementsEqualToIndex<5>(Unpack(S5())); -} - -TEST(Unpack, CorrectOrder6) { - struct S6 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5; - }; - CheckTupleElementsEqualToIndex<6>(Unpack(S6())); -} - -TEST(Unpack, CorrectOrder7) { - struct S7 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6; - }; - CheckTupleElementsEqualToIndex<7>(Unpack(S7())); -} - -TEST(Unpack, CorrectOrder8) { - struct S8 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7; - }; - CheckTupleElementsEqualToIndex<8>(Unpack(S8())); -} - -TEST(Unpack, CorrectOrder9) { - struct S9 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8; - }; - CheckTupleElementsEqualToIndex<9>(Unpack(S9())); -} - -TEST(Unpack, CorrectOrder10) { - struct S10 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9; - }; - CheckTupleElementsEqualToIndex<10>(Unpack(S10())); -} - -TEST(Unpack, CorrectOrder11) { - struct S11 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10; - }; - CheckTupleElementsEqualToIndex<11>(Unpack(S11())); -} - -TEST(Unpack, CorrectOrder12) { - struct S12 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11; - }; - CheckTupleElementsEqualToIndex<12>(Unpack(S12())); -} - -TEST(Unpack, CorrectOrder13) { - struct S13 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12; - }; - CheckTupleElementsEqualToIndex<13>(Unpack(S13())); -} - -TEST(Unpack, CorrectOrder14) { - struct S14 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13; - }; - CheckTupleElementsEqualToIndex<14>(Unpack(S14())); -} - -TEST(Unpack, CorrectOrder15) { - struct S15 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14; - }; - CheckTupleElementsEqualToIndex<15>(Unpack(S15())); -} - -TEST(Unpack, CorrectOrder16) { - struct S16 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15; - }; - CheckTupleElementsEqualToIndex<16>(Unpack(S16())); -} - -TEST(Unpack, CorrectOrder17) { - struct S17 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16; - }; - CheckTupleElementsEqualToIndex<17>(Unpack(S17())); -} - -TEST(Unpack, CorrectOrder18) { - struct S18 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17; - }; - CheckTupleElementsEqualToIndex<18>(Unpack(S18())); -} - -TEST(Unpack, CorrectOrder19) { - struct S19 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18; - }; - CheckTupleElementsEqualToIndex<19>(Unpack(S19())); -} - -TEST(Unpack, CorrectOrder20) { - struct S20 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19; - }; - CheckTupleElementsEqualToIndex<20>(Unpack(S20())); -} - -TEST(Unpack, CorrectOrder21) { - struct S21 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20; - }; - CheckTupleElementsEqualToIndex<21>(Unpack(S21())); -} - -TEST(Unpack, CorrectOrder22) { - struct S22 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21; - }; - CheckTupleElementsEqualToIndex<22>(Unpack(S22())); -} - -TEST(Unpack, CorrectOrder23) { - struct S23 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22; - }; - CheckTupleElementsEqualToIndex<23>(Unpack(S23())); -} - -TEST(Unpack, CorrectOrder24) { - struct S24 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23; - }; - CheckTupleElementsEqualToIndex<24>(Unpack(S24())); -} - -TEST(Unpack, CorrectOrder25) { - struct S25 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24; - }; - CheckTupleElementsEqualToIndex<25>(Unpack(S25())); -} - -TEST(Unpack, CorrectOrder26) { - struct S26 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25; - }; - CheckTupleElementsEqualToIndex<26>(Unpack(S26())); -} - -TEST(Unpack, CorrectOrder27) { - struct S27 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26; - }; - CheckTupleElementsEqualToIndex<27>(Unpack(S27())); -} - -TEST(Unpack, CorrectOrder28) { - struct S28 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27; - }; - CheckTupleElementsEqualToIndex<28>(Unpack(S28())); -} - -TEST(Unpack, CorrectOrder29) { - struct S29 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28; - }; - CheckTupleElementsEqualToIndex<29>(Unpack(S29())); -} - -TEST(Unpack, CorrectOrder30) { - struct S30 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29; - }; - CheckTupleElementsEqualToIndex<30>(Unpack(S30())); -} - -TEST(Unpack, CorrectOrder31) { - struct S31 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30; - }; - CheckTupleElementsEqualToIndex<31>(Unpack(S31())); -} - -TEST(Unpack, CorrectOrder32) { - struct S32 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31; - }; - CheckTupleElementsEqualToIndex<32>(Unpack(S32())); -} - -#ifndef _MSC_VER // MSVC constexpr evaluation hits a default limit -TEST(Unpack, CorrectOrder33) { - struct S33 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32; - }; - CheckTupleElementsEqualToIndex<33>(Unpack(S33())); -} - -TEST(Unpack, CorrectOrder34) { - struct S34 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33; - }; - CheckTupleElementsEqualToIndex<34>(Unpack(S34())); -} - -TEST(Unpack, CorrectOrder35) { - struct S35 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34; - }; - CheckTupleElementsEqualToIndex<35>(Unpack(S35())); -} - -TEST(Unpack, CorrectOrder36) { - struct S36 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34, a35 = 35; - }; - CheckTupleElementsEqualToIndex<36>(Unpack(S36())); -} - -TEST(Unpack, CorrectOrder37) { - struct S37 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34, a35 = 35, a36 = 36; - }; - CheckTupleElementsEqualToIndex<37>(Unpack(S37())); -} - -TEST(Unpack, CorrectOrder38) { - struct S38 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34, a35 = 35, a36 = 36, - a37 = 37; - }; - CheckTupleElementsEqualToIndex<38>(Unpack(S38())); -} - -TEST(Unpack, CorrectOrder39) { - struct S39 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34, a35 = 35, a36 = 36, - a37 = 37, a38 = 38; - }; - CheckTupleElementsEqualToIndex<39>(Unpack(S39())); -} - -TEST(Unpack, CorrectOrder40) { - struct S40 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34, a35 = 35, a36 = 36, - a37 = 37, a38 = 38, a39 = 39; - }; - CheckTupleElementsEqualToIndex<40>(Unpack(S40())); -} - -TEST(Unpack, CorrectOrder41) { - struct S41 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34, a35 = 35, a36 = 36, - a37 = 37, a38 = 38, a39 = 39, a40 = 40; - }; - CheckTupleElementsEqualToIndex<41>(Unpack(S41())); -} - -TEST(Unpack, CorrectOrder42) { - struct S42 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34, a35 = 35, a36 = 36, - a37 = 37, a38 = 38, a39 = 39, a40 = 40, a41 = 41; - }; - CheckTupleElementsEqualToIndex<42>(Unpack(S42())); -} - -TEST(Unpack, CorrectOrder43) { - struct S43 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34, a35 = 35, a36 = 36, - a37 = 37, a38 = 38, a39 = 39, a40 = 40, a41 = 41, a42 = 42; - }; - CheckTupleElementsEqualToIndex<43>(Unpack(S43())); -} - -TEST(Unpack, CorrectOrder44) { - struct S44 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34, a35 = 35, a36 = 36, - a37 = 37, a38 = 38, a39 = 39, a40 = 40, a41 = 41, a42 = 42, a43 = 43; - }; - CheckTupleElementsEqualToIndex<44>(Unpack(S44())); -} - -TEST(Unpack, CorrectOrder45) { - struct S45 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34, a35 = 35, a36 = 36, - a37 = 37, a38 = 38, a39 = 39, a40 = 40, a41 = 41, a42 = 42, a43 = 43, - a44 = 44; - }; - CheckTupleElementsEqualToIndex<45>(Unpack(S45())); -} - -TEST(Unpack, CorrectOrder46) { - struct S46 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34, a35 = 35, a36 = 36, - a37 = 37, a38 = 38, a39 = 39, a40 = 40, a41 = 41, a42 = 42, a43 = 43, - a44 = 44, a45 = 45; - }; - CheckTupleElementsEqualToIndex<46>(Unpack(S46())); -} - -TEST(Unpack, CorrectOrder47) { - struct S47 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34, a35 = 35, a36 = 36, - a37 = 37, a38 = 38, a39 = 39, a40 = 40, a41 = 41, a42 = 42, a43 = 43, - a44 = 44, a45 = 45, a46 = 46; - }; - CheckTupleElementsEqualToIndex<47>(Unpack(S47())); -} - -TEST(Unpack, CorrectOrder48) { - struct S48 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34, a35 = 35, a36 = 36, - a37 = 37, a38 = 38, a39 = 39, a40 = 40, a41 = 41, a42 = 42, a43 = 43, - a44 = 44, a45 = 45, a46 = 46, a47 = 47; - }; - CheckTupleElementsEqualToIndex<48>(Unpack(S48())); -} - -TEST(Unpack, CorrectOrder49) { - struct S49 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34, a35 = 35, a36 = 36, - a37 = 37, a38 = 38, a39 = 39, a40 = 40, a41 = 41, a42 = 42, a43 = 43, - a44 = 44, a45 = 45, a46 = 46, a47 = 47, a48 = 48; - }; - CheckTupleElementsEqualToIndex<49>(Unpack(S49())); -} - -TEST(Unpack, CorrectOrder50) { - struct S50 { - int a0 = 0, a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8, - a9 = 9, a10 = 10, a11 = 11, a12 = 12, a13 = 13, a14 = 14, a15 = 15, - a16 = 16, a17 = 17, a18 = 18, a19 = 19, a20 = 20, a21 = 21, a22 = 22, - a23 = 23, a24 = 24, a25 = 25, a26 = 26, a27 = 27, a28 = 28, a29 = 29, - a30 = 30, a31 = 31, a32 = 32, a33 = 33, a34 = 34, a35 = 35, a36 = 36, - a37 = 37, a38 = 38, a39 = 39, a40 = 40, a41 = 41, a42 = 42, a43 = 43, - a44 = 44, a45 = 45, a46 = 46, a47 = 47, a48 = 48, a49 = 49; - }; - CheckTupleElementsEqualToIndex<50>(Unpack(S50())); -} - -// When adding support for more fields, add corresponding CorrectOrderNN test(s) -// here. -#endif // _MSC_VER -#endif // _MSC_VER >= 1939 - -} // namespace -} // namespace aggregate_internal -ABSL_NAMESPACE_END -} // namespace absl
diff --git a/absl/extend/internal/dependencies.h b/absl/extend/internal/dependencies.h deleted file mode 100644 index 572f7a3..0000000 --- a/absl/extend/internal/dependencies.h +++ /dev/null
@@ -1,83 +0,0 @@ -// Copyright 2026 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_EXTEND_INTERNAL_DEPENDENCIES_H_ -#define ABSL_EXTEND_INTERNAL_DEPENDENCIES_H_ - -#include <type_traits> - -#include "absl/base/config.h" - -namespace absl { -ABSL_NAMESPACE_BEGIN -namespace dependencies_internal { - -// Dependencies is a meta-function which constructs a collection which -// recursively looks through types and either adds them to the list, or, if they -// have a `using deps = void(...);` takes those listed dependencies as well. For -// example, given: -// -// struct X {}; -// struct Y {}; -// struct A {}; -// struct B { using deps = void(A, X); }; -// struct C { using deps = void(A, Y); }; -// struct D { using deps = void(B, C); }; -// -// Dependencies<D>() will return a function pointer returning void and accepting -// arguments of types A, B, C, D, X, and Y in some unspecified order each -// exactly once, and no other types. -template <typename T> -auto GetDependencies(T*) -> typename T::deps*; -auto GetDependencies(void*) -> void (*)(); - -template <typename FnPtr, typename... Ts> -struct CombineDeps {}; -template <typename... Ps, typename... Ts> -struct CombineDeps<void (*)(Ps...), Ts...> { - using type = void (*)(Ps..., Ts...); -}; - -template <typename... Processed> -auto DependenciesImpl(void (*)(), void (*)(Processed...)) { - return static_cast<void (*)(Processed...)>(nullptr); -} - -template <typename T, typename... Ts, typename... Processed> -auto DependenciesImpl(void (*)(T, Ts...), void (*)(Processed...)) { - if constexpr ((std::is_same_v<T, Processed> || ...)) { - return DependenciesImpl(static_cast<void (*)(Ts...)>(nullptr), - static_cast<void (*)(Processed...)>(nullptr)); - } else { - using deps = decltype(GetDependencies(static_cast<T*>(nullptr))); - if constexpr (std ::is_same_v<deps, void (*)()>) { - return DependenciesImpl(static_cast<void (*)(Ts...)>(nullptr), - static_cast<void (*)(T, Processed...)>(nullptr)); - } else { - return DependenciesImpl( - static_cast<typename CombineDeps<deps, Ts...>::type>(nullptr), - static_cast<void (*)(T, Processed...)>(nullptr)); - } - } -} - -template <typename... Ts> -using Dependencies = decltype(DependenciesImpl( - static_cast<void (*)(Ts...)>(nullptr), static_cast<void (*)()>(nullptr))); - -} // namespace dependencies_internal -ABSL_NAMESPACE_END -} // namespace absl - -#endif // ABSL_EXTEND_INTERNAL_DEPENDENCIES_H_
diff --git a/absl/extend/internal/dependencies_test.cc b/absl/extend/internal/dependencies_test.cc deleted file mode 100644 index 7fa4a13..0000000 --- a/absl/extend/internal/dependencies_test.cc +++ /dev/null
@@ -1,117 +0,0 @@ -// Copyright 2026 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/extend/internal/dependencies.h" - -#include <type_traits> - -#include "gtest/gtest.h" -#include "absl/base/config.h" - -namespace absl { -ABSL_NAMESPACE_BEGIN -namespace dependencies_internal { -namespace { - -struct X {}; -struct Y {}; -struct A {}; -struct B { - using deps = void(A, X); -}; -struct C { - using deps = void(A, Y); -}; -struct D { - using deps = void(B, C); -}; - -// We don't actually want to check equality because Dependencies doesn't -// guarantee any ordering or repetition. Instead, we just want to check -// containment. -template <typename, typename> -struct Contains : std::false_type {}; - -template <typename Needle, typename... Haystack> -struct Contains<void(Haystack...), Needle> - : std::integral_constant<bool, (std::is_same_v<Needle, Haystack> || ...)> { -}; - -template <typename T> -struct Inspect; - -template <typename... Args> -struct Inspect<void (*)(Args...)> { - template <typename T> - static constexpr int Count() { - return (std::is_same_v<T, Args> + ...); - } - - static constexpr int Total() { return sizeof...(Args); } -}; - -TEST(Dependencies, Works) { - testing::StaticAssertTypeEq<decltype(Dependencies<X>()), void (*)(X)>(); - - EXPECT_EQ(Inspect<Dependencies<B>>::Count<A>(), 1); - EXPECT_EQ(Inspect<Dependencies<B>>::Count<B>(), 1); - EXPECT_EQ(Inspect<Dependencies<B>>::Count<C>(), 0); - EXPECT_EQ(Inspect<Dependencies<B>>::Count<D>(), 0); - EXPECT_EQ(Inspect<Dependencies<B>>::Count<X>(), 1); - EXPECT_EQ(Inspect<Dependencies<B>>::Count<Y>(), 0); - EXPECT_EQ(Inspect<Dependencies<B>>::Total(), 3); - - EXPECT_EQ(Inspect<Dependencies<D>>::Count<A>(), 1); - EXPECT_EQ(Inspect<Dependencies<D>>::Count<B>(), 1); - EXPECT_EQ(Inspect<Dependencies<D>>::Count<C>(), 1); - EXPECT_EQ(Inspect<Dependencies<D>>::Count<D>(), 1); - EXPECT_EQ(Inspect<Dependencies<D>>::Count<X>(), 1); - EXPECT_EQ(Inspect<Dependencies<D>>::Count<Y>(), 1); - EXPECT_EQ(Inspect<Dependencies<D>>::Total(), 6); -} - -struct Recursion { - using deps = void(Recursion); -}; - -template <bool B> -struct MutualRecursion { - using deps = void(MutualRecursion<!B>); -}; - -TEST(Dependencies, Cycles) { - EXPECT_EQ(Inspect<Dependencies<Recursion>>::Count<Recursion>(), 1); - EXPECT_EQ(Inspect<Dependencies<Recursion>>::Total(), 1); - - EXPECT_EQ(Inspect<Dependencies<MutualRecursion<true>>>::Count< - MutualRecursion<true>>(), - 1); - EXPECT_EQ(Inspect<Dependencies<MutualRecursion<true>>>::Count< - MutualRecursion<false>>(), - 1); - EXPECT_EQ(Inspect<Dependencies<MutualRecursion<false>>>::Total(), 2); - - EXPECT_EQ(Inspect<Dependencies<MutualRecursion<false>>>::Count< - MutualRecursion<true>>(), - 1); - EXPECT_EQ(Inspect<Dependencies<MutualRecursion<false>>>::Count< - MutualRecursion<false>>(), - 1); - EXPECT_EQ(Inspect<Dependencies<MutualRecursion<true>>>::Total(), 2); -} - -} // namespace -} // namespace dependencies_internal -ABSL_NAMESPACE_END -} // namespace absl
diff --git a/absl/extend/internal/is_tuple_hashable.h b/absl/extend/internal/is_tuple_hashable.h deleted file mode 100644 index 74495b5..0000000 --- a/absl/extend/internal/is_tuple_hashable.h +++ /dev/null
@@ -1,45 +0,0 @@ -// Copyright 2026 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_EXTEND_INTERNAL_IS_TUPLE_HASHABLE_H_ -#define ABSL_EXTEND_INTERNAL_IS_TUPLE_HASHABLE_H_ - -#include <tuple> -#include <type_traits> - -#include "absl/base/config.h" -#include "absl/hash/hash.h" - -namespace absl { -ABSL_NAMESPACE_BEGIN -namespace extend_internal { - -// Trait to check if all members of a tuple are absl::Hash-able. -// -template <typename T> -struct IsTupleHashable {}; - -// TODO(b/185498964): We wouldn't need absl::Hash if the hasher object provided -// an "is_hashable" trait. -template <typename... Ts> -struct IsTupleHashable<std::tuple<Ts...>> - : std::integral_constant<bool, - (std::is_constructible_v<absl::Hash<Ts>> && ...)> { -}; - -} // namespace extend_internal -ABSL_NAMESPACE_END -} // namespace absl - -#endif // ABSL_EXTEND_INTERNAL_IS_TUPLE_HASHABLE_H_
diff --git a/absl/extend/internal/num_bases.h b/absl/extend/internal/num_bases.h deleted file mode 100644 index a7bcac6..0000000 --- a/absl/extend/internal/num_bases.h +++ /dev/null
@@ -1,87 +0,0 @@ -// Copyright 2026 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_EXTEND_INTERNAL_NUM_BASES_H_ -#define ABSL_EXTEND_INTERNAL_NUM_BASES_H_ - -#include <stddef.h> - -#include <optional> -#include <type_traits> -#include <utility> - -#include "absl/base/config.h" -#include "absl/extend/internal/num_initializers.h" - -namespace absl { -ABSL_NAMESPACE_BEGIN -namespace aggregate_internal { - -template <typename U> -struct OnlyBases { - template <typename T> - using IsStrictBase = - std::enable_if_t<std::is_base_of_v<T, U> && !std::is_same_v<T, U>, int>; - - template <typename T, IsStrictBase<T> = 0> - operator T&&() const; // NOLINT(google-explicit-constructor) - template <typename T, IsStrictBase<T> = 0> - operator T&() const; // NOLINT(google-explicit-constructor) -}; - -template <typename T, size_t... I> -constexpr std::optional<int> NumBasesImpl(std::index_sequence<I...>) { - if constexpr (BraceInitializableWith< - T, OnlyBases<T>, OnlyBases<T>, - decltype( // Cast to void to avoid unintentionally invoking - // comma operator or warning on unused LHS - (void)I, Anything{})...>::value) { - // The first two initializers look like bases. - // The second might be a member or a base, so we give up. - return std::nullopt; - } else if constexpr (BraceInitializableWith< - T, OnlyBases<T>, Anything, - decltype( // Cast to void to avoid unintentionally - // invoking comma operator or warning on - // unused LHS - (void)I, Anything{})...>::value) { - // The first initializer is a base, but not the second. We have 1 base. - return 1; - } else { - // The first initializer is not a base. We have 0 bases. - return 0; - } -} - -// Returns the number of base classes of the given type, with best effort: -// -// - If the type is empty (i.e. `std::is_empty_v<T>` is true), returns nullopt. -// - If the type has no bases, returns 0. -// - If the type has exactly 1 base, returns 1. -// - Otherwise, returns nullopt. -template <typename T> -constexpr std::optional<int> NumBases() { - if constexpr (std::is_empty_v<T>) { - return std::nullopt; - } else { - constexpr int num_initializers = NumInitializers<T>(); - return NumBasesImpl<T>(std::make_index_sequence<num_initializers - 1>()); - } -} - -} // namespace aggregate_internal -ABSL_NAMESPACE_END -} // namespace absl - -#endif // ABSL_EXTEND_INTERNAL_NUM_BASES_H_
diff --git a/absl/extend/internal/num_bases_test.cc b/absl/extend/internal/num_bases_test.cc deleted file mode 100644 index ca6a063..0000000 --- a/absl/extend/internal/num_bases_test.cc +++ /dev/null
@@ -1,91 +0,0 @@ -// Copyright 2026 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/extend/internal/num_bases.h" - -#include <optional> - -#include "gmock/gmock.h" -#include "gtest/gtest.h" -#include "absl/base/config.h" - -namespace absl { -ABSL_NAMESPACE_BEGIN -namespace aggregate_internal { -namespace { - -using ::testing::Eq; -using ::testing::Optional; - -TEST(NumBases, NoBases) { - struct S { - int i; - }; - EXPECT_THAT(NumBases<S>(), Optional(0)); - - struct Empty {}; - // We can't deal with empty classes right now. - EXPECT_THAT(NumBases<Empty>(), Eq(std::nullopt)); -} - -TEST(NumBases, OneBase) { - struct EmptyBase {}; - struct NonEmptyBase { - int i; - }; - - // We can't deal with empty classes right now. - struct EmptyEmpty : EmptyBase {}; - EXPECT_THAT(NumBases<EmptyEmpty>(), Eq(std::nullopt)); - - struct EmptyNonEmpty : NonEmptyBase {}; - EXPECT_THAT(NumBases<EmptyNonEmpty>(), Optional(1)); - - struct NonEmptyEmpty : EmptyBase { - int i; - }; - EXPECT_THAT(NumBases<NonEmptyEmpty>(), Optional(1)); - - struct NonEmptyNonEmpty : NonEmptyBase { - int j; - }; - EXPECT_THAT(NumBases<NonEmptyNonEmpty>(), Optional(1)); -} - -TEST(NumBases, TwoBases) { - struct Base1 {}; - struct Base2 {}; - struct S : Base1, Base2 { - int i; - }; - - EXPECT_THAT(NumBases<S>(), Eq(std::nullopt)); -} - -TEST(NumBases, OneBaseAndField) { - // Special case for 1 base where we fail to detect it. - // The first member also happens to be a base. - - struct Base {}; - struct S : Base { - Base member; - }; - - EXPECT_THAT(NumBases<S>(), Eq(std::nullopt)); -} - -} // namespace -} // namespace aggregate_internal -ABSL_NAMESPACE_END -} // namespace absl
diff --git a/absl/extend/internal/num_initializers.h b/absl/extend/internal/num_initializers.h deleted file mode 100644 index 1224e72..0000000 --- a/absl/extend/internal/num_initializers.h +++ /dev/null
@@ -1,113 +0,0 @@ -// Copyright 2026 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_EXTEND_INTERNAL_NUM_INITIALIZERS_H_ -#define ABSL_EXTEND_INTERNAL_NUM_INITIALIZERS_H_ - -#include <type_traits> -#include <utility> - -#include "absl/base/config.h" -#include "absl/base/optimization.h" - -namespace absl { -ABSL_NAMESPACE_BEGIN -namespace aggregate_internal { - -template <typename U> -struct AnythingExcept { - template <typename T, - std::enable_if_t<!std::is_same_v<U, std::decay_t<T>>, int> = 0> - operator T() const { // NOLINT(google-explicit-constructor) - ABSL_UNREACHABLE(); - } -}; - -struct Anything { - template <typename T> - operator T() const { // NOLINT(google-explicit-constructor) - ABSL_UNREACHABLE(); - } -}; - -struct NotDefaultConstructible { - NotDefaultConstructible() = delete; - explicit NotDefaultConstructible(int); -}; - -template <typename T> -struct Tester { - T t; - NotDefaultConstructible n; -}; - -template <class Void, typename T, typename... Args> -struct BraceInitializableWithImpl : std::false_type { - static_assert(std::is_void_v<Void>, "First template parameter must be void"); -}; - -template <typename T, typename... Args> -struct BraceInitializableWithImpl< - std::enable_if_t< - !std::is_null_pointer_v<decltype(Tester<T>{std::declval<Args>()...})>>, - T, Args...> : std::true_type {}; - -#ifdef __clang__ -#pragma clang diagnostic push -// -Wmissing-braces triggers here because we are expanding arguments into the -// first member of `Tester`. Not having the braces is necessary because we don't -// know how many arguments are going to be used to initialize the `T` and we -// need them to be tried greedily. -#pragma clang diagnostic ignored "-Wmissing-braces" -#endif - -template <typename T, typename... Args> -using BraceInitializableWith = BraceInitializableWithImpl<void, T, Args...>; - -#ifdef __clang__ -#pragma clang diagnostic pop -#endif - -// Count the number of initializers required for a struct of type `T`. Note that -// we do not support C-style array members. Prefer using a std::array. -// -// Repeatedly tests if `T` is brace-constructible with a given number of -// arguments. Each time it is not, one more argument is added and -// `NumInitializers` is called recursively. -template <typename T, typename... Args> -constexpr int NumInitializers(Args... args) { - static_assert(!std::is_empty_v<T>); - // By attempting to brace-initialize a Tester<T> where the first member is - // `AnythingExcept<T>`, we force the aggregate to be expanded, meaning the - // first some-number of arguments are passed to `T`'s aggregate - // initialization. This will fail (and therefore recurse into - // `NumInitializers` with one more argument) if we have not found enough - // arguments to initialize `T`. This is because the second member of the - // `Tester<T>` has type `NotDefaultConstructible` which cannot be default - // constructed. - if constexpr (BraceInitializableWith<T, AnythingExcept<T>, Args...>::value) { - return sizeof...(Args); - } else { - static_assert(sizeof...(Args) <= sizeof(T), - "Automatic field count does not support fields like l-value " - "references or bit fields. Try specifying the field count."); - return NumInitializers<T>(args..., Anything()); - } -} - -} // namespace aggregate_internal -ABSL_NAMESPACE_END -} // namespace absl - -#endif // ABSL_EXTEND_INTERNAL_NUM_INITIALIZERS_H_
diff --git a/absl/extend/internal/num_initializers_test.cc b/absl/extend/internal/num_initializers_test.cc deleted file mode 100644 index 96c7b41..0000000 --- a/absl/extend/internal/num_initializers_test.cc +++ /dev/null
@@ -1,250 +0,0 @@ -// Copyright 2026 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/extend/internal/num_initializers.h" - -#include <stdint.h> - -#include <any> -#include <array> -#include <optional> - -#include "gtest/gtest.h" -#include "absl/base/config.h" - -namespace absl { -ABSL_NAMESPACE_BEGIN -namespace aggregate_internal { -namespace { - -TEST(NumInitializers, SimpleStructs) { - struct A1 { - int a; - }; - EXPECT_EQ(NumInitializers<A1>(), 1); - - struct A2 { - int a; - int b; - }; - EXPECT_EQ(NumInitializers<A2>(), 2); - - struct A3 { - int a; - const int& b; - int&& c; - }; - EXPECT_EQ(NumInitializers<A3>(), 3); -} - -TEST(NumInitializers, SimpleStructsWithDefaults) { - struct A1 { - int a = 1; - }; - EXPECT_EQ(NumInitializers<A1>(), 1); - - struct A2 { - int a = 1; - int b = 2; - }; - EXPECT_EQ(NumInitializers<A2>(), 2); - - struct A3 { - int a = 0; - const int& b; - int&& c; - }; - EXPECT_EQ(NumInitializers<A3>(), 3); -} - -TEST(NumInitializers, EmptyBase) { - struct Base {}; - - struct A1 : Base { - int a; - }; - EXPECT_EQ(NumInitializers<A1>(), 2); - - struct A2 : Base { - int a; - int b; - }; - EXPECT_EQ(NumInitializers<A2>(), 3); - - struct A3 : Base { - int a; - const int& b; - int&& c; - }; - EXPECT_EQ(NumInitializers<A3>(), 4); -} - -TEST(NumInitializers, Base) { - struct Base { - int x; - int y; - }; - - struct A1 : Base { - int a; - }; - EXPECT_EQ(NumInitializers<A1>(), 2); - - struct A2 : Base { - int a; - int b; - }; - EXPECT_EQ(NumInitializers<A2>(), 3); - - struct A3 : Base { - int a; - const int& b; - int&& c; - }; - EXPECT_EQ(NumInitializers<A3>(), 4); -} - -TEST(NumInitializers, MultipleBases) { - struct Base1 { - int x1; - int y1; - }; - struct Base2 { - int x2; - int y2; - }; - - struct A1 : Base1, Base2 { - int a; - }; - EXPECT_EQ(NumInitializers<A1>(), 3); - - struct A2 : Base1, Base2 { - int a; - int b; - }; - EXPECT_EQ(NumInitializers<A2>(), 4); - - struct A3 : Base1, Base2 { - int a; - const int& b; - int&& c; - }; - EXPECT_EQ(NumInitializers<A3>(), 5); -} - -TEST(NumInitializers, StdArrayMembers) { - struct A { - std::array<int, 3> a; - int b; - }; - EXPECT_EQ(NumInitializers<A>(), 2); -} - -TEST(NumInitializers, StructMembers) { - struct A { - struct Nested { - int x; - int y; - } n; - int b; - }; - EXPECT_EQ(NumInitializers<A>(), 2); -} - -TEST(NumInitializers, MoveOnlyMembers) { - class MoveOnly { - public: - MoveOnly() = default; - MoveOnly(MoveOnly&&) = default; - MoveOnly& operator=(MoveOnly&&) = default; - - MoveOnly(MoveOnly const&) = delete; - MoveOnly& operator=(MoveOnly const&) = delete; - }; - - struct A { - MoveOnly a; - int b; - MoveOnly c; - MoveOnly&& d; - // MoveOnly& e; // does not compile, until a brave soul implements it. - }; - EXPECT_EQ(NumInitializers<A>(), 4); -} - -// Not supported on older compilers due to mysterious compiler bug(s) that are -// somewhat difficult to track down. (See b/478243383.) -// -// TODO(b/479561657): Enable this unconditionally. -#if !defined(_MSC_VER) || _MSC_VER >= 1939 -TEST(NumInitializers, MutableRefConstructibleMembers) { - class MutableRefConstructible { - public: - MutableRefConstructible() = default; - - MutableRefConstructible(MutableRefConstructible&) { - { - // Dummy braces to avoid modernize-use-equals-default diagnostic. - // We avoid `= default` due to compiler bug on _MSC_VER < 1940. - } - } - - MutableRefConstructible(const MutableRefConstructible&) = delete; - }; - - struct A { - MutableRefConstructible a; - int b; - MutableRefConstructible c; - MutableRefConstructible&& d; - }; - EXPECT_EQ(NumInitializers<A>(), 4); -} - -TEST(NumInitializers, ImmovableMembers) { - struct Immovable { - Immovable() = default; - Immovable(Immovable&&) = delete; - }; - - struct A { - const Immovable& a; - Immovable&& b; - }; - EXPECT_EQ(NumInitializers<A>(), 2); -} -#endif // _MSC_VER >= 1939 - -TEST(NumInitializers, StdAnyMembers) { - struct A1 { - std::any a; // cover `AnythingExcept` - int b; - std::any c; - }; - EXPECT_EQ(NumInitializers<A1>(), 3); - - struct A2 { - int a; - std::any b; // cover `Anything` - const std::any& c; - std::any&& d; - }; - EXPECT_EQ(NumInitializers<A2>(), 4); -} - -} // namespace -} // namespace aggregate_internal -ABSL_NAMESPACE_END -} // namespace absl
diff --git a/absl/extend/internal/reflection.cc b/absl/extend/internal/reflection.cc deleted file mode 100644 index 1d47998..0000000 --- a/absl/extend/internal/reflection.cc +++ /dev/null
@@ -1,112 +0,0 @@ -// Copyright 2026 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/extend/internal/reflection.h" - -#include <stddef.h> - -#include <cstdarg> - -#include "absl/base/config.h" -#include "absl/strings/match.h" -#include "absl/strings/string_view.h" -#include "absl/types/span.h" - -namespace absl { -ABSL_NAMESPACE_BEGIN -namespace extend_internal { - -// `PrintfHijack` is called repeatedly with each `fmt` line and corresponding -// arguments `va` via `__builtin_dump_struct`. While there is no guarantee about -// the `fmt` strings provided, it is typical that lines come in 5 flavors: -// 1. A string containing only "%s", accepting the name of the struct itself. -// 2. A string containing only "%s%s", accepting the name of a base class. -// 3. A string containing only whitespace and an open brace "{" indicating that -// we are entering a new struct. -// 4. A string with "=" where the value passed into the format specifier which -// immediately precedes "=" is the name of a struct field. -// 5. A string ending with a "}" indicating the conclusion of a struct. -// -// For example, for a struct -// ``` -// struct Bacon { -// int repeatability; -// double flavor; -// double fattiness; -// struct Metadata { -// bool is_pork; -// bool is_expired; -// } metadata; -// }; -// ``` -// we would expect the following values for `fmt` to be passed to `ParseLine`, -// along with the following data in `va`: -// `fmt` | `va` -// --------------------|------------- -// "%s" | {"Bacon"} -// " {\n" | {} -// "%s%s %s = %d\n" | {" ", "int", "repeatability", ???} -// "%s%s %s = %f\n" | {" ", "double", "flavor", ???} -// "%s%s %s = %f\n" | {" ", "double", "fattiness", ???} -// "%s%s %s =" | {" ", "Metadata", "metadata"} -// " {\n" | {} -// "%s%s %s = %d\n" | {" ", "_Bool", "is_pork", ???} -// "%s%s %s = %d\n" | {" ", "_Bool", "is_expired", ???} -// "%s}\n" | {" "} -// "}\n" | {} -// -// `PrintfHijack` inspects each format string and argument set, extracting field -// names for the given struct and writes them to `fields`. If an unexpected -// format string is encountered, `state.index` will be set to -1 indicating a -// failure. Parsing succeeds if after every call to `PrintfHijack`, -// `state.index == fields.size()`. -int PrintfHijack(ParsingState& state, absl::Span<absl::string_view> fields, - const char* fmt, ...) { - if (state.index < 0) return 0; - - if (absl::EndsWith(fmt, "{\n")) { - ++state.brace_count; - return 0; - } else if (absl::EndsWith(fmt, "}") || absl::EndsWith(fmt, "}\n")) { - --state.brace_count; - return 0; - } else if (state.brace_count != 1) { - // Ignore everything that's not at the top-level (we only care about the - // names of fields in this type. - return 0; - } else if (absl::StartsWith(fmt, "%s%s %s =")) { - std::va_list va; - va_start(va, fmt); - - static_cast<void>(va_arg(va, const char*)); // Indentation whitespace - static_cast<void>(va_arg(va, const char*)); // Field's type name - fields[static_cast<size_t>(state.index)] = - va_arg(va, const char*); // Field name - ++state.index; - - va_end(va); - } else if (fmt == absl::string_view("%s%s")) { - // Ignore base classes. - return 0; - } else { - // Unexpected case. Mark parsing as failed. - state.index = -1; - } - - return 0; -} - -} // namespace extend_internal -ABSL_NAMESPACE_END -} // namespace absl
diff --git a/absl/extend/internal/reflection.h b/absl/extend/internal/reflection.h deleted file mode 100644 index 6751374..0000000 --- a/absl/extend/internal/reflection.h +++ /dev/null
@@ -1,75 +0,0 @@ -// Copyright 2026 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_EXTEND_INTERNAL_REFLECTION_H_ -#define ABSL_EXTEND_INTERNAL_REFLECTION_H_ - -#include <array> -#include <cstddef> - -#include "absl/base/config.h" -#include "absl/strings/string_view.h" -#include "absl/types/span.h" - -#if defined(ABSL_EXTEND_INTERNAL_TURN_OFF_FIELD_NAMES_FOR_TEST) -#define ABSL_INTERNAL_EXTEND_PARSE_FIELD_NAMES 0 -#elif defined(TARGET_OS_OSX) || defined(__ANDROID__) -// TODO(b/234010485): Implement field names for these. -#define ABSL_INTERNAL_EXTEND_PARSE_FIELD_NAMES 0 -#elif ABSL_HAVE_BUILTIN(__builtin_dump_struct) -#define ABSL_INTERNAL_EXTEND_PARSE_FIELD_NAMES 1 -#else -#define ABSL_INTERNAL_EXTEND_PARSE_FIELD_NAMES 0 -#endif - -namespace absl { -ABSL_NAMESPACE_BEGIN -namespace extend_internal { - -struct ParsingState { - // The index of the field currently being parsed. - int index = 0; - // The number of unmatched '{' characters encountered so far while parsing. - int brace_count = 0; -}; - -// Called by` __builtin_dump_struct` for each line of the struct representation. -// Rather than printing the struct representation, we parse `fmt` to extract the -// lines containing struct field names and store them in `T::kFieldNames`. -// Note: `__builtin_dump_struct` provides no guarantees whatsoever on its -// output, so our parsing is entirely best-effort. -int PrintfHijack(ParsingState& state, absl::Span<absl::string_view> fields, - const char* fmt, ...); - -// Forward declaration of test helper. -template <typename T> -struct ReflectionTestingExtension; - -// Not nested in ReflectionExtension to reduce template instantiations. -template <size_t N> -struct FieldNameInfo { - static constexpr size_t kFieldCount = N; - -#if ABSL_INTERNAL_EXTEND_PARSE_FIELD_NAMES - std::array<absl::string_view, kFieldCount> field_names; -#endif - // Indicates whether parsing was successful. - bool success; -}; - -} // namespace extend_internal -ABSL_NAMESPACE_END -} // namespace absl - -#endif // ABSL_EXTEND_INTERNAL_REFLECTION_H_
diff --git a/absl/extend/internal/tuple.h b/absl/extend/internal/tuple.h deleted file mode 100644 index 747e549..0000000 --- a/absl/extend/internal/tuple.h +++ /dev/null
@@ -1,51 +0,0 @@ -// Copyright 2026 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_EXTEND_INTERNAL_TUPLE_H_ -#define ABSL_EXTEND_INTERNAL_TUPLE_H_ - -#include <cstddef> -#include <tuple> -#include <type_traits> -#include <utility> - -#include "absl/base/config.h" - -namespace absl { -ABSL_NAMESPACE_BEGIN -namespace extend_internal { - -template <std::size_t... N, typename F, typename... T> -void ZippedForEachImpl(std::index_sequence<N...>, F f, T&&... t) { - const auto for_i = [&](auto i) { f(std::get<i>(std::forward<T>(t))...); }; - (for_i(std::integral_constant<size_t, N>{}), ...); -} - -template <typename F, typename... T> -void ZippedForEach(F f, T&... t) { - using tuple_t = std::decay_t<decltype((std::declval<T>(), ...))>; - using seq_t = std::make_index_sequence<std::tuple_size_v<tuple_t>>; - (ZippedForEachImpl)(seq_t{}, f, t...); -} - -template <typename F, size_t... Ns> -auto MakeTupleFromCallable(std::index_sequence<Ns...>, F f) { - return std::make_tuple(f(std::integral_constant<size_t, Ns>{})...); -} - -} // namespace extend_internal -ABSL_NAMESPACE_END -} // namespace absl - -#endif // ABSL_EXTEND_INTERNAL_TUPLE_H_
diff --git a/absl/profiling/hashtable.cc b/absl/profiling/hashtable.cc index 7c1a839..f1dbe32 100644 --- a/absl/profiling/hashtable.cc +++ b/absl/profiling/hashtable.cc
@@ -60,7 +60,6 @@ const auto capacity_id = builder.InternString("capacity"); const auto size_id = builder.InternString("size"); const auto num_erases_id = builder.InternString("num_erases"); - const auto num_insert_hits_id = builder.InternString("num_insert_hits"); const auto num_rehashes_id = builder.InternString("num_rehashes"); const auto max_probe_length_id = builder.InternString("max_probe_length"); const auto total_probe_length_id = builder.InternString("total_probe_length"); @@ -89,9 +88,6 @@ add_label(size_id, info.size.load(std::memory_order_relaxed)); add_label(num_erases_id, info.num_erases.load(std::memory_order_relaxed)); - // TODO(b/436909492): Revisit whether this value is useful. - add_label(num_insert_hits_id, - info.num_insert_hits.load(std::memory_order_relaxed)); add_label(num_rehashes_id, info.num_rehashes.load(std::memory_order_relaxed)); add_label(max_probe_length_id,
diff --git a/absl/profiling/internal/profile_builder.cc b/absl/profiling/internal/profile_builder.cc index 1ca0d3b..54170c4 100644 --- a/absl/profiling/internal/profile_builder.cc +++ b/absl/profiling/internal/profile_builder.cc
@@ -400,6 +400,38 @@ const bool is_main_executable = builder.mappings_.empty(); + // Storage for path to executable as dlpi_name isn't populated for the + // main executable. +1 to allow for the null terminator that readlink + // does not add. + char self_filename[PATH_MAX + 1]; + const char* filename = info->dlpi_name; + if (filename == nullptr || filename[0] == '\0') { + // This is either the main executable or the VDSO. The main + // executable is always the first entry processed by callbacks. + if (is_main_executable) { + // This is the main executable. + ssize_t ret = readlink("/proc/self/exe", self_filename, + sizeof(self_filename) - 1); + if (ret >= 0 && static_cast<size_t>(ret) < sizeof(self_filename)) { + self_filename[ret] = '\0'; + filename = self_filename; + } + } else { + // This is the VDSO. + filename = GetSoName(info); + } + } + + char resolved_path[PATH_MAX]; + absl::string_view resolved_filename; + if (realpath(filename, resolved_path)) { + resolved_filename = resolved_path; + } else { + resolved_filename = filename; + } + + const std::string build_id = GetBuildId(info); + // Evaluate all the loadable segments. for (int i = 0; i < info->dlpi_phnum; ++i) { if (info->dlpi_phdr[i].p_type != PT_LOAD) { @@ -414,39 +446,6 @@ const size_t memory_limit = memory_start + pt_load->p_memsz; const size_t file_offset = pt_load->p_offset; - // Storage for path to executable as dlpi_name isn't populated for the - // main executable. +1 to allow for the null terminator that readlink - // does not add. - char self_filename[PATH_MAX + 1]; - const char* filename = info->dlpi_name; - if (filename == nullptr || filename[0] == '\0') { - // This is either the main executable or the VDSO. The main - // executable is always the first entry processed by callbacks. - if (is_main_executable) { - // This is the main executable. - ssize_t ret = readlink("/proc/self/exe", self_filename, - sizeof(self_filename) - 1); - if (ret >= 0 && - static_cast<size_t>(ret) < sizeof(self_filename)) { - self_filename[ret] = '\0'; - filename = self_filename; - } - } else { - // This is the VDSO. - filename = GetSoName(info); - } - } - - char resolved_path[PATH_MAX]; - absl::string_view resolved_filename; - if (realpath(filename, resolved_path)) { - resolved_filename = resolved_path; - } else { - resolved_filename = filename; - } - - const std::string build_id = GetBuildId(info); - // Add to profile. builder.AddMapping(memory_start, memory_limit, file_offset, resolved_filename, build_id);
diff --git a/absl/strings/escaping.cc b/absl/strings/escaping.cc index 9f887b8..1171e8d 100644 --- a/absl/strings/escaping.cc +++ b/absl/strings/escaping.cc
@@ -954,19 +954,6 @@ return Base64UnescapeInternal(src.data(), src.size(), dest, kUnWebSafeBase64); } -void Base64Escape(absl::string_view src, std::string* absl_nonnull dest) { - strings_internal::Base64EscapeInternal( - reinterpret_cast<const unsigned char*>(src.data()), src.size(), dest, - true, strings_internal::kBase64Chars); -} - -void WebSafeBase64Escape(absl::string_view src, - std::string* absl_nonnull dest) { - strings_internal::Base64EscapeInternal( - reinterpret_cast<const unsigned char*>(src.data()), src.size(), dest, - false, strings_internal::kWebSafeBase64Chars); -} - std::string Base64Escape(absl::string_view src) { std::string dest; strings_internal::Base64EscapeInternal(
diff --git a/absl/strings/escaping.h b/absl/strings/escaping.h index 3aaf39c..aaacc28 100644 --- a/absl/strings/escaping.h +++ b/absl/strings/escaping.h
@@ -126,16 +126,26 @@ // Encodes a `src` string into a base64-encoded 'dest' string with padding // characters. This function conforms with RFC 4648 section 4 (base64) and RFC // 2045. -void Base64Escape(absl::string_view src, std::string* absl_nonnull dest); std::string Base64Escape(absl::string_view src); +[[deprecated( + "Use the string-returning version of " + "Base64Escape()")]] ABSL_REFACTOR_INLINE inline void +Base64Escape(absl::string_view src, std::string* absl_nonnull dest) { + *dest = Base64Escape(src); +} // WebSafeBase64Escape() // // Encodes a `src` string into a base64 string, like Base64Escape() does, but // outputs '-' instead of '+' and '_' instead of '/', and does not pad 'dest'. // This function conforms with RFC 4648 section 5 (base64url). -void WebSafeBase64Escape(absl::string_view src, std::string* absl_nonnull dest); std::string WebSafeBase64Escape(absl::string_view src); +[[deprecated( + "Use the string-returning version of " + "WebSafeBase64Escape()")]] ABSL_REFACTOR_INLINE inline void +WebSafeBase64Escape(absl::string_view src, std::string* absl_nonnull dest) { + *dest = WebSafeBase64Escape(src); +} // Base64Unescape() //
diff --git a/absl/strings/escaping_benchmark.cc b/absl/strings/escaping_benchmark.cc index 32b8f6e..64b5a41 100644 --- a/absl/strings/escaping_benchmark.cc +++ b/absl/strings/escaping_benchmark.cc
@@ -49,9 +49,7 @@ } } for (auto _ : state) { - std::string escaped; - benchmark::DoNotOptimize(raw); - absl::WebSafeBase64Escape(raw, &escaped); + std::string escaped = absl::WebSafeBase64Escape(raw); benchmark::DoNotOptimize(escaped); } }
diff --git a/absl/strings/escaping_test.cc b/absl/strings/escaping_test.cc index cb9e37f..9651953 100644 --- a/absl/strings/escaping_test.cc +++ b/absl/strings/escaping_test.cc
@@ -683,8 +683,7 @@ static_assert(kSize % 3 == 0, "kSize must be divisible by 3"); const std::string huge(kSize, 'x'); - std::string escaped; - absl::Base64Escape(huge, &escaped); + std::string escaped = absl::Base64Escape(huge); // Generates the string that should match a base64 encoded "xxx..." string. // "xxx" in base64 is "eHh4".