fix(core,net-http,text-json): a default-constructed exception carries .NET's fallback message (#2323)

System::Exception{} reported an empty message. .NET's is
`_message ?? SR.Format(SR.Exception_WasThrown, GetClassName())` (Exception.cs:61,65)
-- "Exception of type '{0}' was thrown." (Strings.resx:2333) -- with {0} the runtime
type name.

BOTH RECORDED BLOCKERS ARE RESOLVED, and the second dissolves rather than being
worked around.

  1. The exact resource text was unreadable with /rv absent. It is readable now.

  2. {0} is GetType(), which is reflection this port permanently lacks. But .NET
     computes the fallback LAZILY only so that _message can stay null for
     serialization; the observable is identical if the constructor just stores it,
     which is what a hundred subclasses in this repository already do. So {0} is
     resolved STATICALLY, at each site, by the one entity that knows the answer:
     the type itself. No reflection, no new virtual, no layout change, no signature
     change, no optional.

Hard-coding the base string and letting subclasses inherit it was the option the
review rejected, and rightly: a message naming the WRONG type is a lie, where an
empty one is merely an absence.

THE REVIEW'S PREMISE MEASUREMENT WAS WRONG. It recorded that "18 subclasses supply
a NON-EMPTY default message and exactly ONE type does not -- System::Exception
itself", so the blast radius was the base constructed directly. Re-measured across
all 103 exception subclasses: THREE reach the base fallback. `= default` on a
derived exception default-constructs its base, and two types spell it that way --
HttpRequestException (.NET's is `{ }`, HttpRequestException.cs:10-11) and
JsonException (`: base() { }`, JsonException.cs:78, with Message overridden as
`_message ?? base.Message`). Both are given the message .NET produces for them,
naming themselves.

An EXPLICITLY empty message stays empty, which is also .NET: its fallback fires on
a null message, and `new Exception("")` has Message == "".

THE GUARD. The cost of static resolution is that a future subclass written as
`= default` would silently report System.Exception.
ExceptionFallbackMessageTests.NoOtherExceptionInheritsTheBaseFallback asserts that
a representative set carries neither the base string nor an empty message, so such
a subclass is caught here rather than discovered downstream. The two out-of-module
rows live in modules/net-http/tests and modules/text-json/tests, because Core.Base
depends on neither and a test is not a reason to add a public component edge
(#2354's rule). The module graph is unchanged at 41/92.

DOWNSTREAM IS NOT EMPTY, which is the point of measuring it. mobile-eggbert: zero
sites. cna: FIVE exception types whose default constructors chain to
System::Exception() -- GameUpdateRequiredException, GuideAlreadyVisibleException,
GamerPrivilegeException, GamerServicesNotAvailableException and NetworkException,
each at modules/gamer-services/src/Xna/<Type>.cpp lines 7 and 25 -- whose default
message now names the WRONG type, plus SIX tests asserting EXPECT_STREQ("",
ex.what()) that will fail. cna may be read but not edited without a per-action
instruction, so this is recorded as ticket #2377, not performed. The correct
downstream repair is the one applied here: give each of the six its own message.

Three pins inverted (two in Core.Base, one in the integration suite). Three
mutations, all caught.

Gate: 17,318 run, 17,318 passed, 0 failed, 0 skipped across 38 executables, GREEN.

docs/Migration-ExceptionFallbackMessage.md

Author: robertvokac

CLAUDE.md

@@ -0,0 +1,111 @@
+<!-- SPDX-License-Identifier: MIT -->
+<!-- Copyright (c) Robert Vokac and contributors -->
+
+# Migration — a default-constructed exception carries .NET's fallback message (ticket #2323)
+
+*2026-08-18.* `System::Exception{}.getMessageProperty()` is now
+`"Exception of type 'System.Exception' was thrown."` It used to be empty.
+
+**This changes a message downstream code may assert on.** `cna` has six such assertions — see §6.
+Landed under `docs/StandingApprovals.md` SA-5. No signature, layout, vtable or `noexcept` change.
+
+---
+
+## 1. What changed
+
+| Expression | Was | Is |
+|---|---|---|
+| `System::Exception{}.getMessageProperty()` | `""` | `"Exception of type 'System.Exception' was thrown."` |
+| `System::Exception{}.what()` | `""` | the same string |
+| `HttpRequestException{}` | `""` | `"Exception of type 'System.Net.Http.HttpRequestException' was thrown."` |
+| `JsonException{}` | `""` | `"Exception of type 'System.Text.Json.JsonException' was thrown."` |
+| `System::Exception("")` | `""` | `""` — **unchanged** |
+| every other exception type's default | its own message | **unchanged** |
+
+An **explicitly empty** message stays empty, and that is .NET too: its fallback fires on a
+**null** message, and `new Exception("")` has `Message == ""`.
+
+## 2. The reference
+
+```csharp
+public virtual string Message => _message ?? SR.Format(SR.Exception_WasThrown, GetClassName());
+private string GetClassName() => GetType().ToString();
+```
+*(`Exception.cs:61,65`; `Exception_WasThrown` is `"Exception of type '{0}' was thrown."`,
+`Strings.resx:2333`.)*
+
+The review recorded two blockers. The first — the exact resource text — is simply readable now.
+The second is real and permanent: `{0}` is `GetType()`, which is reflection this port does not
+have.
+
+## 3. What dissolves the second blocker
+
+.NET computes the fallback **lazily** only so `_message` can stay null for serialization; the
+observable is identical if the constructor just stores it — which is what a hundred subclasses in
+this repository already do.
+
+So `{0}` is resolved **statically, at each site, by the one entity that knows the answer**: the
+type itself. No reflection, no new virtual, no layout change, no signature change, no `optional`.
+
+Hard-coding the base's string and letting subclasses inherit it was the option the review
+rejected, and rightly: **a message naming the wrong type is a lie, where an empty one is merely an
+absence.** The subclasses that reach the base fallback are given their own.
+
+## 4. The review's premise measurement was wrong
+
+It recorded that *"18 subclasses supply a NON-EMPTY default message and exactly ONE type does
+not — `System::Exception` itself"*, concluding the blast radius was the base constructed directly.
+
+Re-measured across all **103** exception subclasses in the repository: **three** types reach the
+base fallback, not one. `= default` on a derived exception default-constructs its base, and two
+types spell it that way — `HttpRequestException` and `JsonException`. Both are given their own
+message, matching what .NET produces for each.
+
+## 5. The guard
+
+The cost of static resolution is that a **future** subclass written as `= default` would silently
+report `System.Exception`. `ExceptionFallbackMessageTests.NoOtherExceptionInheritsTheBaseFallback`
+asserts that a representative set of types does not carry the base string and does not carry an
+empty message, so such a subclass is caught rather than discovered downstream.
+
+The two out-of-module rows live in `modules/net-http/tests` and `modules/text-json/tests`, because
+`Core.Base` does not depend on either and **a test is not a reason to add a public component
+edge** (#2354's rule). The module graph is unchanged at 41/92.
+
+## 6. Downstream, measured — and it is not empty
+
+Per SA-2 condition 5. `mobile-eggbert`: **zero** sites.
+
+`cna`: **five** exception types whose default constructors chain to `System::Exception()` —
+`GameUpdateRequiredException`, `GuideAlreadyVisibleException`, `GamerPrivilegeException`,
+`GamerServicesNotAvailableException` and `NetworkException`, each at
+`modules/gamer-services/src/Xna/<Type>.cpp` lines 7 and 25. Their default message changes from
+`""` to the base string, **which names the wrong type**, and `cna` has **six** tests asserting
+`EXPECT_STREQ("", ex.what())` that will fail.
+
+`cna` may be read but not edited without a per-action instruction, so this is recorded rather
+than performed: ticket **#2377**. The correct downstream repair is the same one applied here to
+`HttpRequestException` and `JsonException` — give each of the six its own message naming itself,
+which is what FNA's and .NET's counterparts produce.
+
+## 7. To migrate
+
+If you assert on a default-constructed exception's message, assert the new string, or construct
+with an explicit `""` if you genuinely want an empty one. If you derive from `System::Exception`
+with `= default`, supply your own default message instead:
+
+```cpp
+// before
+MyException() = default;                       // now reports "System.Exception"
+
+// after
+MyException() : System::Exception("Exception of type 'My.Namespace.MyException' was thrown.") {}
+```
+
+## 8. Evidence
+
+| Mutation | Caught |
+|---|---|
+| The base goes back to an empty message | ✅ |
+| `HttpRequestException` inherits the base string (`= default`) | ✅ (2 tests, one of them the integration suite) |
+| `JsonException` inherits the base string (`= default`) | ✅ |

docs/Migration-ExceptionFallbackMessage.md

@@ -9,8 +9,24 @@
 
 namespace System {
 
+    // Ticket #2323 (SR-AUD-092, 2026-08-18). This used to leave the message EMPTY, where .NET's
+    // is `_message ?? SR.Format(SR.Exception_WasThrown, GetClassName())` (Exception.cs:61,65) --
+    // "Exception of type '{0}' was thrown.", Strings.resx:2333, with {0} the RUNTIME TYPE NAME.
+    //
+    // The review recorded two blockers. The first, the exact resource text, is simply readable
+    // now. The second is real and permanent: {0} is reflection, which this port does not have.
+    //
+    // WHAT DISSOLVES IT is that .NET computes the fallback LAZILY only so that `_message` can
+    // stay null for serialization; the observable is identical if the constructor just stores it,
+    // which is what a hundred subclasses in this repository already do. So {0} is resolved
+    // STATICALLY, at each site, by the one entity that knows the answer -- the type itself. No
+    // reflection, no new virtual, no layout change, no signature change.
+    //
+    // Hard-coding this string into the base and letting subclasses inherit it was the option the
+    // review rejected, and rightly: a message naming the WRONG type is a lie, where an empty one
+    // is merely an absence. The two subclasses that reach here are given their own (#2323).
     Exception::Exception()
-        : message_("") {
+        : message_("Exception of type 'System.Exception' was thrown.") {
     }
 
     Exception::Exception(const char* msg)

modules/core/src/System/Exception.cpp

@@ -2,6 +2,13 @@
 // 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/IO/IOException.hpp"
+#include "System/SystemException.hpp"
+#include "System/InvalidOperationException.hpp"
+#include "System/IndexOutOfRangeException.hpp"
+#include "System/FormatException.hpp"
+#include "System/NotSupportedException.hpp"
+#include "System/NotImplementedException.hpp"
 #include "System/Exception.hpp"
 #include "System/ArgumentNullException.hpp"
 #include "System/ObjectDisposedException.hpp"
@@ -14,9 +21,12 @@ TEST(ExceptionNewTests, CStringCtor_MessageMatches) {
     EXPECT_EQ(e.getMessageProperty(), "hello");
 }
 
-TEST(ExceptionNewTests, DefaultCtor_MessageEmpty) {
+// FLIPPED by #2323 (2026-08-18). The empty message was not .NET's; .NET's is
+// `_message ?? SR.Format(SR.Exception_WasThrown, GetClassName())` (Exception.cs:61,65).
+TEST(ExceptionNewTests, DefaultCtor_MessageIsDotNetsFallback) {
     System::Exception e;
-    EXPECT_TRUE(e.getMessageProperty().empty());
+    EXPECT_EQ(e.getMessageProperty(), "Exception of type 'System.Exception' was thrown.");
+    EXPECT_STREQ(e.what(), "Exception of type 'System.Exception' was thrown.");
 }
 
 TEST(ExceptionNewTests, InnerExceptionPtr_StoredAndRetrievable) {
@@ -63,3 +73,57 @@ TEST(ObjectDisposedExceptionNewTests, ObjectName_Stored) {
     System::ObjectDisposedException e("myResource");
     EXPECT_EQ(e.getObjectNameProperty(), "myResource");
 }
+
+// ===========================================================================
+// #2323 — the base fallback, and the guard that stops it spreading
+// ===========================================================================
+//
+// .NET's Exception.Message is `_message ?? SR.Format(SR.Exception_WasThrown, GetClassName())`
+// (Exception.cs:61,65), i.e. "Exception of type '{0}' was thrown." (Strings.resx:2333) with {0}
+// the RUNTIME TYPE NAME. {0} is reflection, which this port permanently does not have, so it is
+// resolved STATICALLY at each site by the one entity that knows the answer: the type itself.
+//
+// THE REVIEW'S PREMISE MEASUREMENT WAS WRONG, and that is why this guard exists. It recorded
+// that "18 subclasses supply a NON-EMPTY default message and exactly ONE type does not --
+// System::Exception itself", so the blast radius was "the base type constructed directly".
+// Re-measured over all 103 subclasses: THREE reach the base fallback, not one. `= default` on a
+// derived exception default-constructs its base, and two types spell it that way.
+//
+// The cost of the static resolution is that a FUTURE subclass written as `= default` would
+// silently report `System.Exception` -- a message naming the wrong type, which is a lie where an
+// empty one was merely an absence. That is what this test is for.
+TEST(ExceptionFallbackMessageTests, TheBaseNamesItself) {
+    EXPECT_EQ(System::Exception{}.getMessageProperty(),
+              "Exception of type 'System.Exception' was thrown.");
+    // The other two types that reach this fallback live in modules that Core.Base does not
+    // depend on, so their rows are in their own suites -- modules/net-http and modules/text-json.
+    // A refactor is not a reason to add a public component edge (#2354's rule), and neither is a
+    // test.
+}
+
+TEST(ExceptionFallbackMessageTests, NoOtherExceptionInheritsTheBaseFallback) {
+    // The guard. Every one of these has its own default message, so none may report the base's
+    // string; if one starts to, a subclass has been added or changed to reach the fallback and
+    // must be given its own name in the same change.
+    const std::string baseFallback = "Exception of type 'System.Exception' was thrown.";
+    const auto notTheBase = [&baseFallback](const std::string& message, const char* what) {
+        EXPECT_NE(message, baseFallback) << what << " now inherits the base fallback";
+        EXPECT_FALSE(message.empty()) << what << " has no default message at all";
+    };
+    notTheBase(System::SystemException{}.getMessageProperty(), "SystemException");
+    notTheBase(System::ArgumentException{}.getMessageProperty(), "ArgumentException");
+    notTheBase(System::ArgumentNullException{}.getMessageProperty(), "ArgumentNullException");
+    notTheBase(System::InvalidOperationException{}.getMessageProperty(), "InvalidOperationException");
+    notTheBase(System::NotSupportedException{}.getMessageProperty(), "NotSupportedException");
+    notTheBase(System::NotImplementedException{}.getMessageProperty(), "NotImplementedException");
+    notTheBase(System::FormatException{}.getMessageProperty(), "FormatException");
+    notTheBase(System::IndexOutOfRangeException{}.getMessageProperty(), "IndexOutOfRangeException");
+    notTheBase(System::IO::IOException{}.getMessageProperty(), "IOException");
+}
+
+TEST(ExceptionFallbackMessageTests, AnExplicitlyEmptyMessageStaysEmpty) {
+    // .NET's fallback fires on a NULL message, not an empty one: `new Exception("")` has
+    // `Message == ""`. This port cannot distinguish null from empty in a std::string, and does
+    // not need to -- the fallback lives in the constructor that was given no message at all.
+    EXPECT_TRUE(System::Exception("").getMessageProperty().empty());
+}

modules/core/tests/System/ExceptionNewTests.cpp

@@ -45,9 +45,14 @@ using System::ObjectDisposedException;
 // Exception (base)
 // ---------------------------------------------------------------------------
 
-TEST(ExceptionTests, DefaultCtorEmptyMessage) {
+// FLIPPED by #2323 (2026-08-18) -- see ExceptionNewTests for the reference lines. An
+// EXPLICITLY empty message is still empty, which is also .NET: its fallback fires on a NULL
+// message, and `new Exception("")` has `Message == ""`.
+TEST(ExceptionTests, DefaultCtorCarriesTheDotNetFallbackButAnExplicitEmptyStringDoesNot) {
     Exception e;
-    EXPECT_TRUE(e.getMessageProperty().empty() || e.getMessageProperty() == "");
+    EXPECT_EQ(e.getMessageProperty(), "Exception of type 'System.Exception' was thrown.");
+    Exception explicitlyEmpty("");
+    EXPECT_TRUE(explicitlyEmpty.getMessageProperty().empty());
 }
 
 TEST(ExceptionTests, MessageFromCString) {

modules/core/tests/System/ExceptionTests.cpp

@@ -23,7 +23,19 @@ namespace System::Net::Http {
 
     public:
         /** Creates a new instance with no message. */
-        HttpRequestException() = default;
+        /**
+         * @brief Constructs an exception with .NET's fallback message for this type.
+         *
+         * Ticket #2323. .NET's `HttpRequestException()` is `{ }` (HttpRequestException.cs:10-11),
+         * so `Message` falls through to `Exception`'s
+         * `SR.Format(SR.Exception_WasThrown, GetClassName())` and names THIS type. `{0}` is
+         * reflection, which this port does not have, so it is resolved statically here -- by the
+         * one entity that knows the answer. Inheriting the base's string would have named
+         * `System.Exception`, which is a lie rather than an absence.
+         */
+        HttpRequestException()
+            : System::Exception(
+                  "Exception of type 'System.Net.Http.HttpRequestException' was thrown.") {}
 
         /** Creates a new instance with the specified message. */
         explicit HttpRequestException(const std::string& message) : System::Exception(message) {}

modules/net-http/include/System/Net/Http/HttpRequestException.hpp

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) Robert Vokac and contributors
+// Portions based on .NET runtime API (MIT License, Copyright .NET Foundation and Contributors)
+//
+// Ticket #2323 (SR-AUD-092). The companion of
+// modules/core/tests/System/ExceptionNewTests.cpp's ExceptionFallbackMessageTests, in its own
+// module because Core.Base does not depend on Net.Http and a test is not a reason to add a
+// public component edge (#2354's rule).
+//
+// .NET's Exception.Message is `_message ?? SR.Format(SR.Exception_WasThrown, GetClassName())`
+// (Exception.cs:61,65) -- "Exception of type '{0}' was thrown." (Strings.resx:2333) -- and .NET's
+// HttpRequestException() is `{ }` (HttpRequestException.cs:10-11), so it reaches that fallback
+// and {0} names THIS type. {0} is reflection, which this port permanently lacks, so it is
+// resolved statically here rather than inherited from the base: a message naming the wrong type
+// would be a lie, where the empty message this replaced was merely an absence.
+#include <gtest/gtest.h>
+#include <string>
+#include "System/Net/Http/HttpRequestException.hpp"
+
+TEST(HttpRequestExceptionFallbackTests, DefaultCtorNamesThisTypeNotTheBase) {
+    const System::Net::Http::HttpRequestException e;
+    EXPECT_EQ(e.getMessageProperty(),
+              "Exception of type 'System.Net.Http.HttpRequestException' was thrown.");
+    EXPECT_NE(e.getMessageProperty(), "Exception of type 'System.Exception' was thrown.")
+        << "inheriting the base's string would name the wrong type";
+}
+
+TEST(HttpRequestExceptionFallbackTests, AnExplicitlyEmptyMessageStaysEmpty) {
+    // .NET's fallback fires on a NULL message, not an empty one.
+    EXPECT_TRUE(System::Net::Http::HttpRequestException("").getMessageProperty().empty());
+    EXPECT_EQ(System::Net::Http::HttpRequestException("boom").getMessageProperty(), "boom");
+}

modules/net-http/tests/System/Net/HttpRequestExceptionFallbackTests.cpp

@@ -23,7 +23,17 @@ namespace System::Text::Json {
         std::optional<std::string> path_;
 
     public:
-        JsonException() = default;
+        /**
+         * @brief Constructs an exception with .NET's fallback message for this type.
+         *
+         * Ticket #2323. .NET's `JsonException()` is `: base() { }` (JsonException.cs:78) and its
+         * `Message` override is `_message ?? base.Message` (:141-147), so it reaches
+         * `Exception`'s `SR.Format(SR.Exception_WasThrown, GetClassName())` and names THIS type.
+         * See HttpRequestException for why `{0}` is resolved statically.
+         */
+        JsonException()
+            : System::Exception(
+                  "Exception of type 'System.Text.Json.JsonException' was thrown.") {}
         explicit JsonException(const std::string& message) : System::Exception(message) {}
         JsonException(const std::string& message, std::exception_ptr innerException)
             : System::Exception(message, innerException) {}

modules/text-json/include/System/Text/Json/JsonException.hpp

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) Robert Vokac and contributors
+// Portions based on .NET runtime API (MIT License, Copyright .NET Foundation and Contributors)
+//
+// Ticket #2323 (SR-AUD-092). See HttpRequestExceptionFallbackTests for the shared rationale;
+// this is the second of the two subclasses that reach `System::Exception`'s fallback.
+//
+// .NET's JsonException() is `: base() { }` (JsonException.cs:78) and its Message override is
+// `_message ?? base.Message` (:141-147), so it reaches Exception's formatted default and names
+// THIS type.
+#include <gtest/gtest.h>
+#include <string>
+#include "System/Text/Json/JsonException.hpp"
+
+TEST(JsonExceptionFallbackTests, DefaultCtorNamesThisTypeNotTheBase) {
+    const System::Text::Json::JsonException e;
+    EXPECT_EQ(e.getMessageProperty(),
+              "Exception of type 'System.Text.Json.JsonException' was thrown.");
+    EXPECT_NE(e.getMessageProperty(), "Exception of type 'System.Exception' was thrown.")
+        << "inheriting the base's string would name the wrong type";
+}
+
+TEST(JsonExceptionFallbackTests, AnExplicitlyEmptyMessageStaysEmpty) {
+    EXPECT_TRUE(System::Text::Json::JsonException("").getMessageProperty().empty());
+    EXPECT_EQ(System::Text::Json::JsonException("boom").getMessageProperty(), "boom");
+}