Fix nullable payload flow after ThrowIfProblem

Author: KSemenenko

Directory.Build.props

@@ -27,8 +27,8 @@
         <RepositoryUrl>https://github.com/managedcode/Communication</RepositoryUrl>
         <PackageProjectUrl>https://github.com/managedcode/Communication</PackageProjectUrl>
         <Product>Managed Code - Communication</Product>
-        <Version>10.3.15</Version>
-        <PackageVersion>10.3.15</PackageVersion>
+        <Version>10.3.16</Version>
+        <PackageVersion>10.3.16</PackageVersion>
 
     </PropertyGroup>
     <PropertyGroup Condition="'$(GITHUB_ACTIONS)' == 'true'">

ManagedCode.Communication.Tests/Results/ResultThrowIfProblemFlowTests.cs

@@ -0,0 +1,126 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.Loader;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Shouldly;
+
+namespace ManagedCode.Communication.Tests.Results;
+
+public sealed class ResultThrowIfProblemFlowTests
+{
+    private const string AssemblyName = "CommunicationThrowIfProblemRegression";
+    private const string TrustedAssembliesKey = "TRUSTED_PLATFORM_ASSEMBLIES";
+    private const string EntryType = "Scenario";
+    private const string EntryMethod = "Execute";
+    private const string Consumer = """
+        #nullable enable
+        using ManagedCode.Communication;
+        using ManagedCode.Communication.CollectionResultT;
+
+        public static class Scenario
+        {
+            private const string Payload = "payload";
+            private const string FailureTitle = "The entry could not be read.";
+            private const string FailureDetail = "The requested entry does not exist.";
+
+            private static int Read(Result<string> result)
+            {
+                result.ThrowIfProblem();
+                return result.Value.Length;
+            }
+
+            private static int ReadNullable(Result<string?> result)
+            {
+                result.ThrowIfProblem();
+                return result.Value.Length;
+            }
+
+            private static int ReadCollection(CollectionResult<string> result)
+            {
+                result.ThrowIfProblem();
+                return result.Value.Length + result.Collection.Length;
+            }
+
+            public static bool Execute()
+            {
+                if (Read(Result<string>.Succeed(Payload)) != Payload.Length ||
+                    ReadNullable(Result<string?>.Succeed(Payload)) != Payload.Length ||
+                    ReadCollection(CollectionResult<string>.Succeed([Payload])) != 2 ||
+                    ReadCollection(CollectionResult<string>.Succeed([])) != 0)
+                {
+                    return false;
+                }
+
+                var problem = Problem.Create(FailureTitle, FailureDetail);
+                var failed = Result<string>.Fail(problem);
+                try { _ = Read(failed); return false; }
+                catch (ProblemException exception)
+                {
+                    if (!ReferenceEquals(exception.Problem, problem)) { return false; }
+                }
+
+                var nullable = Result<string?>.Fail(problem);
+                try { _ = ReadNullable(nullable); return false; }
+                catch (ProblemException exception)
+                {
+                    if (!ReferenceEquals(exception.Problem, problem)) { return false; }
+                }
+
+                var page = CollectionResult<string>.Fail(problem);
+                try { _ = ReadCollection(page); return false; }
+                catch (ProblemException exception)
+                {
+                    if (!ReferenceEquals(exception.Problem, problem)) { return false; }
+                }
+
+                var emptyPage = default(CollectionResult<string>);
+                if (emptyPage.Value.Length != 0 || emptyPage.Collection.Length != 0) { return false; }
+                try { _ = Read(default); return false; }
+                catch (ProblemException exception)
+                {
+                    if (exception.Problem is null) { return false; }
+                }
+                try { _ = ReadNullable(default); return false; }
+                catch (ProblemException exception)
+                {
+                    if (exception.Problem is null) { return false; }
+                }
+                try { _ = ReadCollection(emptyPage); return false; }
+                catch (ProblemException exception)
+                {
+                    return exception.Problem is not null;
+                }
+            }
+        }
+        """;
+
+    [Test]
+    public void ThrowIfProblem_ConsumerCompilesWithoutNullableWarnings_ExecutesSuccessFailureAndDefault()
+    {
+        var references = ((string)AppContext.GetData(TrustedAssembliesKey)!).Split(Path.PathSeparator)
+            .Append(typeof(Result).Assembly.Location).Distinct().Select(path => MetadataReference.CreateFromFile(path));
+        var compilation = CSharpCompilation.Create(AssemblyName,
+            [CSharpSyntaxTree.ParseText(Consumer)], references,
+            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary,
+                nullableContextOptions: NullableContextOptions.Enable, generalDiagnosticOption: ReportDiagnostic.Error));
+        using var image = new MemoryStream();
+        var emitted = compilation.Emit(image);
+        emitted.Success.ShouldBeTrue(string.Join(Environment.NewLine, emitted.Diagnostics));
+        emitted.Diagnostics.ShouldBeEmpty();
+        image.Position = 0;
+        var context = new AssemblyLoadContext(AssemblyName, isCollectible: true);
+        try
+        {
+            var assembly = context.LoadFromStream(image);
+            assembly.GetType(EntryType)!.GetMethod(EntryMethod, BindingFlags.Public | BindingFlags.Static)!
+                .Invoke(null, null).ShouldBe(true);
+        }
+        finally
+        {
+            context.Unload();
+        }
+    }
+}

ManagedCode.Communication/CollectionResultT/CollectionResult.cs

@@ -79,10 +79,10 @@ public T[] Collection
     }
 
     /// <summary>
-    ///     Gets the collection as a Value property, for <see cref="IResult{T}" /> compatibility.
+    ///     Gets the non-null collection as a Value property, for <see cref="IResult{T}" /> compatibility.
     /// </summary>
     [JsonIgnore]
-    public T[]? Value => Collection;
+    public T[] Value => Collection;
 
     /// <summary>
     ///     1-based index of this page.

ManagedCode.Communication/ResultT/ResultT.Exception.cs

@@ -19,10 +19,13 @@ public partial struct Result<T>
     /// <summary>
     ///     Throws a ProblemException if the result has a problem.
     /// </summary>
-    [MemberNotNullWhen(false, nameof(Value))]
+    [MemberNotNull(nameof(Value))]
     public void ThrowIfProblem()
     {
-        ResultProblemExtensions.ThrowIfProblem(this);
+        if (IsFailed)
+        {
+            throw new ProblemException(Problem);
+        }
     }
 
     /// <summary>

README.md

@@ -172,6 +172,22 @@ These guarantees concern the payload itself. A nullable property inside the payl
 inside a collection, still needs its own domain check. Keep the guard and value access on the same result;
 reassigning it or checking a different result does not establish the guarantee.
 
+When the caller needs an exception instead of a failed result, use `ThrowIfProblem()`:
+
+```csharp
+static int RequireTextLength(Result<string> result)
+{
+    result.ThrowIfProblem();
+    return result.Value.Length;
+}
+```
+
+A failed result throws `ProblemException` carrying its original `Problem`. On normal return,
+`Result<T>.ThrowIfProblem()` establishes a non-null `Value`, including nullable type arguments;
+no additional null guard or null-forgiving operator is needed. Collection results expose their
+existing non-null item array through both `Collection` and `Value`, including an empty array
+when there are no items.
+
 ### Success without data
 
 Use non-generic `Result` for acknowledgements, completed mutations, and deliberately ignored events: