Fixed RDG handling for nullable scenarios (#54335)

Author: tcortega

src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Endpoint.cs

@@ -108,7 +108,7 @@ public override int GetHashCode() =>
 
     public static bool SignatureEquals(Endpoint a, Endpoint b)
     {
-        if (!string.Equals(a.Response?.WrappedResponseType, b.Response?.WrappedResponseType, StringComparison.Ordinal) ||
+        if (!string.Equals(a.Response?.WrappedResponseTypeDisplayName, b.Response?.WrappedResponseTypeDisplayName, StringComparison.Ordinal) ||
             !a.HttpMethod.Equals(b.HttpMethod, StringComparison.Ordinal) ||
             a.Parameters.Length != b.Parameters.Length)
         {
@@ -129,7 +129,7 @@ public static bool SignatureEquals(Endpoint a, Endpoint b)
     public static int GetSignatureHashCode(Endpoint endpoint)
     {
         var hashCode = new HashCode();
-        hashCode.Add(endpoint.Response?.WrappedResponseType);
+        hashCode.Add(endpoint.Response?.WrappedResponseTypeDisplayName);
         hashCode.Add(endpoint.HttpMethod);
 
         foreach (var parameter in endpoint.Parameters)

src/Http/Http.Extensions/gen/StaticRouteHandlerModel/EndpointResponse.cs

@@ -14,7 +14,8 @@ namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerM
 internal class EndpointResponse
 {
     public ITypeSymbol? ResponseType { get; set; }
-    public string WrappedResponseType { get; set; }
+    public ITypeSymbol WrappedResponseType { get; set; }
+    public string WrappedResponseTypeDisplayName { get; set; }
     public string? ContentType { get; set; }
     public bool IsAwaitable { get; set; }
     public bool HasNoResponse { get; set; }
@@ -27,7 +28,8 @@ internal EndpointResponse(IMethodSymbol method, WellKnownTypes wellKnownTypes)
     {
         WellKnownTypes = wellKnownTypes;
         ResponseType = UnwrapResponseType(method, out bool isAwaitable, out bool awaitableIsVoid);
-        WrappedResponseType = method.ReturnType.ToDisplayString(EmitterConstants.DisplayFormat);
+        WrappedResponseType = method.ReturnType;
+        WrappedResponseTypeDisplayName = method.ReturnType.ToDisplayString(EmitterConstants.DisplayFormat);
         IsAwaitable = isAwaitable;
         HasNoResponse = method.ReturnsVoid || awaitableIsVoid;
         IsIResult = GetIsIResult();
@@ -100,13 +102,14 @@ public override bool Equals(object obj)
     {
         return obj is EndpointResponse otherEndpointResponse &&
             SymbolEqualityComparer.Default.Equals(otherEndpointResponse.ResponseType, ResponseType) &&
-            otherEndpointResponse.WrappedResponseType.Equals(WrappedResponseType, StringComparison.Ordinal) &&
+            SymbolEqualityComparer.Default.Equals(otherEndpointResponse.WrappedResponseType, WrappedResponseType) &&
+            otherEndpointResponse.WrappedResponseTypeDisplayName.Equals(WrappedResponseTypeDisplayName, StringComparison.Ordinal) &&
             otherEndpointResponse.IsAwaitable == IsAwaitable &&
             otherEndpointResponse.HasNoResponse == HasNoResponse &&
             otherEndpointResponse.IsIResult == IsIResult &&
             string.Equals(otherEndpointResponse.ContentType, ContentType, StringComparison.OrdinalIgnoreCase);
     }
 
     public override int GetHashCode() =>
-        HashCode.Combine(SymbolEqualityComparer.Default.GetHashCode(ResponseType), WrappedResponseType, IsAwaitable, HasNoResponse, IsIResult, ContentType);
+        HashCode.Combine(SymbolEqualityComparer.Default.GetHashCode(ResponseType), SymbolEqualityComparer.Default.GetHashCode(WrappedResponseType), WrappedResponseTypeDisplayName, IsAwaitable, HasNoResponse, IsIResult, ContentType);
 }

src/Http/Http.Extensions/gen/StaticRouteHandlerModel/StaticRouteHandlerModel.Emitter.cs

@@ -22,15 +22,15 @@ public static string EmitHandlerDelegateType(this Endpoint endpoint)
         // IResult (int arg0, Todo arg1) => throw null!
         if (endpoint.Parameters.Length == 0)
         {
-            return endpoint.Response == null || (endpoint.Response.HasNoResponse && !endpoint.Response.IsAwaitable) ? "void ()" : $"{endpoint.Response.WrappedResponseType} ()";
+            return endpoint.Response == null || (endpoint.Response.HasNoResponse && !endpoint.Response.IsAwaitable) ? "void ()" : $"{endpoint.Response.WrappedResponseTypeDisplayName} ()";
         }
         var parameterTypeList = string.Join(", ", endpoint.Parameters.Select((p, i) => $"{EmitUnwrappedParameterType(p)} arg{i}{(p.HasDefaultValue ? $"= {p.DefaultValue}" : string.Empty)}"));
 
         if (endpoint.Response == null || (endpoint.Response.HasNoResponse && !endpoint.Response.IsAwaitable))
         {
             return $"void ({parameterTypeList})";
         }
-        return $"{endpoint.Response.WrappedResponseType} ({parameterTypeList})";
+        return $"{endpoint.Response.WrappedResponseTypeDisplayName} ({parameterTypeList})";
     }
 
     private static string EmitUnwrappedParameterType(EndpointParameter p)
@@ -88,7 +88,7 @@ public static void EmitRequestHandler(this Endpoint endpoint, CodeWriter codeWri
         {
             codeWriter.WriteLine($"var task = handler({endpoint.EmitArgumentList()});");
         }
-        if (endpoint.Response.IsAwaitable && endpoint.Response.ResponseType?.NullableAnnotation == NullableAnnotation.Annotated)
+        if (endpoint.Response.IsAwaitable && endpoint.Response.WrappedResponseType.NullableAnnotation == NullableAnnotation.Annotated)
         {
             codeWriter.WriteLine("if (task == null)");
             codeWriter.StartBlock();
@@ -380,7 +380,7 @@ public static void EmitFilteredInvocation(this Endpoint endpoint, CodeWriter cod
         else if (endpoint.Response?.IsAwaitable == true)
         {
             codeWriter.WriteLine($"var task = handler({endpoint.EmitFilteredArgumentList()});");
-            if (endpoint.Response?.ResponseType?.NullableAnnotation == NullableAnnotation.Annotated)
+            if (endpoint.Response?.WrappedResponseType.NullableAnnotation == NullableAnnotation.Annotated)
             {
                 codeWriter.WriteLine("if (task == null)");
                 codeWriter.StartBlock();

src/Http/Http.Extensions/test/RequestDelegateGenerator/CompileTimeCreationTests.cs

@@ -427,7 +427,7 @@ public async Task MapAction_NoJsonTypeInfoResolver_ThrowsException()
         Assert.Equal("JsonSerializerOptions instance must specify a TypeInfoResolver setting before being marked as read-only.", exception.Message);
     }
 
-    public static IEnumerable<object[]> NullResult
+    public static IEnumerable<object[]> NullResultWithNullAnnotation
     {
         get
         {
@@ -443,7 +443,7 @@ public static IEnumerable<object[]> NullResult
     }
 
     [Theory]
-    [MemberData(nameof(NullResult))]
+    [MemberData(nameof(NullResultWithNullAnnotation))]
     public async Task RequestDelegateThrowsInvalidOperationExceptionOnNullDelegate(string innerSource, string message)
     {
         var source = $"""
@@ -458,6 +458,21 @@ public async Task RequestDelegateThrowsInvalidOperationExceptionOnNullDelegate(s
         Assert.Equal(message, exception.Message);
     }
 
+    [Theory]
+    [InlineData("Task<bool> () => null!")]
+    [InlineData("Task<bool?> () => null!")]
+    public async Task AwaitableRequestDelegateThrowsNullReferenceExceptionOnUnannotatedNullDelegate(string innerSource)
+    {
+        var source = $"""
+app.MapGet("/", {innerSource});
+""";
+        var (_, compilation) = await RunGeneratorAsync(source);
+        var endpoint = GetEndpointFromCompilation(compilation);
+
+        var httpContext = CreateHttpContext();
+        _ = await Assert.ThrowsAsync<NullReferenceException>(async () => await endpoint.RequestDelegate(httpContext));
+    }
+
     [Theory]
     [InlineData("")]
     [InlineData("[FromRoute]")]