[RDG] Fix mismatched nullability for structs and HTTP method whitespace (#49805)

Author: captainsafia

src/Http/Http.Extensions/gen/RequestDelegateGeneratorSources.cs

@@ -3,6 +3,8 @@
 
 using System;
 using System.Collections.Immutable;
+using System.Globalization;
+using System.IO;
 using System.Linq;
 using System.Text;
 using Microsoft.CodeAnalysis.CSharp;
@@ -587,13 +589,14 @@ private static bool ShouldUseWith(this JsonTypeInfo jsonTypeInfo, [NotNullWhen(f
 
     public static string GetVerbs(ImmutableHashSet<string> verbs)
     {
-        var builder = new StringBuilder();
+        using var stringWriter = new StringWriter(CultureInfo.InvariantCulture);
+        using var codeWriter = new CodeWriter(stringWriter, baseIndent: 2);
 
         foreach (string verb in verbs.OrderBy(p => p, StringComparer.Ordinal))
         {
-            builder.AppendLine($$"""private static readonly string[] {{verb}}Verb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.{{verb}} };""");
+            codeWriter.WriteLine($$"""private static readonly string[] {{verb}}Verb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.{{verb}} };""");
         }
 
-        return builder.ToString();
+        return stringWriter.ToString();
     }
 }

src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Model/EndpointParameterExtensions.cs

@@ -26,13 +26,25 @@ public static ITypeSymbol UnwrapParameterType(this EndpointParameter parameter)
         // If the route handler parameter type is a value type, then we use it as the return type of the BindAsync method.
         // Even if the BindAsync method returns a type with mismatched nullability, we need to be able to correctly handle
         // mapping nullable value types to non-nullable value types, as in the following example.
+        //
         // public struct NullableStruct
         // {
         //    public static ValueTask<NullableStruct?> BindAsync(HttpContext context, ParameterInfo parameter) {}
         // }
         // app.MapPost("/", (NullableStruct foo) => { })
         if (handlerParameterType.IsValueType)
         {
+            // For generic structs like Struct<T> we want to use the return type of the BindAsync method as the return type
+            // to avoid issues with mapping the generic type parameter if it contains mismatched nullability.
+            //
+            // public struct Struct<T>
+            // {
+            //    public static ValueTask<Struct<T?>> BindAsync(HttpContext context, ParameterInfo parameter) {}
+            // }
+            if (handlerParameterType is INamedTypeSymbol { IsGenericType: true, OriginalDefinition: { SpecialType: not SpecialType.System_Nullable_T } })
+            {
+                return bindAsyncReturnType;
+            }
             return handlerParameterType;
         }
 

src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/VerifyAsParametersBaseline.generated.txt

@@ -56,7 +56,9 @@ namespace Microsoft.AspNetCore.Http.Generated
     file static class GeneratedRouteBuilderExtensionsCore
     {
         private static readonly string[] GetVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Get };
-private static readonly string[] PostVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Post };
+        private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch };
+        private static readonly string[] PostVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Post };
+        private static readonly string[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put };
 
         [InterceptsLocation(@"TestMapActions.cs", 44, 5)]
         internal static RouteHandlerBuilder MapGet0(
@@ -191,7 +193,7 @@ private static readonly string[] PostVerb = new[] { global::Microsoft.AspNetCore
         }
 
         [InterceptsLocation(@"TestMapActions.cs", 45, 5)]
-        internal static RouteHandlerBuilder MapGet1(
+        internal static RouteHandlerBuilder MapPost1(
             this IEndpointRouteBuilder endpoints,
             [StringSyntax("Route")] string pattern,
             Delegate handler)
@@ -310,13 +312,13 @@ private static readonly string[] PostVerb = new[] { global::Microsoft.AspNetCore
                 endpoints,
                 pattern,
                 handler,
-                GetVerb,
+                PostVerb,
                 populateMetadata,
                 createRequestDelegate);
         }
 
         [InterceptsLocation(@"TestMapActions.cs", 46, 5)]
-        internal static RouteHandlerBuilder MapGet2(
+        internal static RouteHandlerBuilder MapPut2(
             this IEndpointRouteBuilder endpoints,
             [StringSyntax("Route")] string pattern,
             Delegate handler)
@@ -406,13 +408,13 @@ private static readonly string[] PostVerb = new[] { global::Microsoft.AspNetCore
                 endpoints,
                 pattern,
                 handler,
-                GetVerb,
+                PutVerb,
                 populateMetadata,
                 createRequestDelegate);
         }
 
         [InterceptsLocation(@"TestMapActions.cs", 47, 5)]
-        internal static RouteHandlerBuilder MapPost3(
+        internal static RouteHandlerBuilder MapPatch3(
             this IEndpointRouteBuilder endpoints,
             [StringSyntax("Route")] string pattern,
             Delegate handler)
@@ -521,7 +523,7 @@ private static readonly string[] PostVerb = new[] { global::Microsoft.AspNetCore
                 endpoints,
                 pattern,
                 handler,
-                PostVerb,
+                PatchVerb,
                 populateMetadata,
                 createRequestDelegate);
         }

src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.AsParameters.cs

@@ -237,9 +237,9 @@ static void parametersListWithMetadataType([AsParameters] ParametersListWithMeta
     args.HttpContext.Items.Add("value", args.Value);
 }
 app.MapGet("/parameterListWithDefaultValue/{value}", parameterListWithDefaultValue);
-app.MapGet("/parameterListRecordStruct/{value}", parameterListRecordStruct);
-app.MapGet("/parametersListWithHttpContext", parametersListWithHttpContext);
-app.MapPost("/parametersListWithImplicitFromBody", ([AsParameters] ParametersListWithImplicitFromBody args) => args.Todo.Name ?? string.Empty);
+app.MapPost("/parameterListRecordStruct/{value}", parameterListRecordStruct);
+app.MapPut("/parametersListWithHttpContext", parametersListWithHttpContext);
+app.MapPatch("/parametersListWithImplicitFromBody", ([AsParameters] ParametersListWithImplicitFromBody args) => args.Todo.Name ?? string.Empty);
 app.MapGet("/parametersListWithMetadataType", parametersListWithMetadataType);
 """);
 

src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.BindAsync.cs

@@ -314,15 +314,19 @@ public async Task BindAsyncRunsBeforeBodyBinding()
     public async Task MapAction_BindAsync_MismatchedNullability()
     {
         var source = """
-app.MapGet("/", (BindableWithMismatchedNullability<Todo> param) => "Hello world!");
+app.MapGet("/1", (BindableWithMismatchedNullability<Todo> param) => "Hello /1!");
+app.MapGet("/2", (BindableStructWithMismatchedNullability<Todo> param) => "Hello /2!");
 """;
         var (_, compilation) = await RunGeneratorAsync(source);
-        var endpoint = GetEndpointFromCompilation(compilation);
-
-        var httpContext = CreateHttpContext();
-
-        await endpoint.RequestDelegate(httpContext);
+        var endpoints = GetEndpointsFromCompilation(compilation);
 
-        await VerifyResponseBodyAsync(httpContext, "Hello world!");
+        var index = 1;
+        foreach (var endpoint in endpoints)
+        {
+            var httpContext = CreateHttpContext();
+            await endpoint.RequestDelegate(httpContext);
+            await VerifyResponseBodyAsync(httpContext, $"Hello /{index}!");
+            index++;
+        }
     }
 }

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

@@ -1048,6 +1048,22 @@ public BindableWithMismatchedNullability(T? value)
     }
 }
 
+public struct BindableStructWithMismatchedNullability<T>
+{
+    public BindableStructWithMismatchedNullability(T? value)
+    {
+        Value = value;
+    }
+
+    public T? Value { get; }
+
+    public static async ValueTask<BindableStructWithMismatchedNullability<T?>> BindAsync(HttpContext httpContext, ParameterInfo parameter)
+    {
+        await Task.CompletedTask;
+        return new BindableStructWithMismatchedNullability<T?>(default);
+    }
+}
+
 public class BindableClassWithNullReturn
 {
     public static async ValueTask<BindableClassWithNullReturn?> BindAsync(HttpContext httpContext, ParameterInfo parameter)