fix(core): Func<void> and Converter<T, void> are ill-formed (#2299, SR-AUD-126)

Func<void> compiled, and it was THE SAME TYPE as Action -- not convertible to
it, the same type, because an alias template introduces no new type.
Converter<T, void> collapsed onto ActionT<T> the same way. .NET cannot express
any of this: void is not a permitted C# generic argument.

Landed under SA-8 rather than SA-10: nothing here changes a signature, the port
was simply MORE PERMISSIVE than .NET, which is exactly SA-8's direction.

All 17 Func/FuncT* aliases and BOTH Converter declarations are constrained. Both
mattered: System/Converter.hpp and System/Action.hpp declare it identically, and
a repair touching one would have left the other accepting void.

THE FINDING'S SECOND PRESCRIPTION IS STRUCTURALLY IMPOSSIBLE AND IS NOT
ATTEMPTED, which the review had already established and which is now recorded as
a declaration rather than left as a gap: with alias templates there is only ONE
type, so no declaration can accept an Action and reject a Func-shaped callable.
Constraining removes the SPELLING; it cannot create a CATEGORY. Preserving the
category would mean replacing every alias with a distinct class type -- a
whole-API break this repository has not asked for.

A DETECTION-IDIOM DETAIL WORTH KEEPING, measured while writing the fixture:
testing for the absence of a constrained alias must be written over a DEPENDENT
parameter. gcc evaluates a constrained alias eagerly in a non-dependent
'requires', so the direct spelling is a HARD ERROR rather than a false value --
and in the fixture it leaked a diagnostic outside its own site region, making
every verdict in that file untrustworthy until it was rewritten.

Fixture set: 32 fixtures / 184 sites. Gate 17,283 run, 0 failed. Module graph
unchanged at 41/92.

Author: robertvokac

CLAUDE.md

@@ -0,0 +1,69 @@
+<!-- SPDX-License-Identifier: MIT -->
+<!-- Copyright (c) Robert Vokac and contributors -->
+
+# Migration — `Func<void>` and `Converter<T, void>` no longer exist (ticket #2299)
+
+*2026-08-18.* `Func<void>` compiled, and it was **the same type as `Action`** — not convertible to
+it, the same type, because an alias template introduces no new type. .NET cannot express any of
+this: `void` is not a permitted C# generic argument.
+
+Landed under `docs/StandingApprovals.md` **SA-8** (the port was *more permissive* than .NET) with
+SA-2's five conditions. A **compile-domain** source break: no runtime behaviour changes.
+
+---
+
+## 1. What changed
+
+| Spelling | Was | Is |
+|---|---|---|
+| `Func<void>` | compiled — **and was `Action`** | **ill-formed** |
+| `FuncT<T, void>` … all 17 arities | compiled | **ill-formed** |
+| `Converter<T, void>` | compiled — **and was `ActionT<T>`** | **ill-formed** |
+| `Func<int>`, `Converter<int, std::string>`, … | — | **unchanged** |
+| `Action`, `ActionT<T>` | — | **unchanged** |
+
+Both `Converter` declarations moved — `System/Converter.hpp` and `System/Action.hpp` declare it
+identically, and a repair that touched one would have left the other accepting `void`.
+
+## 2. What this does NOT do, and cannot
+
+The finding's second prescription — *"preventing APIs that require .NET parity from accepting the
+substitute aliases"* — is **structurally impossible** with alias templates. There is only **one
+type**, so no declaration can accept an `Action` and reject a `Func`-shaped callable.
+
+Constraining removes the **spelling**; it cannot create a **category**. Preserving the category
+would mean replacing every alias with a distinct class type — a whole-API break this repository
+has not asked for. A test records that limit as a declaration rather than leaving it to be
+rediscovered as a gap.
+
+## 3. To migrate
+
+```cpp
+Func<void> f;              // now ill-formed
+Action f;                  // what you meant, and it always existed
+
+Converter<int, void> h;    // now ill-formed
+ActionT<int> h;            // what you meant
+```
+
+## 4. A detection-idiom detail worth keeping
+
+Testing for the absence of a constrained alias must be written over a **dependent** parameter:
+
+```cpp
+template <typename R> concept FuncIsSpellable = requires { typename System::Func<R>; };
+static_assert(!FuncIsSpellable<void>);          // works
+
+static_assert(!requires { typename System::Func<void>; });   // HARD ERROR on gcc
+```
+
+gcc evaluates a constrained alias eagerly in a **non-dependent** `requires`, so the direct form is
+an error rather than a false value. Measured while writing the negative fixture, where it leaked a
+diagnostic outside its own site region and made every verdict in that file untrustworthy until it
+was rewritten.
+
+## 5. Downstream, measured
+
+Neither `cna` nor `mobile-eggbert` names any `Func`/`FuncT`/`Converter` alias at all — **zero
+sites in both** — and neither spells `Func<void>` or `Converter<T, void>` anywhere. Zero
+production sites in this repository name them either.

audit/AUDIT_FINDINGS_INDEX.md

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <functional>
+#include "System/Func.hpp"
 #include "System/Span.hpp"
 
 namespace System {
@@ -185,7 +186,7 @@ namespace System {
      * SR-AUD-126 note: `TOutput` is unconstrained, so `Converter<T, void>` is
      * the same type as `ActionT<T>` here and is not expressible in .NET at all.
      */
-    template<typename TInput, typename TOutput>
+    template<typename TInput, NonVoidResult TOutput>
     using Converter = std::function<TOutput(TInput)>;
 
 } // namespace System

docs/Migration-FuncNonVoidResult.md

@@ -3,6 +3,7 @@
 // Portions based on .NET runtime API (MIT License, Copyright .NET Foundation and Contributors)
 #pragma once
 #include <functional>
+#include "System/Func.hpp"
 
 namespace System {
 
@@ -24,7 +25,7 @@ namespace System {
  * is a compile-domain public source break either way. This alias is declared
  * identically in `System/Action.hpp`; both spellings mean the same type.
  */
-template<typename TInput, typename TOutput>
+template<typename TInput, NonVoidResult TOutput>
 using Converter = std::function<TOutput(TInput)>;
 
 } // namespace System

modules/core/include/System/Action.hpp

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <functional>
+#include <type_traits>
 
 namespace System {
 
@@ -17,7 +18,20 @@ namespace System {
      * `FuncT<T, R>`, `FuncT2<T1, T2, R>` … `FuncT16<…>`. Ported code changes
      * spelling with arity, and the result type is always **last**, as in .NET.
      *
-     * @warning **`R` is unconstrained, so `Func<void>` compiles and is the very
+     * @par `R` is constrained to a non-void type since ticket #2299
+     * `Func<void>` used to compile, and it was **the same type as** `Action` — not convertible
+     * to it, the same type, because an alias template introduces no new type. `Converter<T,
+     * void>` and `ActionT<T>` coincided the same way. .NET cannot express any of this: `void` is
+     * not a permitted C# generic argument, so `Func<void>` does not exist there and the port was
+     * merging two delegate categories under incompatible public names.
+     *
+     * `NonVoidResult` makes the spelling ill-formed, which is as far as an alias can go. **The
+     * finding's second prescription is structurally impossible and is not attempted**: with
+     * aliases there is only ONE type, so no declaration can accept `Action` and reject
+     * `Func<void>`. Preserving the category would mean replacing every alias with a distinct
+     * class type — a whole-API break this repository has not asked for.
+     *
+     * @warning **Historical note.** Before #2299, `R` was unconstrained, so `Func<void>` was the very
      * same type as `Action`** — not merely convertible to it, the same type,
      * because both are aliases of `std::function<void()>`. `Converter<T, void>`
      * and `ActionT<T>` coincide the same way. .NET keeps the two categories
@@ -44,47 +58,57 @@ namespace System {
      * it throws `std::bad_function_call`, which is `std::function`'s own
      * diagnostic and not a `System::Exception`.
      */
+    /**
+     * @brief The constraint every `Func`/`FuncT*` result type must satisfy (ticket #2299).
+     *
+     * `void` is not a permitted generic argument in C#, so .NET has no `Func<void>`. Spelling one
+     * here produced `Action` — the same type, not merely a convertible one — which merged two
+     * delegate categories under incompatible public names.
+     */
     template<typename R>
+    concept NonVoidResult = !std::is_void_v<R>;
+
+    template<NonVoidResult R>
     using Func = std::function<R()>;
 
     /**
      * @brief Encapsulates a method that has one parameter and returns a value.
      *
      * C++ counterpart of the .NET System.Func<T, TResult> delegate.
      */
-    template<typename T, typename R>
+    template<typename T, NonVoidResult R>
     using FuncT = std::function<R(T)>;
 
     /**
      * @brief Encapsulates a method that has two parameters and returns a value.
      *
      * C++ counterpart of the .NET System.Func<T1, T2, TResult> delegate.
      */
-    template<typename T1, typename T2, typename R>
+    template<typename T1, typename T2, NonVoidResult R>
     using FuncT2 = std::function<R(T1, T2)>;
 
     /**
      * @brief Encapsulates a method that has three parameters and returns a value.
      *
      * C++ counterpart of the .NET System.Func<T1, T2, T3, TResult> delegate.
      */
-    template<typename T1, typename T2, typename T3, typename R>
+    template<typename T1, typename T2, typename T3, NonVoidResult R>
     using FuncT3 = std::function<R(T1, T2, T3)>;
 
     /**
      * @brief Encapsulates a method that has four parameters and returns a value.
      *
      * C++ counterpart of the .NET System.Func<T1, T2, T3, T4, TResult> delegate.
      */
-    template<typename T1, typename T2, typename T3, typename T4, typename R>
+    template<typename T1, typename T2, typename T3, typename T4, NonVoidResult R>
     using FuncT4 = std::function<R(T1, T2, T3, T4)>;
 
     /**
      * @brief Encapsulates a method that has five parameters and returns a value.
      *
      * C++ counterpart of the .NET System.Func<T1, T2, T3, T4, T5, TResult> delegate.
      */
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename R>
+    template<typename T1, typename T2, typename T3, typename T4, typename T5, NonVoidResult R>
     using FuncT5 = std::function<R(T1, T2, T3, T4, T5)>;
 
     /**
@@ -93,7 +117,7 @@ namespace System {
      * C++ counterpart of the .NET System.Func<T1..T6, TResult> delegate.
      */
     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-             typename R>
+             NonVoidResult R>
     using FuncT6 = std::function<R(T1, T2, T3, T4, T5, T6)>;
 
     /**
@@ -102,7 +126,7 @@ namespace System {
      * C++ counterpart of the .NET System.Func<T1..T7, TResult> delegate.
      */
     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-             typename T7, typename R>
+             typename T7, NonVoidResult R>
     using FuncT7 = std::function<R(T1, T2, T3, T4, T5, T6, T7)>;
 
     /**
@@ -111,7 +135,7 @@ namespace System {
      * C++ counterpart of the .NET System.Func<T1..T8, TResult> delegate.
      */
     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-             typename T7, typename T8, typename R>
+             typename T7, typename T8, NonVoidResult R>
     using FuncT8 = std::function<R(T1, T2, T3, T4, T5, T6, T7, T8)>;
 
     /**
@@ -120,7 +144,7 @@ namespace System {
      * C++ counterpart of the .NET System.Func<T1..T9, TResult> delegate.
      */
     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-             typename T7, typename T8, typename T9, typename R>
+             typename T7, typename T8, typename T9, NonVoidResult R>
     using FuncT9 = std::function<R(T1, T2, T3, T4, T5, T6, T7, T8, T9)>;
 
     /**
@@ -129,7 +153,7 @@ namespace System {
      * C++ counterpart of the .NET System.Func<T1..T10, TResult> delegate.
      */
     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-             typename T7, typename T8, typename T9, typename T10, typename R>
+             typename T7, typename T8, typename T9, typename T10, NonVoidResult R>
     using FuncT10 = std::function<R(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>;
 
     /**
@@ -138,7 +162,7 @@ namespace System {
      * C++ counterpart of the .NET System.Func<T1..T11, TResult> delegate.
      */
     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
-             typename T7, typename T8, typename T9, typename T10, typename T11, typename R>
+             typename T7, typename T8, typename T9, typename T10, typename T11, NonVoidResult R>
     using FuncT11 = std::function<R(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>;
 
     /**
@@ -148,7 +172,7 @@ namespace System {
      */
     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
              typename T7, typename T8, typename T9, typename T10, typename T11, typename T12,
-             typename R>
+             NonVoidResult R>
     using FuncT12 = std::function<R(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>;
 
     /**
@@ -158,7 +182,7 @@ namespace System {
      */
     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
              typename T7, typename T8, typename T9, typename T10, typename T11, typename T12,
-             typename T13, typename R>
+             typename T13, NonVoidResult R>
     using FuncT13 = std::function<R(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>;
 
     /**
@@ -168,7 +192,7 @@ namespace System {
      */
     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
              typename T7, typename T8, typename T9, typename T10, typename T11, typename T12,
-             typename T13, typename T14, typename R>
+             typename T13, typename T14, NonVoidResult R>
     using FuncT14 = std::function<R(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
                                      T14)>;
 
@@ -179,7 +203,7 @@ namespace System {
      */
     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
              typename T7, typename T8, typename T9, typename T10, typename T11, typename T12,
-             typename T13, typename T14, typename T15, typename R>
+             typename T13, typename T14, typename T15, NonVoidResult R>
     using FuncT15 = std::function<R(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
                                      T14, T15)>;
 
@@ -190,7 +214,7 @@ namespace System {
      */
     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
              typename T7, typename T8, typename T9, typename T10, typename T11, typename T12,
-             typename T13, typename T14, typename T15, typename T16, typename R>
+             typename T13, typename T14, typename T15, typename T16, NonVoidResult R>
     using FuncT16 = std::function<R(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
                                      T14, T15, T16)>;
 

modules/core/include/System/Converter.hpp

@@ -2,6 +2,9 @@
 // Copyright (c) Robert Vokac and contributors
 // Portions based on .NET runtime API (MIT License, Copyright .NET Foundation and Contributors)
 #include <gtest/gtest.h>
+#include "System/Action.hpp"
+#include "System/Converter.hpp"
+#include <type_traits>
 #include <functional>
 #include <stdexcept>
 #include <string>
@@ -146,3 +149,54 @@ TEST(FuncTests, ReferenceResultIsNotCopied) {
     EXPECT_EQ(storage, 11);
     EXPECT_EQ(&byReference(), &storage);
 }
+
+// ---------------------------------------------------------------------------
+// #2299 / SR-AUD-126 — Func<void> and Converter<T, void> no longer exist
+// ---------------------------------------------------------------------------
+
+namespace detail2299 {
+/// Detection idiom over the alias templates: an ill-formed spelling must be expressible as a
+/// value rather than as a hard error.
+template <typename R>
+concept FuncIsSpellable = requires { typename System::Func<R>; };
+template <typename T, typename R>
+concept ConverterIsSpellable = requires { typename System::Converter<T, R>; };
+}  // namespace detail2299
+
+TEST(FuncTests, Fix2299_FuncOfVoidIsIllFormed) {
+    // THE FINDING. `Func<void>` used to compile, and it was THE SAME TYPE as Action -- not
+    // convertible to it, the same type, because an alias template introduces no new type. .NET
+    // cannot express this at all: `void` is not a permitted C# generic argument, so `Func<void>`
+    // does not exist there, and the port was merging two delegate categories under incompatible
+    // public names.
+    static_assert(!detail2299::FuncIsSpellable<void>, "#2299: Func<void> is ill-formed");
+    static_assert(detail2299::FuncIsSpellable<int>, "...and every ordinary result type still works");
+    static_assert(detail2299::FuncIsSpellable<std::string>, "including a non-trivial one");
+
+    static_assert(!detail2299::ConverterIsSpellable<int, void>,
+                  "#2299: Converter<T, void> is ill-formed too -- it collapsed onto ActionT<T>");
+    static_assert(detail2299::ConverterIsSpellable<int, std::string>,
+                  "...and an ordinary conversion still works");
+}
+
+TEST(FuncTests, Decl2299_TheCATEGORIESStillCannotBeSeparated) {
+    // WHAT #2299 DID NOT DO, AND CANNOT. The finding's second prescription -- "prevent APIs that
+    // require .NET parity from accepting the substitute aliases" -- is STRUCTURALLY IMPOSSIBLE
+    // with alias templates: there is only one type, so no declaration can accept an Action and
+    // reject a Func-shaped callable. Constraining removes the SPELLING; it cannot create a
+    // category.
+    //
+    // Preserving the category would mean replacing every alias with a distinct class type, a
+    // whole-API break this repository has not asked for. This row records that limit as a
+    // declaration rather than leaving it to be rediscovered as a gap.
+    static_assert(std::is_same_v<System::Action, std::function<void()>>,
+                  "Action is still a bare alias, so it has no identity of its own");
+    static_assert(std::is_same_v<System::Func<int>, std::function<int()>>,
+                  "and so is Func -- the constraint is on the SPELLING, not on the type");
+
+    // An ordinary Action still works, unchanged.
+    int calls = 0;
+    System::Action a = [&calls] { ++calls; };
+    a();
+    EXPECT_EQ(1, calls);
+}