fix(__any_allocator): add friend declaration so the cross-specialization converting constructor compiles (NVIDIA#2159)

* fix(__any_allocator): add friend declaration so the cross-specialization converting constructor compiles on MSVC

__any_allocator's converting constructor reads the private member of another
specialization of the same class template, which the standard permits
([class.access], since C++17) but MSVC rejects with C2248. The conversion is
instantiated whenever task_scheduler's type-erased backend copies an
allocator on the heap-allocation fallback path (e.g. with an asio-based
scheduler), so stdexec::task + asio + MSVC currently fails to compile.

Add an explicit friend declaration (harmless on GCC/Clang) and a regression
test that instantiates the converting constructor directly.

Fixes NVIDIA#2158

* docs: correct the rationale — the cross-specialization access is rejected by GCC, Clang and MSVC alike

The converting constructor of __any_allocator reads the private member of
another specialization of the same template. That is rejected by all major
compilers (MSVC C2248; Clang/GCC 'private member' error); upstream never
noticed because the constructor is only instantiated on the heap-allocation
fallback path of task_scheduler (large operation states, e.g. asio-based
schedulers), which the upstream test matrix does not exercise. The friend
declaration makes the conversion legal on every compiler.

* style: fix clang-format violations in test_any_allocator.cpp

Author: deretame

include/stdexec/__detail/__any_allocator.hpp

@@ -67,6 +67,12 @@ namespace STDEXEC
 
     __any_allocator() = default;
 
+    // The converting constructor below accesses the private member of another
+    // specialization of this template, which is rejected by MSVC, Clang and
+    // GCC. Declare the friendship explicitly.
+    template <class>
+    friend struct __any_allocator;
+
     template <__not_same_as<__any_allocator> _Alloc>
       requires __is_not_instance_of<_Alloc, __any_allocator> && __simple_allocator<_Alloc>
     __any_allocator(_Alloc __alloc) noexcept

test/CMakeLists.txt

@@ -75,6 +75,7 @@ set(stdexec_test_sources
     stdexec/algos/consumers/test_sync_wait.cpp
     stdexec/algos/consumers/test_spawn.cpp
     stdexec/detail/test_any.cpp
+    stdexec/detail/test_any_allocator.cpp
     stdexec/detail/test_common_domain.cpp
     stdexec/detail/test_completion_signatures.cpp
     stdexec/detail/test_demangle.cpp

test/stdexec/detail/test_any_allocator.cpp

@@ -0,0 +1,40 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ * Licensed under the Apache License, Version 2.0 with LLVM Exceptions (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://llvm.org/LICENSE.txt
+ *
+ * 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 <stdexec/execution.hpp>
+
+#include <test_common/catch2.hpp>
+
+#include <utility>
+
+// The converting constructor __any_allocator(_Uy) reads the private member of
+// another specialization of the same class template. That access is rejected by
+// all major compilers (MSVC C2248, Clang and GCC report it as accessing a
+// private member), so the constructor only compiles because it is never
+// instantiated in the upstream test matrix. It *is* instantiated whenever
+// task_scheduler's type-erased backend copies an allocator on the
+// heap-allocation fallback path (e.g. with an asio-based scheduler), breaking
+// the build on every compiler; the friend declaration makes the conversion
+// legal. This test instantiates the constructor directly and guards the fix
+// for NVIDIA/stdexec#2158.
+TEST_CASE("__any_allocator cross-specialization converting constructor compiles",
+          "[detail][allocator]")
+{
+  STDEXEC::__any_allocator<int>       src;
+  STDEXEC::__any_allocator<std::byte> dst(std::move(src));  // instantiates the converting ctor
+  CHECK(dst.has_value() == false);
+}